/// <summary> /// Power off the device if GPIO controller and power enable pin is provided. /// </summary> public void PowerOff() { if (_powerEnablePin == -1) { throw new InvalidOperationException("Cannot power off without providing GPIO controller and power enable pin."); } _gpioController?.Write(_powerEnablePin, PinValue.Low); }
private void OpenPinAndWrite(int pin, PinValue value) { _controller?.OpenPin(pin, PinMode.Output); _controller?.Write(pin, value); }
/// <summary> /// Read through One-Wire /// </summary> internal virtual void ReadThroughOneWire() { byte readVal = 0; uint count; // keep data line HIGH _controller.SetPinMode(_pin, PinMode.Output); _controller.Write(_pin, PinValue.High); DelayHelper.DelayMilliseconds(20, true); // send trigger signal _controller.Write(_pin, PinValue.Low); // wait at least 18 milliseconds // here wait for 18 milliseconds will cause sensor initialization to fail DelayHelper.DelayMilliseconds(20, true); // pull up data line _controller.Write(_pin, PinValue.High); // wait 20 - 40 microseconds DelayHelper.DelayMicroseconds(30, true); _controller.SetPinMode(_pin, PinMode.InputPullUp); // DHT corresponding signal - LOW - about 80 microseconds count = _loopCount; while (_controller.Read(_pin) == PinValue.Low) { if (count-- == 0) { IsLastReadSuccessful = false; return; } } // HIGH - about 80 microseconds count = _loopCount; while (_controller.Read(_pin) == PinValue.High) { if (count-- == 0) { IsLastReadSuccessful = false; return; } } // the read data contains 40 bits for (int i = 0; i < 40; i++) { // beginning signal per bit, about 50 microseconds count = _loopCount; while (_controller.Read(_pin) == PinValue.Low) { if (count-- == 0) { IsLastReadSuccessful = false; return; } } // 26 - 28 microseconds represent 0 // 70 microseconds represent 1 _stopwatch.Restart(); count = _loopCount; while (_controller.Read(_pin) == PinValue.High) { if (count-- == 0) { IsLastReadSuccessful = false; return; } } _stopwatch.Stop(); // bit to byte // less than 40 microseconds can be considered as 0, not necessarily less than 28 microseconds // here take 30 microseconds readVal <<= 1; if (!(_stopwatch.ElapsedTicks * 1000000F / Stopwatch.Frequency <= 30)) { readVal |= 1; } if (((i + 1) % 8) == 0) { _readBuff[i / 8] = readVal; } } _lastMeasurement = Environment.TickCount; if ((_readBuff[4] == ((_readBuff[0] + _readBuff[1] + _readBuff[2] + _readBuff[3]) & 0xFF))) { IsLastReadSuccessful = (_readBuff[0] != 0) || (_readBuff[2] != 0); } else { IsLastReadSuccessful = false; } }
/// <summary> /// Effectively the start button for the AWS software. Initialises everything and begins /// AWS operation. /// </summary> public async Task Startup() { LogMessage("Startup ------------"); try { await config.LoadAsync(); } catch (Exception ex) { LogException(ex); return; } gpio = new GpioController(PinNumberingScheme.Logical); gpio.OpenPin(config.dataLedPin, PinMode.Output); gpio.Write(config.dataLedPin, PinValue.Low); gpio.OpenPin(config.errorLedPin, PinMode.Output); gpio.Write(config.errorLedPin, PinValue.Low); try { clock = new Clock(config.clockTickPin, gpio); clock.Open(); if (clock.IsTimeValid) { LogMessage("Clock time is " + clock.Time.ToString("yyyy-MM-dd HH:mm:ss")); } else { gpio.Write(config.errorLedPin, PinValue.High); LogMessage("Clock time is not valid"); return; } } catch (Exception ex) { gpio.Write(config.errorLedPin, PinValue.High); LogException(ex); return; } if (!StartupFileSystem()) { return; } dataLogger = new DataLogger(config, clock, gpio); dataLogger.DataLogged += DataLogger_DataLogged; if (!dataLogger.Open()) { for (int i = 0; i < 5; i++) { gpio.Write(config.errorLedPin, PinValue.High); Thread.Sleep(250); gpio.Write(config.errorLedPin, PinValue.Low); Thread.Sleep(250); } } Thread.Sleep(1500); gpio.Write(config.dataLedPin, PinValue.High); gpio.Write(config.errorLedPin, PinValue.High); Thread.Sleep(2500); gpio.Write(config.dataLedPin, PinValue.Low); gpio.Write(config.errorLedPin, PinValue.Low); Thread.Sleep(1500); try { dataLogger.Start(); } catch { gpio.Write(config.errorLedPin, PinValue.High); LogMessage("Failed to start data logger"); return; } Console.ReadKey(); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { _deviceId = System.Environment.GetEnvironmentVariable("IOTEDGE_DEVICEID"); _moduleId = Environment.GetEnvironmentVariable("IOTEDGE_MODULEID"); Console.WriteLine(); Console.WriteLine(" _ _ _ _ _ _ __ _ "); Console.WriteLine(" (_)___| |_ ___ ___ __| |__ _ ___ ___| |__ ___ ___ _ _| (_)/ _| |_ "); Console.WriteLine(" | / _ \\ _|___/ -_) _` / _` / -_)___| '_ \\/ -_) -_) '_| | | _| _|"); Console.WriteLine(" |_\\___/\\__| \\___\\__,_\\__, \\___| |_.__/\\___\\___|_| |_|_|_| \\__|"); Console.WriteLine(" |___/ "); Console.WriteLine(); Console.WriteLine(" Copyright © 2020 - josa josa josa"); Console.WriteLine(" "); MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; //// Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); // Attach callback for Twin desired properties updates await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(onDesiredPropertiesUpdate, ioTHubModuleClient); // Execute callback method for Twin desired properties updates var twin = await ioTHubModuleClient.GetTwinAsync(); await onDesiredPropertiesUpdate(twin.Properties.Desired, ioTHubModuleClient); Console.WriteLine("Device twin initialized."); await ioTHubModuleClient.OpenAsync(); Console.WriteLine($"Module '{_deviceId}'-'{_moduleId}' initialized."); Console.WriteLine("Attached routing output: output1."); //// Initialize GPIO _controller = new GpioController(); _controller.OpenPin(UpRelayPin, PinMode.Output); _controller.OpenPin(DownRelayPin, PinMode.Output); _controller.OpenPin(FloodedPin, PinMode.Input); _controller.Write(UpRelayPin, PinValue.High); //by default high _controller.Write(DownRelayPin, PinValue.High); //by default high Console.WriteLine("Default GPIO relays Initialized."); //// Direct methods await ioTHubModuleClient.SetMethodHandlerAsync( "Up", UpMethodCallBack, ioTHubModuleClient); Console.WriteLine("Attached method handler: Up."); await ioTHubModuleClient.SetMethodHandlerAsync( "Down", DownMethodCallBack, ioTHubModuleClient); Console.WriteLine("Attached method handler: Down."); await ioTHubModuleClient.SetMethodHandlerAsync( "Ambiant", AmbiantValuesMethodCallBack, ioTHubModuleClient); Console.WriteLine("Attached method handler: Ambiant."); await ioTHubModuleClient.SetMethodHandlerAsync( "Circus", CircusMethodCallBack, ioTHubModuleClient); Console.WriteLine("Attached method handler: Circus."); await ioTHubModuleClient.SetMethodHandlerAsync( "Advertise", AdvertiseMethodCallBack, ioTHubModuleClient); Console.WriteLine("Attached method handler: Advertise."); await ioTHubModuleClient.SetMethodHandlerAsync( "FindEmptySlot", FindEmptySlotMethodCallBack, ioTHubModuleClient); Console.WriteLine("Attached method handler: FindEmptySlot."); await ioTHubModuleClient.SetMethodHandlerAsync( "MarkPosition", MarkPositionMethodCallBack, ioTHubModuleClient); Console.WriteLine("Attached method handler: MarkPosition."); await ioTHubModuleClient.SetMethodHandlerAsync( "BottleHolders", BottleHoldersMethodCallBack, ioTHubModuleClient); Console.WriteLine("Attached method handler: BottleHolders."); await ioTHubModuleClient.SetMethodHandlerAsync( "Roulette", RouletteMethodCallBack, ioTHubModuleClient); Console.WriteLine("Attached method handler: Roulette."); SetupI2CRead(); SetupI2CWrite(); //// start reading beer state if (_mcp23xxxRead != null) { var thread = new Thread(() => ThreadBody(ioTHubModuleClient)); thread.Start(); } if (_liftState == LiftState.Unknown) { // move the lift down (initial state) in case of 'unknown' state await DownMethodCallBack(null, ioTHubModuleClient); } }
/// <summary> /// Start a reading /// </summary> /// <returns> /// <c>true</c> if read is successfull, otherwise <c>false</c>. /// </returns> public bool ReadData() { // Set the max value for waiting micro second // 27 = debug // 99 = release byte waitMS = 99; #if DEBUG waitMS = 27; #endif _stopwatch.Start(); PinValue lststate = PinValue.High; uint counter = 0; byte j = 0, i; for (i = 0; i < 5; i++) { _dht11Val[i] = 0; } // write on the pin _controller.SetPinMode(_pin, PinMode.Output); _controller.Write(_pin, PinValue.Low); //wait 18 milliseconds Wait(18); _controller.Write(_pin, PinValue.High); // Wait about 40 microseconds Wait(0.03); _controller.SetPinMode(_pin, PinMode.Input); for (i = 0; i < MAX_TIME; i++) { counter = 0; while (_controller.Read(_pin) == lststate) { counter++; // This wait about 1 microsecond // No other way to do it for such a precision for (byte wt = 0; wt < waitMS; wt++) { ; } if (counter == MAX_WAIT) { break; } } lststate = _controller.Read(_pin); if (counter == MAX_WAIT) { break; } // top 3 transistions are ignored if ((i >= 4) && (i % 2 == 0)) { _dht11Val[j / 8] <<= 1; if (counter > 16) { _dht11Val[j / 8] |= 1; } j++; } } _stopwatch.Stop(); if ((j >= 40) && (_dht11Val[4] == ((_dht11Val[0] + _dht11Val[1] + _dht11Val[2] + _dht11Val[3]) & 0xFF))) { IsLastReadSuccessful = (_dht11Val[0] != 0) || (_dht11Val[2] != 0); } else { IsLastReadSuccessful = false; } return(IsLastReadSuccessful); }
public void Write(PinValue pinValue) { _controller.Write(_pinNumber, pinValue); }
protected void PowerUp() => gpioController.Write(pinNumber, PinValue.High);
public static void Main() { //var gcode = " G1 X5453 Y3423.423"; //var code = GCode.FromLine(gcode); //Console.WriteLine("Hello, .NET on PI!"); //return; var controller = new GpioController(PinNumberingScheme.Board); var stopwatch = Stopwatch.StartNew(); //Thread.SpinWait(); var thread = new Thread(() => { }); thread.Priority = ThreadPriority.Highest; thread.Name = "Stepper Worker"; const int dirPin = 15; const int dirPin2 = 18; const int stepPin = 13; const int stepPin2 = 16; controller.OpenPin(dirPin, PinMode.Output); controller.OpenPin(dirPin2, PinMode.Output); controller.OpenPin(stepPin, PinMode.Output); controller.OpenPin(stepPin2, PinMode.Output); controller.Write(dirPin, PinValue.High); controller.Write(dirPin2, PinValue.High); controller.Write(stepPin, PinValue.Low); controller.Write(stepPin2, PinValue.Low); while (true) { Console.Write("high="); var delay1 = int.Parse(Console.ReadLine() !) * 1000; Console.Write("dir?"); var dir = string.IsNullOrEmpty(Console.ReadLine()); controller.Write(dirPin, dir); controller.Write(dirPin2, dir); for (var i = 0; i < 400 * 20; i++) { controller.Write(stepPin, PinValue.High); controller.Write(stepPin2, PinValue.High); Sleep(delay1); controller.Write(stepPin, PinValue.Low); controller.Write(stepPin2, PinValue.Low); Sleep(delay1); //Console.Write('.'); } Console.WriteLine(); } controller.ClosePin(dirPin); controller.ClosePin(stepPin); //controller.OpenPin(kotiPin, PinMode.Output); // for (var index = 0;; index++) // { // var pinValue = index % 2 == 0 ? PinValue.High : PinValue.Low; // Console.WriteLine(pinValue); // controller.Write(kotiPin, pinValue); // Thread.Sleep(TimeSpan.FromSeconds(1)); // } void Sleep(int delayTicks) { var now = stopwatch.ElapsedTicks; while (stopwatch.ElapsedTicks - now < delayTicks) { GC.KeepAlive(stopwatch); } } }
public void Forward() { _controller.Write(_in1, PinValue.Low); _controller.Write(_in2, PinValue.High); }
private PinValue WriteByte(byte data) { // We send data by 8 bits for (byte i = 0; i < 8; i++) { _controller.Write(_pinClk, PinValue.Low); DelayHelper.DelayMicroseconds(ClockWidthMicroseconds, true); // LSB first if ((data & 0x01) == 0x01) { _controller.Write(_pinDio, PinValue.High); } else { _controller.Write(_pinDio, PinValue.Low); } // LSB first data >>= 1; _controller.Write(_pinClk, PinValue.High); DelayHelper.DelayMicroseconds(ClockWidthMicroseconds, true); } // Wait for the acknowledge _controller.Write(_pinClk, PinValue.Low); _controller.Write(_pinDio, PinValue.High); _controller.Write(_pinClk, PinValue.High); DelayHelper.DelayMicroseconds(ClockWidthMicroseconds, true); _controller.SetPinMode(_pinDio, PinMode.Input); // Wait 1 µs, it's the waiting time between clk up and down // That's according to the documentation DelayHelper.DelayMicroseconds(ClockWidthMicroseconds, true); var ack = _controller.Read(_pinDio); if (ack == PinValue.Low) { // We get acknowledge from the device _controller.SetPinMode(_pinDio, PinMode.Output); _controller.Write(_pinDio, PinValue.Low); } _controller.Write(_pinClk, PinValue.High); DelayHelper.DelayMicroseconds(ClockWidthMicroseconds, true); _controller.Write(_pinClk, PinValue.Low); DelayHelper.DelayMicroseconds(ClockWidthMicroseconds, true); _controller.SetPinMode(_pinDio, PinMode.Output); return(ack); }