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); }