From 6005f54592a66a1982844723c1c37bdf4b4bc05f Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Mon, 9 Jul 2012 20:05:42 -0600
Subject: [PATCH 01/34] Added initial port of TM16XX library

Port of Ricardo Batista's TM16XX C library from
http://code.google.com/p/tm1638-library/
---
 RaspberryPiDotNet.suo                      | Bin 24576 -> 24576 bytes
 RaspberryPiDotNet/RaspberryPiDotNet.csproj |   2 +
 RaspberryPiDotNet/TM16XX/TM1638.cs         | 138 +++++++++++
 RaspberryPiDotNet/TM16XX/TM16XX.cs         | 257 +++++++++++++++++++++
 4 files changed, 397 insertions(+)
 create mode 100644 RaspberryPiDotNet/TM16XX/TM1638.cs
 create mode 100644 RaspberryPiDotNet/TM16XX/TM16XX.cs

diff --git a/RaspberryPiDotNet.suo b/RaspberryPiDotNet.suo
index 4e36650fc51972ade48be8f07330c2172d6c4370..f0a8510bdd15df27e7da67c5e4b81564e7baa650 100644
GIT binary patch
delta 258
zcmZoTz}RqraYGIZUqM)m&fM6ujLZx`ptHG(rHxrY?`d{Mj=z`F3a7uV-A)3UlLI*n
zHal>%FtKm|6-^ef(V6^(>-^-yEQXuEaQm}xGO`1Ol|WK`b{d;Y1bPf6DJw7=GMG(P
zWRachAYj6}1}OP!a-gI4<|B@8xOmqBx$A&<JrMuf80gHn$d8-x%H)Fz!kmc=DGZ4W
zF$^w~A1Vk>7UGqeoTp;Ms5g0HsIGMggD(TnRE7v3jA20LxiRE3<S~>m6f@{CBm>DC
nSADOj1-x^!DX2AEWW4Md%jDA*l9PoDk|zH#64+c6)yE0|zMD$h

delta 152
zcmZoTz}RqraYGIZ--izFT#N9tjLZx`puM?@rHxr&gIthD)~2bB8=JNZPrtvAYjPlm
z!Da`J7A6*UprXkFHae5PaGmF5{0{^iAdx;hjm=-U{aGeEOWSU45NI%%9HTBUc><5g
z<RgwYlNFp?HXm_(!?iIafN_x@_aqgG$-+*#K;eYR2^`Xsg$$A=|1lESTol#E3IN7e
BHF*F4

diff --git a/RaspberryPiDotNet/RaspberryPiDotNet.csproj b/RaspberryPiDotNet/RaspberryPiDotNet.csproj
index a08d16d..e9890be 100644
--- a/RaspberryPiDotNet/RaspberryPiDotNet.csproj
+++ b/RaspberryPiDotNet/RaspberryPiDotNet.csproj
@@ -51,6 +51,8 @@
     <Compile Include="MicroLiquidCrystal\ILcdTransferProvider.cs" />
     <Compile Include="MicroLiquidCrystal\Lcd.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="TM16XX\TM1638.cs" />
+    <Compile Include="TM16XX\TM16XX.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/RaspberryPiDotNet/TM16XX/TM1638.cs b/RaspberryPiDotNet/TM16XX/TM1638.cs
new file mode 100644
index 0000000..b55124f
--- /dev/null
+++ b/RaspberryPiDotNet/TM16XX/TM1638.cs
@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace RaspberryPiDotNet
+{
+    public class TM1638 : TM16XX
+    {
+        private byte TM1638_COLOR_RED = 1;
+        private byte TM1638_COLOR_GREEN = 2;
+
+        public TM1638(GPIO data, GPIO clock, GPIO strobe, bool activateDisplay, byte intensity)
+            : base(data, clock, strobe, 8, activateDisplay, intensity)
+        {
+        }
+
+        public void setDisplayToHexNumber(ulong number, byte dots, bool leadingZeros, byte[] numberFont)
+        {
+            for (int i = 0; i < _displays; i++)
+            {
+                if (!leadingZeros && number == 0)
+                    clearDisplayDigit((byte)(_displays - i - 1), (dots & (1 << i)) != 0);
+                else
+                {
+                    setDisplayDigit((byte)(number & 0xF), (byte)(_displays - i - 1), (dots & (1 << i)) != 0, numberFont);
+                    number >>= 4;
+                }
+            }
+        }
+
+        public void setDisplayToDecNumberAt(ulong number, byte dots, byte startingPos, bool leadingZeros, byte[] numberFont)
+        {
+            if (number > 99999999L)
+                setDisplayToError();
+            else
+            {
+                for (int i = 0; i < _displays - startingPos; i++)
+                {
+                    if (number != 0)
+                    {
+                        setDisplayDigit((byte)(number % 10), (byte)(_displays - i - 1), (dots & (1 << i)) != 0, numberFont);
+                        number /= 10;
+                    }
+                    else
+                    {
+                        if (leadingZeros)
+                        {
+                            setDisplayDigit((byte)0, (byte)(_displays - i - 1), (dots & (1 << i)) != 0, numberFont);
+                        }
+                        else
+                        {
+                            clearDisplayDigit((byte)(_displays - i - 1), (dots & (1 << i)) != 0);
+                        }
+                    }
+                }
+            }
+        }
+
+        public void setDisplayToDecNumber(ulong number, byte dots, bool leadingZeros, byte[] numberFont)
+        {
+            setDisplayToDecNumberAt(number, dots, 0, leadingZeros, numberFont);
+        }
+
+        public void setDisplayToSignedDecNumber(long number, byte dots, bool leadingZeros, byte[] numberFont)
+        {
+            if (number >= 0)
+            {
+                setDisplayToDecNumberAt((ulong)number, dots, 0, leadingZeros, numberFont);
+            }
+            else
+            {
+                if (-number > 9999999L)
+                {
+                    setDisplayToError();
+                }
+                else
+                {
+                    setDisplayToDecNumberAt((ulong)-number, dots, 1, leadingZeros, numberFont);
+                    sendChar(0, (byte)charMap['-'], (dots & (0x80)) != 0);
+                }
+            }
+        }
+
+        public void setDisplayToBinNumber(byte number, byte dots, byte[] numberFont)
+        {
+            for (int i = 0; i < _displays; i++)
+            {
+                setDisplayDigit((byte)((number & (1 << i)) == 0 ? 0 : 1), (byte)(_displays - i - 1), (dots & (1 << i)) != 0, numberFont);
+            }
+        }
+
+        public void setLED(byte color, byte pos)
+        {
+            sendData((byte)((pos << 1) + 1), color);
+        }
+
+        void setLEDs(ushort leds)
+        {
+            for (int i = 0; i < _displays; i++)
+            {
+                byte color = 0;
+
+                if ((leds & (1 << i)) != 0)
+                {
+                    color |= TM1638_COLOR_RED;
+                }
+
+                if ((leds & (1 << (i + 8))) != 0)
+                {
+                    color |= TM1638_COLOR_GREEN;
+                }
+
+                setLED(color, (byte)i);
+            }
+        }
+
+        public byte getButtons()
+        {
+            byte keys = 0;
+
+            _strobe.Write(false);
+            send(0x42);
+            for (byte i = 0; i < 4; i++)
+            {
+                keys |= (byte)(receive() << i);
+            }
+            _strobe.Write(true);
+
+            return keys;
+        }
+
+        public override void sendChar(byte pos, byte data, bool dot)
+        {
+            sendData((byte)(pos << 1), (byte)(data | (dot ? Convert.ToByte("10000000", 2) : 0)));
+        }
+    }
+}
diff --git a/RaspberryPiDotNet/TM16XX/TM16XX.cs b/RaspberryPiDotNet/TM16XX/TM16XX.cs
new file mode 100644
index 0000000..abc59b6
--- /dev/null
+++ b/RaspberryPiDotNet/TM16XX/TM16XX.cs
@@ -0,0 +1,257 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+// This class is the base class for the TM1638/TM1640 board.
+// It is a port of the TM1638 library by Ricardo Batista
+// URL: http://code.google.com/p/tm1638-library/
+namespace RaspberryPiDotNet
+{
+    public abstract class TM16XX
+    {
+        protected GPIO _data;
+        protected GPIO _clock;
+        protected GPIO _strobe;
+        protected int _displays;
+
+        public static Dictionary<char, byte> charMap = new Dictionary<char, byte>()
+        {
+            { ' ', Convert.ToByte("00000000",2) },
+            { '!', Convert.ToByte("10000110",2) },
+            { '"', Convert.ToByte("00100010",2) },
+            { '#', Convert.ToByte("01111110",2) },
+            { '$', Convert.ToByte("01101101",2) },
+            { '%', Convert.ToByte("00000000",2) },
+            { '&', Convert.ToByte("00000000",2) },
+            { '\'', Convert.ToByte("00000010",2) },
+            { '(', Convert.ToByte("00110000",2) },
+            { ')', Convert.ToByte("00000110",2) },
+            { '*', Convert.ToByte("01100011",2) },
+            { '+', Convert.ToByte("00000000",2) },
+            { ',', Convert.ToByte("00000100",2) },
+            { '-', Convert.ToByte("01000000",2) },
+            { '.', Convert.ToByte("10000000",2) },
+            { '/', Convert.ToByte("01010010",2) },
+            { '0', Convert.ToByte("00111111",2) },
+            { '1', Convert.ToByte("00000110",2) },
+            { '2', Convert.ToByte("01011011",2) },
+            { '3', Convert.ToByte("01001111",2) },
+            { '4', Convert.ToByte("01100110",2) },
+            { '5', Convert.ToByte("01101101",2) },
+            { '6', Convert.ToByte("01111101",2) },
+            { '7', Convert.ToByte("00100111",2) },
+            { '8', Convert.ToByte("01111111",2) },
+            { '9', Convert.ToByte("01101111",2) },
+            { ':', Convert.ToByte("00000000",2) },
+            { ';', Convert.ToByte("00000000",2) },
+            { '<', Convert.ToByte("00000000",2) },
+            { '=', Convert.ToByte("01001000",2) },
+            { '>', Convert.ToByte("00000000",2) },
+            { '?', Convert.ToByte("01010011",2) },
+            { '@', Convert.ToByte("01011111",2) },
+            { 'A', Convert.ToByte("01110111",2) },
+            { 'B', Convert.ToByte("01111111",2) },
+            { 'C', Convert.ToByte("00111001",2) },
+            { 'D', Convert.ToByte("00111111",2) },
+            { 'E', Convert.ToByte("01111001",2) },
+            { 'F', Convert.ToByte("01110001",2) },
+            { 'G', Convert.ToByte("00111101",2) },
+            { 'H', Convert.ToByte("01110110",2) },
+            { 'I', Convert.ToByte("00000110",2) },
+            { 'J', Convert.ToByte("00011111",2) },
+            { 'K', Convert.ToByte("01101001",2) },
+            { 'L', Convert.ToByte("00111000",2) },
+            { 'M', Convert.ToByte("00010101",2) },
+            { 'N', Convert.ToByte("00110111",2) },
+            { 'O', Convert.ToByte("00111111",2) },
+            { 'P', Convert.ToByte("01110011",2) },
+            { 'Q', Convert.ToByte("01100111",2) },
+            { 'R', Convert.ToByte("00110001",2) },
+            { 'S', Convert.ToByte("01101101",2) },
+            { 'T', Convert.ToByte("01111000",2) },
+            { 'U', Convert.ToByte("00111110",2) },
+            { 'V', Convert.ToByte("00101010",2) },
+            { 'W', Convert.ToByte("00011101",2) },
+            { 'X', Convert.ToByte("01110110",2) },
+            { 'Y', Convert.ToByte("01101110",2) },
+            { 'Z', Convert.ToByte("01011011",2) },
+            { '[', Convert.ToByte("00111001",2) },
+            { '\\', Convert.ToByte("01100100",2) },
+            { ']', Convert.ToByte("00001111",2) },
+            { '^', Convert.ToByte("00000000",2) },
+            { '_', Convert.ToByte("00001000",2) },
+            { '`', Convert.ToByte("00100000",2) },
+            { 'a', Convert.ToByte("01011111",2) },
+            { 'b', Convert.ToByte("01111100",2) },
+            { 'c', Convert.ToByte("01011000",2) },
+            { 'd', Convert.ToByte("01011110",2) },
+            { 'e', Convert.ToByte("01111011",2) },
+            { 'f', Convert.ToByte("00110001",2) },
+            { 'g', Convert.ToByte("01101111",2) },
+            { 'h', Convert.ToByte("01110100",2) },
+            { 'i', Convert.ToByte("00000100",2) },
+            { 'j', Convert.ToByte("00001110",2) },
+            { 'k', Convert.ToByte("01110101",2) },
+            { 'l', Convert.ToByte("00110000",2) },
+            { 'm', Convert.ToByte("01010101",2) },
+            { 'n', Convert.ToByte("01010100",2) },
+            { 'o', Convert.ToByte("01011100",2) },
+            { 'p', Convert.ToByte("01110011",2) },
+            { 'q', Convert.ToByte("01100111",2) },
+            { 'r', Convert.ToByte("01010000",2) },
+            { 's', Convert.ToByte("01101101",2) },
+            { 't', Convert.ToByte("01111000",2) },
+            { 'u', Convert.ToByte("00011100",2) },
+            { 'v', Convert.ToByte("00101010",2) },
+            { 'w', Convert.ToByte("00011101",2) },
+            { 'x', Convert.ToByte("01110110",2) },
+            { 'y', Convert.ToByte("01101110",2) },
+            { 'z', Convert.ToByte("01000111",2) },
+            { '{', Convert.ToByte("01000110",2) },
+            { '|', Convert.ToByte("00000110",2) },
+            { '}', Convert.ToByte("01110000",2) },
+            { '~', Convert.ToByte("00000001",2) }
+        };
+
+        public TM16XX(GPIO data, GPIO clock, GPIO strobe, int displays, bool activateDisplay, int intensity)
+        {
+            // Set the pins
+            _data = data;
+            _clock = clock;
+            _strobe = strobe;
+            _displays = displays;
+
+            _strobe.Write(true);
+            _clock.Write(true);
+
+            sendCommand(0x40);
+            sendCommand((byte)(0x80 | (activateDisplay ? 0x08 : 0x00) | Math.Min(7, intensity)));
+
+            _strobe.Write(false);
+            send(0xC0);
+            for (int i = 0; i < 16; i++)
+            {
+                send(0x00);
+            }
+            _strobe.Write(true);
+        }
+
+        public void setupDisplay(bool active, int intensity)
+        {
+            sendCommand((byte)(0x80 | (active ? 8 : 0) | Math.Min(7, intensity)));
+
+            // necessary for the TM1640
+            _strobe.Write(false);
+            _clock.Write(false);
+            _clock.Write(true);
+            _strobe.Write(true);
+        }
+
+        public void setDisplayDigit(byte digit, byte pos, bool dot, byte[] numberFont)
+        {
+            sendChar(pos, numberFont[digit & 0xF], dot);
+        }
+
+        public void setDisplayToError()
+        {
+            byte[] error = new byte[5] {
+                charMap['E'],
+                charMap['r'],
+                charMap['r'],
+                charMap['o'],
+                charMap['r']
+            };
+            setDisplay(error, 5);
+
+	        for (int i = 8; i < _displays; i++)
+            {
+	            clearDisplayDigit((byte)i, false);
+	        }
+        }
+
+        public void clearDisplayDigit(byte pos, bool dot)
+        {
+            sendChar(pos, 0, dot);
+        }
+
+        public void setDisplay(byte[] values, int size)
+        {
+            for (int i = 0; i < size; i++)
+            {
+                sendChar((byte)i, values[i], false);
+            }
+        }
+
+        public void clearDisplay()
+        {
+            for (int i = 0; i < _displays; i++)
+            {
+                sendData((byte)(i << 1), (byte)0);
+            }
+        }
+
+        public void setDisplayToString(string str, ushort dots, byte pos, byte[] font)
+        {
+            int stringLength = str.Length;
+
+            for (int i = 0; i < _displays - pos; i++)
+                if (i < stringLength)
+                    sendChar((byte)(i + (int)pos), (byte)(font[str[i] - 32]), (dots & (1 << (_displays - i - 1))) != 0);
+                else
+                    break;
+        }
+
+        public void sendCommand(byte cmd)
+        {
+            _strobe.Write(false);
+            send(cmd);
+            _strobe.Write(true);
+        }
+
+        public void sendData(byte address, byte data)
+        {
+            sendCommand(0x44);
+            _strobe.Write(false);
+            send((byte)(0xC0 | address));
+            send(data);
+            _strobe.Write(true);
+        }
+
+        public void send(byte data)
+        {
+            for (int i = 0; i < 8; i++)
+            {
+                _clock.Write(false);
+                _data.Write((data & 1) > 0 ? true : false);
+                data >>= 1;
+                _clock.Write(true);
+            }
+        }
+
+        public byte receive()
+        {
+            byte temp = 0;
+
+            // Pull-up on
+            _data.Write(true);
+
+            for (int i = 0; i < 8; i++)
+            {
+                temp >>= 1;
+                _clock.Write(false);
+
+                if (_data.Read())
+                    temp |= 0x80;
+
+                _clock.Write(true);
+            }
+
+            _data.Write(false);
+
+            return temp;
+        }
+
+        public abstract void sendChar(byte pos, byte data, bool dot);
+    }
+}

From 4fc4e8d5145fd7bacc385a99cfccbb226882d5a1 Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Mon, 9 Jul 2012 22:20:53 -0600
Subject: [PATCH 02/34] make the LED colors public

---
 RaspberryPiDotNet/TM16XX/TM1638.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/RaspberryPiDotNet/TM16XX/TM1638.cs b/RaspberryPiDotNet/TM16XX/TM1638.cs
index b55124f..059187b 100644
--- a/RaspberryPiDotNet/TM16XX/TM1638.cs
+++ b/RaspberryPiDotNet/TM16XX/TM1638.cs
@@ -7,8 +7,8 @@ namespace RaspberryPiDotNet
 {
     public class TM1638 : TM16XX
     {
-        private byte TM1638_COLOR_RED = 1;
-        private byte TM1638_COLOR_GREEN = 2;
+        public readonly byte TM1638_COLOR_RED = 1;
+        public readonly byte TM1638_COLOR_GREEN = 2;
 
         public TM1638(GPIO data, GPIO clock, GPIO strobe, bool activateDisplay, byte intensity)
             : base(data, clock, strobe, 8, activateDisplay, intensity)

From 597a6fb3b80908a2ef6ceb1ffeac32f9894ab319 Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Mon, 9 Jul 2012 23:10:43 -0600
Subject: [PATCH 03/34] removed the font parameter

---
 RaspberryPiDotNet/TM16XX/TM1638.cs | 57 +++++++++++-------------------
 RaspberryPiDotNet/TM16XX/TM16XX.cs |  8 +++--
 2 files changed, 25 insertions(+), 40 deletions(-)

diff --git a/RaspberryPiDotNet/TM16XX/TM1638.cs b/RaspberryPiDotNet/TM16XX/TM1638.cs
index 059187b..cc2082e 100644
--- a/RaspberryPiDotNet/TM16XX/TM1638.cs
+++ b/RaspberryPiDotNet/TM16XX/TM1638.cs
@@ -7,15 +7,18 @@ namespace RaspberryPiDotNet
 {
     public class TM1638 : TM16XX
     {
-        public readonly byte TM1638_COLOR_RED = 1;
-        public readonly byte TM1638_COLOR_GREEN = 2;
-
         public TM1638(GPIO data, GPIO clock, GPIO strobe, bool activateDisplay, byte intensity)
             : base(data, clock, strobe, 8, activateDisplay, intensity)
         {
         }
 
-        public void setDisplayToHexNumber(ulong number, byte dots, bool leadingZeros, byte[] numberFont)
+        public enum TM1638_LED_COLOR : byte
+        {
+            RED = 1,
+            GREEN = 2
+        };
+
+        public void setDisplayToHexNumber(ulong number, byte dots, bool leadingZeros)
         {
             for (int i = 0; i < _displays; i++)
             {
@@ -23,13 +26,13 @@ public void setDisplayToHexNumber(ulong number, byte dots, bool leadingZeros, by
                     clearDisplayDigit((byte)(_displays - i - 1), (dots & (1 << i)) != 0);
                 else
                 {
-                    setDisplayDigit((byte)(number & 0xF), (byte)(_displays - i - 1), (dots & (1 << i)) != 0, numberFont);
+                    setDisplayDigit((byte)(number & 0xF), (byte)(_displays - i - 1), (dots & (1 << i)) != 0);
                     number >>= 4;
                 }
             }
         }
 
-        public void setDisplayToDecNumberAt(ulong number, byte dots, byte startingPos, bool leadingZeros, byte[] numberFont)
+        public void setDisplayToDecNumberAt(ulong number, byte dots, byte startingPos, bool leadingZeros)
         {
             if (number > 99999999L)
                 setDisplayToError();
@@ -39,14 +42,14 @@ public void setDisplayToDecNumberAt(ulong number, byte dots, byte startingPos, b
                 {
                     if (number != 0)
                     {
-                        setDisplayDigit((byte)(number % 10), (byte)(_displays - i - 1), (dots & (1 << i)) != 0, numberFont);
+                        setDisplayDigit((byte)(number % 10), (byte)(_displays - i - 1), (dots & (1 << i)) != 0);
                         number /= 10;
                     }
                     else
                     {
                         if (leadingZeros)
                         {
-                            setDisplayDigit((byte)0, (byte)(_displays - i - 1), (dots & (1 << i)) != 0, numberFont);
+                            setDisplayDigit((byte)0, (byte)(_displays - i - 1), (dots & (1 << i)) != 0);
                         }
                         else
                         {
@@ -57,16 +60,16 @@ public void setDisplayToDecNumberAt(ulong number, byte dots, byte startingPos, b
             }
         }
 
-        public void setDisplayToDecNumber(ulong number, byte dots, bool leadingZeros, byte[] numberFont)
+        public void setDisplayToDecNumber(ulong number, byte dots, bool leadingZeros)
         {
-            setDisplayToDecNumberAt(number, dots, 0, leadingZeros, numberFont);
+            setDisplayToDecNumberAt(number, dots, 0, leadingZeros);
         }
 
-        public void setDisplayToSignedDecNumber(long number, byte dots, bool leadingZeros, byte[] numberFont)
+        public void setDisplayToSignedDecNumber(long number, byte dots, bool leadingZeros)
         {
             if (number >= 0)
             {
-                setDisplayToDecNumberAt((ulong)number, dots, 0, leadingZeros, numberFont);
+                setDisplayToDecNumberAt((ulong)number, dots, 0, leadingZeros);
             }
             else
             {
@@ -76,43 +79,23 @@ public void setDisplayToSignedDecNumber(long number, byte dots, bool leadingZero
                 }
                 else
                 {
-                    setDisplayToDecNumberAt((ulong)-number, dots, 1, leadingZeros, numberFont);
+                    setDisplayToDecNumberAt((ulong)-number, dots, 1, leadingZeros);
                     sendChar(0, (byte)charMap['-'], (dots & (0x80)) != 0);
                 }
             }
         }
 
-        public void setDisplayToBinNumber(byte number, byte dots, byte[] numberFont)
+        public void setDisplayToBinNumber(byte number, byte dots)
         {
             for (int i = 0; i < _displays; i++)
             {
-                setDisplayDigit((byte)((number & (1 << i)) == 0 ? 0 : 1), (byte)(_displays - i - 1), (dots & (1 << i)) != 0, numberFont);
+                setDisplayDigit((byte)((number & (1 << i)) == 0 ? 0 : 1), (byte)(_displays - i - 1), (dots & (1 << i)) != 0);
             }
         }
 
-        public void setLED(byte color, byte pos)
-        {
-            sendData((byte)((pos << 1) + 1), color);
-        }
-
-        void setLEDs(ushort leds)
+        public void setLED(TM1638_LED_COLOR color, byte pos)
         {
-            for (int i = 0; i < _displays; i++)
-            {
-                byte color = 0;
-
-                if ((leds & (1 << i)) != 0)
-                {
-                    color |= TM1638_COLOR_RED;
-                }
-
-                if ((leds & (1 << (i + 8))) != 0)
-                {
-                    color |= TM1638_COLOR_GREEN;
-                }
-
-                setLED(color, (byte)i);
-            }
+            sendData((byte)((pos << 1) + 1), (byte)color);
         }
 
         public byte getButtons()
diff --git a/RaspberryPiDotNet/TM16XX/TM16XX.cs b/RaspberryPiDotNet/TM16XX/TM16XX.cs
index abc59b6..01d3926 100644
--- a/RaspberryPiDotNet/TM16XX/TM16XX.cs
+++ b/RaspberryPiDotNet/TM16XX/TM16XX.cs
@@ -148,9 +148,11 @@ public void setupDisplay(bool active, int intensity)
             _strobe.Write(true);
         }
 
-        public void setDisplayDigit(byte digit, byte pos, bool dot, byte[] numberFont)
+        public void setDisplayDigit(byte digit, byte pos, bool dot)
         {
-            sendChar(pos, numberFont[digit & 0xF], dot);
+            char chr = Char.Parse(digit.ToString());
+            if (charMap.Keys.Contains(chr))
+                sendChar(pos, charMap[digit.ToString()[0]], dot);
         }
 
         public void setDisplayToError()
@@ -191,7 +193,7 @@ public void clearDisplay()
             }
         }
 
-        public void setDisplayToString(string str, ushort dots, byte pos, byte[] font)
+        public void setDisplayToString(string str, ushort dots, byte pos)
         {
             int stringLength = str.Length;
 

From 1d4edf514d436bf09bc18e15e557cfacc1f18292 Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Tue, 10 Jul 2012 00:20:03 -0600
Subject: [PATCH 04/34] minor enhancements

---
 RaspberryPiDotNet/TM16XX/TM1638.cs | 14 ++++---------
 RaspberryPiDotNet/TM16XX/TM16XX.cs | 33 +++++++++++++++++++++++++++---
 2 files changed, 34 insertions(+), 13 deletions(-)

diff --git a/RaspberryPiDotNet/TM16XX/TM1638.cs b/RaspberryPiDotNet/TM16XX/TM1638.cs
index cc2082e..aa983a3 100644
--- a/RaspberryPiDotNet/TM16XX/TM1638.cs
+++ b/RaspberryPiDotNet/TM16XX/TM1638.cs
@@ -3,6 +3,9 @@
 using System.Linq;
 using System.Text;
 
+// This class is the base class for the TM1638/TM1640 board.
+// It is a port of the TM1638 library by Ricardo Batista
+// URL: http://code.google.com/p/tm1638-library/
 namespace RaspberryPiDotNet
 {
     public class TM1638 : TM16XX
@@ -20,16 +23,7 @@ public enum TM1638_LED_COLOR : byte
 
         public void setDisplayToHexNumber(ulong number, byte dots, bool leadingZeros)
         {
-            for (int i = 0; i < _displays; i++)
-            {
-                if (!leadingZeros && number == 0)
-                    clearDisplayDigit((byte)(_displays - i - 1), (dots & (1 << i)) != 0);
-                else
-                {
-                    setDisplayDigit((byte)(number & 0xF), (byte)(_displays - i - 1), (dots & (1 << i)) != 0);
-                    number >>= 4;
-                }
-            }
+            setDisplayToString(number.ToString("x").ToUpper());
         }
 
         public void setDisplayToDecNumberAt(ulong number, byte dots, byte startingPos, bool leadingZeros)
diff --git a/RaspberryPiDotNet/TM16XX/TM16XX.cs b/RaspberryPiDotNet/TM16XX/TM16XX.cs
index 01d3926..06bff40 100644
--- a/RaspberryPiDotNet/TM16XX/TM16XX.cs
+++ b/RaspberryPiDotNet/TM16XX/TM16XX.cs
@@ -15,7 +15,18 @@ public abstract class TM16XX
         protected GPIO _strobe;
         protected int _displays;
 
-        public static Dictionary<char, byte> charMap = new Dictionary<char, byte>()
+        /// <summary>
+        /// The character map for the seven segment displays.
+        /// The bits are displayed by mapping bellow
+        ///  -- 0 --
+        /// |       |
+        /// 5       1
+        ///  -- 6 --
+        /// 4       2
+        /// |       |
+        ///  -- 3 --  .7
+        /// </summary>
+        public readonly static Dictionary<char, byte> charMap = new Dictionary<char, byte>()
         {
             { ' ', Convert.ToByte("00000000",2) },
             { '!', Convert.ToByte("10000110",2) },
@@ -137,6 +148,17 @@ public TM16XX(GPIO data, GPIO clock, GPIO strobe, int displays, bool activateDis
             _strobe.Write(true);
         }
 
+        public bool ActivateDisplay
+        {
+            set
+            {
+                if (value)
+                    sendCommand(0x88);
+                else
+                    sendCommand(0x80);
+            }
+        }
+        
         public void setupDisplay(bool active, int intensity)
         {
             sendCommand((byte)(0x80 | (active ? 8 : 0) | Math.Min(7, intensity)));
@@ -193,13 +215,18 @@ public void clearDisplay()
             }
         }
 
-        public void setDisplayToString(string str, ushort dots, byte pos)
+        public void setDisplayToString(string str)
+        {
+            setDisplayToString(str, 0, 0);
+        }
+
+        public void setDisplayToString(string str, byte dots, byte pos)
         {
             int stringLength = str.Length;
 
             for (int i = 0; i < _displays - pos; i++)
                 if (i < stringLength)
-                    sendChar((byte)(i + (int)pos), (byte)(font[str[i] - 32]), (dots & (1 << (_displays - i - 1))) != 0);
+                    sendChar((byte)(i + (int)pos), (byte)(charMap[str[i]]), (dots & (1 << (_displays - i - 1))) != 0);
                 else
                     break;
         }

From 2ec7e83e8bc91a8ecdab1526eb87e49a57978f42 Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Tue, 10 Jul 2012 20:18:50 -0600
Subject: [PATCH 05/34] Fixes to support input

---
 RaspberryPiDotNet/GPIOMem.cs | 25 +++++++++++++++++--------
 1 file changed, 17 insertions(+), 8 deletions(-)

diff --git a/RaspberryPiDotNet/GPIOMem.cs b/RaspberryPiDotNet/GPIOMem.cs
index c39d14a..64c711f 100644
--- a/RaspberryPiDotNet/GPIOMem.cs
+++ b/RaspberryPiDotNet/GPIOMem.cs
@@ -90,13 +90,17 @@ private static void ExportPin(GPIOPins pin, DirectionEnum direction)
                 // If the direction matches, return out of the function. If not, change the direction
                 if (_exportedPins[(int)pin] == direction)
                     return;
-                else
-                {
-                    // Set the direction on the pin and update the exported list
-                    bcm2835_gpio_fsel((uint)pin, direction == DirectionEnum.IN ? (uint)0 : (uint)1);
-                    _exportedPins[(int)pin] = direction;
-                    return;
-                }
+
+            // Set the direction on the pin and update the exported list
+            // BCM2835_GPIO_FSEL_INPT = 0
+            // BCM2835_GPIO_FSEL_OUTP = 1
+            bcm2835_gpio_fsel((uint)pin, direction == DirectionEnum.IN ? (uint)0 : (uint)1);
+            if (direction == DirectionEnum.IN)
+                // BCM2835_GPIO_PUD_OFF = 0b00 = 0
+                // BCM2835_GPIO_PUD_DOWN = 0b01 = 1
+                // BCM2835_GPIO_PUD_UP = 0b10 = 2
+                bcm2835_gpio_set_pud((uint)pin, 0);
+            _exportedPins[(int)pin] = direction;
         }
 
         /// <summary>
@@ -125,6 +129,7 @@ public static bool Read(GPIOPins pin)
             ExportPin(pin, DirectionEnum.IN);
 
             uint value = bcm2835_gpio_lev((uint)pin);
+            Console.WriteLine("Value = " + value);
             bool returnValue = value == 0 ? false : true;
             Debug.WriteLine("input from pin " + pin + "/gpio " + (int)pin + ", value was " + returnValue);
 
@@ -169,8 +174,12 @@ public override void Dispose()
         [DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_write")]
         static extern void bcm2835_gpio_write(uint pin, uint value);
 
-        [DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_write")]
+        [DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_lev")]
         static extern uint bcm2835_gpio_lev(uint pin);
+
+        [DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_set_pud")]
+        static extern void bcm2835_gpio_set_pud(uint pin, uint pud);
+
         #endregion
     }
 }

From f346db0630d00cd33762e671b11550679e5b497a Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Tue, 10 Jul 2012 20:28:07 -0600
Subject: [PATCH 06/34] Removing unnecessary debug statement

---
 RaspberryPiDotNet/GPIOMem.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/RaspberryPiDotNet/GPIOMem.cs b/RaspberryPiDotNet/GPIOMem.cs
index 64c711f..fa5be5c 100644
--- a/RaspberryPiDotNet/GPIOMem.cs
+++ b/RaspberryPiDotNet/GPIOMem.cs
@@ -129,7 +129,6 @@ public static bool Read(GPIOPins pin)
             ExportPin(pin, DirectionEnum.IN);
 
             uint value = bcm2835_gpio_lev((uint)pin);
-            Console.WriteLine("Value = " + value);
             bool returnValue = value == 0 ? false : true;
             Debug.WriteLine("input from pin " + pin + "/gpio " + (int)pin + ", value was " + returnValue);
 

From ce0bf4a1cd6ce6cdc49c9dd8278b2edac2f19200 Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Wed, 29 Aug 2012 22:21:41 -0600
Subject: [PATCH 07/34] Adding GPIODebug class

---
 RaspberryPiDotNet/GPIODebug.cs             | 118 +++++++++++++++++++++
 RaspberryPiDotNet/RaspberryPiDotNet.csproj |   1 +
 2 files changed, 119 insertions(+)
 create mode 100644 RaspberryPiDotNet/GPIODebug.cs

diff --git a/RaspberryPiDotNet/GPIODebug.cs b/RaspberryPiDotNet/GPIODebug.cs
new file mode 100644
index 0000000..6ee2327
--- /dev/null
+++ b/RaspberryPiDotNet/GPIODebug.cs
@@ -0,0 +1,118 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace RaspberryPiDotNet
+{
+    /// <summary>
+    /// Raspberry Pi GPIO debug class.
+    /// </summary>
+    public class GPIODebug : GPIO, IDisposable
+    {
+        private bool _currentValue = false;
+
+        #region Constructor
+        /// <summary>
+        /// Access to the specified GPIO setup as an output port with an initial value of false (0)
+        /// </summary>
+        /// <param name="pin">The GPIO pin</param>
+        public GPIODebug(GPIOPins pin)
+            : base(pin,DirectionEnum.OUT,false)
+        {
+        }
+
+        /// <summary>
+        /// Access to the specified GPIO setup with the specified direction with an initial value of false (0)
+        /// </summary>
+        /// <param name="pin">The GPIO pin</param>
+        /// <param name="direction">Direction</param>
+        public GPIODebug(GPIOPins pin, DirectionEnum direction)
+            : base(pin, direction, false)
+        {
+        }
+
+        /// <summary>
+        /// Access to the specified GPIO setup with the specified direction with the specified initial value
+        /// </summary>
+        /// <param name="pin">The GPIO pin</param>
+        /// <param name="direction">Direction</param>
+        /// <param name="initialValue">Initial Value</param>
+        public GPIODebug(GPIOPins pin, DirectionEnum direction, bool initialValue)
+            : base(pin, direction, initialValue)
+        {
+            Write(pin, initialValue);
+        }
+        #endregion
+
+        #region Static Methods
+        /// <summary>
+        /// Export the GPIO setting the direction. This creates the /sys/class/gpio/gpioXX directory.
+        /// </summary>
+        /// <param name="pin">The GPIO pin</param>
+        /// <param name="direction"></param>
+        private static void ExportPin(GPIOPins pin, DirectionEnum direction)
+        {
+        }
+
+        /// <summary>
+        /// Unexport the GPIO. This removes the /sys/class/gpio/gpioXX directory.
+        /// </summary>
+        /// <param name="pin">The pin to unexport</param>
+        private static void UnexportPin(GPIOPins pin)
+        {
+        }
+
+        /// <summary>
+        /// Static method to write a value to the specified pin. Does nothing when using the GPIODebug class.
+        /// </summary>
+        /// <param name="pin">The GPIO pin</param>
+        /// <param name="value">The value to write to the pin</param>
+        public static void Write(GPIOPins pin, bool value)
+        {
+        }
+
+        /// <summary>
+        /// Static method to read a value to the specified pin. Always returns false when using the GPIODebug class.
+        /// </summary>
+        /// <param name="pin">The GPIO pin</param>
+        /// <returns>The value read from the pin</returns>
+        public static bool Read(GPIOPins pin)
+        {
+            return false;
+        }
+
+        public static void CleanUp()
+        {
+        }
+        #endregion
+
+        #region Class Methods
+        /// <summary>
+        /// Write a value to the pin
+        /// </summary>
+        /// <param name="value">The value to write to the pin</param>
+        public override void Write(bool value)
+        {
+            _currentValue = value;
+        }
+
+        /// <summary>
+        /// Read a value from the pin
+        /// </summary>
+        /// <returns>The value read from the pin</returns>
+        public override bool Read()
+        {
+            return _currentValue;
+        }
+
+        /// <summary>
+        /// Dispose of the GPIO pin
+        /// </summary>
+        public override void Dispose()
+        {
+            UnexportPin(_pin);
+        }
+        #endregion
+    }
+}
diff --git a/RaspberryPiDotNet/RaspberryPiDotNet.csproj b/RaspberryPiDotNet/RaspberryPiDotNet.csproj
index e9890be..85ed9bb 100644
--- a/RaspberryPiDotNet/RaspberryPiDotNet.csproj
+++ b/RaspberryPiDotNet/RaspberryPiDotNet.csproj
@@ -44,6 +44,7 @@
   <ItemGroup>
     <Compile Include="DS1620.cs" />
     <Compile Include="GPIO.cs" />
+    <Compile Include="GPIODebug.cs" />
     <Compile Include="GPIOFile.cs" />
     <Compile Include="GPIOMem.cs" />
     <Compile Include="MicroLiquidCrystal\RaspPiGPIOFileLcdTransferProvider.cs" />

From bb82288c2b9233b53d4bd9c11d9520b53f524d8f Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Wed, 29 Aug 2012 22:39:29 -0600
Subject: [PATCH 08/34] Added additional instructions for GPIOMem class

---
 RaspberryPiDotNet/GPIOMem.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/RaspberryPiDotNet/GPIOMem.cs b/RaspberryPiDotNet/GPIOMem.cs
index fa5be5c..cec75ca 100644
--- a/RaspberryPiDotNet/GPIOMem.cs
+++ b/RaspberryPiDotNet/GPIOMem.cs
@@ -18,6 +18,7 @@ namespace RaspberryPiDotNet
     ///    cd bcm2835-1.3/src
     ///    make libbcm2835.a
     ///    cc -shared bcm2835.o -o libbcm2835.so
+    /// Place the shared object in the same directory as the executable and other assemblies.
     /// </summary>
     public class GPIOMem : GPIO, IDisposable
     {

From 38d5257c376d6c4f2216ee0b5754c4f58bfb7285 Mon Sep 17 00:00:00 2001
From: Stonie <andrew@stonie.net>
Date: Sun, 2 Sep 2012 13:28:03 +1000
Subject: [PATCH 09/34] fix for upstream #1

---
 RaspberryPiDotNet/TM16XX/TM1638.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/RaspberryPiDotNet/TM16XX/TM1638.cs b/RaspberryPiDotNet/TM16XX/TM1638.cs
index aa983a3..ccc7329 100644
--- a/RaspberryPiDotNet/TM16XX/TM1638.cs
+++ b/RaspberryPiDotNet/TM16XX/TM1638.cs
@@ -109,7 +109,7 @@ public byte getButtons()
 
         public override void sendChar(byte pos, byte data, bool dot)
         {
-            sendData((byte)(pos << 1), (byte)(data | (dot ? Convert.ToByte("10000000", 2) : 0)));
+            sendData((byte)(pos << 1), (byte)(data | (dot ? Convert.ToByte("10000000", 2) : Convert.ToByte("00000000", 2))));
         }
     }
 }

From 83df3830097d1accc7236d6f777ff7ea3c187f6f Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Sun, 2 Sep 2012 10:47:34 -0600
Subject: [PATCH 10/34] Updating the readme

---
 README.md | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 67 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index ffa276a..c1deb27 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,67 @@
-RaspberryPi.Net
-===============
-
-Raspberry PI .NET library
\ No newline at end of file
+RaspberryPi.Net
+===============
+
+Introduction
+------------
+The purpose of this library is to provide a Mono.NET interface to the GPIO pins
+on the Raspberry Pi. All of this code is written using Visual Studio 2010
+Express but the goal is to be fully compatible with Mono.
+
+The GPIO pins are best described
+[here](http://elinux.org/Rpi_Low-level_peripherals#General_Purpose_Input.2FOutput_.28GPIO.29).
+They can be accessed in 2 ways, either using the file-based I/O (GPIOFile.cs)
+or direct memory (GPIOMem.cs) using Mike McCauley''s BCM2835 library which is
+available [here](http://www.open.com.au/mikem/bcm2835/index.html). There is
+also a GPIODebug.cs class that can be used to test your application without a
+Raspberry Pi.
+
+Here is a sample bit of code to blink an LED attached to pin 12
+```C#
+GPIOMem led = new GPIOMem(GPIO.GPIOPins.Pin12);
+while(true)
+{
+    led.Write(true);
+    System.Threading.Thread.Sleep(500);
+    led.Write(false);
+    System.Threading.Thread.Sleep(500);
+}
+```
+
+Using GPIOMem
+-------------
+The GPIOMem class uses the .NET Interop layer to expose C functions from Mike
+McCauley''s BCM2835 library. This requires the use of a separate shared object
+(.so) but this library is considerably faster than the GPIOFile method.
+
+The Makefile for his library compiles a shared object where a statically linked
+library is required. To compile a statically linked binary, do the following:
+
+```bash
+# tar -zxf bcm2835-1.3.tar.gz
+# cd bcm2835-1.3/src
+# make libbcm2835.a
+# cc -shared bcm2835.o -o libbcm2835.so
+```
+
+Liquid Crystal Display
+----------------------
+This class is a port of the MicroLiquidCrystal NetDuino library from
+[here](http://microliquidcrystal.codeplex.com). It provides an interface to
+address HD44780 compatible displays. 
+
+Example code:
+```C#
+RaspPiGPIOMemLcdTransferProvider lcdProvider = new RaspPiGPIOMemLcdTransferProvider(
+    GPIOFile.GPIOPins.Pin21,
+    GPIOFile.GPIOPins.Pin23,
+    GPIOFile.GPIOPins.Pin11,
+    GPIOFile.GPIOPins.Pin13,
+    GPIOFile.GPIOPins.Pin15,
+    GPIOFile.GPIOPins.Pin19);
+
+Lcd lcd = new Lcd(lcdProvider);
+lcd.Begin(16, 2);
+lcd.Clear();
+lcd.SetCursorPosition(0, 0);
+lcd.Write("Hello World!");
+```

From c6ea76270e7b07a5b6b8098358ccff5b07d6068c Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Sun, 2 Sep 2012 10:55:33 -0600
Subject: [PATCH 11/34] Updates to readme.

---
 README.md | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index c1deb27..0b977bd 100644
--- a/README.md
+++ b/README.md
@@ -5,12 +5,15 @@ Introduction
 ------------
 The purpose of this library is to provide a Mono.NET interface to the GPIO pins
 on the Raspberry Pi. All of this code is written using Visual Studio 2010
-Express but the goal is to be fully compatible with Mono.
+Express but the goal is to be fully compatible with Mono. This library is
+written using .NET 4.0 therefore the latest version of Mono (2.10) is
+recommended. At the time of this update, the Raspbian wheezy 2012-07-15 image
+has Mono 2.10.8.1.
 
 The GPIO pins are best described
 [here](http://elinux.org/Rpi_Low-level_peripherals#General_Purpose_Input.2FOutput_.28GPIO.29).
 They can be accessed in 2 ways, either using the file-based I/O (GPIOFile.cs)
-or direct memory (GPIOMem.cs) using Mike McCauley''s BCM2835 library which is
+or direct memory (GPIOMem.cs) using Mike McCauley's BCM2835 library which is
 available [here](http://www.open.com.au/mikem/bcm2835/index.html). There is
 also a GPIODebug.cs class that can be used to test your application without a
 Raspberry Pi.

From b90e95a42deeb6c3f3dee2811f718b69bf7e02ad Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Mon, 3 Sep 2012 16:04:58 -0600
Subject: [PATCH 12/34] Updates to readme

---
 README.md | 38 ++++++++++++++++++++++++++++++--------
 1 file changed, 30 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 0b977bd..b031cae 100644
--- a/README.md
+++ b/README.md
@@ -4,11 +4,11 @@ RaspberryPi.Net
 Introduction
 ------------
 The purpose of this library is to provide a Mono.NET interface to the GPIO pins
-on the Raspberry Pi. All of this code is written using Visual Studio 2010
+on the Raspberry Pi. All of this code was written using Visual Studio 2010
 Express but the goal is to be fully compatible with Mono. This library is
 written using .NET 4.0 therefore the latest version of Mono (2.10) is
 recommended. At the time of this update, the Raspbian wheezy 2012-07-15 image
-has Mono 2.10.8.1.
+installs Mono 2.10.8.1.
 
 The GPIO pins are best described
 [here](http://elinux.org/Rpi_Low-level_peripherals#General_Purpose_Input.2FOutput_.28GPIO.29).
@@ -20,16 +20,38 @@ Raspberry Pi.
 
 Here is a sample bit of code to blink an LED attached to pin 12
 ```C#
-GPIOMem led = new GPIOMem(GPIO.GPIOPins.Pin12);
-while(true)
+using System;
+using RaspberryPiDotNet;
+
+namespace Test
 {
-    led.Write(true);
-    System.Threading.Thread.Sleep(500);
-    led.Write(false);
-    System.Threading.Thread.Sleep(500);
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            GPIOMem led = new GPIOMem(GPIO.GPIOPins.Pin12);
+            while(true)
+            {
+                led.Write(true);
+                System.Threading.Thread.Sleep(500);
+                led.Write(false);
+                System.Threading.Thread.Sleep(500);
+            }
+        }
+    }
 }
 ```
 
+Installing Mono
+---------------
+To install Mono on your Raspberry Pi, run the following:
+```bash
+$ sudo aptitude update 
+$ sudo aptitude install mono-runtime
+```
+
+My preference is for aptitude, however, apt-get can also be used.
+
 Using GPIOMem
 -------------
 The GPIOMem class uses the .NET Interop layer to expose C functions from Mike

From aa8689bd54852843e47343c095199114c47b3db1 Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Wed, 26 Sep 2012 18:24:38 -0600
Subject: [PATCH 13/34] Adding the suo file to the ignore list

---
 .gitignore | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/.gitignore b/.gitignore
index 9ac0ec3..0c70bf8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,8 @@
-# Build Folders (you can keep bin if you'd like, to store dlls and pdbs)
-bin
-obj
-
-# mstest test results
-TestResults
\ No newline at end of file
+# Build Folders (you can keep bin if you'd like, to store dlls and pdbs)
+bin
+obj
+
+# mstest test results
+TestResults
+
+RaspberryPiDotNet.suo
\ No newline at end of file

From 1039862c85494e660efafc0ea3e48fc487c4c85e Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Wed, 26 Sep 2012 18:24:57 -0600
Subject: [PATCH 14/34] Adding LED to available pins.

---
 RaspberryPiDotNet/GPIO.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/RaspberryPiDotNet/GPIO.cs b/RaspberryPiDotNet/GPIO.cs
index e06ec31..094fef8 100644
--- a/RaspberryPiDotNet/GPIO.cs
+++ b/RaspberryPiDotNet/GPIO.cs
@@ -70,7 +70,8 @@ public enum GPIOPins
             Pin22 = 25,
             Pin23 = 11,
             Pin24 = 8,
-            Pin26 = 7
+            Pin26 = 7,
+            LED = 16
         };
 
         /// <summary>

From 3c6f0a3ee2eca81e9e487e5b311854b8a24336c2 Mon Sep 17 00:00:00 2001
From: Gilberto Garcia <ferraripr@gmail.com>
Date: Sun, 28 Oct 2012 18:07:57 -0400
Subject: [PATCH 15/34] Adding MCP3008 class.

This class uses analog to digital capabilities for the Raspberry Pi.
---
 RaspberryPiDotNet/MCP3008.cs | 109 +++++++++++++++++++++++++++++++++++
 1 file changed, 109 insertions(+)
 create mode 100644 RaspberryPiDotNet/MCP3008.cs

diff --git a/RaspberryPiDotNet/MCP3008.cs b/RaspberryPiDotNet/MCP3008.cs
new file mode 100644
index 0000000..d121ab4
--- /dev/null
+++ b/RaspberryPiDotNet/MCP3008.cs
@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+// Original author: Mikey Sklar - https://gist.github.com/3151375
+// Adafruit article: http://learn.adafruit.com/reading-a-analog-in-and-controlling-audio-volume-with-the-raspberry-pi
+// Ported from python and modified by: Gilberto Garcia <ferraripr@gmail.com>; twitter: @ferraripr
+namespace RaspberryPiDotNet
+{
+    /// <summary>
+    /// Raspberry Pi using MCP3008 A/D Converters with SPI Serial Interface
+    /// <seealso cref="http://ww1.microchip.com/downloads/en/DeviceDoc/21295d.pdf"/>
+    /// </summary>
+    public class MCP3008
+    {
+        private int adcnum;
+        private GPIOMem clockpin;
+        private GPIOMem mosipin;
+        private GPIOMem misopin;
+        private GPIOMem cspin;
+
+        /// <summary>
+        /// Connect MCP3008 with clock, Serial Peripheral Interface(SPI) and channel
+        /// </summary>
+        /// <param name="adc_channel">MCP3008 channel number 0-7 (pin 1-8 on chip).</param>
+        /// <param name="SPICLK">Clock pin</param>
+        /// <param name="SPIMOSI">SPI Master Output, Slave Input (MOSI)</param>
+        /// <param name="SPIMISO">SPI Master Input, Slave Output (MISO)</param>
+        /// <param name="SPICS">SPI Chip Select</param>
+        public MCP3008(int adc_channel, GPIOMem SPICLK, GPIOMem SPIMOSI, GPIOMem SPIMISO, GPIOMem SPICS)
+        {
+            adcnum = adc_channel;
+            clockpin = SPICLK;
+            mosipin = SPIMOSI;
+            misopin = SPIMISO;
+            cspin = SPICS;
+            //
+            if (adc_channel >= 0 && adc_channel <= 7)
+            {
+                //This is the range we are looking for, from CH0 to CH7. 
+            }
+            else
+            {
+                throw new IndexOutOfRangeException("MCP3008 Channel Input is out of range, Channel input should be from 0-7 (8-Channel).");
+            }
+        }
+
+        /// <summary>
+        /// Analog to digital conversion
+        /// </summary>
+        public int AnalogToDigital
+        {
+            get
+            {
+                return readadc();
+            }
+        }
+
+        private int readadc()
+        {
+            if ((adcnum > 7) || adcnum < 0)
+            {
+                return -1;
+            }
+            cspin.Write(true);
+
+            clockpin.Write(false); // #start clock low
+            cspin.Write(false); // #bring CS low
+
+            int commandout = adcnum;
+            commandout |= 0x18; //# start bit + single-ended bit
+            commandout <<= 3;  //# we only need to send 5 bits here
+
+            for (int i = 0; i < 5; i++)
+            {
+                if ((commandout & 0x80) == 128)
+                {
+                    mosipin.Write(true);
+                }
+                else
+                {
+                    mosipin.Write(false);
+                }
+                commandout <<= 1;
+                clockpin.Write(true);
+                clockpin.Write(false);
+            }
+
+            int adcout = 0;
+            //# read in one empty bit, one null bit and 10 ADC bits
+            for (int i = 0; i < 12; i++)
+            {
+                clockpin.Write(true);
+                clockpin.Write(false);
+                adcout <<= 1;
+                if (misopin.Read())
+                {
+                    adcout |= 0x1;
+                }
+            }
+
+            cspin.Write(true);
+            adcout /= 2;//# first bit is 'null' so drop it
+            return adcout;
+        }
+
+    }
+}

From a00297a335f6c39bfec8b257174ab8a7cfd4bfc1 Mon Sep 17 00:00:00 2001
From: Gilberto Garcia <ferraripr@gmail.com>
Date: Sun, 28 Oct 2012 19:37:56 -0400
Subject: [PATCH 16/34] MCP3008 example code

---
 README.md | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)

diff --git a/README.md b/README.md
index b031cae..7bed88f 100644
--- a/README.md
+++ b/README.md
@@ -90,3 +90,63 @@ lcd.Clear();
 lcd.SetCursorPosition(0, 0);
 lcd.Write("Hello World!");
 ```
+
+Using MCP3008
+-------------
+This class is a port of a Python Script by Mikey Sklar
+[here](https://raw.github.com/gist/3249416/7689f68f3ddbb74aceecda23e395c729668bd520/adafruit-cosm-temp.py).
+It provides analog to digital conversion to the Raspberry Pi.
+
+The following example shows how to connect an analog temperature sensor to the Pi.
+
+Example code:
+```C#
+using System;
+using System.Collections.Generic;
+using System.Text;
+using RaspberryPiDotNet;
+using System.Threading;
+
+namespace RPi_Temperature
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            //# set up the SPI interface pins
+            //# SPI port on the ADC to the Cobbler
+            GPIOMem SPICLK = new GPIOMem(GPIO.GPIOPins.GPIO18, GPIO.DirectionEnum.OUT);
+            GPIOMem SPIMISO = new GPIOMem(GPIO.GPIOPins.GPIO23, GPIO.DirectionEnum.IN);
+            GPIOMem SPIMOSI = new GPIOMem(GPIO.GPIOPins.GPIO24, GPIO.DirectionEnum.OUT);
+            GPIOMem SPICS = new GPIOMem(GPIO.GPIOPins.GPIO25, GPIO.DirectionEnum.OUT);
+
+            // temperature sensor connected to channel 0 of mcp3008
+            int adcnum = 0;
+            double read_adc0 = 0.0;
+
+            while (true)
+            {
+                MCP3008 MCP3008 = new MCP3008(adcnum, SPICLK, SPIMOSI, SPIMISO, SPICS);
+                // read the analog pin (temperature sensor LM35)
+                read_adc0 = MCP3008.AnalogToDigital;
+                double millivolts = Convert.ToDouble(read_adc0) * (3300.0 / 1024);
+
+                double volts = (Convert.ToDouble(read_adc0) / 1024.0f) * 3.3f;
+                double temp_C = ((millivolts - 100.0) / 10.0) - 40.0;
+                double temp_F = (temp_C * 9.0 / 5.0) + 32;
+
+#if DEBUG
+                System.Console.WriteLine("MCP3008_Channel: " + adcnum);
+                System.Console.WriteLine("read_adc0: " + read_adc0);
+                System.Console.WriteLine("millivolts: " + (float)millivolts);
+                System.Console.WriteLine("tempC: " + (float)temp_C);
+                System.Console.WriteLine("tempF: " + (float)temp_F);
+                System.Console.WriteLine("volts: " + (float)volts);
+				System.Console.WriteLine("\n");				
+#endif
+                Thread.Sleep(3000);
+            }
+        }
+    }
+}
+```
\ No newline at end of file

From 1a5c941a0161f66d08806dbe03a3b722a359bccc Mon Sep 17 00:00:00 2001
From: Gilberto Garcia <ferraripr@gmail.com>
Date: Wed, 31 Oct 2012 19:54:41 -0400
Subject: [PATCH 17/34] Adding DateTime.Now equivalent

DateTime.Now in Raspberry Pi does not work properly on Raspbian
distribution.  This modification shows DateTime.Now equivalent.
---
 README.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7bed88f..bba065d 100644
--- a/README.md
+++ b/README.md
@@ -142,7 +142,11 @@ namespace RPi_Temperature
                 System.Console.WriteLine("tempC: " + (float)temp_C);
                 System.Console.WriteLine("tempF: " + (float)temp_F);
                 System.Console.WriteLine("volts: " + (float)volts);
-				System.Console.WriteLine("\n");				
+		//The following line makes the trick on Raspberry Pi for displaying DateTime.Now
+		//equivalent.
+		Console.WriteLine("Date time stamp: {0}/{1}/{2} {3}:{4}:{5}",now.Month,now.Day,now.Year,
+		                  now.Hour,now.Minute,now.Second);
+		System.Console.WriteLine("\n");
 #endif
                 Thread.Sleep(3000);
             }

From 2d63bc8ad597078c4a24c081fa4adbc2ec1be9f6 Mon Sep 17 00:00:00 2001
From: Gilberto Garcia <ferraripr@gmail.com>
Date: Sat, 3 Nov 2012 09:17:37 -0400
Subject: [PATCH 18/34] Comment update

Minor update that points to the correct link of original source.
---
 RaspberryPiDotNet/MCP3008.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/RaspberryPiDotNet/MCP3008.cs b/RaspberryPiDotNet/MCP3008.cs
index d121ab4..45d7e59 100644
--- a/RaspberryPiDotNet/MCP3008.cs
+++ b/RaspberryPiDotNet/MCP3008.cs
@@ -1,9 +1,9 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
-// Original author: Mikey Sklar - https://gist.github.com/3151375
+// Original author: Mikey Sklar - git://gist.github.com/3249416.git
 // Adafruit article: http://learn.adafruit.com/reading-a-analog-in-and-controlling-audio-volume-with-the-raspberry-pi
 // Ported from python and modified by: Gilberto Garcia <ferraripr@gmail.com>; twitter: @ferraripr
 namespace RaspberryPiDotNet

From f7bf45928959727fac37715435c927818ce11369 Mon Sep 17 00:00:00 2001
From: Gilberto Garcia <ferraripr@gmail.com>
Date: Sun, 11 Nov 2012 21:56:00 -0500
Subject: [PATCH 19/34] Modified MCP3008 class, now using abstract GPIO class.

---
 RaspberryPiDotNet.sln.docstates.suo        | Bin 0 -> 1030 bytes
 RaspberryPiDotNet.suo                      | Bin 24576 -> 26624 bytes
 RaspberryPiDotNet/MCP3008.cs               |  10 +++++-----
 RaspberryPiDotNet/RaspberryPiDotNet.csproj |   1 +
 4 files changed, 6 insertions(+), 5 deletions(-)
 create mode 100644 RaspberryPiDotNet.sln.docstates.suo

diff --git a/RaspberryPiDotNet.sln.docstates.suo b/RaspberryPiDotNet.sln.docstates.suo
new file mode 100644
index 0000000000000000000000000000000000000000..f067a31f6cb722fca16f47132521497ca25162b2
GIT binary patch
literal 1030
zcmeHD%TB{E5OjLvU$$}_+p#Nzh~xB#5L|O{9)J;zgX0`flW*o1NKq>x`T^y@u69Se
zdzjg|LhmbtR><oOUUH9*0SElmPPciwesphRu&%qA9?Z~Jt@j`IR=aT5hH2Vkszjy)
zfsCaD=(gB`WO)IM5JD+cTyZ*2pV5(Xn+vK%hC#7Z0OdRZsdNTfQqJO}AOgqpIZ=5=
zy{?DeyVt4Sl;hC)p)}3Tc6JEf1n0}f)#I-1!cacj@G@4VKWXpnx@*JFxpCpJS)NfO
z#R8`}XpwWEvQQujRV+<t#uu?^wx~0VnnolPB#9+ZV>nbyNZ>d%Pb99BmhcFnXsPe8
Tw-<0cLiz%%$B+Nv?>g`W<kGGz

literal 0
HcmV?d00001

diff --git a/RaspberryPiDotNet.suo b/RaspberryPiDotNet.suo
index f0a8510bdd15df27e7da67c5e4b81564e7baa650..8ee3d78dca9fc072ddb1668961a7d47c65288155 100644
GIT binary patch
delta 3383
zcmb_feN0?c7Qc7;X8MMqbjmm7qXSe5h{FH_oziMyW)O-f1q!I8$}o&{EDZSO&8~DC
z7}VYR(N@dZ?3ztBaW^*En68SmChjI8?d~6bMiQeY{-M#o{71Vc-Dn$y{hi0KR%_#C
z^d`S|&pr3vbMLw5+;h*1FUk0_eEyh8aS0(PZmKD+1#tu51nPj5)z#JdWWBP`vs2D1
zU2;2>D%&>Mb2G)v(pz!^y5lshyrFIZRSwXpn<{C^s?h!BF0~Adigji@L!qzCl`a;`
zu%ROz*aTz%n*rvtr1de`plQFwG0Th+G`0Z_pcG)~yySM^I)GQ=ah0g6lJxbcYmzkU
z#r>=>>&Ln^0Cxh7Kof8`u)cV6lHP+oT(CT%FrSWXJeEI;jySOS-7ll_+NAHyt-pHz
z%*|zW)T6o*EozIDlIE;FsnLBq^2$fWgb0fW5EZ)6L;&AO)I-9LIw)ddf>y15tIUN+
z2f#;Ywt&c{>9kwuUv`&yBU&?bDXr5g_!PLwqokE$w%e={8(USAywWrfUWpG%2<z%t
zcSy8jeO+{5wGld9TtG8-r162HXhK;ds6BlbxfGRPsl=P<O_I)U^3r%lB^cR2ezMM{
zr3|lS$|QsdyJ(Bb3-nxPuzGYN90^BtEuc?oL!*<y*hDCzM~BA3`r+8fkQRtejf6C9
zdMfOs1#d1b`b+2SKJpdbNO8N*D%h3S4Gg{P^dEb-%0^``F<6-t+tRHTpqZa!(Zwy@
zYr3<_Jjjv-;uj`5n%SvZL9%->pDt#0(?9KXvY297-74$L4#ZvQJ3u@DaG{U<XJNY&
zZO1XQ$zAVha5cJ{b|#i`kD6w^uve?-6WeXyv|fMmT*tx(&%B*=W^i+tSpLTsw?AC=
z_qMam?*^az^8R8L)g`poI$Nury!V#By#Lf(@5)QhFjru{=br5IE9XnPp8n(Lv%fF7
zu<QSvuO<ZuYR%tk?r{k5JK9^6lXngGqCXYn*~Sc`A2y7>rKmtU$yU_BR|qZ<633uU
zL`=iyd}6=o7rVIwhcH`oE1f8Cw+MD3cCDl{35AI-WZ!gD4^23IljGx|pdOx#M4j!S
zNJt9@o&K=F2x!y8^#|v-`c<Bu!$R2#`qsFm8jYs~UEaEn4MKY1iSmO<fql9bj*Qhf
zCZfSfZ9F_u;}{5OQOLj1O)slezMVS*jlssIx?K(Kkjt~{P|f<pD|gZnh#uAhBjcfK
z%IWyNoI~t-8<T6PzR8KHfELnJmedzM8iHr4^FO5Y3&pyWH&CqP9kTDKN$A^@4W`jT
zI$HL+%2%uCe`=Q>Q208pd1AT4+EFM(ySL95<oHl{4Fhs~ppP9{wySThla{V?S-S^M
zUmkq%EqVASNNKj*J;PF7sF;%SK&pcB{BY|!#Ls%+!s`))ceQ)F_8m-7UWe^l8T~2B
za8lf<QgyXm&ZR72vA>!AJy>sMU3ycN5_e|GSjw{(`zxrqsxu`g;kk?5>BjyITU;|%
z+);f}4yL?EoOF&K@ni&XX6$FMzkhRs@LVBh;HT`2J|D<1PT+x*r7ZSG=#%QAlx$E@
z=}!Eu_LPOZgENU4&+8@y&!!Ox68i3C#fXpmXsyM^mi=lb8uoR@MKJh%GA9|OXF*&B
zxZIAsVjO`xfD3m7-!Yh=oAPW`bW?MhVq{JTy5{FGRHaL;$J^F}bh2){FBTXN>(lE2
zZ@BK@dO-b=NIZL01m)yISXnhLhK@fNGJlpWIB8L>%)M$4yt0jCc5Y(sw!LcG9Gd*D
zKL|Vo{2KTTa2$9T;B4+u)Q<rtlI>Hd9|xWQPBZUx&yk$Jf_N5qjv1I_V4-KXOe_s}
zOjb^=dU5=JrgM&*lzb%a%-H_ndykqgeX~+g8oTh>Z}V$i>=XQUURh|l$0I*Yc^M7|
zf7shg!!@}y<JpsVs&{x}!rQbcspQZIeO+%)Xm>7eAiH;p9NyvYz@^wr*OJviIN7-2
zcAU~i&>9s3$TC9WmsD!op>Q(KzFfNiBAHjhM>S-+_hL{GIp_hjVn!~!4+8Ena^VTu
zmQ_qGneGNYT}(B~pqN5Ghn6Uo7&DgB@Qc!hblrobr5*_kYW$HD$Z9&LG+1ge?}&*m
zw^T|u*br%3yJP%M!27a20^(Iex=6I%^@@a^-uc!t*=P)3vboJC(VKx|K<3@L2i^WF
G>;D4f^t|E#

delta 3300
zcmd6qe{54#6vyA~Uc1+BY~3i>!C>9kWE<;fN9iUG(zTTzV_8QqBY_&&+D?nzTH051
zxUq^L!Vt!ezlABN6O|vv`nPEU|A-+WF)_sW2Z{QhKmI`@M48{)zBZsJTY`p5KD+mv
z``+!j=bdxzC2^T0Qtaa)m3VV%YKju71}z_$1wm+}wvO=8ZQqQG9ZW-&V#TaTx3}T=
zW0zPSW(67)zmOJUVBo^xRkf7TiuAO)LsCOglvO&4MEXr#Ytcf%SLPIAJWF|~7`<MZ
zD^>cmDP0=V$O0(%PgDRCs03ADGpGhN;6bn$)Pg!t50-!ikp01>7+Zi9jDTf;&n-u9
z2YVEm>sBb^R_y9$%>i*MWE#pJGV;j;gvRfmd?Ms&cb;<ov2WC=ucHl;CFzhHj7psj
z?gTbQY{>((t-X3&=c4nXRjt8m5)JCsixOW=-`b$g$KV)U*R^Zed<?luxf7X=;su@j
zrGf&eoD6?3bHcNUx(n->NF~lS1fM1k71|k<JDm^=w_v0(Z7n5=oSI+Z<$Qt88Di`z
zwHEs-d!pe1uRrXI_Xh^#n0IF|7Vim}VshLc44axPR?E2FrDfbM?&9<pmGvGvud}ie
z`bF=N_-89qrr2zXmv|%{L}T{pYbAJEv}$-j{9Z`AO4}v4Y>MwAz1p=>k5=Guz`uQZ
zvx_J`+at|}$Ui+-ZRe4v0=#)6(eU<w55`7&Vv*iJG&&dw`or=-K)!?K@klV-=!*>v
zJ=11)HQQ`$EoRFjwl=eEwaad9X|cDNEp}T|%QDMyo4wgK{4ICN$X%T>a~t{t{nIu>
zv<;7`Xk~Hly*8vj=!=F!!5#6S-xnQ>$vvU8$09-QrM_S&5c2uuXwN{bFA#;7cUpt~
zKy=z>+lG&%t(LOxOFHK4QX&3V7i=&I!l!~ySRr_6v}`#!7A&la2vH#{Y!?F1%R)@>
zLheBy5qhDE;@|i@x5Sfs4#-5_yo9C^!bwIq=B*=_ekCR5Ckh7fPEhb;HJN@iF3bP=
zwqMeaqpX8WPTMC7WX75(zVJ&?R8~yN6=I%hvW#|BU6f2vmMaq^FM3qu5toV4MJDY*
z1o;~0Mpslx;|c1jtfH@~i?kEL>!FrSm)KLc%}mx9i`~}6h5NcMF{f*z3+0T?&8<lO
zP_vdXIrr!)t4+Pe*|Bb~qPakyEon!Un4q8PC0bRdXB(9n9ck89lfm3alNMv{iN?;N
z^!rEoQ^{@Zg)A+`a?71<(6b&z;)|B%3egoZ)i))h*25Y~HLW1aRztFLbA-{J&fUq~
zEf-Z{iL(Es{P1N_nhOb=P`-qtOXNkGS1r2c=%NdvMSU8I8>mI==|W#Ch064#cSc73
zv9io8iT*WqkzIcY-CX1@o?haA_g^JGPpj#skcbL&lN<6-Hic&FJo>!2dE9UsXY(1u
z{ycXkBmdVra))oRWoBgrVRTzF3Jj^p&xlMjr1)XN&jk1VQ75<LqHTJ?rtBlvWj2@-
zG2pq?1l;$<fz)UlzSTHB&X~;WXtwc70I$^U`y!Q=B9*e1W&4cH{6xvL`V_zF@wjrQ
zFGKe_O=fua5ctt{Yx{dx@S7FC6r~%n%CeEWpQ4%5@majW@2bzC-wXDE=fQsP0yqE;
zf>Ce?ya*11BVY_11>=CgOW<Yjih!f~RSaGOuY)(ho8TBY4ko}`;B9aMoCNQHcfosL
z61)#ife*lk;3L2dJ%j!%IG6bk#}#$<d^gwh<FxmsZx11ib_ntG>CZKTxIf6aMTBtA
hD3R)tDVIY^rn((@RBG={n!H!@$kJS%Ecc&ee*!rj(ANL}

diff --git a/RaspberryPiDotNet/MCP3008.cs b/RaspberryPiDotNet/MCP3008.cs
index 45d7e59..14c259f 100644
--- a/RaspberryPiDotNet/MCP3008.cs
+++ b/RaspberryPiDotNet/MCP3008.cs
@@ -15,10 +15,10 @@ namespace RaspberryPiDotNet
     public class MCP3008
     {
         private int adcnum;
-        private GPIOMem clockpin;
-        private GPIOMem mosipin;
-        private GPIOMem misopin;
-        private GPIOMem cspin;
+        private GPIO clockpin;
+        private GPIO mosipin;
+        private GPIO misopin;
+        private GPIO cspin;
 
         /// <summary>
         /// Connect MCP3008 with clock, Serial Peripheral Interface(SPI) and channel
@@ -28,7 +28,7 @@ public class MCP3008
         /// <param name="SPIMOSI">SPI Master Output, Slave Input (MOSI)</param>
         /// <param name="SPIMISO">SPI Master Input, Slave Output (MISO)</param>
         /// <param name="SPICS">SPI Chip Select</param>
-        public MCP3008(int adc_channel, GPIOMem SPICLK, GPIOMem SPIMOSI, GPIOMem SPIMISO, GPIOMem SPICS)
+        public MCP3008(int adc_channel, GPIO SPICLK, GPIO SPIMOSI, GPIO SPIMISO, GPIO SPICS)
         {
             adcnum = adc_channel;
             clockpin = SPICLK;
diff --git a/RaspberryPiDotNet/RaspberryPiDotNet.csproj b/RaspberryPiDotNet/RaspberryPiDotNet.csproj
index 85ed9bb..5cac6df 100644
--- a/RaspberryPiDotNet/RaspberryPiDotNet.csproj
+++ b/RaspberryPiDotNet/RaspberryPiDotNet.csproj
@@ -47,6 +47,7 @@
     <Compile Include="GPIODebug.cs" />
     <Compile Include="GPIOFile.cs" />
     <Compile Include="GPIOMem.cs" />
+    <Compile Include="MCP3008.cs" />
     <Compile Include="MicroLiquidCrystal\RaspPiGPIOFileLcdTransferProvider.cs" />
     <Compile Include="MicroLiquidCrystal\RaspPiGPIOMemLcdTransferProvider.cs" />
     <Compile Include="MicroLiquidCrystal\ILcdTransferProvider.cs" />

From 11285685cc027a96061462295b3fc83a3922f7c7 Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Sun, 6 Jan 2013 13:24:05 -0700
Subject: [PATCH 20/34] Add updated pins for revision 2 boards

I'm not a fan of this commit but it will serve it's purpose for now. I
would prefer a better way to do this.
---
 RaspberryPiDotNet/GPIO.cs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/RaspberryPiDotNet/GPIO.cs b/RaspberryPiDotNet/GPIO.cs
index 094fef8..8548eea 100644
--- a/RaspberryPiDotNet/GPIO.cs
+++ b/RaspberryPiDotNet/GPIO.cs
@@ -38,6 +38,8 @@ public enum GPIOPins
         {
             GPIO_NONE = -1,
             GPIO00 = 0,
+            GPIO02_REV2 = 2,
+            GPIO03_REV2 = 3,
             GPIO01 = 1,
             GPIO04 = 4,
             GPIO07 = 7,
@@ -54,14 +56,18 @@ public enum GPIOPins
             GPIO23 = 23,
             GPIO24 = 24,
             GPIO25 = 25,
+            GPIO27_REV2 = 27,
             Pin03 = 0,
+            Pin03_REV2 = 2,
             Pin05 = 1,
+            Pin05_REV2 = 3,
             Pin07 = 4,
             Pin08 = 14,
             Pin10 = 15,
             Pin11 = 17,
             Pin12 = 18,
             Pin13 = 21,
+            Pin13_REV2 = 27,
             Pin15 = 22,
             Pin16 = 23,
             Pin18 = 24,

From 227169e656225c39a167f9bec8f4ef13000e24ff Mon Sep 17 00:00:00 2001
From: Captain-Coder <Captain_Coder@sharklasers.com>
Date: Tue, 8 Jan 2013 16:16:58 +0100
Subject: [PATCH 21/34] Enhanced preformance and general OO/c#-ish-ness of the
 project

---
 RaspberryPiDotNet/DS1620.cs                   |   5 +-
 RaspberryPiDotNet/GPIO.cs                     | 281 +++++++++++-------
 RaspberryPiDotNet/GPIODebug.cs                |  64 +---
 RaspberryPiDotNet/GPIODirection.cs            |  11 +
 RaspberryPiDotNet/GPIOFile.cs                 | 158 +++-------
 RaspberryPiDotNet/GPIOMem.cs                  | 160 ++++------
 RaspberryPiDotNet/GPIOPins.cs                 |  71 +++++
 RaspberryPiDotNet/MCP3008.cs                  |   3 -
 .../ILcdTransferProvider.cs                   |   7 +-
 RaspberryPiDotNet/MicroLiquidCrystal/Lcd.cs   |   2 -
 .../RaspPiGPIOFileLcdTransferProvider.cs      |  31 +-
 .../RaspPiGPIOMemLcdTransferProvider.cs       |  31 +-
 RaspberryPiDotNet/RaspberryPiDotNet.csproj    |  11 +-
 RaspberryPiDotNet/TM16XX/TM1638.cs            |   3 -
 RaspberryPiDotNet/TM16XX/TM16XX.cs            |   4 +-
 15 files changed, 396 insertions(+), 446 deletions(-)
 create mode 100644 RaspberryPiDotNet/GPIODirection.cs
 create mode 100644 RaspberryPiDotNet/GPIOPins.cs

diff --git a/RaspberryPiDotNet/DS1620.cs b/RaspberryPiDotNet/DS1620.cs
index 05e6c83..078353c 100644
--- a/RaspberryPiDotNet/DS1620.cs
+++ b/RaspberryPiDotNet/DS1620.cs
@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System;
 using System.Threading;
 
 // Derived based on work done by AdamS at http://forums.netduino.com/index.php?/topic/3335-netduino-plus-and-ds1620-anyone/page__view__findpost__p__22972
diff --git a/RaspberryPiDotNet/GPIO.cs b/RaspberryPiDotNet/GPIO.cs
index 8548eea..64b0f75 100644
--- a/RaspberryPiDotNet/GPIO.cs
+++ b/RaspberryPiDotNet/GPIO.cs
@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 // Author: Aaron Anderson <aanderson@netopia.ca>
 namespace RaspberryPiDotNet
@@ -11,108 +9,64 @@ namespace RaspberryPiDotNet
     /// </summary>
     public abstract class GPIO : IDisposable
     {
-        /// <remarks>
-        /// Refer to http://elinux.org/Rpi_Low-level_peripherals for diagram.
-        /// P1-01 = bottom left, P1-02 = top left
-        /// pi connector P1 pin    = GPIOnum
-        ///                  P1-03 = GPIO0
-        ///                  P1-05 = GPIO1
-        ///                  P1-07 = GPIO4
-        ///                  P1-08 = GPIO14 - alt function (UART0_TXD) on boot-up
-        ///                  P1-10 = GPIO15 - alt function (UART0_TXD) on boot-up
-        ///                  P1-11 = GPIO17
-        ///                  P1-12 = GPIO18
-        ///                  P1-13 = GPIO21
-        ///                  P1-15 = GPIO22
-        ///                  P1-16 = GPIO23
-        ///                  P1-18 = GPIO24
-        ///                  P1-19 = GPIO10
-        ///                  P1-21 = GPIO9
-        ///                  P1-22 = GPIO25
-        ///                  P1-23 = GPIO11
-        ///                  P1-24 = GPIO8
-        ///                  P1-26 = GPIO7
-        /// So to turn on Pin7 on the GPIO connector, pass in enumGPIOPIN.gpio4 as the pin parameter
-        /// </remarks>
-        public enum GPIOPins
-        {
-            GPIO_NONE = -1,
-            GPIO00 = 0,
-            GPIO02_REV2 = 2,
-            GPIO03_REV2 = 3,
-            GPIO01 = 1,
-            GPIO04 = 4,
-            GPIO07 = 7,
-            GPIO08 = 8,
-            GPIO09 = 9,
-            GPIO10 = 10,
-            GPIO11 = 11,
-            GPIO14 = 14,
-            GPIO15 = 15,
-            GPIO17 = 17,
-            GPIO18 = 18,
-            GPIO21 = 21,
-            GPIO22 = 22,
-            GPIO23 = 23,
-            GPIO24 = 24,
-            GPIO25 = 25,
-            GPIO27_REV2 = 27,
-            Pin03 = 0,
-            Pin03_REV2 = 2,
-            Pin05 = 1,
-            Pin05_REV2 = 3,
-            Pin07 = 4,
-            Pin08 = 14,
-            Pin10 = 15,
-            Pin11 = 17,
-            Pin12 = 18,
-            Pin13 = 21,
-            Pin13_REV2 = 27,
-            Pin15 = 22,
-            Pin16 = 23,
-            Pin18 = 24,
-            Pin19 = 10,
-            Pin21 = 9,
-            Pin22 = 25,
-            Pin23 = 11,
-            Pin24 = 8,
-            Pin26 = 7,
-            LED = 16
-        };
-
         /// <summary>
-        /// Specifies the direction of the GPIO port
+        /// Dictionary that stores created (exported) pins that where not disposed.
         /// </summary>
-        public enum DirectionEnum { IN, OUT };
+        private static Dictionary<GPIOPins, GPIO> _exportedPins = new Dictionary<GPIOPins, GPIO>();
 
         /// <summary>
-        /// Dictionary that stores whether a pin is setup or not
+        /// The currently assigned GPIO pin. Used for class methods.
         /// </summary>
-        protected static Dictionary<int, DirectionEnum> _exportedPins = new Dictionary<int, DirectionEnum>();
+        protected readonly GPIOPins _pin;
 
-        /// <summary>
-        /// The currently assigned GPIO pin. Used for class methods and not static methods.
-        /// </summary>
-        protected GPIOPins _pin;
+		/// <summary>
+		/// Variable to track the disposed state
+		/// </summary>
+		private bool _disposed = false;
+		private GPIODirection _direction;
 
-        /// <summary>
-        /// Access to the specified GPIO setup as an output port with an initial value of false (0)
-        /// </summary>
-        /// <param name="pin">The GPIO pin</param>
-        public GPIO(GPIOPins pin)
-            : this(pin,DirectionEnum.OUT,false)
-        {
-        }
+		/// <summary>
+		/// Gets the pin that this GPIO instance represents
+		/// </summary>
+		public GPIOPins Pin
+		{
+			get
+			{
+				if (_disposed)
+					throw new ObjectDisposedException(string.Empty);
+				return _pin;
+			}
+		}
+		
+		/// <summary>
+		/// Gets or sets the communication direction for this pin
+		/// </summary>
+		public virtual GPIODirection PinDirection
+		{
+			get
+			{
+				if (_disposed)
+					throw new ObjectDisposedException(string.Empty);
+				return _direction;
+			}
+			set
+			{
+				if (_disposed)
+					throw new ObjectDisposedException(string.Empty);
+				_direction = value;
+			}
+		}
 
-        /// <summary>
-        /// Access to the specified GPIO setup with the specified direction with an initial value of false (0)
-        /// </summary>
-        /// <param name="pin">The GPIO pin</param>
-        /// <param name="direction">Direction</param>
-        public GPIO(GPIOPins pin, DirectionEnum direction)
-            : this(pin, direction, false)
-        {
-        }
+		/// <summary>
+		/// Gets the disposal state of this GPIO instance
+		/// </summary>
+		public bool IsDisposed
+		{
+			get
+			{
+				return _disposed;
+			}
+		}
 
         /// <summary>
         /// Access to the specified GPIO setup with the specified direction with the specified initial value
@@ -120,31 +74,152 @@ public GPIO(GPIOPins pin, DirectionEnum direction)
         /// <param name="pin">The GPIO pin</param>
         /// <param name="direction">Direction</param>
         /// <param name="initialValue">Initial Value</param>
-        public GPIO(GPIOPins pin, DirectionEnum direction, bool initialValue)
+        protected GPIO(GPIOPins pin, GPIODirection direction, bool initialValue)
         {
-            this._pin = pin;
+			lock (_exportedPins)
+			{
+				if (_exportedPins.ContainsKey(pin))
+					throw new Exception("Cannot use pin with multiple instances. Unexport the previous instance with Dispose() first! (pin " + (uint)pin + ")");
+				_exportedPins[pin] = this;
+
+				_pin = pin;
+				try
+				{
+					PinDirection = direction;
+					Write(initialValue);
+				}
+				catch
+				{
+					Dispose();
+					throw;
+				}
+			}
         }
 
-        protected static string GetGPIONumber(GPIOPins pin)
+		/// <summary>
+		/// Finalizer to make sure we cleanup after ourselves.
+		/// </summary>
+        ~GPIO()
         {
-            return ((int)pin).ToString(); //e.g. returns 17 for enum value of gpio17
+			if (!_disposed)
+				Dispose();
         }
 
+		/// <summary>
+		/// Sets a pin to output the give value.
+		/// 
+		/// Creates (exports) the pin if needed, and sets it to Out direction.
+		/// </summary>
+		/// <param name="pin">The pin who's value to set</param>
+		/// <param name="value">The value to set</param>
+		public static void Write(GPIOPins pin, bool value)
+		{
+			CreatePin(pin, GPIODirection.Out).Write(value);
+		}
+
+		/// <summary>
+		/// Gets the value of a given pin.
+		/// 
+		/// Creates (exports) the pin if needed, and sets it to In direction.
+		/// </summary>
+		/// <param name="pin">The pin who's value to get</param>
+		/// <returns>The value of the pin</returns>
+		public static bool Read(GPIOPins pin)
+		{
+			return CreatePin(pin, GPIODirection.In).Read();
+		}
+
+		/// <summary>
+		/// Creates a pin if it has not already been created (exported), creates a GPIOMem if possible, otherwise falls back to GPIOFile.
+		/// </summary>
+		/// <param name="pin">The pin to create or export</param>
+		/// <param name="dir">The direction the pin is to have</param>
+		/// <returns>The GPIO instance representing the pin</returns>
+		public static GPIO CreatePin(GPIOPins pin, GPIODirection dir)
+		{
+			lock (_exportedPins)
+				if (_exportedPins.ContainsKey(pin))
+				{
+					if (_exportedPins[pin].PinDirection != dir)
+						_exportedPins[pin].PinDirection = dir;
+					return _exportedPins[pin];
+				}
+
+			try
+			{
+				return new GPIOMem(pin, dir);
+			}
+#if DEBUG
+			catch (Exception e)
+			{
+				System.Diagnostics.Debug.WriteLine("Unable to create pin " + (uint)pin + " as GPIOMem because: " + e.ToString());
+			}
+#else
+			catch //stuff like lib load problems, wrong exports, etc...
+			{
+			}
+#endif
+			try
+			{
+				return new GPIOFile(pin, dir);
+			}
+#if DEBUG
+			catch (Exception e)
+			{
+				System.Diagnostics.Debug.WriteLine("Unable to create pin " + (uint)pin + " as GPIOFile because: " + e.ToString());
+			}
+#else
+			catch //stuff like GPIO Sys FS does not exist or is not responding, open by another process, etc...
+			{
+			}
+#endif
+
+#if DEBUG
+			System.Diagnostics.Debug.WriteLine("Using debug GPIO pin for pin number " + (uint)pin);
+			return new GPIODebug(pin, dir);
+#else
+			throw new Exception("Cannot access GPIO pin " + (uint)pin + ". Make sure libbcm2835.so is accessible, or that GPIO SYSFS is working and not in use by another process");
+#endif
+		}
+
         /// <summary>
         /// Write a value to the pin
         /// </summary>
         /// <param name="value">The value to write to the pin</param>
-        public abstract void Write(bool value);
+		public virtual void Write(bool value)
+		{
+			if (IsDisposed)
+				throw new ObjectDisposedException(string.Empty);
+			if (_direction != GPIODirection.Out)
+				PinDirection = GPIODirection.Out;
+		}
 
         /// <summary>
         /// Read a value from the pin
         /// </summary>
         /// <returns>The value read from the pin</returns>
-        public abstract bool Read();
+		public virtual bool Read()
+		{
+			if (IsDisposed)
+				throw new ObjectDisposedException(string.Empty);
+			if (_direction != GPIODirection.In)
+				PinDirection = GPIODirection.In;
+			return false;
+		}
 
         /// <summary>
         /// Dispose of the GPIO pin
         /// </summary>
-        public abstract void Dispose();
+		public virtual void Dispose()
+		{
+			if (_disposed)
+				throw new ObjectDisposedException(string.Empty);
+
+			_disposed = true;
+			lock (_exportedPins)
+			{
+				_exportedPins.Remove(_pin);
+			}
+		}
     }
 }
diff --git a/RaspberryPiDotNet/GPIODebug.cs b/RaspberryPiDotNet/GPIODebug.cs
index 6ee2327..ac0f414 100644
--- a/RaspberryPiDotNet/GPIODebug.cs
+++ b/RaspberryPiDotNet/GPIODebug.cs
@@ -1,14 +1,11 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 namespace RaspberryPiDotNet
 {
     /// <summary>
     /// Raspberry Pi GPIO debug class.
     /// </summary>
-    public class GPIODebug : GPIO, IDisposable
+    public class GPIODebug : GPIO
     {
         private bool _currentValue = false;
 
@@ -18,7 +15,7 @@ public class GPIODebug : GPIO, IDisposable
         /// </summary>
         /// <param name="pin">The GPIO pin</param>
         public GPIODebug(GPIOPins pin)
-            : base(pin,DirectionEnum.OUT,false)
+            : this(pin,GPIODirection.Out,false)
         {
         }
 
@@ -27,8 +24,8 @@ public GPIODebug(GPIOPins pin)
         /// </summary>
         /// <param name="pin">The GPIO pin</param>
         /// <param name="direction">Direction</param>
-        public GPIODebug(GPIOPins pin, DirectionEnum direction)
-            : base(pin, direction, false)
+        public GPIODebug(GPIOPins pin, GPIODirection direction)
+            : this(pin, direction, false)
         {
         }
 
@@ -38,51 +35,8 @@ public GPIODebug(GPIOPins pin, DirectionEnum direction)
         /// <param name="pin">The GPIO pin</param>
         /// <param name="direction">Direction</param>
         /// <param name="initialValue">Initial Value</param>
-        public GPIODebug(GPIOPins pin, DirectionEnum direction, bool initialValue)
+        public GPIODebug(GPIOPins pin, GPIODirection direction, bool initialValue)
             : base(pin, direction, initialValue)
-        {
-            Write(pin, initialValue);
-        }
-        #endregion
-
-        #region Static Methods
-        /// <summary>
-        /// Export the GPIO setting the direction. This creates the /sys/class/gpio/gpioXX directory.
-        /// </summary>
-        /// <param name="pin">The GPIO pin</param>
-        /// <param name="direction"></param>
-        private static void ExportPin(GPIOPins pin, DirectionEnum direction)
-        {
-        }
-
-        /// <summary>
-        /// Unexport the GPIO. This removes the /sys/class/gpio/gpioXX directory.
-        /// </summary>
-        /// <param name="pin">The pin to unexport</param>
-        private static void UnexportPin(GPIOPins pin)
-        {
-        }
-
-        /// <summary>
-        /// Static method to write a value to the specified pin. Does nothing when using the GPIODebug class.
-        /// </summary>
-        /// <param name="pin">The GPIO pin</param>
-        /// <param name="value">The value to write to the pin</param>
-        public static void Write(GPIOPins pin, bool value)
-        {
-        }
-
-        /// <summary>
-        /// Static method to read a value to the specified pin. Always returns false when using the GPIODebug class.
-        /// </summary>
-        /// <param name="pin">The GPIO pin</param>
-        /// <returns>The value read from the pin</returns>
-        public static bool Read(GPIOPins pin)
-        {
-            return false;
-        }
-
-        public static void CleanUp()
         {
         }
         #endregion
@@ -94,7 +48,9 @@ public static void CleanUp()
         /// <param name="value">The value to write to the pin</param>
         public override void Write(bool value)
         {
-            _currentValue = value;
+			System.Diagnostics.Debug.WriteLine("GPIO pin " + _pin + " set to " + value);
+			base.Write(value);
+			_currentValue = value;
         }
 
         /// <summary>
@@ -103,6 +59,8 @@ public override void Write(bool value)
         /// <returns>The value read from the pin</returns>
         public override bool Read()
         {
+			System.Diagnostics.Debug.WriteLine("GPIO pin " + _pin + " reads as " + _currentValue);
+			base.Read();
             return _currentValue;
         }
 
@@ -111,7 +69,7 @@ public override bool Read()
         /// </summary>
         public override void Dispose()
         {
-            UnexportPin(_pin);
+			base.Dispose();
         }
         #endregion
     }
diff --git a/RaspberryPiDotNet/GPIODirection.cs b/RaspberryPiDotNet/GPIODirection.cs
new file mode 100644
index 0000000..1333a17
--- /dev/null
+++ b/RaspberryPiDotNet/GPIODirection.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace RaspberryPiDotNet
+{
+    /// <summary>
+    /// Specifies the direction of the GPIO port
+    /// </summary>
+    public enum GPIODirection { In, Out };
+}
diff --git a/RaspberryPiDotNet/GPIOFile.cs b/RaspberryPiDotNet/GPIOFile.cs
index 0f1665c..637b3ce 100644
--- a/RaspberryPiDotNet/GPIOFile.cs
+++ b/RaspberryPiDotNet/GPIOFile.cs
@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Diagnostics;
 using System.IO;
 
@@ -12,7 +9,7 @@ namespace RaspberryPiDotNet
     /// <summary>
     /// Raspberry Pi GPIO using the file-based access method.
     /// </summary>
-    public class GPIOFile : GPIO, IDisposable
+    public class GPIOFile : GPIO
     {
         /// <summary>
         /// The path on the Raspberry Pi for the GPIO interface
@@ -25,7 +22,7 @@ public class GPIOFile : GPIO, IDisposable
         /// </summary>
         /// <param name="pin">The GPIO pin</param>
         public GPIOFile(GPIOPins pin)
-            : base(pin,DirectionEnum.OUT,false)
+            : this(pin,GPIODirection.Out,false)
         {
         }
 
@@ -34,10 +31,9 @@ public GPIOFile(GPIOPins pin)
         /// </summary>
         /// <param name="pin">The GPIO pin</param>
         /// <param name="direction">Direction</param>
-        public GPIOFile(GPIOPins pin, DirectionEnum direction)
-            : base(pin, direction, false)
+        public GPIOFile(GPIOPins pin, GPIODirection direction)
+            : this(pin, direction, false)
         {
-            ExportPin(pin, direction);
         }
 
         /// <summary>
@@ -46,120 +42,38 @@ public GPIOFile(GPIOPins pin, DirectionEnum direction)
         /// <param name="pin">The GPIO pin</param>
         /// <param name="direction">Direction</param>
         /// <param name="initialValue">Initial Value</param>
-        public GPIOFile(GPIOPins pin, DirectionEnum direction, bool initialValue)
+        public GPIOFile(GPIOPins pin, GPIODirection direction, bool initialValue)
             : base(pin, direction, initialValue)
         {
-            ExportPin(pin, direction);
-            Write(pin, initialValue);
         }
 
-        ~GPIOFile()
-        {
-            UnexportPin(_pin);
-        }
         #endregion
 
-        #region Static Methods
-        /// <summary>
-        /// Export the GPIO setting the direction. This creates the /sys/class/gpio/gpioXX directory.
-        /// </summary>
-        /// <param name="pin">The GPIO pin</param>
-        /// <param name="direction"></param>
-        private static void ExportPin(GPIOPins pin, DirectionEnum direction)
-        {
-            // If the pin is already exported, check it's in the proper direction
-            if (_exportedPins.Keys.Contains((int)pin))
-                // If the direction matches, return out of the function. If not, change the direction
-                if (_exportedPins[(int)pin] == direction)
-                    return;
-                else
-                {
-                    // Set the direction on the pin and update the exported list
-                    File.WriteAllText(GPIO_PATH + "gpio" + GetGPIONumber(pin) + "/direction", direction.ToString().ToLower());
-                    _exportedPins[(int)pin] = direction;
-                    return;
-                }
-
-            if (!Directory.Exists(GPIO_PATH + "gpio" + GetGPIONumber(pin)))
-            {
-                Debug.WriteLine("Exporting " + GetGPIONumber(pin));
-                //export
-                File.WriteAllText(GPIO_PATH + "export", GetGPIONumber(pin));
-            }
-
-            // set i/o direction
-            Debug.WriteLine("Setting direction on pin " + pin + "/gpio " + (int)pin + " as " + direction);
-            File.WriteAllText(GPIO_PATH + "gpio" + GetGPIONumber(pin) + "/direction", direction.ToString().ToLower());
-
-            // Update the list of exported pins
-            _exportedPins[(int)pin] = direction;
-        }
-
-        /// <summary>
-        /// Unexport the GPIO. This removes the /sys/class/gpio/gpioXX directory.
-        /// </summary>
-        /// <param name="pin">The pin to unexport</param>
-        private static void UnexportPin(GPIOPins pin)
-        {
-            Debug.WriteLine("unexporting pin " + pin);
-            File.WriteAllText(GPIO_PATH + "unexport", GetGPIONumber(pin));
-
-            // Remove the pin from the list of exported pins
-            _exportedPins.Remove((int)pin);
-        }
-
-        /// <summary>
-        /// Static method to write a value to the specified pin. When using the static methods ensure you use the CleanUp() method when done.
-        /// </summary>
-        /// <param name="pin">The GPIO pin</param>
-        /// <param name="value">The value to write to the pin</param>
-        public static void Write(GPIOPins pin, bool value)
-        {
-            if (pin == GPIOPins.GPIO_NONE)
-                return;
-
-            ExportPin(pin, DirectionEnum.OUT);
-
-            string writeValue = value ? "1" : "0";
-            File.WriteAllText(GPIO_PATH + "gpio" + GetGPIONumber(pin) + "/value", writeValue);
-            Debug.WriteLine("output to pin " + pin + "/gpio " + (int)pin + ", value was " + value);
-        }
-
-        /// <summary>
-        /// Static method to read a value to the specified pin. When using the static methods ensure you use the CleanUp() method when done.
-        /// </summary>
-        /// <param name="pin">The GPIO pin</param>
-        /// <returns>The value read from the pin</returns>
-        public static bool Read(GPIOPins pin)
-        {
-            bool returnValue = false;
-
-            ExportPin(pin, DirectionEnum.IN);
-
-            string filename = GPIO_PATH + "gpio" + GetGPIONumber(pin) + "/value";
-            if (File.Exists(filename))
-            {
-                string readValue = File.ReadAllText(filename);
-                if (readValue.Length > 0 && readValue[0] == '1')
-                    returnValue = true;
-            }
-            else
-                throw new Exception(string.Format("Cannot read from {0}. File does not exist", pin));
-
-            Debug.WriteLine("input from pin " + pin + "/gpio " + (int)pin + ", value was " + returnValue);
-
-            return returnValue;
-        }
-
-        public static void CleanUp()
-        {
-            // Loop over all exported pins and unexported them
-            foreach (GPIOPins pin in _exportedPins.Keys)
-            {
-                UnexportPin(pin);
-            }
-        }
-        #endregion
+		#region Properties
+
+		/// <summary>
+		/// Gets or sets the communication direction for this pin
+		/// </summary>
+		public override GPIODirection PinDirection
+		{
+			get
+			{
+				return base.PinDirection;
+			}
+			set
+			{
+				if (PinDirection != (base.PinDirection = value)) // Left to right eval ensures base class gets to check for disposed object access
+				{
+					if (!Directory.Exists(GPIO_PATH + "gpio" + (uint)_pin))
+						File.WriteAllText(GPIO_PATH + "export", ((uint)_pin).ToString());
+
+					// set i/o direction
+					File.WriteAllText(GPIO_PATH + "gpio" + (uint)_pin + "/direction", value.ToString().ToLower());
+				}
+			}
+		}
+
+		#endregion
 
         #region Class Methods
         /// <summary>
@@ -168,8 +82,8 @@ public static void CleanUp()
         /// <param name="value">The value to write to the pin</param>
         public override void Write(bool value)
         {
-            // Call the static method
-            Write(_pin, value);
+			base.Write(value);
+			File.WriteAllText(GPIO_PATH + "gpio" + (uint)_pin + "/value", value ? "1" : "0");
         }
 
         /// <summary>
@@ -178,8 +92,9 @@ public override void Write(bool value)
         /// <returns>The value read from the pin</returns>
         public override bool Read()
         {
-            // Call the static method
-            return Read(_pin);
+			base.Read();
+			string readValue = File.ReadAllText(GPIO_PATH + "gpio" + (uint)_pin + "/value");
+			return (readValue.Length > 0 && readValue[0] == '1');
         }
 
         /// <summary>
@@ -187,7 +102,8 @@ public override bool Read()
         /// </summary>
         public override void Dispose()
         {
-            UnexportPin(_pin);
+            base.Dispose();
+			File.WriteAllText(GPIO_PATH + "unexport", ((uint)_pin).ToString());
         }
         #endregion
     }
diff --git a/RaspberryPiDotNet/GPIOMem.cs b/RaspberryPiDotNet/GPIOMem.cs
index cec75ca..19a7783 100644
--- a/RaspberryPiDotNet/GPIOMem.cs
+++ b/RaspberryPiDotNet/GPIOMem.cs
@@ -1,9 +1,6 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Runtime.InteropServices;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 
 namespace RaspberryPiDotNet
 {
@@ -20,17 +17,24 @@ namespace RaspberryPiDotNet
     ///    cc -shared bcm2835.o -o libbcm2835.so
     /// Place the shared object in the same directory as the executable and other assemblies.
     /// </summary>
-    public class GPIOMem : GPIO, IDisposable
+    public class GPIOMem : GPIO
     {
-        private static bool _initialized = false;
-
-        #region Constructor
-        /// <summary>
+		#region Static Constructor
+		static GPIOMem()
+		{
+            // initialize the mapped memory
+			if (!bcm2835_init())
+				throw new Exception("Unable to initialize bcm2835.so library");
+		}
+		#endregion
+
+		#region Constructor
+		/// <summary>
         /// Access to the specified GPIO setup as an output port with an initial value of false (0)
         /// </summary>
         /// <param name="pin">The GPIO pin</param>
         public GPIOMem(GPIOPins pin)
-            : base(pin,DirectionEnum.OUT,false)
+            : this(pin,GPIODirection.Out,false)
         {
         }
 
@@ -39,10 +43,9 @@ public GPIOMem(GPIOPins pin)
         /// </summary>
         /// <param name="pin">The GPIO pin</param>
         /// <param name="direction">Direction</param>
-        public GPIOMem(GPIOPins pin, DirectionEnum direction)
-            : base(pin, direction, false)
+        public GPIOMem(GPIOPins pin, GPIODirection direction)
+            : this(pin, direction, false)
         {
-            ExportPin(pin, direction);
         }
 
         /// <summary>
@@ -51,91 +54,39 @@ public GPIOMem(GPIOPins pin, DirectionEnum direction)
         /// <param name="pin">The GPIO pin</param>
         /// <param name="direction">Direction</param>
         /// <param name="initialValue">Initial Value</param>
-        public GPIOMem(GPIOPins pin, DirectionEnum direction, bool initialValue)
+        public GPIOMem(GPIOPins pin, GPIODirection direction, bool initialValue)
             : base(pin, direction, initialValue)
         {
-            ExportPin(pin, direction);
-            Write(pin, initialValue);
         }
         #endregion
 
-        #region Static Methods
-        /// <summary>
-        /// Initialize the memory access to the GPIO
-        /// </summary>
-        /// <returns></returns>
-        private static bool Initialize()
-        {
-            int ret = 1;
-            if (!_initialized)
-            {
-                // initialize the mapped memory
-                ret = bcm2835_init();
-                _initialized = true;
-            }
-
-            return ret == 0 ? false : true;
-        }
-
-        /// <summary>
-        /// Export the GPIO setting the direction. This creates the /sys/class/gpio/gpioXX directory.
-        /// </summary>
-        /// <param name="pin">The GPIO pin</param>
-        /// <param name="direction"></param>
-        private static void ExportPin(GPIOPins pin, DirectionEnum direction)
-        {
-            Initialize();
-
-            // If the pin is already exported, check it's in the proper direction
-            if (_exportedPins.Keys.Contains((int)pin))
-                // If the direction matches, return out of the function. If not, change the direction
-                if (_exportedPins[(int)pin] == direction)
-                    return;
-
-            // Set the direction on the pin and update the exported list
-            // BCM2835_GPIO_FSEL_INPT = 0
-            // BCM2835_GPIO_FSEL_OUTP = 1
-            bcm2835_gpio_fsel((uint)pin, direction == DirectionEnum.IN ? (uint)0 : (uint)1);
-            if (direction == DirectionEnum.IN)
-                // BCM2835_GPIO_PUD_OFF = 0b00 = 0
-                // BCM2835_GPIO_PUD_DOWN = 0b01 = 1
-                // BCM2835_GPIO_PUD_UP = 0b10 = 2
-                bcm2835_gpio_set_pud((uint)pin, 0);
-            _exportedPins[(int)pin] = direction;
-        }
-
-        /// <summary>
-        /// Static method to write a value to the specified pin.
-        /// </summary>
-        /// <param name="pin">The GPIO pin</param>
-        /// <param name="value">The value to write to the pin</param>
-        public static void Write(GPIOPins pin, bool value)
-        {
-            if (pin == GPIOPins.GPIO_NONE)
-                return;
-
-            ExportPin(pin, DirectionEnum.OUT);
-
-            bcm2835_gpio_write((uint)pin, value ? (uint)1 : (uint)0);
-            Debug.WriteLine("output to pin " + pin + "/gpio " + (int)pin + ", value was " + value);
-        }
-
-        /// <summary>
-        /// Static method to read a value to the specified pin.
-        /// </summary>
-        /// <param name="pin">The GPIO pin</param>
-        /// <returns>The value read from the pin</returns>
-        public static bool Read(GPIOPins pin)
-        {
-            ExportPin(pin, DirectionEnum.IN);
-
-            uint value = bcm2835_gpio_lev((uint)pin);
-            bool returnValue = value == 0 ? false : true;
-            Debug.WriteLine("input from pin " + pin + "/gpio " + (int)pin + ", value was " + returnValue);
-
-            return returnValue;
-        }
-        #endregion
+		#region Properties
+
+		/// <summary>
+		/// Gets or sets the communication direction for this pin
+		/// </summary>
+		public override GPIODirection PinDirection
+		{
+			get
+			{
+				return base.PinDirection;
+			}
+			set
+			{
+				if (PinDirection != (base.PinDirection = value)) // Left to right eval ensures base class gets to check for disposed object access
+				{
+					// Set the direction on the pin
+					bcm2835_gpio_fsel(_pin, value == GPIODirection.Out);
+					if (value == GPIODirection.In)
+						// BCM2835_GPIO_PUD_OFF = 0b00 = 0
+						// BCM2835_GPIO_PUD_DOWN = 0b01 = 1
+						// BCM2835_GPIO_PUD_UP = 0b10 = 2
+						bcm2835_gpio_set_pud(_pin, 0);
+				}
+			}
+		}
+
+		#endregion
 
         #region Class Methods
         /// <summary>
@@ -144,7 +95,8 @@ public static bool Read(GPIOPins pin)
         /// <param name="value">The value to write to the pin</param>
         public override void Write(bool value)
         {
-            Write(_pin, value);
+			base.Write(value);
+            bcm2835_gpio_write(_pin, value);
         }
 
         /// <summary>
@@ -153,32 +105,26 @@ public override void Write(bool value)
         /// <returns>The value read from the pin</returns>
         public override bool Read()
         {
-            return Read(_pin);
-        }
-
-        /// <summary>
-        /// Dispose of the GPIO pin
-        /// </summary>
-        public override void Dispose()
-        {
+			base.Read();
+            return bcm2835_gpio_lev(_pin);
         }
         #endregion
 
         #region Imported functions
         [DllImport("libbcm2835.so", EntryPoint = "bcm2835_init")]
-        static extern int bcm2835_init();
+		static extern bool bcm2835_init();
 
         [DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_fsel")]
-        static extern void bcm2835_gpio_fsel(uint pin, uint mode);
+        static extern void bcm2835_gpio_fsel(GPIOPins pin, bool mode_out); 
 
         [DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_write")]
-        static extern void bcm2835_gpio_write(uint pin, uint value);
+        static extern void bcm2835_gpio_write(GPIOPins pin, bool value);
 
         [DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_lev")]
-        static extern uint bcm2835_gpio_lev(uint pin);
+        static extern bool bcm2835_gpio_lev(GPIOPins pin);
 
         [DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_set_pud")]
-        static extern void bcm2835_gpio_set_pud(uint pin, uint pud);
+        static extern void bcm2835_gpio_set_pud(GPIOPins pin, uint pud);
 
         #endregion
     }
diff --git a/RaspberryPiDotNet/GPIOPins.cs b/RaspberryPiDotNet/GPIOPins.cs
new file mode 100644
index 0000000..5fd8df6
--- /dev/null
+++ b/RaspberryPiDotNet/GPIOPins.cs
@@ -0,0 +1,71 @@
+namespace RaspberryPiDotNet
+{
+    /// <remarks>
+    /// Refer to http://elinux.org/Rpi_Low-level_peripherals for diagram.
+    /// P1-01 = bottom left, P1-02 = top left
+    /// pi connector P1 pin    = GPIOnum
+    ///                  P1-03 = GPIO0
+    ///                  P1-05 = GPIO1
+    ///                  P1-07 = GPIO4
+    ///                  P1-08 = GPIO14 - alt function (UART0_TXD) on boot-up
+    ///                  P1-10 = GPIO15 - alt function (UART0_TXD) on boot-up
+    ///                  P1-11 = GPIO17
+    ///                  P1-12 = GPIO18
+    ///                  P1-13 = GPIO21
+    ///                  P1-15 = GPIO22
+    ///                  P1-16 = GPIO23
+    ///                  P1-18 = GPIO24
+    ///                  P1-19 = GPIO10
+    ///                  P1-21 = GPIO9
+    ///                  P1-22 = GPIO25
+    ///                  P1-23 = GPIO11
+    ///                  P1-24 = GPIO8
+    ///                  P1-26 = GPIO7
+    /// So to turn on Pin7 on the GPIO connector, pass in enumGPIOPIN.gpio4 as the pin parameter
+    /// </remarks>
+	public enum GPIOPins : uint
+	{
+		GPIO_NONE = uint.MaxValue,
+		GPIO00 = 0,
+		GPIO02_REV2 = 2,
+		GPIO03_REV2 = 3,
+		GPIO01 = 1,
+		GPIO04 = 4,
+		GPIO07 = 7,
+		GPIO08 = 8,
+		GPIO09 = 9,
+		GPIO10 = 10,
+		GPIO11 = 11,
+		GPIO14 = 14,
+		GPIO15 = 15,
+		GPIO17 = 17,
+		GPIO18 = 18,
+		GPIO21 = 21,
+		GPIO22 = 22,
+		GPIO23 = 23,
+		GPIO24 = 24,
+		GPIO25 = 25,
+		GPIO27_REV2 = 27,
+		Pin03 = 0,
+		Pin03_REV2 = 2,
+		Pin05 = 1,
+		Pin05_REV2 = 3,
+		Pin07 = 4,
+		Pin08 = 14,
+		Pin10 = 15,
+		Pin11 = 17,
+		Pin12 = 18,
+		Pin13 = 21,
+		Pin13_REV2 = 27,
+		Pin15 = 22,
+		Pin16 = 23,
+		Pin18 = 24,
+		Pin19 = 10,
+		Pin21 = 9,
+		Pin22 = 25,
+		Pin23 = 11,
+		Pin24 = 8,
+		Pin26 = 7,
+		LED = 16,
+	};
+}
diff --git a/RaspberryPiDotNet/MCP3008.cs b/RaspberryPiDotNet/MCP3008.cs
index 14c259f..a350ae2 100644
--- a/RaspberryPiDotNet/MCP3008.cs
+++ b/RaspberryPiDotNet/MCP3008.cs
@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 // Original author: Mikey Sklar - git://gist.github.com/3249416.git
 // Adafruit article: http://learn.adafruit.com/reading-a-analog-in-and-controlling-audio-volume-with-the-raspberry-pi
diff --git a/RaspberryPiDotNet/MicroLiquidCrystal/ILcdTransferProvider.cs b/RaspberryPiDotNet/MicroLiquidCrystal/ILcdTransferProvider.cs
index 86149f9..1c84c71 100644
--- a/RaspberryPiDotNet/MicroLiquidCrystal/ILcdTransferProvider.cs
+++ b/RaspberryPiDotNet/MicroLiquidCrystal/ILcdTransferProvider.cs
@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-// Micro Liquid Crystal Library
+// Micro Liquid Crystal Library
 // http://microliquidcrystal.codeplex.com
 // Appache License Version 2.0
 
diff --git a/RaspberryPiDotNet/MicroLiquidCrystal/Lcd.cs b/RaspberryPiDotNet/MicroLiquidCrystal/Lcd.cs
index d8538db..26cbb8e 100644
--- a/RaspberryPiDotNet/MicroLiquidCrystal/Lcd.cs
+++ b/RaspberryPiDotNet/MicroLiquidCrystal/Lcd.cs
@@ -1,6 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Text;
 using System.Threading;
 
diff --git a/RaspberryPiDotNet/MicroLiquidCrystal/RaspPiGPIOFileLcdTransferProvider.cs b/RaspberryPiDotNet/MicroLiquidCrystal/RaspPiGPIOFileLcdTransferProvider.cs
index 0034e39..0dc89eb 100644
--- a/RaspberryPiDotNet/MicroLiquidCrystal/RaspPiGPIOFileLcdTransferProvider.cs
+++ b/RaspberryPiDotNet/MicroLiquidCrystal/RaspPiGPIOFileLcdTransferProvider.cs
@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 // Code modified from original - GPIOLcdTransferProvider.cs
 // Original code uses license:
@@ -22,19 +19,19 @@ public class RaspPiGPIOFileLcdTransferProvider : IDisposable, ILcdTransferProvid
         private readonly bool _fourBitMode;
         private bool _disposed;
 
-        public RaspPiGPIOFileLcdTransferProvider(GPIOFile.GPIOPins rs, GPIOFile.GPIOPins enable, GPIOFile.GPIOPins d4, GPIOFile.GPIOPins d5, GPIOFile.GPIOPins d6, GPIOFile.GPIOPins d7)
-            : this(true, rs, GPIOFile.GPIOPins.GPIO_NONE, enable, GPIOFile.GPIOPins.GPIO_NONE, GPIOFile.GPIOPins.GPIO_NONE, GPIOFile.GPIOPins.GPIO_NONE, GPIOFile.GPIOPins.GPIO_NONE, d4, d5, d6, d7)
+        public RaspPiGPIOFileLcdTransferProvider(GPIOPins rs, GPIOPins enable, GPIOPins d4, GPIOPins d5, GPIOPins d6, GPIOPins d7)
+            : this(true, rs, GPIOPins.GPIO_NONE, enable, GPIOPins.GPIO_NONE, GPIOPins.GPIO_NONE, GPIOPins.GPIO_NONE, GPIOPins.GPIO_NONE, d4, d5, d6, d7)
         { }
 
-        public RaspPiGPIOFileLcdTransferProvider(GPIOFile.GPIOPins rs, GPIOFile.GPIOPins rw, GPIOFile.GPIOPins enable, GPIOFile.GPIOPins d4, GPIOFile.GPIOPins d5, GPIOFile.GPIOPins d6, GPIOFile.GPIOPins d7)
-            : this(true, rs, rw, enable, GPIOFile.GPIOPins.GPIO_NONE, GPIOFile.GPIOPins.GPIO_NONE, GPIOFile.GPIOPins.GPIO_NONE, GPIOFile.GPIOPins.GPIO_NONE, d4, d5, d6, d7)
+        public RaspPiGPIOFileLcdTransferProvider(GPIOPins rs, GPIOPins rw, GPIOPins enable, GPIOPins d4, GPIOPins d5, GPIOPins d6, GPIOPins d7)
+            : this(true, rs, rw, enable, GPIOPins.GPIO_NONE, GPIOPins.GPIO_NONE, GPIOPins.GPIO_NONE, GPIOPins.GPIO_NONE, d4, d5, d6, d7)
         { }
 
-        public RaspPiGPIOFileLcdTransferProvider(GPIOFile.GPIOPins rs, GPIOFile.GPIOPins enable, GPIOFile.GPIOPins d0, GPIOFile.GPIOPins d1, GPIOFile.GPIOPins d2, GPIOFile.GPIOPins d3, GPIOFile.GPIOPins d4, GPIOFile.GPIOPins d5, GPIOFile.GPIOPins d6, GPIOFile.GPIOPins d7)
-            : this(false, rs, GPIOFile.GPIOPins.GPIO_NONE, enable, d0, d1, d2, d3, d4, d5, d6, d7)
+        public RaspPiGPIOFileLcdTransferProvider(GPIOPins rs, GPIOPins enable, GPIOPins d0, GPIOPins d1, GPIOPins d2, GPIOPins d3, GPIOPins d4, GPIOPins d5, GPIOPins d6, GPIOPins d7)
+            : this(false, rs, GPIOPins.GPIO_NONE, enable, d0, d1, d2, d3, d4, d5, d6, d7)
         { }
 
-        public RaspPiGPIOFileLcdTransferProvider(GPIOFile.GPIOPins rs, GPIOFile.GPIOPins rw, GPIOFile.GPIOPins enable, GPIOFile.GPIOPins d0, GPIOFile.GPIOPins d1, GPIOFile.GPIOPins d2, GPIOFile.GPIOPins d3, GPIOFile.GPIOPins d4, GPIOFile.GPIOPins d5, GPIOFile.GPIOPins d6, GPIOFile.GPIOPins d7)
+        public RaspPiGPIOFileLcdTransferProvider(GPIOPins rs, GPIOPins rw, GPIOPins enable, GPIOPins d0, GPIOPins d1, GPIOPins d2, GPIOPins d3, GPIOPins d4, GPIOPins d5, GPIOPins d6, GPIOPins d7)
             : this(false, rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7)
         { }
 
@@ -53,27 +50,27 @@ public RaspPiGPIOFileLcdTransferProvider(GPIOFile.GPIOPins rs, GPIOFile.GPIOPins
         /// <param name="d5"></param>
         /// <param name="d6"></param>
         /// <param name="d7"></param>
-        public RaspPiGPIOFileLcdTransferProvider(bool fourBitMode, GPIOFile.GPIOPins rs, GPIOFile.GPIOPins rw, GPIOFile.GPIOPins enable, 
-                                                 GPIOFile.GPIOPins d0, GPIOFile.GPIOPins d1, GPIOFile.GPIOPins d2, GPIOFile.GPIOPins d3, 
-                                                 GPIOFile.GPIOPins d4, GPIOFile.GPIOPins d5, GPIOFile.GPIOPins d6, GPIOFile.GPIOPins d7)
+        public RaspPiGPIOFileLcdTransferProvider(bool fourBitMode, GPIOPins rs, GPIOPins rw, GPIOPins enable, 
+                                                 GPIOPins d0, GPIOPins d1, GPIOPins d2, GPIOPins d3, 
+                                                 GPIOPins d4, GPIOPins d5, GPIOPins d6, GPIOPins d7)
         {
             _fourBitMode = fourBitMode;
 
-            if (rs == GPIOFile.GPIOPins.GPIO_NONE) throw new ArgumentException("rs");
+            if (rs == GPIOPins.GPIO_NONE) throw new ArgumentException("rs");
             _rsPort = new GPIOFile(rs);
 
             // we can save 1 pin by not using RW. Indicate by passing GPIO.GPIOPins.GPIO_NONE instead of pin#
-            if (rw != GPIOFile.GPIOPins.GPIO_NONE) // (RW is optional)
+            if (rw != GPIOPins.GPIO_NONE) // (RW is optional)
                 _rwPort = new GPIOFile(rw);
 
-            if (enable == GPIOFile.GPIOPins.GPIO_NONE) throw new ArgumentException("enable");
+            if (enable == GPIOPins.GPIO_NONE) throw new ArgumentException("enable");
             _enablePort = new GPIOFile(enable);
 
             var dataPins = new[] { d0, d1, d2, d3, d4, d5, d6, d7};
             _dataPorts = new GPIOFile[8];
             for (int i = 0; i < 8; i++)
             {
-                if (dataPins[i] != GPIOFile.GPIOPins.GPIO_NONE)
+                if (dataPins[i] != GPIOPins.GPIO_NONE)
                     _dataPorts[i] = new GPIOFile(dataPins[i]);
             }
         }
diff --git a/RaspberryPiDotNet/MicroLiquidCrystal/RaspPiGPIOMemLcdTransferProvider.cs b/RaspberryPiDotNet/MicroLiquidCrystal/RaspPiGPIOMemLcdTransferProvider.cs
index a891361..680202c 100644
--- a/RaspberryPiDotNet/MicroLiquidCrystal/RaspPiGPIOMemLcdTransferProvider.cs
+++ b/RaspberryPiDotNet/MicroLiquidCrystal/RaspPiGPIOMemLcdTransferProvider.cs
@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 // Code modified from original - GPIOLcdTransferProvider.cs
 // Original code uses license:
@@ -22,19 +19,19 @@ public class RaspPiGPIOMemLcdTransferProvider : IDisposable, ILcdTransferProvide
         private readonly bool _fourBitMode;
         private bool _disposed;
 
-        public RaspPiGPIOMemLcdTransferProvider(GPIOMem.GPIOPins rs, GPIOMem.GPIOPins enable, GPIOMem.GPIOPins d4, GPIOMem.GPIOPins d5, GPIOMem.GPIOPins d6, GPIOMem.GPIOPins d7)
-            : this(true, rs, GPIOMem.GPIOPins.GPIO_NONE, enable, GPIOMem.GPIOPins.GPIO_NONE, GPIOMem.GPIOPins.GPIO_NONE, GPIOMem.GPIOPins.GPIO_NONE, GPIOMem.GPIOPins.GPIO_NONE, d4, d5, d6, d7)
+        public RaspPiGPIOMemLcdTransferProvider(GPIOPins rs, GPIOPins enable, GPIOPins d4, GPIOPins d5, GPIOPins d6, GPIOPins d7)
+            : this(true, rs, GPIOPins.GPIO_NONE, enable, GPIOPins.GPIO_NONE, GPIOPins.GPIO_NONE, GPIOPins.GPIO_NONE, GPIOPins.GPIO_NONE, d4, d5, d6, d7)
         { }
 
-        public RaspPiGPIOMemLcdTransferProvider(GPIOMem.GPIOPins rs, GPIOMem.GPIOPins rw, GPIOMem.GPIOPins enable, GPIOMem.GPIOPins d4, GPIOMem.GPIOPins d5, GPIOMem.GPIOPins d6, GPIOMem.GPIOPins d7)
-            : this(true, rs, rw, enable, GPIOMem.GPIOPins.GPIO_NONE, GPIOMem.GPIOPins.GPIO_NONE, GPIOMem.GPIOPins.GPIO_NONE, GPIOMem.GPIOPins.GPIO_NONE, d4, d5, d6, d7)
+        public RaspPiGPIOMemLcdTransferProvider(GPIOPins rs, GPIOPins rw, GPIOPins enable, GPIOPins d4, GPIOPins d5, GPIOPins d6, GPIOPins d7)
+            : this(true, rs, rw, enable, GPIOPins.GPIO_NONE, GPIOPins.GPIO_NONE, GPIOPins.GPIO_NONE, GPIOPins.GPIO_NONE, d4, d5, d6, d7)
         { }
 
-        public RaspPiGPIOMemLcdTransferProvider(GPIOMem.GPIOPins rs, GPIOMem.GPIOPins enable, GPIOMem.GPIOPins d0, GPIOMem.GPIOPins d1, GPIOMem.GPIOPins d2, GPIOMem.GPIOPins d3, GPIOMem.GPIOPins d4, GPIOMem.GPIOPins d5, GPIOMem.GPIOPins d6, GPIOMem.GPIOPins d7)
-            : this(false, rs, GPIOMem.GPIOPins.GPIO_NONE, enable, d0, d1, d2, d3, d4, d5, d6, d7)
+        public RaspPiGPIOMemLcdTransferProvider(GPIOPins rs, GPIOPins enable, GPIOPins d0, GPIOPins d1, GPIOPins d2, GPIOPins d3, GPIOPins d4, GPIOPins d5, GPIOPins d6, GPIOPins d7)
+            : this(false, rs, GPIOPins.GPIO_NONE, enable, d0, d1, d2, d3, d4, d5, d6, d7)
         { }
 
-        public RaspPiGPIOMemLcdTransferProvider(GPIOMem.GPIOPins rs, GPIOMem.GPIOPins rw, GPIOMem.GPIOPins enable, GPIOMem.GPIOPins d0, GPIOMem.GPIOPins d1, GPIOMem.GPIOPins d2, GPIOMem.GPIOPins d3, GPIOMem.GPIOPins d4, GPIOMem.GPIOPins d5, GPIOMem.GPIOPins d6, GPIOMem.GPIOPins d7)
+        public RaspPiGPIOMemLcdTransferProvider(GPIOPins rs, GPIOPins rw, GPIOPins enable, GPIOPins d0, GPIOPins d1, GPIOPins d2, GPIOPins d3, GPIOPins d4, GPIOPins d5, GPIOPins d6, GPIOPins d7)
             : this(false, rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7)
         { }
 
@@ -53,27 +50,27 @@ public RaspPiGPIOMemLcdTransferProvider(GPIOMem.GPIOPins rs, GPIOMem.GPIOPins rw
         /// <param name="d5"></param>
         /// <param name="d6"></param>
         /// <param name="d7"></param>
-        public RaspPiGPIOMemLcdTransferProvider(bool fourBitMode, GPIOMem.GPIOPins rs, GPIOMem.GPIOPins rw, GPIOMem.GPIOPins enable, 
-                                                 GPIOMem.GPIOPins d0, GPIOMem.GPIOPins d1, GPIOMem.GPIOPins d2, GPIOMem.GPIOPins d3, 
-                                                 GPIOMem.GPIOPins d4, GPIOMem.GPIOPins d5, GPIOMem.GPIOPins d6, GPIOMem.GPIOPins d7)
+        public RaspPiGPIOMemLcdTransferProvider(bool fourBitMode, GPIOPins rs, GPIOPins rw, GPIOPins enable, 
+                                                 GPIOPins d0, GPIOPins d1, GPIOPins d2, GPIOPins d3, 
+                                                 GPIOPins d4, GPIOPins d5, GPIOPins d6, GPIOPins d7)
         {
             _fourBitMode = fourBitMode;
 
-            if (rs == GPIOMem.GPIOPins.GPIO_NONE) throw new ArgumentException("rs");
+            if (rs == GPIOPins.GPIO_NONE) throw new ArgumentException("rs");
             _rsPort = new GPIOMem(rs);
 
             // we can save 1 pin by not using RW. Indicate by passing GPIO.GPIOPins.GPIO_NONE instead of pin#
-            if (rw != GPIOMem.GPIOPins.GPIO_NONE) // (RW is optional)
+            if (rw != GPIOPins.GPIO_NONE) // (RW is optional)
                 _rwPort = new GPIOMem(rw);
 
-            if (enable == GPIOMem.GPIOPins.GPIO_NONE) throw new ArgumentException("enable");
+            if (enable == GPIOPins.GPIO_NONE) throw new ArgumentException("enable");
             _enablePort = new GPIOMem(enable);
 
             var dataPins = new[] { d0, d1, d2, d3, d4, d5, d6, d7};
             _dataPorts = new GPIOMem[8];
             for (int i = 0; i < 8; i++)
             {
-                if (dataPins[i] != GPIOMem.GPIOPins.GPIO_NONE)
+                if (dataPins[i] != GPIOPins.GPIO_NONE)
                     _dataPorts[i] = new GPIOMem(dataPins[i]);
             }
         }
diff --git a/RaspberryPiDotNet/RaspberryPiDotNet.csproj b/RaspberryPiDotNet/RaspberryPiDotNet.csproj
index 5cac6df..4d4541a 100644
--- a/RaspberryPiDotNet/RaspberryPiDotNet.csproj
+++ b/RaspberryPiDotNet/RaspberryPiDotNet.csproj
@@ -10,8 +10,9 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>RaspberryPiDotNet</RootNamespace>
     <AssemblyName>RaspberryPiDotNet</AssemblyName>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -34,19 +35,15 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="DS1620.cs" />
     <Compile Include="GPIO.cs" />
     <Compile Include="GPIODebug.cs" />
+    <Compile Include="GPIODirection.cs" />
     <Compile Include="GPIOFile.cs" />
     <Compile Include="GPIOMem.cs" />
+    <Compile Include="GPIOPins.cs" />
     <Compile Include="MCP3008.cs" />
     <Compile Include="MicroLiquidCrystal\RaspPiGPIOFileLcdTransferProvider.cs" />
     <Compile Include="MicroLiquidCrystal\RaspPiGPIOMemLcdTransferProvider.cs" />
diff --git a/RaspberryPiDotNet/TM16XX/TM1638.cs b/RaspberryPiDotNet/TM16XX/TM1638.cs
index ccc7329..048e107 100644
--- a/RaspberryPiDotNet/TM16XX/TM1638.cs
+++ b/RaspberryPiDotNet/TM16XX/TM1638.cs
@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 // This class is the base class for the TM1638/TM1640 board.
 // It is a port of the TM1638 library by Ricardo Batista
diff --git a/RaspberryPiDotNet/TM16XX/TM16XX.cs b/RaspberryPiDotNet/TM16XX/TM16XX.cs
index 06bff40..aec2df1 100644
--- a/RaspberryPiDotNet/TM16XX/TM16XX.cs
+++ b/RaspberryPiDotNet/TM16XX/TM16XX.cs
@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 // This class is the base class for the TM1638/TM1640 board.
 // It is a port of the TM1638 library by Ricardo Batista
@@ -173,7 +171,7 @@ public void setupDisplay(bool active, int intensity)
         public void setDisplayDigit(byte digit, byte pos, bool dot)
         {
             char chr = Char.Parse(digit.ToString());
-            if (charMap.Keys.Contains(chr))
+            if (charMap.ContainsKey(chr))
                 sendChar(pos, charMap[digit.ToString()[0]], dot);
         }
 

From ec682a77b18f701de7faf8da139af169a9d1c8fe Mon Sep 17 00:00:00 2001
From: Arakis <arakis@stne.net>
Date: Tue, 15 Jan 2013 13:11:47 +0100
Subject: [PATCH 22/34] - Added P5-Header pins - Clean up rev. 2 pins (more
 clearly now) - Changed framework to 4.0

---
 RaspberryPiDotNet/GPIOPins.cs              | 186 ++++++++++++++-------
 RaspberryPiDotNet/RaspberryPiDotNet.csproj |   2 +-
 2 files changed, 124 insertions(+), 64 deletions(-)

diff --git a/RaspberryPiDotNet/GPIOPins.cs b/RaspberryPiDotNet/GPIOPins.cs
index 5fd8df6..0efdf74 100644
--- a/RaspberryPiDotNet/GPIOPins.cs
+++ b/RaspberryPiDotNet/GPIOPins.cs
@@ -1,71 +1,131 @@
 namespace RaspberryPiDotNet
 {
-    /// <remarks>
-    /// Refer to http://elinux.org/Rpi_Low-level_peripherals for diagram.
-    /// P1-01 = bottom left, P1-02 = top left
-    /// pi connector P1 pin    = GPIOnum
-    ///                  P1-03 = GPIO0
-    ///                  P1-05 = GPIO1
-    ///                  P1-07 = GPIO4
-    ///                  P1-08 = GPIO14 - alt function (UART0_TXD) on boot-up
-    ///                  P1-10 = GPIO15 - alt function (UART0_TXD) on boot-up
-    ///                  P1-11 = GPIO17
-    ///                  P1-12 = GPIO18
-    ///                  P1-13 = GPIO21
-    ///                  P1-15 = GPIO22
-    ///                  P1-16 = GPIO23
-    ///                  P1-18 = GPIO24
-    ///                  P1-19 = GPIO10
-    ///                  P1-21 = GPIO9
-    ///                  P1-22 = GPIO25
-    ///                  P1-23 = GPIO11
-    ///                  P1-24 = GPIO8
-    ///                  P1-26 = GPIO7
-    /// So to turn on Pin7 on the GPIO connector, pass in enumGPIOPIN.gpio4 as the pin parameter
-    /// </remarks>
+	/// <remarks>
+	/// Refer to http://elinux.org/Rpi_Low-level_peripherals for diagram.
+	/// P1-01 = bottom left, P1-02 = top left
+	/// pi connector P1 pin    = GPIOnum
+	///                  P1-03 = GPIO0
+	///                  P1-05 = GPIO1
+	///                  P1-07 = GPIO4
+	///                  P1-08 = GPIO14 - alt function (UART0_TXD) on boot-up
+	///                  P1-10 = GPIO15 - alt function (UART0_TXD) on boot-up
+	///                  P1-11 = GPIO17
+	///                  P1-12 = GPIO18
+	///                  P1-13 = GPIO21
+	///                  P1-15 = GPIO22
+	///                  P1-16 = GPIO23
+	///                  P1-18 = GPIO24
+	///                  P1-19 = GPIO10
+	///                  P1-21 = GPIO9
+	///                  P1-22 = GPIO25
+	///                  P1-23 = GPIO11
+	///                  P1-24 = GPIO8
+	///                  P1-26 = GPIO7
+	///                  
+	///                  P5-03 = GPI28
+	///                  P5-04 = GPI29
+	///                  P5-05 = GPI30
+	///                  P5-06 = GPI31
+	/// 
+	/// So to turn on Pin7 on the GPIO connector, pass in enumGPIOPIN.gpio4 as the pin parameter
+	/// </remarks>
 	public enum GPIOPins : uint
 	{
+
 		GPIO_NONE = uint.MaxValue,
-		GPIO00 = 0,
-		GPIO02_REV2 = 2,
-		GPIO03_REV2 = 3,
-		GPIO01 = 1,
-		GPIO04 = 4,
-		GPIO07 = 7,
-		GPIO08 = 8,
-		GPIO09 = 9,
-		GPIO10 = 10,
-		GPIO11 = 11,
-		GPIO14 = 14,
-		GPIO15 = 15,
-		GPIO17 = 17,
-		GPIO18 = 18,
-		GPIO21 = 21,
-		GPIO22 = 22,
-		GPIO23 = 23,
-		GPIO24 = 24,
-		GPIO25 = 25,
-		GPIO27_REV2 = 27,
-		Pin03 = 0,
-		Pin03_REV2 = 2,
-		Pin05 = 1,
-		Pin05_REV2 = 3,
-		Pin07 = 4,
-		Pin08 = 14,
-		Pin10 = 15,
-		Pin11 = 17,
-		Pin12 = 18,
-		Pin13 = 21,
-		Pin13_REV2 = 27,
-		Pin15 = 22,
-		Pin16 = 23,
-		Pin18 = 24,
-		Pin19 = 10,
-		Pin21 = 9,
-		Pin22 = 25,
-		Pin23 = 11,
-		Pin24 = 8,
-		Pin26 = 7,
+
+		//Revision 1
+
+		GPIO_00 = 0,
+		GPIO_01 = 1,
+		GPIO_04 = 4,
+		GPIO_07 = 7,
+		GPIO_08 = 8,
+		GPIO_09 = 9,
+		GPIO_10 = 10,
+		GPIO_11 = 11,
+		GPIO_14 = 14,
+		GPIO_15 = 15,
+		GPIO_17 = 17,
+		GPIO_18 = 18,
+		GPIO_21 = 21,
+		GPIO_22 = 22,
+		GPIO_23 = 23,
+		GPIO_24 = 24,
+		GPIO_25 = 25,
+
+		Pin_P1_03 = 0,
+		Pin_P1_05 = 1,
+		Pin_P1_07 = 4,
+		Pin_P1_08 = 14,
+		Pin_P1_10 = 15,
+		Pin_P1_11 = 17,
+		Pin_P1_12 = 18,
+		Pin_P1_13 = 21,
+		Pin_P1_15 = 22,
+		Pin_P1_16 = 23,
+		Pin_P1_18 = 24,
+		Pin_P1_19 = 10,
+		Pin_P1_21 = 9,
+		Pin_P1_22 = 25,
+		Pin_P1_23 = 11,
+		Pin_P1_24 = 8,
+		Pin_P1_26 = 7,
 		LED = 16,
+
+		//Revision 2
+
+		V2_GPIO_00 = 0,
+		V2_GPIO_02 = 2,
+		V2_GPIO_03 = 3,
+		V2_GPIO_01 = 1,
+		V2_GPIO_04 = 4,
+		V2_GPIO_07 = 7,
+		V2_GPIO_08 = 8,
+		V2_GPIO_09 = 9,
+		V2_GPIO_10 = 10,
+		V2_GPIO_11 = 11,
+		V2_GPIO_14 = 14,
+		V2_GPIO_15 = 15,
+		V2_GPIO_17 = 17,
+		V2_GPIO_18 = 18,
+		V2_GPIO_21 = 21,
+		V2_GPIO_22 = 22,
+		V2_GPIO_23 = 23,
+		V2_GPIO_24 = 24,
+		V2_GPIO_25 = 25,
+		V2_GPIO_27 = 27,
+
+		//Revision 2, new plug P5
+		V2_GPIO_28 = 28,
+		V2_GPIO_29 = 29,
+		V2_GPIO_30 = 30,
+		V2_GPIO_31 = 31,
+
+		V2_Pin_P1_03 = 2,
+		V2_Pin_P1_05 = 3,
+		V2_Pin_P1_07 = 4,
+		V2_Pin_P1_08 = 14,
+		V2_Pin_P1_10 = 15,
+		V2_Pin_P1_11 = 17,
+		V2_Pin_P1_12 = 18,
+		V2_Pin_P1_13 = 27,
+		V2_Pin_P1_15 = 22,
+		V2_Pin_P1_16 = 23,
+		V2_Pin_P1_18 = 24,
+		V2_Pin_P1_19 = 10,
+		V2_Pin_P1_21 = 9,
+		V2_Pin_P1_22 = 25,
+		V2_Pin_P1_23 = 11,
+		V2_Pin_P1_24 = 8,
+		V2_Pin_P1_26 = 7,
+		V2_LED = 16,
+
+		//Revision 2, new plug P5
+		V2_Pin_P5_03 = 28,
+		V2_Pin_P5_04 = 29,
+		V2_Pin_P5_05 = 30,
+		V2_Pin_P5_06 = 31,
+
 	};
 }
diff --git a/RaspberryPiDotNet/RaspberryPiDotNet.csproj b/RaspberryPiDotNet/RaspberryPiDotNet.csproj
index 4d4541a..da97838 100644
--- a/RaspberryPiDotNet/RaspberryPiDotNet.csproj
+++ b/RaspberryPiDotNet/RaspberryPiDotNet.csproj
@@ -10,7 +10,7 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>RaspberryPiDotNet</RootNamespace>
     <AssemblyName>RaspberryPiDotNet</AssemblyName>
-    <TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <TargetFrameworkProfile />
   </PropertyGroup>

From 939001828dd2d25c1f69f114283e26e124f43a67 Mon Sep 17 00:00:00 2001
From: Arakis <arakis@stne.net>
Date: Tue, 15 Jan 2013 14:08:59 +0100
Subject: [PATCH 23/34] Added new methods from current bcm2835 driver:
 SetMulti, ClearMulti, WriteMulti

---
 RaspberryPiDotNet/GPIOMem.cs | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/RaspberryPiDotNet/GPIOMem.cs b/RaspberryPiDotNet/GPIOMem.cs
index 19a7783..59588e3 100644
--- a/RaspberryPiDotNet/GPIOMem.cs
+++ b/RaspberryPiDotNet/GPIOMem.cs
@@ -126,6 +126,28 @@ public override bool Read()
         [DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_set_pud")]
         static extern void bcm2835_gpio_set_pud(GPIOPins pin, uint pud);
 
+				[DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_set_multi")]
+				static extern void bcm2835_gpio_set_multi(GPIOPins mask);
+
+				[DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_clr_multi")]
+				static extern void bcm2835_gpio_clr_multi(GPIOPins mask);
+
+				[DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_write_multi")]
+				static extern void bcm2835_gpio_write_multi(GPIOPins mask, bool on);
+
         #endregion
+
+				public static void SetMulti(GPIOPins mask) {
+					bcm2835_gpio_set_multi(mask);
+				}
+
+				public static void ClearMulti(GPIOPins mask) {
+					bcm2835_gpio_clr_multi(mask);
+				}
+
+				public static void WriteMulti(GPIOPins mask, bool value) {
+					bcm2835_gpio_write_multi(mask, value);
+				}
+
     }
 }

From a1ce3b71ec1020e30f3317da25b5378686de7270 Mon Sep 17 00:00:00 2001
From: Arakis <arakis@stne.net>
Date: Tue, 15 Jan 2013 15:36:39 +0100
Subject: [PATCH 24/34] Added GPIOPinMask for better bit operations

---
 RaspberryPiDotNet/GPIO.cs     | 152 ++++++++++++-------------
 RaspberryPiDotNet/GPIOMem.cs  | 201 +++++++++++++++++-----------------
 RaspberryPiDotNet/GPIOPins.cs | 101 +++++++++++++++++
 3 files changed, 272 insertions(+), 182 deletions(-)

diff --git a/RaspberryPiDotNet/GPIO.cs b/RaspberryPiDotNet/GPIO.cs
index 64b0f75..98934bd 100644
--- a/RaspberryPiDotNet/GPIO.cs
+++ b/RaspberryPiDotNet/GPIO.cs
@@ -4,20 +4,20 @@
 // Author: Aaron Anderson <aanderson@netopia.ca>
 namespace RaspberryPiDotNet
 {
-    /// <summary>
-    /// Abstract class for the GPIO connector on the Pi (P1) (as found next to the yellow RCA video socket on the Rpi circuit board)
-    /// </summary>
-    public abstract class GPIO : IDisposable
-    {
-        /// <summary>
-        /// Dictionary that stores created (exported) pins that where not disposed.
-        /// </summary>
-        private static Dictionary<GPIOPins, GPIO> _exportedPins = new Dictionary<GPIOPins, GPIO>();
-
-        /// <summary>
-        /// The currently assigned GPIO pin. Used for class methods.
-        /// </summary>
-        protected readonly GPIOPins _pin;
+	/// <summary>
+	/// Abstract class for the GPIO connector on the Pi (P1) (as found next to the yellow RCA video socket on the Rpi circuit board)
+	/// </summary>
+	public abstract class GPIO : IDisposable
+	{
+		/// <summary>
+		/// Dictionary that stores created (exported) pins that where not disposed.
+		/// </summary>
+		private static Dictionary<GPIOPins, GPIO> _exportedPins = new Dictionary<GPIOPins, GPIO>();
+
+		/// <summary>
+		/// The currently assigned GPIO pin. Used for class methods.
+		/// </summary>
+		protected readonly GPIOPins _pin;
 
 		/// <summary>
 		/// Variable to track the disposed state
@@ -28,29 +28,33 @@ public abstract class GPIO : IDisposable
 		/// <summary>
 		/// Gets the pin that this GPIO instance represents
 		/// </summary>
-		public GPIOPins Pin
-		{
-			get
-			{
+		public GPIOPins Pin {
+			get {
 				if (_disposed)
 					throw new ObjectDisposedException(string.Empty);
 				return _pin;
 			}
 		}
-		
+
+		/// <summary>
+		/// Gets the bit mask of this pin.
+		/// </summary>
+		public GPIOPinMask Mask {
+			get {
+				return (GPIOPinMask)(1 << (ushort)Pin); //Pin-Value has a low range (0-~32), so even casting to byte would be ok.
+			}
+		}
+
 		/// <summary>
 		/// Gets or sets the communication direction for this pin
 		/// </summary>
-		public virtual GPIODirection PinDirection
-		{
-			get
-			{
+		public virtual GPIODirection PinDirection {
+			get {
 				if (_disposed)
 					throw new ObjectDisposedException(string.Empty);
 				return _direction;
 			}
-			set
-			{
+			set {
 				if (_disposed)
 					throw new ObjectDisposedException(string.Empty);
 				_direction = value;
@@ -60,50 +64,44 @@ public virtual GPIODirection PinDirection
 		/// <summary>
 		/// Gets the disposal state of this GPIO instance
 		/// </summary>
-		public bool IsDisposed
-		{
-			get
-			{
+		public bool IsDisposed {
+			get {
 				return _disposed;
 			}
 		}
 
-        /// <summary>
-        /// Access to the specified GPIO setup with the specified direction with the specified initial value
-        /// </summary>
-        /// <param name="pin">The GPIO pin</param>
-        /// <param name="direction">Direction</param>
-        /// <param name="initialValue">Initial Value</param>
-        protected GPIO(GPIOPins pin, GPIODirection direction, bool initialValue)
-        {
-			lock (_exportedPins)
-			{
+		/// <summary>
+		/// Access to the specified GPIO setup with the specified direction with the specified initial value
+		/// </summary>
+		/// <param name="pin">The GPIO pin</param>
+		/// <param name="direction">Direction</param>
+		/// <param name="initialValue">Initial Value</param>
+		protected GPIO(GPIOPins pin, GPIODirection direction, bool initialValue) {
+			if (pin == GPIOPins.GPIO_NONE) throw new ArgumentException("Invalid pin");
+			lock (_exportedPins) {
 				if (_exportedPins.ContainsKey(pin))
 					throw new Exception("Cannot use pin with multiple instances. Unexport the previous instance with Dispose() first! (pin " + (uint)pin + ")");
 				_exportedPins[pin] = this;
 
 				_pin = pin;
-				try
-				{
+				try {
 					PinDirection = direction;
 					Write(initialValue);
 				}
-				catch
-				{
+				catch {
 					Dispose();
 					throw;
 				}
 			}
-        }
+		}
 
 		/// <summary>
 		/// Finalizer to make sure we cleanup after ourselves.
 		/// </summary>
-        ~GPIO()
-        {
+		~GPIO() {
 			if (!_disposed)
 				Dispose();
-        }
+		}
 
 		/// <summary>
 		/// Sets a pin to output the give value.
@@ -112,8 +110,7 @@ protected GPIO(GPIOPins pin, GPIODirection direction, bool initialValue)
 		/// </summary>
 		/// <param name="pin">The pin who's value to set</param>
 		/// <param name="value">The value to set</param>
-		public static void Write(GPIOPins pin, bool value)
-		{
+		public static void Write(GPIOPins pin, bool value) {
 			CreatePin(pin, GPIODirection.Out).Write(value);
 		}
 
@@ -124,8 +121,7 @@ public static void Write(GPIOPins pin, bool value)
 		/// </summary>
 		/// <param name="pin">The pin who's value to get</param>
 		/// <returns>The value of the pin</returns>
-		public static bool Read(GPIOPins pin)
-		{
+		public static bool Read(GPIOPins pin) {
 			return CreatePin(pin, GPIODirection.In).Read();
 		}
 
@@ -135,23 +131,19 @@ public static bool Read(GPIOPins pin)
 		/// <param name="pin">The pin to create or export</param>
 		/// <param name="dir">The direction the pin is to have</param>
 		/// <returns>The GPIO instance representing the pin</returns>
-		public static GPIO CreatePin(GPIOPins pin, GPIODirection dir)
-		{
+		public static GPIO CreatePin(GPIOPins pin, GPIODirection dir) {
 			lock (_exportedPins)
-				if (_exportedPins.ContainsKey(pin))
-				{
+				if (_exportedPins.ContainsKey(pin)) {
 					if (_exportedPins[pin].PinDirection != dir)
 						_exportedPins[pin].PinDirection = dir;
 					return _exportedPins[pin];
 				}
 
-			try
-			{
+			try {
 				return new GPIOMem(pin, dir);
 			}
 #if DEBUG
-			catch (Exception e)
-			{
+			catch (Exception e) {
 				System.Diagnostics.Debug.WriteLine("Unable to create pin " + (uint)pin + " as GPIOMem because: " + e.ToString());
 			}
 #else
@@ -159,13 +151,11 @@ public static GPIO CreatePin(GPIOPins pin, GPIODirection dir)
 			{
 			}
 #endif
-			try
-			{
+			try {
 				return new GPIOFile(pin, dir);
 			}
 #if DEBUG
-			catch (Exception e)
-			{
+			catch (Exception e) {
 				System.Diagnostics.Debug.WriteLine("Unable to create pin " + (uint)pin + " as GPIOFile because: " + e.ToString());
 			}
 #else
@@ -182,24 +172,22 @@ public static GPIO CreatePin(GPIOPins pin, GPIODirection dir)
 #endif
 		}
 
-        /// <summary>
-        /// Write a value to the pin
-        /// </summary>
-        /// <param name="value">The value to write to the pin</param>
-		public virtual void Write(bool value)
-		{
+		/// <summary>
+		/// Write a value to the pin
+		/// </summary>
+		/// <param name="value">The value to write to the pin</param>
+		public virtual void Write(bool value) {
 			if (IsDisposed)
 				throw new ObjectDisposedException(string.Empty);
 			if (_direction != GPIODirection.Out)
 				PinDirection = GPIODirection.Out;
 		}
 
-        /// <summary>
-        /// Read a value from the pin
-        /// </summary>
-        /// <returns>The value read from the pin</returns>
-		public virtual bool Read()
-		{
+		/// <summary>
+		/// Read a value from the pin
+		/// </summary>
+		/// <returns>The value read from the pin</returns>
+		public virtual bool Read() {
 			if (IsDisposed)
 				throw new ObjectDisposedException(string.Empty);
 			if (_direction != GPIODirection.In)
@@ -207,19 +195,17 @@ public virtual bool Read()
 			return false;
 		}
 
-        /// <summary>
-        /// Dispose of the GPIO pin
-        /// </summary>
-		public virtual void Dispose()
-		{
+		/// <summary>
+		/// Dispose of the GPIO pin
+		/// </summary>
+		public virtual void Dispose() {
 			if (_disposed)
 				throw new ObjectDisposedException(string.Empty);
 
 			_disposed = true;
-			lock (_exportedPins)
-			{
+			lock (_exportedPins) {
 				_exportedPins.Remove(_pin);
 			}
 		}
-    }
+	}
 }
diff --git a/RaspberryPiDotNet/GPIOMem.cs b/RaspberryPiDotNet/GPIOMem.cs
index 59588e3..c2b0487 100644
--- a/RaspberryPiDotNet/GPIOMem.cs
+++ b/RaspberryPiDotNet/GPIOMem.cs
@@ -4,25 +4,24 @@
 
 namespace RaspberryPiDotNet
 {
-    /// <summary>
-    /// Raspberry Pi GPIO using the direct memory access method.
-    /// This requires the bcm2835 GPIO library provided by 
-    /// Mike McCauley (mikem@open.com.au) at http://www.open.com.au/mikem/bcm2835/index.html.
-    /// 
-    /// To create the shared object, download the source code from the link above. The standard Makefile compiles a
-    /// statically linked library. To build a shared object, do:
-    ///    tar -zxf bcm2835-1.3.tar.gz
-    ///    cd bcm2835-1.3/src
-    ///    make libbcm2835.a
-    ///    cc -shared bcm2835.o -o libbcm2835.so
-    /// Place the shared object in the same directory as the executable and other assemblies.
-    /// </summary>
-    public class GPIOMem : GPIO
-    {
+	/// <summary>
+	/// Raspberry Pi GPIO using the direct memory access method.
+	/// This requires the bcm2835 GPIO library provided by 
+	/// Mike McCauley (mikem@open.com.au) at http://www.open.com.au/mikem/bcm2835/index.html.
+	/// 
+	/// To create the shared object, download the source code from the link above. The standard Makefile compiles a
+	/// statically linked library. To build a shared object, do:
+	///    tar -zxf bcm2835-1.3.tar.gz
+	///    cd bcm2835-1.3/src
+	///    make libbcm2835.a
+	///    cc -shared bcm2835.o -o libbcm2835.so
+	/// Place the shared object in the same directory as the executable and other assemblies.
+	/// </summary>
+	public class GPIOMem : GPIO
+	{
 		#region Static Constructor
-		static GPIOMem()
-		{
-            // initialize the mapped memory
+		static GPIOMem() {
+			// initialize the mapped memory
 			if (!bcm2835_init())
 				throw new Exception("Unable to initialize bcm2835.so library");
 		}
@@ -30,49 +29,43 @@ static GPIOMem()
 
 		#region Constructor
 		/// <summary>
-        /// Access to the specified GPIO setup as an output port with an initial value of false (0)
-        /// </summary>
-        /// <param name="pin">The GPIO pin</param>
-        public GPIOMem(GPIOPins pin)
-            : this(pin,GPIODirection.Out,false)
-        {
-        }
-
-        /// <summary>
-        /// Access to the specified GPIO setup with the specified direction with an initial value of false (0)
-        /// </summary>
-        /// <param name="pin">The GPIO pin</param>
-        /// <param name="direction">Direction</param>
-        public GPIOMem(GPIOPins pin, GPIODirection direction)
-            : this(pin, direction, false)
-        {
-        }
-
-        /// <summary>
-        /// Access to the specified GPIO setup with the specified direction with the specified initial value
-        /// </summary>
-        /// <param name="pin">The GPIO pin</param>
-        /// <param name="direction">Direction</param>
-        /// <param name="initialValue">Initial Value</param>
-        public GPIOMem(GPIOPins pin, GPIODirection direction, bool initialValue)
-            : base(pin, direction, initialValue)
-        {
-        }
-        #endregion
+		/// Access to the specified GPIO setup as an output port with an initial value of false (0)
+		/// </summary>
+		/// <param name="pin">The GPIO pin</param>
+		public GPIOMem(GPIOPins pin)
+			: this(pin, GPIODirection.Out, false) {
+		}
+
+		/// <summary>
+		/// Access to the specified GPIO setup with the specified direction with an initial value of false (0)
+		/// </summary>
+		/// <param name="pin">The GPIO pin</param>
+		/// <param name="direction">Direction</param>
+		public GPIOMem(GPIOPins pin, GPIODirection direction)
+			: this(pin, direction, false) {
+		}
+
+		/// <summary>
+		/// Access to the specified GPIO setup with the specified direction with the specified initial value
+		/// </summary>
+		/// <param name="pin">The GPIO pin</param>
+		/// <param name="direction">Direction</param>
+		/// <param name="initialValue">Initial Value</param>
+		public GPIOMem(GPIOPins pin, GPIODirection direction, bool initialValue)
+			: base(pin, direction, initialValue) {
+		}
+		#endregion
 
 		#region Properties
 
 		/// <summary>
 		/// Gets or sets the communication direction for this pin
 		/// </summary>
-		public override GPIODirection PinDirection
-		{
-			get
-			{
+		public override GPIODirection PinDirection {
+			get {
 				return base.PinDirection;
 			}
-			set
-			{
+			set {
 				if (PinDirection != (base.PinDirection = value)) // Left to right eval ensures base class gets to check for disposed object access
 				{
 					// Set the direction on the pin
@@ -88,66 +81,76 @@ public override GPIODirection PinDirection
 
 		#endregion
 
-        #region Class Methods
-        /// <summary>
-        /// Write a value to the pin
-        /// </summary>
-        /// <param name="value">The value to write to the pin</param>
-        public override void Write(bool value)
-        {
+		#region Class Methods
+		/// <summary>
+		/// Write a value to the pin
+		/// </summary>
+		/// <param name="value">The value to write to the pin</param>
+		public override void Write(bool value) {
 			base.Write(value);
-            bcm2835_gpio_write(_pin, value);
-        }
-
-        /// <summary>
-        /// Read a value from the pin
-        /// </summary>
-        /// <returns>The value read from the pin</returns>
-        public override bool Read()
-        {
+			bcm2835_gpio_write(_pin, value);
+		}
+
+		/// <summary>
+		/// Read a value from the pin
+		/// </summary>
+		/// <returns>The value read from the pin</returns>
+		public override bool Read() {
 			base.Read();
-            return bcm2835_gpio_lev(_pin);
-        }
-        #endregion
+			return bcm2835_gpio_lev(_pin);
+		}
+		#endregion
 
-        #region Imported functions
-        [DllImport("libbcm2835.so", EntryPoint = "bcm2835_init")]
+		#region Imported functions
+		[DllImport("libbcm2835.so", EntryPoint = "bcm2835_init")]
 		static extern bool bcm2835_init();
 
-        [DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_fsel")]
-        static extern void bcm2835_gpio_fsel(GPIOPins pin, bool mode_out); 
+		[DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_fsel")]
+		static extern void bcm2835_gpio_fsel(GPIOPins pin, bool mode_out);
 
-        [DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_write")]
-        static extern void bcm2835_gpio_write(GPIOPins pin, bool value);
+		[DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_write")]
+		static extern void bcm2835_gpio_write(GPIOPins pin, bool value);
 
-        [DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_lev")]
-        static extern bool bcm2835_gpio_lev(GPIOPins pin);
+		[DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_lev")]
+		static extern bool bcm2835_gpio_lev(GPIOPins pin);
 
-        [DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_set_pud")]
-        static extern void bcm2835_gpio_set_pud(GPIOPins pin, uint pud);
+		[DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_set_pud")]
+		static extern void bcm2835_gpio_set_pud(GPIOPins pin, uint pud);
 
-				[DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_set_multi")]
-				static extern void bcm2835_gpio_set_multi(GPIOPins mask);
+		[DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_set_multi")]
+		static extern void bcm2835_gpio_set_multi(GPIOPinMask mask);
 
-				[DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_clr_multi")]
-				static extern void bcm2835_gpio_clr_multi(GPIOPins mask);
+		[DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_clr_multi")]
+		static extern void bcm2835_gpio_clr_multi(GPIOPinMask mask);
 
-				[DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_write_multi")]
-				static extern void bcm2835_gpio_write_multi(GPIOPins mask, bool on);
+		[DllImport("libbcm2835.so", EntryPoint = "bcm2835_gpio_write_multi")]
+		static extern void bcm2835_gpio_write_multi(GPIOPinMask mask, bool on);
 
-        #endregion
+		#endregion
 
-				public static void SetMulti(GPIOPins mask) {
-					bcm2835_gpio_set_multi(mask);
-				}
+		/// <summary>
+		/// Sets any of the first 32 GPIO output pins specified in the mask to HIGH.
+		/// </summary>
+		/// <param name="mask">Mask of pins to affect. Use eg: (GPIOPinMask.GPIO_00) | GPIOPinMask.GPIO_01)</param>
+		public static void SetMulti(GPIOPinMask mask) {
+			bcm2835_gpio_set_multi(mask);
+		}
 
-				public static void ClearMulti(GPIOPins mask) {
-					bcm2835_gpio_clr_multi(mask);
-				}
+		/// <summary>
+		/// Sets any of the first 32 GPIO output pins specified in the mask to LOW.
+		/// </summary>
+		/// <param name="mask">Mask of pins to affect. Use eg: (GPIOPinMask.GPIO_00) | GPIOPinMask.GPIO_01)</param>
+		public static void ClearMulti(GPIOPinMask mask) {
+			bcm2835_gpio_clr_multi(mask);
+		}
 
-				public static void WriteMulti(GPIOPins mask, bool value) {
-					bcm2835_gpio_write_multi(mask, value);
-				}
+		/// <summary>
+		/// Sets any of the first 32 GPIO output pins specified in the mask to value.
+		/// </summary>
+		/// <param name="mask">Mask of pins to affect. Use eg: (GPIOPinMask.GPIO_00) | GPIOPinMask.GPIO_01)</param>
+		public static void WriteMulti(GPIOPinMask mask, bool value) {
+			bcm2835_gpio_write_multi(mask, value);
+		}
 
-    }
+	}
 }
diff --git a/RaspberryPiDotNet/GPIOPins.cs b/RaspberryPiDotNet/GPIOPins.cs
index 0efdf74..29dc874 100644
--- a/RaspberryPiDotNet/GPIOPins.cs
+++ b/RaspberryPiDotNet/GPIOPins.cs
@@ -128,4 +128,105 @@ public enum GPIOPins : uint
 		V2_Pin_P5_06 = 31,
 
 	};
+
+	public enum GPIOPinMask : uint
+	{
+
+		GPIO_NONE = uint.MaxValue,
+
+		//Revision 1
+
+		GPIO_00 = 0,
+		GPIO_01 = 1,
+		GPIO_04 = 1 << 4,
+		GPIO_07 = 1 << 7,
+		GPIO_08 = 1 << 8,
+		GPIO_09 = 1 << 9,
+		GPIO_10 = 1 << 10,
+		GPIO_11 = 1 << 11,
+		GPIO_14 = 1 << 14,
+		GPIO_15 = 1 << 15,
+		GPIO_17 = 1 << 17,
+		GPIO_18 = 1 << 18,
+		GPIO_21 = 1 << 21,
+		GPIO_22 = 1 << 22,
+		GPIO_23 = 1 << 23,
+		GPIO_24 = 1 << 24,
+		GPIO_25 = 1 << 25,
+
+		Pin_P1_03 = 1 << 0,
+		Pin_P1_05 = 1 << 1,
+		Pin_P1_07 = 1 << 4,
+		Pin_P1_08 = 1 << 14,
+		Pin_P1_10 = 1 << 15,
+		Pin_P1_11 = 1 << 17,
+		Pin_P1_12 = 1 << 18,
+		Pin_P1_13 = 1 << 21,
+		Pin_P1_15 = 1 << 22,
+		Pin_P1_16 = 1 << 23,
+		Pin_P1_18 = 1 << 24,
+		Pin_P1_19 = 1 << 10,
+		Pin_P1_21 = 1 << 9,
+		Pin_P1_22 = 1 << 25,
+		Pin_P1_23 = 1 << 11,
+		Pin_P1_24 = 1 << 8,
+		Pin_P1_26 = 1 << 7,
+		LED = 1 << 16,
+
+		//Revision 2
+
+		V2_GPIO_00 = 1 << 0,
+		V2_GPIO_02 = 1 << 2,
+		V2_GPIO_03 = 1 << 3,
+		V2_GPIO_01 = 1 << 1,
+		V2_GPIO_04 = 1 << 4,
+		V2_GPIO_07 = 1 << 7,
+		V2_GPIO_08 = 1 << 8,
+		V2_GPIO_09 = 1 << 9,
+		V2_GPIO_10 = 1 << 10,
+		V2_GPIO_11 = 1 << 11,
+		V2_GPIO_14 = 1 << 14,
+		V2_GPIO_15 = 1 << 15,
+		V2_GPIO_17 = 1 << 17,
+		V2_GPIO_18 = 1 << 18,
+		V2_GPIO_21 = 1 << 21,
+		V2_GPIO_22 = 1 << 22,
+		V2_GPIO_23 = 1 << 23,
+		V2_GPIO_24 = 1 << 24,
+		V2_GPIO_25 = 1 << 25,
+		V2_GPIO_27 = 1 << 27,
+
+		//Revision 2, new plug P5
+		V2_GPIO_28 = 1 << 28,
+		V2_GPIO_29 = 1 << 29,
+		V2_GPIO_30 = 1 << 30,
+		V2_GPIO_31 = (uint)1 << 31,
+
+		V2_Pin_P1_03 = 1 << 2,
+		V2_Pin_P1_05 = 1 << 3,
+		V2_Pin_P1_07 = 1 << 4,
+		V2_Pin_P1_08 = 1 << 14,
+		V2_Pin_P1_10 = 1 << 15,
+		V2_Pin_P1_11 = 1 << 17,
+		V2_Pin_P1_12 = 1 << 18,
+		V2_Pin_P1_13 = 1 << 27,
+		V2_Pin_P1_15 = 1 << 22,
+		V2_Pin_P1_16 = 1 << 23,
+		V2_Pin_P1_18 = 1 << 24,
+		V2_Pin_P1_19 = 1 << 10,
+		V2_Pin_P1_21 = 1 << 9,
+		V2_Pin_P1_22 = 1 << 25,
+		V2_Pin_P1_23 = 1 << 11,
+		V2_Pin_P1_24 = 1 << 8,
+		V2_Pin_P1_26 = 1 << 7,
+		V2_LED = 1 << 16,
+
+		//Revision 2, new plug P5
+		V2_Pin_P5_03 = 1 << 28,
+		V2_Pin_P5_04 = 1 << 29,
+		V2_Pin_P5_05 = 1 << 30,
+		V2_Pin_P5_06 = (uint)1 << 31,
+
+	};
+
 }

From 38744d70b29768d942a4473378f3f2e3d923ec7b Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Sat, 5 Oct 2013 05:28:05 -0600
Subject: [PATCH 25/34] Updated examples to match new interface

---
 README.md | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index bba065d..c02f47b 100644
--- a/README.md
+++ b/README.md
@@ -29,7 +29,7 @@ namespace Test
     {
         static void Main(string[] args)
         {
-            GPIOMem led = new GPIOMem(GPIO.GPIOPins.Pin12);
+            GPIOMem led = new GPIOMem(GPIOPins.Pin_P1_12);
             while(true)
             {
                 led.Write(true);
@@ -77,12 +77,13 @@ address HD44780 compatible displays.
 Example code:
 ```C#
 RaspPiGPIOMemLcdTransferProvider lcdProvider = new RaspPiGPIOMemLcdTransferProvider(
-    GPIOFile.GPIOPins.Pin21,
-    GPIOFile.GPIOPins.Pin23,
-    GPIOFile.GPIOPins.Pin11,
-    GPIOFile.GPIOPins.Pin13,
-    GPIOFile.GPIOPins.Pin15,
-    GPIOFile.GPIOPins.Pin19);
+    GPIOPins.Pin_P1_21,
+    GPIOPins.Pin_P1_18,
+    GPIOPins.Pin_P1_11,
+    GPIOPins.Pin_P1_13,
+    GPIOPins.Pin_P1_15,
+    GPIOPins.Pin_P1_19);
+
 
 Lcd lcd = new Lcd(lcdProvider);
 lcd.Begin(16, 2);
@@ -104,8 +105,8 @@ Example code:
 using System;
 using System.Collections.Generic;
 using System.Text;
-using RaspberryPiDotNet;
 using System.Threading;
+using RaspberryPiDotNet;
 
 namespace RPi_Temperature
 {
@@ -115,10 +116,10 @@ namespace RPi_Temperature
         {
             //# set up the SPI interface pins
             //# SPI port on the ADC to the Cobbler
-            GPIOMem SPICLK = new GPIOMem(GPIO.GPIOPins.GPIO18, GPIO.DirectionEnum.OUT);
-            GPIOMem SPIMISO = new GPIOMem(GPIO.GPIOPins.GPIO23, GPIO.DirectionEnum.IN);
-            GPIOMem SPIMOSI = new GPIOMem(GPIO.GPIOPins.GPIO24, GPIO.DirectionEnum.OUT);
-            GPIOMem SPICS = new GPIOMem(GPIO.GPIOPins.GPIO25, GPIO.DirectionEnum.OUT);
+            GPIOMem SPICLK = new GPIOMem(GPIOPins.Pin_P1_18, GPIODirection.Out);
+            GPIOMem SPIMISO = new GPIOMem(GPIOPins.Pin_P1_23, GPIODirection.In);
+            GPIOMem SPIMOSI = new GPIOMem(GPIOPins.Pin_P1_24, GPIODirection.Out);
+            GPIOMem SPICS = new GPIOMem(GPIOPins.Pin_P1_22, GPIODirection.Out);
 
             // temperature sensor connected to channel 0 of mcp3008
             int adcnum = 0;
@@ -153,4 +154,4 @@ namespace RPi_Temperature
         }
     }
 }
-```
\ No newline at end of file
+```

From d5d1cda890fa06ffeb0dfdc167fb3450cdd71c18 Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Sun, 6 Oct 2013 03:00:53 -0600
Subject: [PATCH 26/34] Added support for internal resistor for a GPIO pin.
 Only works for GPIOMem at this time.

---
 RaspberryPiDotNet/GPIO.cs                  | 31 ++++++++++++++++++++++
 RaspberryPiDotNet/GPIOMem.cs               | 23 +++++++++++-----
 RaspberryPiDotNet/GPIOResistor.cs          | 14 ++++++++++
 RaspberryPiDotNet/RaspberryPiDotNet.csproj |  1 +
 4 files changed, 63 insertions(+), 6 deletions(-)
 create mode 100644 RaspberryPiDotNet/GPIOResistor.cs

diff --git a/RaspberryPiDotNet/GPIO.cs b/RaspberryPiDotNet/GPIO.cs
index 98934bd..b6218c4 100644
--- a/RaspberryPiDotNet/GPIO.cs
+++ b/RaspberryPiDotNet/GPIO.cs
@@ -23,8 +23,20 @@ public abstract class GPIO : IDisposable
 		/// Variable to track the disposed state
 		/// </summary>
 		private bool _disposed = false;
+
+        /// <summary>
+        /// Direction of the GPIO pin
+        /// </summary>
 		private GPIODirection _direction;
 
+        /// <summary>
+        /// GPIO pull up-down resistor
+        /// </summary>
+        // BCM2835_GPIO_PUD_OFF = 0b00 = 0
+        // BCM2835_GPIO_PUD_DOWN = 0b01 = 1
+        // BCM2835_GPIO_PUD_UP = 0b10 = 2
+        public GPIOResistor _resistor = GPIOResistor.OFF;
+
 		/// <summary>
 		/// Gets the pin that this GPIO instance represents
 		/// </summary>
@@ -61,6 +73,25 @@ public virtual GPIODirection PinDirection {
 			}
 		}
 
+        /// <summary>
+        /// Gets or sets the internal resistor value for the pin
+        /// </summary>
+        public virtual GPIOResistor Resistor
+        {
+            get
+            {
+                if (_disposed)
+                    throw new ObjectDisposedException(string.Empty);
+                return _resistor;
+            }
+            set
+            {
+                if (_disposed)
+                    throw new ObjectDisposedException(string.Empty);
+                _resistor = value;
+            }
+        }
+
 		/// <summary>
 		/// Gets the disposal state of this GPIO instance
 		/// </summary>
diff --git a/RaspberryPiDotNet/GPIOMem.cs b/RaspberryPiDotNet/GPIOMem.cs
index c2b0487..a55577f 100644
--- a/RaspberryPiDotNet/GPIOMem.cs
+++ b/RaspberryPiDotNet/GPIOMem.cs
@@ -57,7 +57,6 @@ public GPIOMem(GPIOPins pin, GPIODirection direction, bool initialValue)
 		#endregion
 
 		#region Properties
-
 		/// <summary>
 		/// Gets or sets the communication direction for this pin
 		/// </summary>
@@ -70,15 +69,27 @@ public override GPIODirection PinDirection {
 				{
 					// Set the direction on the pin
 					bcm2835_gpio_fsel(_pin, value == GPIODirection.Out);
-					if (value == GPIODirection.In)
-						// BCM2835_GPIO_PUD_OFF = 0b00 = 0
-						// BCM2835_GPIO_PUD_DOWN = 0b01 = 1
-						// BCM2835_GPIO_PUD_UP = 0b10 = 2
-						bcm2835_gpio_set_pud(_pin, 0);
+                    if (value == GPIODirection.In)
+                        Resistor = GPIOResistor.OFF;
 				}
 			}
 		}
 
+        /// <summary>
+        /// Gets or sets the internal resistor value for the pin
+        /// </summary>
+        public override GPIOResistor Resistor
+        {
+            get {
+                return base.Resistor;
+            }
+            set {
+                if (Resistor != (base.Resistor = value)) // Left to right eval ensures base class gets to check for disposed object access
+                {
+                    bcm2835_gpio_set_pud(_pin, (uint)value);
+                }
+            }
+        }
 		#endregion
 
 		#region Class Methods
diff --git a/RaspberryPiDotNet/GPIOResistor.cs b/RaspberryPiDotNet/GPIOResistor.cs
new file mode 100644
index 0000000..6065e72
--- /dev/null
+++ b/RaspberryPiDotNet/GPIOResistor.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace RaspberryPiDotNet
+{
+    public enum GPIOResistor
+    {
+        OFF = 0,
+        PULL_DOWN = 1,
+        PULL_UP = 2
+    }
+}
diff --git a/RaspberryPiDotNet/RaspberryPiDotNet.csproj b/RaspberryPiDotNet/RaspberryPiDotNet.csproj
index da97838..fc29ebc 100644
--- a/RaspberryPiDotNet/RaspberryPiDotNet.csproj
+++ b/RaspberryPiDotNet/RaspberryPiDotNet.csproj
@@ -44,6 +44,7 @@
     <Compile Include="GPIOFile.cs" />
     <Compile Include="GPIOMem.cs" />
     <Compile Include="GPIOPins.cs" />
+    <Compile Include="GPIOResistor.cs" />
     <Compile Include="MCP3008.cs" />
     <Compile Include="MicroLiquidCrystal\RaspPiGPIOFileLcdTransferProvider.cs" />
     <Compile Include="MicroLiquidCrystal\RaspPiGPIOMemLcdTransferProvider.cs" />

From 26bd9a34b63158b7a3dea129f0fde0bf94219ffa Mon Sep 17 00:00:00 2001
From: Aaron Anderson <github@netopia.ca>
Date: Fri, 24 Jan 2014 22:42:24 -0700
Subject: [PATCH 27/34] Adding license

---
 LICENSE.txt | 339 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 339 insertions(+)
 create mode 100644 LICENSE.txt

diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000..22fbe5d
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,339 @@
+GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc., <http://fsf.org/>
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    {description}
+    Copyright (C) {year}  {fullname}
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  {signature of Ty Coon}, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
\ No newline at end of file

From fe4194b400742bf07fbd27bb96d1ea5b6b96fd0f Mon Sep 17 00:00:00 2001
From: "Bruno A. dos Santos" <brunoamancio.ti@gmail.com>
Date: Sun, 27 Apr 2014 23:44:52 +0200
Subject: [PATCH 28/34] Added PinState to better express its function

---
 RaspberryPiDotNet/DS1620.cs                | 24 ++++++++++------------
 RaspberryPiDotNet/GPIO.cs                  |  7 ++++---
 RaspberryPiDotNet/GPIODebug.cs             | 21 ++++++-------------
 RaspberryPiDotNet/GPIOFile.cs              | 22 ++++++++++++++------
 RaspberryPiDotNet/GPIOMem.cs               | 15 +++++++++++---
 RaspberryPiDotNet/MCP3008.cs               |  7 +++----
 RaspberryPiDotNet/RaspberryPiDotNet.csproj |  1 +
 RaspberryPiDotNet/TM16XX/TM1638.cs         |  2 +-
 RaspberryPiDotNet/TM16XX/TM16XX.cs         |  9 +++++---
 9 files changed, 60 insertions(+), 48 deletions(-)

diff --git a/RaspberryPiDotNet/DS1620.cs b/RaspberryPiDotNet/DS1620.cs
index 078353c..224c241 100644
--- a/RaspberryPiDotNet/DS1620.cs
+++ b/RaspberryPiDotNet/DS1620.cs
@@ -1,7 +1,8 @@
 using System;
-using System.Threading;
-
-// Derived based on work done by AdamS at http://forums.netduino.com/index.php?/topic/3335-netduino-plus-and-ds1620-anyone/page__view__findpost__p__22972
+using System.Threading;
+
+// Derived based on work done by AdamS at http://forums.netduino.com/index.php?/topic/3335-netduino-plus-and-ds1620-anyone/page__view__findpost__p__22972
+
 namespace RaspberryPiDotNet
 {
     public class DS1620
@@ -34,11 +35,11 @@ public double Temperature
         /// <param name="command">The command</param>
         private void SendCommand(int command)
         {
-            // Sends 8 bit command on DQ output, least sig bit first
-            int n, bit;          
+            // Sends 8 bit command on DQ output, least sig bit first
+            int n;
             for (n = 0; n < 8; n++) 
             {            
-                bit = ((command >> n) & (0x01));
+                var bit = ((command >> n) & (0x01));
                 _dq.Write((bit == 1));
                 _clk.Write(false);
                 _clk.Write(true);      
@@ -50,17 +51,14 @@ private void SendCommand(int command)
         /// </summary>
         /// <returns>The temperature in half degree increments</returns>
         private int ReadData()
-        {
-            int bit, n;
-            int raw_data = 0;            // go into input mode         
+        {
+            int n;
+            var raw_data = 0;            // go into input mode         
 
             for (n = 0; n < 9; n++)
             {
                 _clk.Write(false);
-                if (_dq.Read() == true)
-                    bit = 1;
-                else
-                    bit = 0;
+                var bit = _dq.Read() == PinState.High ? 1 : 0;
                 _clk.Write(true);
                 raw_data = raw_data | (bit << n);
             }
diff --git a/RaspberryPiDotNet/GPIO.cs b/RaspberryPiDotNet/GPIO.cs
index b6218c4..1b2095e 100644
--- a/RaspberryPiDotNet/GPIO.cs
+++ b/RaspberryPiDotNet/GPIO.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 
 // Author: Aaron Anderson <aanderson@netopia.ca>
+
 namespace RaspberryPiDotNet
 {
 	/// <summary>
@@ -152,7 +153,7 @@ public static void Write(GPIOPins pin, bool value) {
 		/// </summary>
 		/// <param name="pin">The pin who's value to get</param>
 		/// <returns>The value of the pin</returns>
-		public static bool Read(GPIOPins pin) {
+		public static PinState Read(GPIOPins pin) {
 			return CreatePin(pin, GPIODirection.In).Read();
 		}
 
@@ -218,12 +219,12 @@ public virtual void Write(bool value) {
 		/// Read a value from the pin
 		/// </summary>
 		/// <returns>The value read from the pin</returns>
-		public virtual bool Read() {
+		public virtual PinState Read() {
 			if (IsDisposed)
 				throw new ObjectDisposedException(string.Empty);
 			if (_direction != GPIODirection.In)
 				PinDirection = GPIODirection.In;
-			return false;
+			return PinState.Low;
 		}
 
 		/// <summary>
diff --git a/RaspberryPiDotNet/GPIODebug.cs b/RaspberryPiDotNet/GPIODebug.cs
index ac0f414..f00aa0d 100644
--- a/RaspberryPiDotNet/GPIODebug.cs
+++ b/RaspberryPiDotNet/GPIODebug.cs
@@ -1,13 +1,12 @@
-using System;
-
-namespace RaspberryPiDotNet
+namespace RaspberryPiDotNet
 {
     /// <summary>
     /// Raspberry Pi GPIO debug class.
     /// </summary>
+// ReSharper disable once InconsistentNaming
     public class GPIODebug : GPIO
     {
-        private bool _currentValue = false;
+        private bool _currentValue;
 
         #region Constructor
         /// <summary>
@@ -52,24 +51,16 @@ public override void Write(bool value)
 			base.Write(value);
 			_currentValue = value;
         }
-
+        
         /// <summary>
         /// Read a value from the pin
         /// </summary>
         /// <returns>The value read from the pin</returns>
-        public override bool Read()
+        public override PinState Read()
         {
 			System.Diagnostics.Debug.WriteLine("GPIO pin " + _pin + " reads as " + _currentValue);
 			base.Read();
-            return _currentValue;
-        }
-
-        /// <summary>
-        /// Dispose of the GPIO pin
-        /// </summary>
-        public override void Dispose()
-        {
-			base.Dispose();
+            return _currentValue ? PinState.High : PinState.Low;
         }
         #endregion
     }
diff --git a/RaspberryPiDotNet/GPIOFile.cs b/RaspberryPiDotNet/GPIOFile.cs
index 637b3ce..f0e0fa5 100644
--- a/RaspberryPiDotNet/GPIOFile.cs
+++ b/RaspberryPiDotNet/GPIOFile.cs
@@ -1,19 +1,20 @@
-using System;
-using System.Diagnostics;
-using System.IO;
+using System.IO;
 
 // Author: Aaron Anderson <aanderson@netopia.ca>
 // Based on work done by x4m and britguy (http://www.raspberrypi.org/phpBB3/viewtopic.php?f=34&t=6720)
+
 namespace RaspberryPiDotNet
 {
     /// <summary>
     /// Raspberry Pi GPIO using the file-based access method.
     /// </summary>
+    // ReSharper disable once InconsistentNaming
     public class GPIOFile : GPIO
     {
         /// <summary>
         /// The path on the Raspberry Pi for the GPIO interface
         /// </summary>
+        // ReSharper disable once InconsistentNaming
         private const string GPIO_PATH = "/sys/class/gpio/";
 
         #region Constructor
@@ -86,15 +87,24 @@ public override void Write(bool value)
 			File.WriteAllText(GPIO_PATH + "gpio" + (uint)_pin + "/value", value ? "1" : "0");
         }
 
+        /// <summary>
+        /// Write a value to the pin
+        /// </summary>
+        /// <param name="value">The value to write to the pin</param>
+        public void Write(PinState value)
+        {
+            Write(value == PinState.High);
+        }
+
         /// <summary>
         /// Read a value from the pin
         /// </summary>
         /// <returns>The value read from the pin</returns>
-        public override bool Read()
+        public override PinState Read()
         {
 			base.Read();
-			string readValue = File.ReadAllText(GPIO_PATH + "gpio" + (uint)_pin + "/value");
-			return (readValue.Length > 0 && readValue[0] == '1');
+			var readValue = File.ReadAllText(GPIO_PATH + "gpio" + (uint)_pin + "/value");
+			return (readValue.Length > 0 && readValue[0] == '1') ? PinState.High : PinState.Low;
         }
 
         /// <summary>
diff --git a/RaspberryPiDotNet/GPIOMem.cs b/RaspberryPiDotNet/GPIOMem.cs
index a55577f..d656eb5 100644
--- a/RaspberryPiDotNet/GPIOMem.cs
+++ b/RaspberryPiDotNet/GPIOMem.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Diagnostics;
 using System.Runtime.InteropServices;
 
 namespace RaspberryPiDotNet
@@ -102,13 +101,23 @@ public override void Write(bool value) {
 			bcm2835_gpio_write(_pin, value);
 		}
 
+        /// <summary>
+        /// Write a value to the pin
+        /// </summary>
+        /// <param name="pinState"></param>
+        public void Write(PinState pinState)
+        {
+            Write(pinState == PinState.High);
+        }
+
 		/// <summary>
 		/// Read a value from the pin
 		/// </summary>
 		/// <returns>The value read from the pin</returns>
-		public override bool Read() {
+        public override PinState Read()
+        {
 			base.Read();
-			return bcm2835_gpio_lev(_pin);
+			return bcm2835_gpio_lev(_pin) ? PinState.High : PinState.Low;
 		}
 		#endregion
 
diff --git a/RaspberryPiDotNet/MCP3008.cs b/RaspberryPiDotNet/MCP3008.cs
index a350ae2..8689c5e 100644
--- a/RaspberryPiDotNet/MCP3008.cs
+++ b/RaspberryPiDotNet/MCP3008.cs
@@ -3,6 +3,7 @@
 // Original author: Mikey Sklar - git://gist.github.com/3249416.git
 // Adafruit article: http://learn.adafruit.com/reading-a-analog-in-and-controlling-audio-volume-with-the-raspberry-pi
 // Ported from python and modified by: Gilberto Garcia <ferraripr@gmail.com>; twitter: @ferraripr
+
 namespace RaspberryPiDotNet
 {
     /// <summary>
@@ -86,15 +87,13 @@ private int readadc()
 
             int adcout = 0;
             //# read in one empty bit, one null bit and 10 ADC bits
-            for (int i = 0; i < 12; i++)
+            for (var i = 0; i < 12; i++)
             {
                 clockpin.Write(true);
                 clockpin.Write(false);
                 adcout <<= 1;
-                if (misopin.Read())
-                {
+                if (misopin.Read() == PinState.High)
                     adcout |= 0x1;
-                }
             }
 
             cspin.Write(true);
diff --git a/RaspberryPiDotNet/RaspberryPiDotNet.csproj b/RaspberryPiDotNet/RaspberryPiDotNet.csproj
index fc29ebc..5556768 100644
--- a/RaspberryPiDotNet/RaspberryPiDotNet.csproj
+++ b/RaspberryPiDotNet/RaspberryPiDotNet.csproj
@@ -50,6 +50,7 @@
     <Compile Include="MicroLiquidCrystal\RaspPiGPIOMemLcdTransferProvider.cs" />
     <Compile Include="MicroLiquidCrystal\ILcdTransferProvider.cs" />
     <Compile Include="MicroLiquidCrystal\Lcd.cs" />
+    <Compile Include="PinState.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="TM16XX\TM1638.cs" />
     <Compile Include="TM16XX\TM16XX.cs" />
diff --git a/RaspberryPiDotNet/TM16XX/TM1638.cs b/RaspberryPiDotNet/TM16XX/TM1638.cs
index 048e107..05dceae 100644
--- a/RaspberryPiDotNet/TM16XX/TM1638.cs
+++ b/RaspberryPiDotNet/TM16XX/TM1638.cs
@@ -3,7 +3,7 @@
 // This class is the base class for the TM1638/TM1640 board.
 // It is a port of the TM1638 library by Ricardo Batista
 // URL: http://code.google.com/p/tm1638-library/
-namespace RaspberryPiDotNet
+namespace RaspberryPiDotNet.TM16XX
 {
     public class TM1638 : TM16XX
     {
diff --git a/RaspberryPiDotNet/TM16XX/TM16XX.cs b/RaspberryPiDotNet/TM16XX/TM16XX.cs
index aec2df1..5064920 100644
--- a/RaspberryPiDotNet/TM16XX/TM16XX.cs
+++ b/RaspberryPiDotNet/TM16XX/TM16XX.cs
@@ -4,15 +4,18 @@
 // This class is the base class for the TM1638/TM1640 board.
 // It is a port of the TM1638 library by Ricardo Batista
 // URL: http://code.google.com/p/tm1638-library/
-namespace RaspberryPiDotNet
+
+namespace RaspberryPiDotNet.TM16XX
 {
     public abstract class TM16XX
     {
+
+        // ReSharper disable InconsistentNaming
         protected GPIO _data;
         protected GPIO _clock;
         protected GPIO _strobe;
         protected int _displays;
-
+        // ReSharper restore InconsistentNaming
         /// <summary>
         /// The character map for the seven segment displays.
         /// The bits are displayed by mapping bellow
@@ -268,7 +271,7 @@ public byte receive()
                 temp >>= 1;
                 _clock.Write(false);
 
-                if (_data.Read())
+                if (_data.Read() == PinState.High)
                     temp |= 0x80;
 
                 _clock.Write(true);

From 5256f95fdd56ca10888aa81ad7aab36a52bdfa7e Mon Sep 17 00:00:00 2001
From: brunoamancio <brunoamancio.ti@gmail.com>
Date: Sun, 27 Apr 2014 23:57:37 +0200
Subject: [PATCH 29/34] Explained more about .so file.

---
 README.md | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index c02f47b..126317e 100644
--- a/README.md
+++ b/README.md
@@ -29,12 +29,12 @@ namespace Test
     {
         static void Main(string[] args)
         {
-            GPIOMem led = new GPIOMem(GPIOPins.Pin_P1_12);
+            GPIOMem led = new GPIOMem(GPIOPins.V2_GPIO_12)
             while(true)
             {
-                led.Write(true);
+                led.Write(PinState.High);
                 System.Threading.Thread.Sleep(500);
-                led.Write(false);
+                led.Write(PinState.Low);
                 System.Threading.Thread.Sleep(500);
             }
         }
@@ -68,6 +68,8 @@ library is required. To compile a statically linked binary, do the following:
 # cc -shared bcm2835.o -o libbcm2835.so
 ```
 
+You can also try using our own compiled file [here](https://www.dropbox.com/s/716brdf0owbx4tf/libbcm2835.so). If it doesn't work, you must compile yourself. It must be in the same folder as the application.
+
 Liquid Crystal Display
 ----------------------
 This class is a port of the MicroLiquidCrystal NetDuino library from

From d515a3106bbaf0b0a30eb57714c28c4ca34fce23 Mon Sep 17 00:00:00 2001
From: "Bruno A. dos Santos" <brunoamancio.ti@gmail.com>
Date: Wed, 30 Apr 2014 01:30:38 +0200
Subject: [PATCH 30/34] Fixed issue when trying to get PinState when
 GPIODirection is Out

---
 RaspberryPiDotNet/GPIO.cs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/RaspberryPiDotNet/GPIO.cs b/RaspberryPiDotNet/GPIO.cs
index 1b2095e..e75ce90 100644
--- a/RaspberryPiDotNet/GPIO.cs
+++ b/RaspberryPiDotNet/GPIO.cs
@@ -222,8 +222,6 @@ public virtual void Write(bool value) {
 		public virtual PinState Read() {
 			if (IsDisposed)
 				throw new ObjectDisposedException(string.Empty);
-			if (_direction != GPIODirection.In)
-				PinDirection = GPIODirection.In;
 			return PinState.Low;
 		}
 

From 27e84a2bdfc47df712a8654039782de67f30d6c9 Mon Sep 17 00:00:00 2001
From: "Bruno A. dos Santos" <brunoamancio.ti@gmail.com>
Date: Wed, 16 Jul 2014 23:43:03 +0200
Subject: [PATCH 31/34] Added missing PinState enum

---
 RaspberryPiDotNet/PinState.cs | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 RaspberryPiDotNet/PinState.cs

diff --git a/RaspberryPiDotNet/PinState.cs b/RaspberryPiDotNet/PinState.cs
new file mode 100644
index 0000000..a68879a
--- /dev/null
+++ b/RaspberryPiDotNet/PinState.cs
@@ -0,0 +1,5 @@
+public enum PinState
+{
+    High,
+    Low
+}
\ No newline at end of file

From d7a8715187c1c401f21908cdeaaf4261ae81c26b Mon Sep 17 00:00:00 2001
From: "Bruno A. dos Santos" <brunoamancio.ti@gmail.com>
Date: Wed, 16 Jul 2014 23:49:22 +0200
Subject: [PATCH 32/34] Added PinStatus to correct namespace and added a
 summary.

---
 RaspberryPiDotNet/PinState.cs | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/RaspberryPiDotNet/PinState.cs b/RaspberryPiDotNet/PinState.cs
index a68879a..ac19c22 100644
--- a/RaspberryPiDotNet/PinState.cs
+++ b/RaspberryPiDotNet/PinState.cs
@@ -1,5 +1,11 @@
-public enum PinState
+namespace RaspberryPiDotNet
 {
-    High,
-    Low
+    /// <summary>
+    /// This is a cleaner way to write the Pin Status
+    /// </summary>
+    public enum PinState
+    {
+        High,
+        Low
+    }
 }
\ No newline at end of file

From 89749764d2acbc254e7951f724fbc3f318a5586c Mon Sep 17 00:00:00 2001
From: Marq Watkin <devhead@pmprog.co.uk>
Date: Wed, 14 Jan 2015 19:26:43 +0000
Subject: [PATCH 33/34] Extra pins for A+ and B+

---
 RaspberryPiDotNet/GPIOPins.cs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/RaspberryPiDotNet/GPIOPins.cs b/RaspberryPiDotNet/GPIOPins.cs
index 29dc874..0e488eb 100644
--- a/RaspberryPiDotNet/GPIOPins.cs
+++ b/RaspberryPiDotNet/GPIOPins.cs
@@ -126,6 +126,17 @@ public enum GPIOPins : uint
 		V2_Pin_P5_04 = 29,
 		V2_Pin_P5_05 = 30,
 		V2_Pin_P5_06 = 31,
+		
+		//A+ and B+ pins
+		V2Plus_Pin_P1_29 = 5,
+		V2Plus_Pin_P1_31 = 6,
+		V2Plus_Pin_P1_32 = 12,
+		V2Plus_Pin_P1_33 = 13,
+		V2Plus_Pin_P1_35 = 19,
+		V2Plus_Pin_P1_36 = 16,
+		V2Plus_Pin_P1_37 = 26,
+		V2Plus_Pin_P1_38 = 20,
+		V2Plus_Pin_P1_40 = 21,
 
 	};
 

From 9fc28a17d977a0a0e4d48991bc7f1bb2c52f5f4f Mon Sep 17 00:00:00 2001
From: Santiago Castro <santi.1410@hotmail.com>
Date: Sun, 16 Apr 2017 16:54:56 -0300
Subject: [PATCH 34/34] Fix broken Markdown headings

---
 README.md | 318 +++++++++++++++++++++++++++---------------------------
 1 file changed, 159 insertions(+), 159 deletions(-)

diff --git a/README.md b/README.md
index 126317e..37a1b40 100644
--- a/README.md
+++ b/README.md
@@ -1,159 +1,159 @@
-RaspberryPi.Net
-===============
-
-Introduction
-------------
-The purpose of this library is to provide a Mono.NET interface to the GPIO pins
-on the Raspberry Pi. All of this code was written using Visual Studio 2010
-Express but the goal is to be fully compatible with Mono. This library is
-written using .NET 4.0 therefore the latest version of Mono (2.10) is
-recommended. At the time of this update, the Raspbian wheezy 2012-07-15 image
-installs Mono 2.10.8.1.
-
-The GPIO pins are best described
-[here](http://elinux.org/Rpi_Low-level_peripherals#General_Purpose_Input.2FOutput_.28GPIO.29).
-They can be accessed in 2 ways, either using the file-based I/O (GPIOFile.cs)
-or direct memory (GPIOMem.cs) using Mike McCauley's BCM2835 library which is
-available [here](http://www.open.com.au/mikem/bcm2835/index.html). There is
-also a GPIODebug.cs class that can be used to test your application without a
-Raspberry Pi.
-
-Here is a sample bit of code to blink an LED attached to pin 12
-```C#
-using System;
-using RaspberryPiDotNet;
-
-namespace Test
-{
-    class Program
-    {
-        static void Main(string[] args)
-        {
-            GPIOMem led = new GPIOMem(GPIOPins.V2_GPIO_12)
-            while(true)
-            {
-                led.Write(PinState.High);
-                System.Threading.Thread.Sleep(500);
-                led.Write(PinState.Low);
-                System.Threading.Thread.Sleep(500);
-            }
-        }
-    }
-}
-```
-
-Installing Mono
----------------
-To install Mono on your Raspberry Pi, run the following:
-```bash
-$ sudo aptitude update 
-$ sudo aptitude install mono-runtime
-```
-
-My preference is for aptitude, however, apt-get can also be used.
-
-Using GPIOMem
--------------
-The GPIOMem class uses the .NET Interop layer to expose C functions from Mike
-McCauley''s BCM2835 library. This requires the use of a separate shared object
-(.so) but this library is considerably faster than the GPIOFile method.
-
-The Makefile for his library compiles a shared object where a statically linked
-library is required. To compile a statically linked binary, do the following:
-
-```bash
-# tar -zxf bcm2835-1.3.tar.gz
-# cd bcm2835-1.3/src
-# make libbcm2835.a
-# cc -shared bcm2835.o -o libbcm2835.so
-```
-
-You can also try using our own compiled file [here](https://www.dropbox.com/s/716brdf0owbx4tf/libbcm2835.so). If it doesn't work, you must compile yourself. It must be in the same folder as the application.
-
-Liquid Crystal Display
-----------------------
-This class is a port of the MicroLiquidCrystal NetDuino library from
-[here](http://microliquidcrystal.codeplex.com). It provides an interface to
-address HD44780 compatible displays. 
-
-Example code:
-```C#
-RaspPiGPIOMemLcdTransferProvider lcdProvider = new RaspPiGPIOMemLcdTransferProvider(
-    GPIOPins.Pin_P1_21,
-    GPIOPins.Pin_P1_18,
-    GPIOPins.Pin_P1_11,
-    GPIOPins.Pin_P1_13,
-    GPIOPins.Pin_P1_15,
-    GPIOPins.Pin_P1_19);
-
-
-Lcd lcd = new Lcd(lcdProvider);
-lcd.Begin(16, 2);
-lcd.Clear();
-lcd.SetCursorPosition(0, 0);
-lcd.Write("Hello World!");
-```
-
-Using MCP3008
--------------
-This class is a port of a Python Script by Mikey Sklar
-[here](https://raw.github.com/gist/3249416/7689f68f3ddbb74aceecda23e395c729668bd520/adafruit-cosm-temp.py).
-It provides analog to digital conversion to the Raspberry Pi.
-
-The following example shows how to connect an analog temperature sensor to the Pi.
-
-Example code:
-```C#
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading;
-using RaspberryPiDotNet;
-
-namespace RPi_Temperature
-{
-    class Program
-    {
-        static void Main(string[] args)
-        {
-            //# set up the SPI interface pins
-            //# SPI port on the ADC to the Cobbler
-            GPIOMem SPICLK = new GPIOMem(GPIOPins.Pin_P1_18, GPIODirection.Out);
-            GPIOMem SPIMISO = new GPIOMem(GPIOPins.Pin_P1_23, GPIODirection.In);
-            GPIOMem SPIMOSI = new GPIOMem(GPIOPins.Pin_P1_24, GPIODirection.Out);
-            GPIOMem SPICS = new GPIOMem(GPIOPins.Pin_P1_22, GPIODirection.Out);
-
-            // temperature sensor connected to channel 0 of mcp3008
-            int adcnum = 0;
-            double read_adc0 = 0.0;
-
-            while (true)
-            {
-                MCP3008 MCP3008 = new MCP3008(adcnum, SPICLK, SPIMOSI, SPIMISO, SPICS);
-                // read the analog pin (temperature sensor LM35)
-                read_adc0 = MCP3008.AnalogToDigital;
-                double millivolts = Convert.ToDouble(read_adc0) * (3300.0 / 1024);
-
-                double volts = (Convert.ToDouble(read_adc0) / 1024.0f) * 3.3f;
-                double temp_C = ((millivolts - 100.0) / 10.0) - 40.0;
-                double temp_F = (temp_C * 9.0 / 5.0) + 32;
-
-#if DEBUG
-                System.Console.WriteLine("MCP3008_Channel: " + adcnum);
-                System.Console.WriteLine("read_adc0: " + read_adc0);
-                System.Console.WriteLine("millivolts: " + (float)millivolts);
-                System.Console.WriteLine("tempC: " + (float)temp_C);
-                System.Console.WriteLine("tempF: " + (float)temp_F);
-                System.Console.WriteLine("volts: " + (float)volts);
-		//The following line makes the trick on Raspberry Pi for displaying DateTime.Now
-		//equivalent.
-		Console.WriteLine("Date time stamp: {0}/{1}/{2} {3}:{4}:{5}",now.Month,now.Day,now.Year,
-		                  now.Hour,now.Minute,now.Second);
-		System.Console.WriteLine("\n");
-#endif
-                Thread.Sleep(3000);
-            }
-        }
-    }
-}
-```
+RaspberryPi.Net
+===============
+
+Introduction
+------------
+The purpose of this library is to provide a Mono.NET interface to the GPIO pins
+on the Raspberry Pi. All of this code was written using Visual Studio 2010
+Express but the goal is to be fully compatible with Mono. This library is
+written using .NET 4.0 therefore the latest version of Mono (2.10) is
+recommended. At the time of this update, the Raspbian wheezy 2012-07-15 image
+installs Mono 2.10.8.1.
+
+The GPIO pins are best described
+[here](http://elinux.org/Rpi_Low-level_peripherals#General_Purpose_Input.2FOutput_.28GPIO.29).
+They can be accessed in 2 ways, either using the file-based I/O (GPIOFile.cs)
+or direct memory (GPIOMem.cs) using Mike McCauley's BCM2835 library which is
+available [here](http://www.open.com.au/mikem/bcm2835/index.html). There is
+also a GPIODebug.cs class that can be used to test your application without a
+Raspberry Pi.
+
+Here is a sample bit of code to blink an LED attached to pin 12
+```C#
+using System;
+using RaspberryPiDotNet;
+
+namespace Test
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            GPIOMem led = new GPIOMem(GPIOPins.V2_GPIO_12)
+            while(true)
+            {
+                led.Write(PinState.High);
+                System.Threading.Thread.Sleep(500);
+                led.Write(PinState.Low);
+                System.Threading.Thread.Sleep(500);
+            }
+        }
+    }
+}
+```
+
+Installing Mono
+---------------
+To install Mono on your Raspberry Pi, run the following:
+```bash
+$ sudo aptitude update 
+$ sudo aptitude install mono-runtime
+```
+
+My preference is for aptitude, however, apt-get can also be used.
+
+Using GPIOMem
+-------------
+The GPIOMem class uses the .NET Interop layer to expose C functions from Mike
+McCauley''s BCM2835 library. This requires the use of a separate shared object
+(.so) but this library is considerably faster than the GPIOFile method.
+
+The Makefile for his library compiles a shared object where a statically linked
+library is required. To compile a statically linked binary, do the following:
+
+```bash
+# tar -zxf bcm2835-1.3.tar.gz
+# cd bcm2835-1.3/src
+# make libbcm2835.a
+# cc -shared bcm2835.o -o libbcm2835.so
+```
+
+You can also try using our own compiled file [here](https://www.dropbox.com/s/716brdf0owbx4tf/libbcm2835.so). If it doesn't work, you must compile yourself. It must be in the same folder as the application.
+
+Liquid Crystal Display
+----------------------
+This class is a port of the MicroLiquidCrystal NetDuino library from
+[here](http://microliquidcrystal.codeplex.com). It provides an interface to
+address HD44780 compatible displays. 
+
+Example code:
+```C#
+RaspPiGPIOMemLcdTransferProvider lcdProvider = new RaspPiGPIOMemLcdTransferProvider(
+    GPIOPins.Pin_P1_21,
+    GPIOPins.Pin_P1_18,
+    GPIOPins.Pin_P1_11,
+    GPIOPins.Pin_P1_13,
+    GPIOPins.Pin_P1_15,
+    GPIOPins.Pin_P1_19);
+
+
+Lcd lcd = new Lcd(lcdProvider);
+lcd.Begin(16, 2);
+lcd.Clear();
+lcd.SetCursorPosition(0, 0);
+lcd.Write("Hello World!");
+```
+
+Using MCP3008
+-------------
+This class is a port of a Python Script by Mikey Sklar
+[here](https://raw.github.com/gist/3249416/7689f68f3ddbb74aceecda23e395c729668bd520/adafruit-cosm-temp.py).
+It provides analog to digital conversion to the Raspberry Pi.
+
+The following example shows how to connect an analog temperature sensor to the Pi.
+
+Example code:
+```C#
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using RaspberryPiDotNet;
+
+namespace RPi_Temperature
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            //# set up the SPI interface pins
+            //# SPI port on the ADC to the Cobbler
+            GPIOMem SPICLK = new GPIOMem(GPIOPins.Pin_P1_18, GPIODirection.Out);
+            GPIOMem SPIMISO = new GPIOMem(GPIOPins.Pin_P1_23, GPIODirection.In);
+            GPIOMem SPIMOSI = new GPIOMem(GPIOPins.Pin_P1_24, GPIODirection.Out);
+            GPIOMem SPICS = new GPIOMem(GPIOPins.Pin_P1_22, GPIODirection.Out);
+
+            // temperature sensor connected to channel 0 of mcp3008
+            int adcnum = 0;
+            double read_adc0 = 0.0;
+
+            while (true)
+            {
+                MCP3008 MCP3008 = new MCP3008(adcnum, SPICLK, SPIMOSI, SPIMISO, SPICS);
+                // read the analog pin (temperature sensor LM35)
+                read_adc0 = MCP3008.AnalogToDigital;
+                double millivolts = Convert.ToDouble(read_adc0) * (3300.0 / 1024);
+
+                double volts = (Convert.ToDouble(read_adc0) / 1024.0f) * 3.3f;
+                double temp_C = ((millivolts - 100.0) / 10.0) - 40.0;
+                double temp_F = (temp_C * 9.0 / 5.0) + 32;
+
+# if DEBUG
+                System.Console.WriteLine("MCP3008_Channel: " + adcnum);
+                System.Console.WriteLine("read_adc0: " + read_adc0);
+                System.Console.WriteLine("millivolts: " + (float)millivolts);
+                System.Console.WriteLine("tempC: " + (float)temp_C);
+                System.Console.WriteLine("tempF: " + (float)temp_F);
+                System.Console.WriteLine("volts: " + (float)volts);
+		//The following line makes the trick on Raspberry Pi for displaying DateTime.Now
+		//equivalent.
+		Console.WriteLine("Date time stamp: {0}/{1}/{2} {3}:{4}:{5}",now.Month,now.Day,now.Year,
+		                  now.Hour,now.Minute,now.Second);
+		System.Console.WriteLine("\n");
+# endif
+                Thread.Sleep(3000);
+            }
+        }
+    }
+}
+```