/// <summary> /// Reads the PWM "off" (falling) value of a channel, and updates it in <see cref="Channels"/>. /// </summary> /// <param name="index">Zero based channel number (0-15).</param> /// <returns>Channel value.</returns> public int ReadChannelOff(int index) { // Validate if (index < 0 | index >= ChannelCount) { throw new ArgumentOutOfRangeException(nameof(index)); } // Calculate register address of second word value var register = (byte)(GetChannelAddress(index) + sizeof(ushort)); // Read and convert value var bytes = I2cExtensions.WriteReadBytes(_hardware, register, sizeof(ushort)); var value = BitConverter.ToUInt16(bytes, 0); // Update channel when changed var oldValue = _channels[index]; if (oldValue.Off != value) { _channels[index] = new Pca9685ChannelValue(oldValue.On, value); } // Return result return(value); }
/// <summary> /// Reads a coefficient value from the PROM. /// </summary> /// <param name="index">Coefficient index (0-7).</param> /// <param name="buffer">Target buffer.</param> /// <param name="offset">Target offset.</param> /// <remarks> /// Reads <see cref="Ms5611PromData.CoefficientSize"/> bytes into the target buffer at the specified offset. /// </remarks> private void ReadPromCoefficient(int index, byte[] buffer, int offset) { // Calculate address var coefficientOffset = (byte)(index * Ms5611PromData.CoefficientSize); var address = (byte)(Ms5611Command.PromRead + coefficientOffset); // Read from hardware return value var coefficient = I2cExtensions.WriteReadBytes(_hardware, address, Ms5611PromData.CoefficientSize); Array.ConstrainedCopy(coefficient, 0, buffer, offset, Ms5611PromData.CoefficientSize); }
/// <summary> /// Reads all channels and updates <see cref="Channels"/>. /// </summary> public void ReadAllChannels() { // Read all channels as one block of data var data = I2cExtensions.WriteReadBytes(_hardware, ChannelStartAddress, ChannelSize * ChannelCount); // Update properties for (var index = 0; index < ChannelCount; index++) { _channels[index] = Pca9685ChannelValue.FromByteArray(data, ChannelSize * index); } }
/// <summary> /// Executes the <see cref="Ms5611Command.ConvertD2Temperature"/> command to measure /// pressure at the specified OSR, waits then returns the result. /// </summary> public int ConvertTemperature(Ms5611Osr rate) { // Send command to hardware I2cExtensions.WriteJoinByte(_hardware, (byte)(Ms5611Command.ConvertD2Temperature + (byte)rate), 0); // Wait for completion WaitForConversion(rate); // Return result var result = I2cExtensions.WriteReadBytes(_hardware, (byte)Ms5611Command.AdcRead, 3); return(result[0] << 16 | result[1] << 8 | result[2]); }
/// <summary> /// Reads a whole channel value (on and off), and updates it in <see cref="Channels"/>. /// </summary> /// <param name="index">Zero based channel number (0-15).</param> /// <returns>Channel value</returns> public Pca9685ChannelValue ReadChannel(int index) { // Validate if (index < 0 | index >= ChannelCount) { throw new ArgumentOutOfRangeException(nameof(index)); } // Calculate register address var register = GetChannelAddress(index); // Read value var bytes = I2cExtensions.WriteReadBytes(_hardware, register, sizeof(ushort) * 2); // Update channel property and return result var value = Pca9685ChannelValue.FromByteArray(bytes); return(_channels[index] = value); }
/// <summary> /// Reads a "page" of bytes "sequentially" starting at the specified address. /// </summary> public byte[] ReadPage(int address, int length) { // Validate if (address < 0 || address > Size - 1) { throw new ArgumentOutOfRangeException(nameof(address)); } if (length < 0 || length > Size - address) { throw new ArgumentOutOfRangeException(nameof(length)); } // Get correct I2C device and data for memory address and flags var device = GetI2cDeviceForMemoryAddress(address); // Read data with chunking when transfer size exceeds limit var resultBuffer = new byte[length]; var remaining = length; var offset = 0; do { var addressBytes = GetMemoryAddressBytes(address); // Check transfer size and reduce when necessary var transferSize = remaining; if (transferSize > I2cExtensions.MaximumTransferSize) { transferSize = I2cExtensions.MaximumTransferSize; } // Read data var buffer = I2cExtensions.WriteReadBytes(device, addressBytes, transferSize); Array.ConstrainedCopy(buffer, 0, resultBuffer, offset, transferSize); // Next transfer when necessary... remaining -= transferSize; offset += transferSize; address += transferSize; }while (remaining > 0); return(resultBuffer); }
/// <summary> /// Reads multiple channel values (both on and off for each), and updates it in <see cref="Channels"/>. /// </summary> /// <param name="index">Zero based channel number (0-15).</param> /// <param name="count">Number of channels to read.</param> /// <returns>Channel values</returns> public Collection <Pca9685ChannelValue> ReadChannels(int index, int count) { // Validate if (index < 0 | index >= ChannelCount) { throw new ArgumentOutOfRangeException(nameof(index)); } if (count < 1 || index + count > ChannelCount) { throw new ArgumentOutOfRangeException(nameof(count)); } // Calculate register address var register = GetChannelAddress(index); // Send I2C command to read channels in one operation var data = I2cExtensions.WriteReadBytes(_hardware, register, ChannelSize * count); // Update channel properties and add to results var results = new Collection <Pca9685ChannelValue>(); for (int channelIndex = index, offset = 0; count > 0; count--, channelIndex++, offset += ChannelSize) { // Calculate value var value = Pca9685ChannelValue.FromByteArray(data, offset); // Update property _channels[channelIndex] = value; // Add to results results.Add(value); } // Return results return(results); }