/// <summary> /// Calibrates the probe using a single point using a mV value. /// </summary> /// <param name="solutionmV">mV value</param> public void CalibrateSingle(float solutionmV) { Write_register((byte)Register.ISE_SOLUTION_REGISTER, solutionmV); Send_command((byte)Command.ISE_CALIBRATE_SINGLE); DelayHelper.DelayMilliseconds(ISE_MV_MEASURE_TIME, allowThreadYield: true); }
private byte Read_byte(byte register) { Change_register(register); DelayHelper.DelayMilliseconds(10, allowThreadYield: true); return(_device.ReadByte()); }
/// <summary> /// Write a PiJuice command /// </summary> /// <param name="command">The PiJuice command</param> /// <param name="data">The data to write</param> internal void WriteCommand(PiJuiceCommand command, ReadOnlySpan <byte> data) { byte tries = 0; Span <byte> buffer = stackalloc byte[data.Length + 2]; data.CopyTo(buffer.Slice(1)); buffer[0] = (byte)command; buffer[buffer.Length - 1] = GetCheckSum(data, checkLastByte: true); // When writing/reading to the I2C port, PiJuice doesn't respond on time in some cases // So we wait a little bit before retrying // In most cases, the I2C read/write can go thru without waiting while (tries < MaxRetries) { try { _i2cDevice.Write(buffer); return; } catch (IOException ex) { tries++; if (tries >= MaxRetries) { throw new IOException($"{nameof(WriteCommand)}: Failed to write command {command}", ex); } DelayHelper.DelayMilliseconds(ReadRetryDelay, false); } } }
public static void MotorTest(List <string> argsList, DCMotor motorL, DCMotor motorR) { double delay; if (argsList.Count > 1) { delay = Convert.ToDouble(argsList[1]); } else { delay = 10; } const double Period = 20.0; Console.WriteLine($"Motor Test"); Stopwatch sw = Stopwatch.StartNew(); string lastSpeedDisp = null; while (sw.ElapsedMilliseconds < (Math.PI * 2000)) { double time = sw.ElapsedMilliseconds / 1000.0; // Note: range is from -1 .. 1 (for 1 pin setup 0 .. 1) motorL.Speed = Math.Sin(2.0 * Math.PI * time / Period); motorR.Speed = Math.Sin(2.0 * Math.PI * time / Period); string disp = $"Speed[L, R] = [{motorL.Speed:0.00}, {motorR.Speed:0.00}]"; if (disp != lastSpeedDisp) { lastSpeedDisp = disp; Console.WriteLine(disp); } DelayHelper.DelayMilliseconds((int)delay, true); } }
/// <summary> /// Initializes the bit mode settings. /// </summary> protected override void InitializeBitMode() { // Prep the pins _controller.OpenPin(_rsPin, PinMode.Output); if (_rwPin != -1) { _controller.OpenPin(_rwPin, PinMode.Output); } if (_backlight != -1) { _controller.OpenPin(_backlight, PinMode.Output); if (_backlightBrightness > 0) { // Turn on the backlight _controller.Write(_backlight, PinValue.High); } } _controller.OpenPin(_enablePin, PinMode.Output); for (int i = 0; i < _dataPins.Length; ++i) { _controller.OpenPin(_dataPins[i], PinMode.Output); } // The HD44780 self-initializes when power is turned on to the following settings: // // - 8 bit, 1 line, 5x7 font // - Display, cursor, and blink off // - Increment with no shift // // It is possible that the initialization will fail if the power is not provided // within specific tolerances. As such, we'll always perform the software based // initialization as described on pages 45/46 of the HD44780 data sheet. We give // a little extra time to the required waits. if (_dataPins.Length == 8) { // Init to 8 bit mode DelayHelper.DelayMilliseconds(50, allowThreadYield: true); Send(0b0011_0000); DelayHelper.DelayMilliseconds(5, allowThreadYield: true); Send(0b0011_0000); DelayHelper.DelayMicroseconds(100, allowThreadYield: true); Send(0b0011_0000); } else { // Init to 4 bit mode, setting _rspin to low as we're writing 4 bits directly. // (Send writes the whole byte in two 4bit/nybble chunks) _controller.Write(_rsPin, PinValue.Low); DelayHelper.DelayMilliseconds(50, allowThreadYield: true); WriteBits(0b0011, 4); DelayHelper.DelayMilliseconds(5, allowThreadYield: true); WriteBits(0b0011, 4); DelayHelper.DelayMicroseconds(100, allowThreadYield: true); WriteBits(0b0011, 4); WriteBits(0b0010, 4); } }
public static void IrTest(List <string> argsList, IrReceiver ir) { Console.WriteLine($"Ir Test"); double delay; if (argsList.Count > 1) { delay = Convert.ToDouble(argsList[1]); } else { delay = 10; } while (true) { int data = ir.GetKey(); if (data == 0 & data != 999) { Console.Write($"_"); } else if (data == 999) { Console.WriteLine($"data: repeated last"); } else { Console.WriteLine($"data: {data} "); } DelayHelper.DelayMilliseconds((int)delay, true); } }
public static void AdcTest(List <string> argsList, Tlc1543 adc) { Console.WriteLine($"ADC Test"); double delay; byte sensorNumber; if (argsList.Count > 1) { delay = Convert.ToDouble(argsList[1]); } else { delay = 10; } if (argsList.Count > 2) { sensorNumber = Convert.ToByte(argsList[2]); } else { sensorNumber = 11; } while (true) { for (int i = 0; i < sensorNumber; i++) { Console.Write($"{i}: {adc.ReadChannel((Tlc1543.Channel)i),4} "); DelayHelper.DelayMilliseconds((int)delay, true); } Console.WriteLine(); } }
private void Write_byte(byte register, byte value) { Change_register(register); _device.WriteByte(value); DelayHelper.DelayMilliseconds(10, allowThreadYield: true); }
/// <summary> /// Create a DHT10 sensor through I2C /// </summary> /// <param name="i2cDevice">I2C Device</param> public Dht10(I2cDevice i2cDevice) : base(i2cDevice) { i2cDevice.WriteByte(DHT10_CMD_SOFTRESET); // make sure DHT10 stable (in the datasheet P7) DelayHelper.DelayMilliseconds(20, true); i2cDevice.WriteByte(DHT10_CMD_INIT); }
private void Send_command(byte data) { Span <byte> bytes = stackalloc byte[2]; bytes[0] = (byte)Register.ISE_TASK_REGISTER; bytes[1] = data; _device.Write(bytes); DelayHelper.DelayMilliseconds(10, allowThreadYield: true); }
/// <summary> /// Initializes the bit mode settings. /// </summary> protected override void InitializeBitMode() { // Init to 8 bit mode DelayHelper.DelayMilliseconds(50, allowThreadYield: true); Send(0b0011_0000); DelayHelper.DelayMilliseconds(5, allowThreadYield: true); Send(0b0011_0000); DelayHelper.DelayMicroseconds(100, allowThreadYield: true); Send(0b0011_0000); }
/// <summary> /// Measure mV /// </summary> /// <returns>mV read from ISE Probe Interface</returns> public float MeasuremV() { Send_command((byte)Command.ISE_MEASURE_MV); DelayHelper.DelayMilliseconds(ISE_MV_MEASURE_TIME, allowThreadYield: true); _mV = Read_register((byte)Register.ISE_MV_REGISTER); _mV = Convert.ToSingle(Math.Round(_mV, 2)); return(_mV); }
internal override void ReadThroughI2c() { // DHT10 has no calibration bits IsLastReadSuccessful = true; _i2cDevice.WriteByte(DHT10_CMD_START); // make sure DHT10 ends measurement (in the datasheet P7) DelayHelper.DelayMilliseconds(75, true); _i2cDevice.Read(_dht10ReadBuff); }
private void Write(Register register) { Span <byte> writeBuff = stackalloc byte[2]; BinaryPrimitives.WriteUInt16BigEndian(writeBuff, (ushort)register); _i2cDevice.Write(writeBuff); // wait SCL free DelayHelper.DelayMilliseconds(20, false); }
/// <summary> /// Read data from PiJuice /// </summary> /// <param name="command">The PiJuice command</param> /// <param name="length">The length of the data to be read</param> /// <returns>Returns an array of the bytes read</returns> internal byte[] ReadCommand(PiJuiceCommand command, byte length) { byte tries = 0; Span <byte> outArray = stackalloc byte[length + 1]; outArray.Clear(); // When writing/reading the I2C port, PiJuice doesn't respond on time in some cases // So we wait a little bit before retrying // In most cases, the I2C read/write can go thru without waiting while (tries < MaxRetries) { try { _i2cDevice.Write(new byte[] { (byte)command }); _i2cDevice.Read(outArray); var checksum = GetCheckSum(outArray); if (checksum != outArray[length]) { outArray[0] |= 0x80; checksum = GetCheckSum(outArray); if (checksum != outArray[length]) { tries++; if (tries >= MaxRetries) { throw new InvalidDataException($"{nameof(ReadCommand)}: Invalid checksum read command {command}, checksum {checksum}"); } DelayHelper.DelayMilliseconds(ReadRetryDelay, false); continue; } } break; } catch (IOException ex) { tries++; if (tries >= MaxRetries - 1) { throw new IOException($"{nameof(ReadCommand)}: Failed to read command {command}", ex); } DelayHelper.DelayMilliseconds(ReadRetryDelay, false); } } return(outArray.Slice(0, length).ToArray()); }
/// <summary> /// Initializes the Seesaw device. /// <param name="i2cDevice">The I2cDevice to initialize the Seesaw device with.</param> /// </summary> protected void Initialize(I2cDevice i2cDevice) { SoftwareReset(); DelayHelper.DelayMilliseconds(10, true); if (ReadByte(SeesawModule.Status, SeesawFunction.StatusHwId) != SessawHardwareId) { throw new NotSupportedException($"The hardware on I2C Bus {I2cDevice.ConnectionSettings.BusId}, Address 0x{I2cDevice.ConnectionSettings.DeviceAddress:X2} does not appear to be an Adafruit SeeSaw module"); } _options = GetOptions(); Version = GetVersion(); }
internal override void ReadThroughI2c() { if (_i2cDevice is null) { throw new Exception("I2C decvice not configured."); } // DHT10 has no calibration bits IsLastReadSuccessful = true; _i2cDevice.WriteByte(DHT10_CMD_START); // make sure DHT10 ends measurement (in the datasheet P7) DelayHelper.DelayMilliseconds(75, true); _i2cDevice.Read(_dht10ReadBuff); }
/// <summary> /// Write a PiJuice command and verify /// </summary> /// <param name="command">The PiJuice command</param> /// <param name="data">The data to write</param> /// <param name="delay">The delay before reading the data</param> internal void WriteCommandVerify(PiJuiceCommand command, ReadOnlySpan <byte> data, int delay = 0) { WriteCommand(command, data); if (delay > 0) { DelayHelper.DelayMilliseconds(delay, false); } var response = ReadCommand(command, (byte)data.Length); if (!data.SequenceEqual(response)) { throw new IOException($"{nameof(WriteCommandVerify)}: Failed to write command {command}"); } }
private void updateSizeLoop() { try { while (resizeDown || resizeLeft || resizeRight || resizeUp) { _window.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Render, new RefreshDelegate(updateSize)); _window.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Render, new RefreshDelegate(updateMouseDown)); DelayHelper.DelayMilliseconds(10); } _window.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Render, new RefreshDelegate(setArrowCursor)); } catch (Exception) { } }
/// <summary> /// Measure temperature /// </summary> /// <returns>Temperature in celsius</returns> public float MeasureTemp() { Send_command((byte)Command.ISE_MEASURE_TEMP); DelayHelper.DelayMilliseconds(ISE_TEMP_MEASURE_TIME, allowThreadYield: true); _tempC = Read_register((byte)Register.ISE_TEMP_REGISTER); if (_tempC == -127.0) { _tempF = -127.0F; } else { _tempF = ((_tempC * 9) / 5) + 32; } return(_tempC); }
public static void CameraTest(List <string> argsList, Camera camera) { Console.WriteLine($"Camera Test"); double delay; if (argsList.Count > 1) { delay = Convert.ToDouble(argsList[1]); } else { delay = 100; } camera.SetCaptureProperty(Emgu.CV.CvEnum.CapProp.Fps, 30); camera.SetCaptureProperty(Emgu.CV.CvEnum.CapProp.FrameWidth, 1920); camera.SetCaptureProperty(Emgu.CV.CvEnum.CapProp.FrameHeight, 1080); //int fourcc = VideoWriter.Fourcc('I', 'Y', 'U', 'V'); // //try //{ // VideoW = new VideoWriter(@"/home/pi/test_%02d.avi", // frameRate, fourcc, // new System.Drawing.Size( // (int)camera.GetCaptureProperty(Emgu.CV.CvEnum.CapProp.FrameWidth), // (int)camera.GetCaptureProperty(Emgu.CV.CvEnum.CapProp.FrameHeight)), // true); //} //catch (Exception e) //{ // Console.WriteLine(e.Message); //} // //VideoW = new VideoWriter(@"/home/pi/test.avi", 30, fourcc, new System.Drawing.Size(1280, 720), true); camera.Start(); while (true) { DelayHelper.DelayMilliseconds((int)delay, true); } }
private void Write_register(byte register, float?data) { byte[] dataArray = { 0, 0, 0, 0 }; if (data != null) { dataArray = BitConverter.GetBytes(Round_total_digits(data.Value)); } Span <byte> bytes = new Span <byte>(new byte[4]); bytes[0] = dataArray[0]; bytes[1] = dataArray[1]; bytes[2] = dataArray[2]; bytes[3] = dataArray[3]; Change_register(register); _device.Write(bytes); DelayHelper.DelayMilliseconds(10, allowThreadYield: true); }
public static void IrTest1(List <string> argsList, IrReceiver ir) { Console.WriteLine($"Ir Test1"); double delay; if (argsList.Count > 1) { delay = Convert.ToDouble(argsList[1]); } else { delay = 10; } while (true) { Console.WriteLine($"{ir.GetKeyTemp()}"); DelayHelper.DelayMilliseconds((int)delay, true); } }
private void Initialize() { // Prep the pins _controller.OpenPin(_rsPin, PinMode.Output); if (_rwPin != -1) { _controller.OpenPin(_rwPin, PinMode.Output); // Set to write. Once we enable reading have reading pull high and reset // after reading to give maximum performance to write (i.e. assume that // the pin is low when writing). _controller.Write(_rwPin, PinValue.Low); } if (_backlight != -1) { _controller.OpenPin(_backlight, PinMode.Output); if (_backlightBrightness > 0) { // Turn on the backlight _controller.Write(_backlight, PinValue.High); } } _controller.OpenPin(_enablePin, PinMode.Output); for (int i = 0; i < _dataPins.Length; ++i) { _controller.OpenPin(_dataPins[i], PinMode.Output); } // The HD44780 self-initializes when power is turned on to the following settings: // // - 8 bit, 1 line, 5x7 font // - Display, cursor, and blink off // - Increment with no shift // // It is possible that the initialization will fail if the power is not provided // within specific tolerances. As such, we'll always perform the software based // initialization as described on pages 45/46 of the HD44780 data sheet. We give // a little extra time to the required waits as described. if (_dataPins.Length == 8) { // Init to 8 bit mode (this is the default, but other drivers // may set the controller to 4 bit mode, so reset to be safe.) DelayHelper.DelayMilliseconds(50, allowThreadYield: true); WriteBits(0b0011_0000, 8); DelayHelper.DelayMilliseconds(5, allowThreadYield: true); WriteBits(0b0011_0000, 8); DelayHelper.DelayMicroseconds(100, allowThreadYield: true); WriteBits(0b0011_0000, 8); } else { // Init to 4 bit mode, setting _rspin to low as we're writing 4 bits directly. // (Send writes the whole byte in two 4bit/nybble chunks) _controller.Write(_rsPin, PinValue.Low); DelayHelper.DelayMilliseconds(50, allowThreadYield: true); WriteBits(0b0011, 4); DelayHelper.DelayMilliseconds(5, allowThreadYield: true); WriteBits(0b0011, 4); DelayHelper.DelayMicroseconds(100, allowThreadYield: true); WriteBits(0b0011, 4); WriteBits(0b0010, 4); } // The busy flag can NOT be checked until this point. }
private void Change_register(byte register) { _device.WriteByte(register); DelayHelper.DelayMilliseconds(10, allowThreadYield: true); }
/// <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; } }