private static void Main()
{
const ConnectorPin measurePin = ConnectorPin.P1Pin7;
Console.WriteLine("DHT-11/DHT-22 Sample: measure humidity and temperature");
Console.WriteLine();
Console.WriteLine("\tMeasure: {0}", measurePin);
Console.WriteLine();
var driver = GpioConnectionSettings.GetBestDriver(GpioConnectionDriverCapabilities.CanChangePinDirectionRapidly);
using (var pin = driver.InOut(measurePin))
using (var dhtConnection = new Dht11Connection(pin))
{
while (!Console.KeyAvailable)
{
var data = dhtConnection.GetData();
if (data != null)
{
Console.WriteLine("{0:0.00}% humidity, {1:0.0}°C, {2} attempts", data.RelativeHumidity.Percent, data.Temperature.DegreesCelsius, data.AttemptCount);
}
else
{
Console.WriteLine("Unable to read data");
}
Timer.Sleep(TimeSpan.FromSeconds(2));
}
}
}
private static Hd44780Configuration LoadGpioConfiguration()
{
const ConnectorPin registerSelectPin = ConnectorPin.P1Pin22;
const ConnectorPin clockPin = ConnectorPin.P1Pin18;
var dataPins = new[]
{
ConnectorPin.P1Pin16,
ConnectorPin.P1Pin15,
ConnectorPin.P1Pin13,
ConnectorPin.P1Pin11
};
Console.WriteLine();
Console.WriteLine("Using GPIO connection");
Console.WriteLine("\tRegister Select: {0}", registerSelectPin);
Console.WriteLine("\tClock: {0}", clockPin);
Console.WriteLine("\tData 1: {0}", dataPins[0]);
Console.WriteLine("\tData 2: {0}", dataPins[1]);
Console.WriteLine("\tData 3: {0}", dataPins[2]);
Console.WriteLine("\tData 4: {0}", dataPins[3]);
Console.WriteLine("\tBacklight: VCC");
Console.WriteLine("\tRead/write: GND");
Console.WriteLine();
var driver = GpioConnectionSettings.DefaultDriver;
return(new Hd44780Configuration
{
Pins = new Hd44780Pins(
driver.Out(registerSelectPin),
driver.Out(clockPin),
dataPins.Select(p => (IOutputBinaryPin)driver.Out(p)))
});
}
public ISolenoid CreateSolenoid(Solenoid s)
{
log.DebugFormat("HardwareService.CreateSolenoid()");
ISolenoid sol;
switch (s.HardwareType)
{
case "GPIO":
log.DebugFormat("{0}", s.Address);
ConnectorPin pin = GetGPIOPin(s.Address);
log.DebugFormat("Got pin {0}", pin.ToString());
sol = new GPIOSolenoid(pin, s.Name, gpio);
break;
case "Distributed":
//return new DistributedSolenoid(s.Name, s.Address);
sol = new BEM106EthernetSolenoid(s.Name, s.Address);
break;
case "SPI":
sol = new SPISolenoid(s.Name, s.Address);
break;
default:
throw new Exception("Unknown Solenoid type");
}
Solenoids.Add(sol);
return(sol);
}
static void Main()
{
const ConnectorPin sdaPin = ConnectorPin.P1Pin03;
const ConnectorPin sclPin = ConnectorPin.P1Pin05;
Console.WriteLine("HTU21DF Sample: Read humidity and temperature");
Console.WriteLine();
Console.WriteLine("\tSDA: {0}", sdaPin);
Console.WriteLine("\tSCL: {0}", sclPin);
Console.WriteLine();
using (var driver = new I2cDriver(sdaPin.ToProcessor(), sclPin.ToProcessor()))
{
var deviceConnection = new Htu21dfConnection(driver.Connect(0x40));
deviceConnection.Begin();
while (!Console.KeyAvailable)
{
var temp = deviceConnection.ReadTemperature();
var humidity = deviceConnection.ReadHumidity();
Console.WriteLine($"Temp is: {temp:F1}C. RH is {humidity:F1}%");
Thread.Sleep(2000);
}
}
}
public void GeneratePinList(int pinCount)
{
int pins = Items.Count;
if (pinCount > pins)
{
for (int i = 1; i <= (pinCount - pins); i++)
{
var item = new ListViewItem("" + (pins + i + 1));
var pin = new ConnectorPin();
pin.ID = "" + (Items.Count + 1);
pin.name = "N/A";
AddPin(pin);
}
}
else if (pinCount < pins)
{
for (int i = pins; i > pinCount; i--)
{
try
{
Items.RemoveAt(i - 1);
}
catch (Exception er)
{
MessageBox.Show(string.Format("An Error occurred removing connector pin {0}\n{1}", i, er.Message));
}
}
}
}
/// <summary>
/// Costruttore che permette di indicare il canale da usare come integer.
/// Usa un trucco, perchè la libreria non supporta l'uso di un integer
/// per istanziare la classe di controllo dell'IO digitale
/// </summary>
/// <param name="NumConnectorPin">
/// Numero del canale
/// E' il numero del piedino nel connettore Gpio del Raspberry Pi, NON quello
/// del SoC Broadcom
/// </param>
/// <param name="IsInput">
/// Direzione dell'IO: se true è un Input, altrimenti è un output
/// </param>
public DigitalIO(int NumConnectorPin, GpioPinDriveMode DriveMode)
{
foreach (ConnectorPin pin in Enum.GetValues(typeof(ConnectorPin)))
{
try
{
if (Enum.GetName(typeof(ConnectorPin),
pin).ToString().IndexOf(NumConnectorPin.ToString(), 0) >= 0)
{
connectorPin = pin;
processorPin = connectorPin.ToProcessor();
Console.WriteLine("Numero pin: {0} Definizione pin:{1}",
NumConnectorPin, Enum.GetName(typeof(ConnectorPin), pin).ToString());
}
PinDirection dir;
if (DriveMode == GpioPinDriveMode.Input)
{
dir = PinDirection.Input;
}
else if (DriveMode == GpioPinDriveMode.Output)
{
dir = PinDirection.Output;
}
else
{
throw new NotImplementedException("Drive mode dell'I/O non ancora possibile con Mono");
}
driver.Allocate(processorPin, dir);
}
catch
{ // se quel pin non c'è nel Raspberry che uso, dà errore
}
}
}
private void ControlsToData()
{
if (connectorPin == null)
{
connectorPin = new ConnectorPin();
}
connectorPin.baseIndexSpecified = !String.IsNullOrEmpty(edtReplacementCharacter.Text);
connectorPin.countSpecified = !String.IsNullOrEmpty(edtCount.Text) && int.Parse(edtCount.Text) > 0;
connectorPin.incrementBySpecified = !String.IsNullOrEmpty(edtIncrementBy.Text) && int.Parse(edtIncrementBy.Text) > 0;
if (connectorPin.baseIndexSpecified)
{
connectorPin.baseIndex = connectorPin.baseIndexSpecified ? int.Parse(edtBaseIndex.Text) : 0;
}
if (connectorPin.countSpecified)
{
connectorPin.count = connectorPin.countSpecified ? int.Parse(edtCount.Text) : 0;
}
if (connectorPin.incrementBySpecified)
{
connectorPin.incrementBy = connectorPin.incrementBySpecified ? int.Parse(edtIncrementBy.Text) : 0;
}
connectorPin.ID = edtId.Text;
connectorPin.name = edtName.Text;
connectorPin.replacementCharacter = !String.IsNullOrEmpty(edtReplacementCharacter.Text) ? edtReplacementCharacter.Text : null;
}
/* Constructor */
protected Stepper(ConnectorPin protection, ConnectorPin direction, ConnectorPin impulse, ConnectorPin reset, ConnectorPin enable)
{
_logger = new Logger(nameof(Stepper));
/* Config pins */
_protectionPin = new GPIOInstance(protection, PinDirection.Input);
_directionPin = new GPIOInstance(direction, PinDirection.Output);
_impulsePin = new GPIOInstance(impulse, PinDirection.Output);
_resetPin = new GPIOInstance(reset, PinDirection.Output);
_enablePin = new GPIOInstance(enable, PinDirection.Output);
/* Disable motor by default to prevent heating */
Enable(false);
/* Set direction as FORWARD by default */
SetDirection(Direction.Forward);
/* Reset pin */
_resetPin.Write(true);
/* Launch PWM */
_gpio_pwm = 23;
System.Diagnostics.Process.Start("/usr/sbin/pi-blaster", "--gpio 23").WaitForExit();
_pwm = new PWM(_gpio_pwm);
_pwm.SetDuty(0);
}
public IAlarm CreateAlarm(Alarm a)
{
log.DebugFormat("HardwareService.CreateAlarm() Address:{0}", a.Address);
IAlarm alarm;
switch (a.HardwareType)
{
case HardwareTypes.GPIO:
ConnectorPin pin = GetGPIOPin(a.Address);
alarm = new GPIOAlarm(pin, a.Name, gpio);
break;
case HardwareTypes.Distributed:
alarm = new DistributedAlarm(a.Id, a.Name, a.Address);
break;
case HardwareTypes.SPI:
return(new SPIAlarm(a.Id, a.Name, a.Address));
break;
default:
throw new Exception("Unknown Alarm type");
}
Alarms.Add(alarm);
return(alarm);
}
private static Hd44780Configuration LoadGpioConfiguration()
{
const ConnectorPin registerSelectPin = ConnectorPin.P1Pin22;
const ConnectorPin clockPin = ConnectorPin.P1Pin18;
var dataPins = new[]
{
ConnectorPin.P1Pin16,
ConnectorPin.P1Pin15,
ConnectorPin.P1Pin13,
ConnectorPin.P1Pin11
};
Console.WriteLine();
Console.WriteLine("Using GPIO connection");
Console.WriteLine("\tRegister Select: {0}", registerSelectPin);
Console.WriteLine("\tClock: {0}", clockPin);
Console.WriteLine("\tData 1: {0}", dataPins[0]);
Console.WriteLine("\tData 2: {0}", dataPins[1]);
Console.WriteLine("\tData 3: {0}", dataPins[2]);
Console.WriteLine("\tData 4: {0}", dataPins[3]);
Console.WriteLine();
var driver = GpioConnectionSettings.DefaultDriver;
return(new Hd44780Configuration
{
RegisterSelect = driver.Out(registerSelectPin),
Clock = driver.Out(clockPin),
Data = dataPins.Select(pin => driver.Out(pin))
});
}
public GpioOutputPin(int pinNumber, String name)
: base(pinNumber, name)
{
_connectorPin = GpioController.IntToConnectorPin(pinNumber);
_processorPin = _connectorPin.ToProcessor();
Log.LogMessage("Output " + name + " on " + _connectorPin);
}
public static void WaitForAllButtons()
{
const ConnectorPin sdaPin = ConnectorPin.P1Pin03;
const ConnectorPin sclPin = ConnectorPin.P1Pin05;
using (var driver = new I2cDriver(sdaPin.ToProcessor(), sclPin.ToProcessor()))
{
var deviceConnection = new Mcp23017I2cConnection(driver.Connect(0x20));
Console.WriteLine("Connected");
Console.WriteLine("press all 5 of the buttons");
deviceConnection.SetDirection(Mcp23017Pin.B1, Mcp23017PinDirection.Input);
deviceConnection.SetDirection(Mcp23017Pin.B3, Mcp23017PinDirection.Input);
deviceConnection.SetDirection(Mcp23017Pin.B5, Mcp23017PinDirection.Input);
deviceConnection.SetDirection(Mcp23017Pin.B6, Mcp23017PinDirection.Input);
deviceConnection.SetDirection(Mcp23017Pin.B7, Mcp23017PinDirection.Input);
deviceConnection.SetResistor(Mcp23017Pin.B1, Mcp23017PinResistor.PullUp);
deviceConnection.SetResistor(Mcp23017Pin.B3, Mcp23017PinResistor.PullUp);
deviceConnection.SetResistor(Mcp23017Pin.B5, Mcp23017PinResistor.PullUp);
deviceConnection.SetResistor(Mcp23017Pin.B6, Mcp23017PinResistor.PullUp);
deviceConnection.SetResistor(Mcp23017Pin.B7, Mcp23017PinResistor.PullUp);
bool[] btns = { false, false, false, false, false };
bool btnsPushed = false;
while (!btnsPushed && !Console.KeyAvailable)
{
Thread.Sleep(100);
if (!deviceConnection.GetPinStatus(Mcp23017Pin.B1))
{
btns[0] = true; Console.Write("UP ");
}
if (!deviceConnection.GetPinStatus(Mcp23017Pin.B3))
{
btns[1] = true; Console.Write("ENTER ");
}
if (!deviceConnection.GetPinStatus(Mcp23017Pin.B5))
{
btns[2] = true; Console.Write("DOWN ");
}
if (!deviceConnection.GetPinStatus(Mcp23017Pin.B6))
{
btns[3] = true; Console.Write("TOPSEL ");
}
if (!deviceConnection.GetPinStatus(Mcp23017Pin.B7))
{
btns[4] = true; Console.Write("BOTSEL ");
}
btnsPushed = btns[0] && btns[1] && btns[2] && btns[3] && btns[4];
}
}
Console.WriteLine();
Console.WriteLine("All buttons pressed");
}
/// <summary>
/// Initializes a new instance of the <see cref="Max9744Device" /> class.
/// </summary>
/// <param name="i2cAddress">The i2c address.</param>
/// <param name="mutePin">The mute pin.</param>
/// <param name="shutdownPin">The shutdown pin.</param>
/// <param name="sdaPin">The sda pin.</param>
/// <param name="sclPin">The SCL pin.</param>
public Max9744Device(
byte i2cAddress,
ConnectorPin mutePin,
ConnectorPin shutdownPin,
ProcessorPin sdaPin,
ProcessorPin sclPin)
: this(i2cAddress, mutePin, shutdownPin, sdaPin, sclPin, null)
{
}
/* Constructor */
public PushButton(ConnectorPin switch_pin)
{
/* Create a new GPIO instance */
this.switchPin = new GPIO(switch_pin, PinDirection.Input);
/* Start the background reader */
this.bgTask = new Thread(buttonReader);
this.bgTask.Start();
}
/// <summary>
/// Convert the specified connector pin to a processor pin.
/// </summary>
/// <param name="pin">The connector pin.</param>
/// <returns>The processor pin.</returns>
public static ProcessorPin ToProcessor(this ConnectorPin pin)
{
if (!processorMappings.TryGetValue(pin, out var processorPin))
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Connector pin {0} is not mapped to processor with pin layout revision {1}", pin.ToString().Replace("Pin", "-"), GpioConnectionSettings.ConnectorPinout));
}
return(processorPin);
}
/// <summary>
/// Initializes a new instance of the <see cref="PullDownSwitchDevice" /> class.
/// </summary>
/// <param name="switchConnectorPin">The switch connector pin.</param>
/// <param name="gpioConnectionDriver">The gpio connection driver.</param>
public PullDownSwitchDevice(ConnectorPin switchConnectorPin, IGpioConnectionDriver gpioConnectionDriver)
{
this.PinConfiguration = switchConnectorPin.Input().PullDown();
this.PinConfiguration.OnStatusChanged(this.OnSwitchChanged);
using (var switchPin = gpioConnectionDriver.In(switchConnectorPin))
{
this.State = switchPin.Read();
}
}
public void AllocatePin(ConnectorPin connectorPin)
{
if (!_allocatedPins.Contains(connectorPin))
{
Driver.Allocate(connectorPin.ToProcessor(), PinDirection.Output);
_allocatedPins.Add(connectorPin);
var msg = string.Format("{0} pin allocated", connectorPin);
Console.WriteLine(msg);
}
}
public void AddPin(ConnectorPin pin)
{
var item = new ListViewItem("" + pin.ID);
item.SubItems.Add(pin.name);
item.SubItems.Add(pin.Definition != null?pin.Definition.Description:"");
item.SubItems.Add("");
item.Tag = pin;
lvList.Items.Add(item);
}
private InputPin?MapConnectorInputPin(ConnectorPin inputPin)
{
var pin = _inputPins.SingleOrDefault(ip => ip.Item2 == inputPin);
if (pin != null)
{
return(pin.Item1);
}
return(null);
}
public ITransceiverSpiConnection Create(ConnectorPin slaveSelectPin, ConnectorPin resetPin, string spiPath = "/dev/spidev0.0")
{
NativeSpiConnection spiConnection = new NativeSpiConnection(new SpiControlDevice(new UnixFile(spiPath, UnixFileMode.ReadWrite)));
spiConnection.SetDelay(0);
spiConnection.SetMaxSpeed(500000);
spiConnection.SetBitsPerWord(8);
IGpioConnectionDriver driver = GpioConnectionSettings.DefaultDriver;
return(new TransceiverSpiConnection(spiConnection, driver.Out(slaveSelectPin), driver.Out(resetPin)));
}
public GPIOSolenoid(int id, string name, string address)
{
log = LogManager.GetLogger("Device");
Id = id;
Name = name;
Address = address;
pin = GPIOService.GetGPIOPin(Address);
pinConfig = pin.Output().Name(name);
GPIOService.Gpio.Add(pinConfig);
}
/* Constructor */
public Motor(ConnectorPin protect, ConnectorPin sense, ConnectorPin inpuls, ConnectorPin reset, ConnectorPin enable)
{
/* Config pins */
protectPin = new GPIO(protect, PinDirection.Input);
sensePin = new GPIO(sense, PinDirection.Output);
inpulsPin = new GPIO(inpuls, PinDirection.Output);
resetPin = new GPIO(reset, PinDirection.Output);
enablePin = new GPIO(enable, PinDirection.Output);
/* Init motor task */
motorTask = new MOTOR_TASK();
/* Disable motor by default to prevent heating */
setEnable(false);
/* Set sense as FORWARD by default */
sensePin.write(true);
/* Launch worker on a new thread */
this.bgTask = new Thread(() =>
{
while (true)
{
/* If there is an reset request */
if (this.motorTask.resetRequested)
{
resetPin.write(true);
Thread.Sleep(5);
resetPin.write(false);
this.motorTask.resetRequested = false;
}
/* If there are no more steps to do */
if (motorTask.stepsToDo == 0)
{
Thread.Sleep(1);
continue;
}
/* Do requested steps */
this.step(); // make one step
Thread.Sleep(50);
if (this.motorTask.stepsToDo != -1) // an exact ammount of steps required steps requested
{
this.motorTask.stepsToDo--;
}
}
});
/* Start the task on a background thread */
bgTask.Start();
}
private static Hd44780Configuration LoadPcf8574Configuration(IEnumerable <string> args)
{
var addressText = args.SkipWhile(s => !String.Equals(s, "pcf8574", StringComparison.InvariantCultureIgnoreCase)).Skip(1).DefaultIfEmpty("0x20").First();
var address = addressText.StartsWith("0x", StringComparison.InvariantCultureIgnoreCase)
? Int32.Parse(addressText.Substring(2), NumberStyles.HexNumber)
: Int32.Parse(addressText);
const Pcf8574Pin clockPin = Pcf8574Pin.P2;
const Pcf8574Pin readWritePin = Pcf8574Pin.P1;
const Pcf8574Pin registerSelectPin = Pcf8574Pin.P0;
const Pcf8574Pin backlightPin = Pcf8574Pin.P3;
var dataPins = new[]
{
Pcf8574Pin.P4,
Pcf8574Pin.P5,
Pcf8574Pin.P6,
Pcf8574Pin.P7
};
Console.WriteLine();
Console.WriteLine("Using I2C connection over PCF8574 expander");
Console.WriteLine("\tRegister Select: {0}", registerSelectPin);
Console.WriteLine("\tClock: {0}", clockPin);
Console.WriteLine("\tData 1: {0}", dataPins[0]);
Console.WriteLine("\tData 2: {0}", dataPins[1]);
Console.WriteLine("\tData 3: {0}", dataPins[2]);
Console.WriteLine("\tData 4: {0}", dataPins[3]);
Console.WriteLine("\tBacklight: {0}", backlightPin);
Console.WriteLine("\tRead/write: {0}", readWritePin);
Console.WriteLine();
const ConnectorPin sdaPin = ConnectorPin.P1Pin03;
const ConnectorPin sclPin = ConnectorPin.P1Pin05;
var driver = new I2cDriver(sdaPin.ToProcessor(), sclPin.ToProcessor())
{
ClockDivider = 512
};
var connection = new Pcf8574I2cConnection(driver.Connect(address));
return(new Hd44780Configuration(driver)
{
Pins = new Hd44780Pins(
connection.Out(registerSelectPin),
connection.Out(clockPin),
dataPins.Select(p => (IOutputBinaryPin)connection.Out(p)))
{
Backlight = connection.Out(backlightPin),
ReadWrite = connection.Out(readWritePin),
}
});
}
private static Hd44780Configuration LoadMcp23008Configuration(IEnumerable <string> args)
{
var addressText = args.SkipWhile(s => !String.Equals(s, "mcp23008", StringComparison.InvariantCultureIgnoreCase)).Skip(1).DefaultIfEmpty("0x20").First();
var address = addressText.StartsWith("0x", StringComparison.InvariantCultureIgnoreCase)
? Int32.Parse(addressText.Substring(2), NumberStyles.HexNumber)
: Int32.Parse(addressText);
const Mcp23008Pin registerSelectPin = Mcp23008Pin.Pin1;
const Mcp23008Pin clockPin = Mcp23008Pin.Pin2;
const Mcp23008Pin backlightPin = Mcp23008Pin.Pin7;
var dataPins = new[]
{
Mcp23008Pin.Pin3,
Mcp23008Pin.Pin4,
Mcp23008Pin.Pin5,
Mcp23008Pin.Pin6
};
Console.WriteLine();
Console.WriteLine("Using I2C connection over MCP23008 Expander");
Console.WriteLine("\tRegister Select: {0}", registerSelectPin);
Console.WriteLine("\tClock: {0}", clockPin);
Console.WriteLine("\tData 1: {0}", dataPins[0]);
Console.WriteLine("\tData 2: {0}", dataPins[1]);
Console.WriteLine("\tData 3: {0}", dataPins[2]);
Console.WriteLine("\tData 4: {0}", dataPins[3]);
Console.WriteLine("\tBacklight: {0}", backlightPin);
Console.WriteLine("\tRead/write: GND");
Console.WriteLine();
const ConnectorPin sdaPin = ConnectorPin.P1Pin03;
const ConnectorPin sclPin = ConnectorPin.P1Pin05;
var driver = new I2cDriver(sdaPin.ToProcessor(), sclPin.ToProcessor())
{
ClockDivider = 512
};
var connection = new Mcp23008I2cConnection(driver.Connect(address));
var retVal = new Hd44780Configuration(driver)
{
Pins = new Hd44780Pins(
connection.Out(registerSelectPin),
connection.Out(clockPin),
dataPins.Select(pin => (IOutputBinaryPin)connection.Out(pin)))
};
retVal.Pins.Backlight = connection.Out(backlightPin);
return(retVal);
}
/// <summary>
/// Convert the specified connector pin to a processor pin.
/// </summary>
/// <param name="pin">The connector pin.</param>
/// <returns>The processor pin.</returns>
public static ProcessorPin ToProcessor(this ConnectorPin pin)
{
ProcessorPin processorPin;
if (processorMappings.TryGetValue(pin, out processorPin))
{
return(processorPin);
}
else
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Connector pin {0} is not mapped to processor on board revision {1}", pin.ToString().Replace("Pin", "-"), Board.Current.Revision));
}
}
public ISpi CreateSpi(Spi s)
{
log.DebugFormat("HardwareService.CreateSpi()");
ConnectorPin spiClock = GetGPIOPin(string.Format("P1Pin{0}", s.Clock));
ConnectorPin spiCs = GetGPIOPin(string.Format("P1Pin{0}", s.CS));
ConnectorPin spiMISO = GetGPIOPin(string.Format("P1Pin{0}", s.MISO));
ConnectorPin spiMOSI = GetGPIOPin(string.Format("P1Pin{0}", s.MOSI));
SpiDevice spi = new SpiDevice(s.Id, s.Name, spiClock, spiCs, spiMISO, spiMOSI, gpioDriver);
Spis.Add(spi);
return(spi);
}
public void AddPin(dbConnectorPin pin)
{
var cpin = new ConnectorPin();
cpin.ID = pin.pinIdx.ToString();
cpin.name = pin.pinName;
//------------------------------------------------------------------------------------------------------------//
//--- Note: The description is intentially left out from this update due to a poor schema design for ATML. ---//
//--- The Definition (ItemDescription) is for the manufacturer pin description and should not be ---//
//--- part of a pin instance. ---//
//------------------------------------------------------------------------------------------------------------//
AddPin(cpin);
}
static void Main()
{
const ConnectorPin adcClock = ConnectorPin.P1Pin23;
const ConnectorPin adcMiso = ConnectorPin.P1Pin21;
const ConnectorPin adcMosi = ConnectorPin.P1Pin19;
const ConnectorPin adcCs = ConnectorPin.P1Pin24;
Console.Clear();
Console.WriteLine("MCP-3208 Sample: Reading ADC points in all channels");
Console.WriteLine();
Console.WriteLine("\tClock: {0}", adcClock);
Console.WriteLine("\tCS: {0}", adcCs);
Console.WriteLine("\tMOSI: {0}", adcMosi);
Console.WriteLine("\tMISO: {0}", adcMiso);
Console.WriteLine();
var driver = new GpioConnectionDriver();
{
Console.CursorVisible = false;
var adcConnection = new Mcp3208SpiConnection(
driver.Out(adcClock),
driver.Out(adcCs),
driver.In(adcMiso),
driver.Out(adcMosi));
while (!Console.KeyAvailable)
{
Console.CursorTop = 0;
Console.Clear();
Mcp3208Channel chan = Mcp3208Channel.Channel0;
for (int i = 0; i < 8; i++)
{
AnalogValue p = adcConnection.Read(chan);
decimal points = p.Value;
Console.WriteLine(i.ToString() + " ADC points " + points.ToString());
using (StreamWriter sw = File.AppendText(".\\prova.txt"))
{
sw.WriteLine(chan.ToString() + " ADC points " + points.ToString());
}
chan++; // enum increase sends to the next channel
}
Thread.Sleep(500);
}
}
Console.CursorTop++;
Console.CursorVisible = true;
}
public static void WriteToLcd()
{
Console.WriteLine("writing to the lcd");
const ConnectorPin sdaPin = ConnectorPin.P1Pin03;
const ConnectorPin sclPin = ConnectorPin.P1Pin05;
using (var driver = new I2cDriver(sdaPin.ToProcessor(), sclPin.ToProcessor()))
{
var deviceConnection = new Mcp23017I2cConnection(driver.Connect(0x20));
Console.WriteLine("Connected");
// turn on LCD backlight (on/off/on)
deviceConnection.SetDirection(Mcp23017Pin.A0, Mcp23017PinDirection.Output);
deviceConnection.SetPinStatus(Mcp23017Pin.A0, true);
Thread.Sleep(500); // wait
deviceConnection.SetPinStatus(Mcp23017Pin.A0, false);
Thread.Sleep(500); // wait
deviceConnection.SetPinStatus(Mcp23017Pin.A0, true);
}
// light is on, let's write
var settings = new Hd44780LcdConnectionSettings
{
ScreenWidth = 16,
ScreenHeight = 2
};
settings.Encoding = Encoding.ASCII;
using (Hd44780Configuration configuration = Hd44780Configuration.LoadGpioConfiguration())
using (var connection = new Hd44780LcdConnection(settings, configuration.Pins))
{
// connection.SetCustomCharacter(1, new byte[] { 0x0, 0x0, 0x04, 0xe, 0x1f, 0x0, 0x0 });
// connection.SetCustomCharacter(2, new byte[] { 0x0, 0x0, 0x1f, 0xe, 0x04, 0x0, 0x0 });
connection.Clear();
connection.WriteLine("Pi & Bash>_");
Thread.Sleep(750);
connection.WriteLine("Test");
Thread.Sleep(750);
connection.WriteLine("Thank You");
Thread.Sleep(750);
connection.WriteLine("more text");
Thread.Sleep(750);
connection.WriteLine("and another bit");
Thread.Sleep(2000);
}
}
static void Main()
{
const ConnectorPin adcClock = ConnectorPin.P1Pin12;
const ConnectorPin adcMiso = ConnectorPin.P1Pin16;
const ConnectorPin adcMosi = ConnectorPin.P1Pin18;
const ConnectorPin adcCs = ConnectorPin.P1Pin22;
Console.WriteLine("MCP-3008 Sample: Reading temperature on Channel 0 and luminosity on Channel 1");
Console.WriteLine();
Console.WriteLine("\tClock: {0}", adcClock);
Console.WriteLine("\tCS: {0}", adcCs);
Console.WriteLine("\tMOSI: {0}", adcMosi);
Console.WriteLine("\tMISO: {0}", adcMiso);
Console.WriteLine();
ElectricPotential voltage = ElectricPotential.FromVolts(3.3);
var driver = new MemoryGpioConnectionDriver(); //GpioConnectionSettings.DefaultDriver;
using (var adcConnection = new Mcp3008SpiConnection(
driver.Out(adcClock),
driver.Out(adcCs),
driver.In(adcMiso),
driver.Out(adcMosi)))
using (var temperatureConnection = new Tmp36Connection(
adcConnection.In(Mcp3008Channel.Channel0),
voltage))
using (var lightConnection = new VariableResistiveDividerConnection(
adcConnection.In(Mcp3008Channel.Channel1),
ResistiveDivider.ForLowerResistor(ElectricResistance.FromKiloohms(10))))
{
Console.CursorVisible = false;
while (!Console.KeyAvailable)
{
var temperature = temperatureConnection.GetTemperature();
var resistor = lightConnection.GetResistance();
var lux = resistor.ToLux();
Console.WriteLine("Temperature = {0,5:0.0} °C\tLight = {1,5:0.0} Lux ({2} ohms)", temperature, lux, (int)resistor.Ohms);
Console.CursorTop--;
Thread.Sleep(1000);
}
}
Console.CursorTop++;
Console.CursorVisible = true;
}
static void Main()
{
const ConnectorPin dacClock = ConnectorPin.P1Pin11;
const ConnectorPin dacCs = ConnectorPin.P1Pin13;
const ConnectorPin dacMosi = ConnectorPin.P1Pin15;
Console.WriteLine("MCP-4822 Sample: Write a changing value on Channel A");
Console.WriteLine();
Console.WriteLine("\tClock: {0}", dacClock);
Console.WriteLine("\tCS: {0}", dacCs);
Console.WriteLine("\tMOSI: {0}", dacMosi);
Console.WriteLine();
var driver = GpioConnectionSettings.DefaultDriver;
using (var clockPin = driver.Out(dacClock))
using (var csPin = driver.Out(dacCs))
using (var mosiPin = driver.Out(dacMosi))
using (var dacConnection = new Mcp4822SpiConnection(clockPin, csPin, mosiPin))
using (var channel = new Mcp4822OutputAnalogPin(dacConnection, Mcp4822Channel.ChannelA))
{
const decimal minimum = 0.0001m;
var ticks = minimum;
var up = true;
while (!Console.KeyAvailable)
{
channel.Write(new AnalogValue(ticks));
if (up)
{
ticks *= 2;
if (ticks >= 1)
{
up = false;
}
}
else
{
ticks /= 2;
if (ticks <= minimum)
{
up = true;
}
}
Thread.Sleep(100);
}
}
}
public static void RunSample(ConnectorPin connectorPin)
{
// Console.Out.WriteLine("Pin:" + connectorPin);
// ProcessorPin led = connectorPin.ToProcessor();
// Console.Out.WriteLine("Load driver:" + led);
//
//
// Console.Out.WriteLine("Pin out");
//
// Console.Out.WriteLine("Pin on");
// driver.Write(led, false);
// Thread.Sleep(2000);
// Console.Out.WriteLine("Pin off");
// driver.Write(led, true);
// Console.Out.WriteLine("Release");
}
public GroveRgbConnection(ConnectorPin dataPin, ConnectorPin clockPin, int ledCount)
{
ledColors = new List<RgbColor>();
for(int i = 0; i < ledCount; i++)
{
// Initialize all leds with white color
ledColors.Add(new RgbColor());
}
this.dataPin = dataPin.ToProcessor();
this.clockPin = clockPin.ToProcessor();
if (Raspberry.Board.Current.IsRaspberryPi)
{
driver = new GpioConnectionDriver();
}
else
{
driver = new FileGpioConnectionDriver();
}
driver.Allocate(this.dataPin, PinDirection.Output);
driver.Allocate(this.clockPin, PinDirection.Output);
}
public void Initialize(ConnectorPin adcClock, ConnectorPin adcMiso, ConnectorPin adcMosi, ConnectorPin adcCs)
{
AdcClock = adcClock;
AdcMiso = adcMiso;
AdcMosi = adcMosi;
AdcCs = adcCs;
Console.WriteLine("MCP-3008 Sample: Reading temperature on Channel 0 and luminosity on Channel 1");
Console.WriteLine();
Console.WriteLine("\tClock: {0}", adcClock);
Console.WriteLine("\tCS: {0}", adcCs);
Console.WriteLine("\tMOSI: {0}", adcMosi);
Console.WriteLine("\tMISO: {0}", adcMiso);
Console.WriteLine();
_driver = new MemoryGpioConnectionDriver();
_adcConnection = new Mcp3008SpiConnection(
_driver.Out(AdcClock),
_driver.Out(AdcCs),
_driver.In(AdcMiso),
_driver.Out(AdcMosi));
}
/// <summary>
/// Gets an output pin on the current driver.
/// </summary>
/// <param name="driver">The driver.</param>
/// <param name="pin">The pin.</param>
/// <returns>The GPIO output binary pin.</returns>
public static GpioOutputBinaryPin Out(this IGpioConnectionDriver driver, ConnectorPin pin)
{
return driver.Out(pin.ToProcessor());
}
/// <summary>
/// Blinks the specified pin.
/// </summary>
/// <param name="pin">The pin.</param>
/// <param name="duration">The duration.</param>
public void Blink(ConnectorPin pin, TimeSpan duration = new TimeSpan())
{
Toggle(pin);
Sleep(duration);
Toggle(pin);
}
/// <summary>
/// Blinks the specified pin.
/// </summary>
/// <param name="pin">The pin.</param>
/// <param name="duration">The duration, in millisecond.</param>
public void Blink(ConnectorPin pin, decimal duration = -1)
{
Toggle(pin);
Sleep(duration);
Toggle(pin);
}
/// <summary>
/// Toggles the specified pin.
/// </summary>
/// <param name="pin">The pin.</param>
public void Toggle(ConnectorPin pin)
{
this[pin] = !this[pin];
}
/// <summary>
/// Removes the specified pin.
/// </summary>
/// <param name="pin">The pin.</param>
public void Remove(ConnectorPin pin)
{
Remove(pinConfigurations[pin.ToProcessor()]);
}
/// <summary>
/// Determines whether the connection contains the specified pin.
/// </summary>
/// <param name="pin">The pin.</param>
/// <returns>
/// <c>true</c> if the connection contains the specified pin; otherwise, <c>false</c>.
/// </returns>
public bool Contains(ConnectorPin pin)
{
return pinConfigurations.ContainsKey(pin.ToProcessor());
}
/// <summary>
/// Gets or sets the status of the specified pin.
/// </summary>
public bool this[ConnectorPin pin]
{
get { return this[pin.ToProcessor()]; }
set { this[pin.ToProcessor()] = value; }
}
// public static HubConnection hubconnection;
// public static IHubProxy raspberryHub;
//
// public CreatePinConfig(HubConnection hubcon, IHubProxy hub)
// {
// hubconnection = hubcon;
// raspberryHub = hub;
// }
public static OutputPinConfiguration CreateOutputPinConfiguration(ConnectorPin pin, Action<bool> Onstatuschanged, string type)
{
return pin.Output().Revert().OnStatusChanged(Onstatuschanged);
}
public virtual void SetPin(ConnectorPin pin, bool isOn)
{
var targetFound = _configuration.Targets.FirstOrDefault(x => x.Pin == (GpIO) 25);
SetPin(targetFound, isOn);
}
/// <summary>
/// Gets a bidirectional pin on the current driver.
/// </summary>
/// <param name="driver">The driver.</param>
/// <param name="pin">The pin.</param>
/// <param name="resistor">The resistor.</param>
/// <returns>
/// The GPIO input binary pin.
/// </returns>
public static GpioInputOutputBinaryPin InOut(this IGpioConnectionDriver driver, ConnectorPin pin, PinResistor resistor = PinResistor.None)
{
return driver.InOut(pin.ToProcessor(), resistor);
}
