private static void WriteIndividualByte(Mcp23xxx mcp23xxx)
{
// This assumes the device is in default Sequential Operation mode.
Console.WriteLine("Write Individual Byte");
using (mcp23xxx)
{
Register.Address address = Register.Address.IODIR;
void IndividualRead(Mcp23xxx mcp, Register.Address addressToRead)
{
byte[] dataRead = mcp23xxx.Read(addressToRead, 1, Port.PortB, Bank.Bank0);
Console.WriteLine($"\tIODIRB: 0x{dataRead[0]:X2}");
}
Console.WriteLine("Before Write");
IndividualRead(mcp23xxx, address);
byte[] dataWrite = new byte[] { 0x12 };
mcp23xxx.Write(address, dataWrite, Port.PortB, Bank.Bank0);
Console.WriteLine("After Write");
IndividualRead(mcp23xxx, address);
dataWrite = new byte[] { 0xFF };
mcp23xxx.Write(address, dataWrite, Port.PortB, Bank.Bank0);
Console.WriteLine("After Writing Again");
IndividualRead(mcp23xxx, address);
}
}
/// <summary>
/// Reads a bit from a register.
/// </summary>
/// <param name="registerAddress">The register address to read.</param>
/// <param name="bitNumber">The register bit number to read.</param>
/// <param name="port">The I/O port used with the registers.</param>
/// <param name="bank">The bank type that determines how the register is mapped.</param>
/// <returns>The value of the register bit read.</returns>
public bool ReadBit(Register.Address registerAddress, int bitNumber, Port port = Port.PortA, Bank bank = Bank.Bank1)
{
ValidateBitNumber(bitNumber);
byte data = Read(registerAddress, port, bank);
return(GetBit(data, bitNumber));
}
public override void Write(Register.Address startingRegisterAddress, byte[] data, Port port = Port.PortA, Bank bank = Bank.Bank1)
{
byte[] writeBuffer = new byte[data.Length + 1]; // Include Register Address.
writeBuffer[0] = Register.GetMappedAddress(startingRegisterAddress, port, bank);
data.CopyTo(writeBuffer, 1);
_i2cDevice.Write(writeBuffer);
}
public override byte[] Read(Register.Address startingRegisterAddress, byte byteCount, Port port = Port.PortA, Bank bank = Bank.Bank1)
{
Write(startingRegisterAddress, new byte[] { }, port, bank); // Set address to register first.
byte[] readBuffer = new byte[byteCount];
_i2cDevice.Read(readBuffer);
return(readBuffer);
}
public override void Write(Register.Address startingRegisterAddress, byte[] data, Port port = Port.PortA, Bank bank = Bank.Bank1)
{
byte[] writeBuffer = new byte[data.Length + 2]; // Include OpCode and Register Address.
writeBuffer[0] = OpCode.GetOpCode(DeviceAddress, false);
writeBuffer[1] = Register.GetMappedAddress(startingRegisterAddress, port, bank);
data.CopyTo(writeBuffer, 2);
_spiDevice.Write(writeBuffer);
}
public void Write(int deviceAddress, Register.Address registerAddress, byte data, Port port = Port.PortA, Bank bank = Bank.Bank1)
{
byte opCode = OpCode.GetOpCode(deviceAddress, false);
byte mappedAddress = Register.GetMappedAddress(registerAddress, port, bank);
byte[] writeBuffer = new byte[] { opCode, mappedAddress, data };
_spiDevice.Write(writeBuffer);
}
public byte Read(int deviceAddress, Register.Address registerAddress, Port port = Port.PortA, Bank bank = Bank.Bank1)
{
byte opCode = OpCode.GetOpCode(deviceAddress, true);
byte mappedAddress = Register.GetMappedAddress(registerAddress, port, bank);
byte[] writeBuffer = new byte[] { opCode, mappedAddress, 0 };
byte[] readBuffer = new byte[3];
_spiDevice.TransferFullDuplex(writeBuffer, readBuffer);
return(readBuffer[2]);
}
public override byte[] Read(Register.Address startingRegisterAddress, byte byteCount, Port port = Port.PortA, Bank bank = Bank.Bank1)
{
byteCount += 2; // Include OpCode and Register Address.
byte[] writeBuffer = new byte[byteCount];
writeBuffer[0] = OpCode.GetOpCode(DeviceAddress, true);
writeBuffer[1] = Register.GetMappedAddress(startingRegisterAddress, port, bank);
byte[] readBuffer = new byte[byteCount];
_spiDevice.TransferFullDuplex(writeBuffer, readBuffer);
return(readBuffer.AsSpan().Slice(2).ToArray()); // First 2 bytes are from sending OpCode and Register Address.
}
/// <summary>
/// Writes to a register bit.
/// </summary>
/// <param name="registerAddress">The register address to write.</param>
/// <param name="bitNumber">The register bit number to write.</param>
/// <param name="bit">The value to write to register bit.</param>
/// <param name="port">The I/O port used with the registers.</param>
/// <param name="bank">The bank type that determines how the register is mapped.</param>
public void WriteBit(Register.Address registerAddress, int bitNumber, bool bit, Port port = Port.PortA, Bank bank = Bank.Bank1)
{
ValidateBitNumber(bitNumber);
byte data = Read(registerAddress, port, bank);
if (bit)
{
SetBit(ref data, bitNumber);
}
else
{
ClearBit(ref data, bitNumber);
}
Write(registerAddress, data, port, bank);
}
/// <summary> /// Reads a number of bytes from registers. /// </summary> /// <param name="startingRegisterAddress">The starting register address to read.</param> /// <param name="byteCount">The number of bytes to read.</param> /// <param name="port">The I/O port used with the register.</param> /// <param name="bank">The bank type that determines how the registers are mapped.</param> /// <returns>The data read from the registers.</returns> public abstract byte[] Read(Register.Address startingRegisterAddress, byte byteCount, Port port = Port.PortA, Bank bank = Bank.Bank1);
public void Write(Register.Address startingRegisterAddress, byte[] data)
{
Write(startingRegisterAddress, data, Port.PortA, Bank.Bank1);
}
public void Write(Register.Address registerAddress, byte data)
{
Write(registerAddress, data, Port.PortA, Bank.Bank1);
}
public byte[] Read(Register.Address startingRegisterAddress, byte byteCount)
{
return(Read(startingRegisterAddress, byteCount, Port.PortA, Bank.Bank1));
}
public byte Read(Register.Address registerAddress)
{
return(Read(registerAddress, Port.PortA, Bank.Bank1));
}
/// <summary> /// Writes a number of bytes to registers. /// </summary> /// <param name="startingRegisterAddress">The starting register address to write.</param> /// <param name="data">The data to write to registers.</param> /// <param name="port">The I/O port used with the registers.</param> /// <param name="bank">The bank type that determines how the registers are mapped.</param> public abstract void Write(Register.Address startingRegisterAddress, byte[] data, Port port = Port.PortA, Bank bank = Bank.Bank1);
public void Get_Mapped_Address(Register.Address address, Port port, Bank bank, byte expectedMappedAddress)
{
byte actualMappedAddress = Register.GetMappedAddress(address, port, bank);
Assert.Equal(expectedMappedAddress, actualMappedAddress);
}
/// <summary>
/// Writes a byte to a register.
/// </summary>
/// <param name="registerAddress">The register address to write.</param>
/// <param name="data">The data to write to the register.</param>
/// <param name="port">The I/O port used with the registers.</param>
/// <param name="bank">The bank type that determines how the register is mapped.</param>
public void Write(Register.Address registerAddress, byte data, Port port = Port.PortA, Bank bank = Bank.Bank1)
{
Write(registerAddress, new byte[] { data }, port, bank);
}
/// <summary>
/// Reads a byte from a register.
/// </summary>
/// <param name="registerAddress">The register address to read.</param>
/// <param name="port">The I/O port used with the registers.</param>
/// <param name="bank">The bank type that determines how the register is mapped.</param>
/// <returns>The data read from the register.</returns>
public byte Read(Register.Address registerAddress, Port port = Port.PortA, Bank bank = Bank.Bank1)
{
byte[] data = Read(registerAddress, 1, port, bank);
return(data[0]);
}
