public uint ReadDoubleWord(long offset)
{
lock (innerLock)
{
return(RegistersCollection.Read(offset));
}
}
public byte[] Read(int count = 1)
{
var dequeued = false;
switch (address)
{
case (byte)Registers.AccelerometerOutputXLow:
dequeued = accelerationFifo.TryDequeueNewSample();
break;
case (byte)Registers.GyroscopeOutputXLow:
dequeued = angularRateFifo.TryDequeueNewSample();
break;
case (byte)Registers.TemperatureOutputLow:
// temperature data is not queued
temperatureFifo.TryDequeueNewSample();
break;
}
if (dequeued)
{
if (currentReportedFifoDepth > 0)
{
currentReportedFifoDepth--;
}
}
var result = RegistersCollection.Read(address);
this.NoisyLog("Reading register {1} (0x{1:X}) from device: 0x{0:X}", result, (Registers)address);
TryIncrementAddress();
return(new byte [] { result });
}
public byte Transmit(byte data)
{
this.Log(LogLevel.Noisy, "Received byte: 0x{0:X} in state {1}", data, state);
byte result = 0;
switch (state)
{
case State.Idle:
HandleCommandByte(data);
result = RegistersCollection.Read((long)RegisterType.HostIrqPending);
break;
case State.Writing:
this.Log(LogLevel.Noisy, "Writing value 0x{0:X} to register {1} (0x{1:X})", data, lastRegister);
RegistersCollection.Write((long)lastRegister, data);
break;
case State.Reading:
this.Log(LogLevel.Noisy, "Reading value from register {0} (0x{0:X})", lastRegister);
result = RegistersCollection.Read((long)lastRegister);
break;
default:
this.Log(LogLevel.Error, "Received byte 0x{0:X} in an unexpected state: {1}. Ignoring it...", data, state);
break;
}
this.Log(LogLevel.Noisy, "Returning byte: 0x{0:X}", result);
return(result);
}
public byte[] Read(int count)
{
var result = RegistersCollection.Read(address);
this.NoisyLog("Reading register {0} (0x{1:X}) from device: 0x{2:X}", cache.Get(address, x => Enum.GetName(typeof(T), x)), address, result);
return(new byte [] { result });
}
public byte[] Read(int count)
{
var result = RegistersCollection.Read(address);
this.NoisyLog("Reading register {1} (0x{1:X}) from device: 0x{0:X}", result, Enum.GetName(typeof(T), address));
return(new byte [] { result });
}
public byte[] Read(int count = 1)
{
var result = RegistersCollection.Read(address);
// this.Log(LogLevel.Warning, "Reading register {1} (0x{1:x}) from device: 0x{0:x}", result, (Registers)address);
TryIncrementAddress();
return(new byte[] { result });
}
public byte[] Read(int count)
{
this.Log(LogLevel.Debug, "Reading {0} bytes from register {1} (0x{1:X})", count, registerAddress);
var result = new byte[count];
for (var i = 0; i < result.Length; i++)
{
result[i] = RegistersCollection.Read((byte)registerAddress);
this.Log(LogLevel.Noisy, "Read value: {0}", result[i]);
RegistersAutoIncrement();
}
return(result);
}
public byte[] Read(int count)
{
this.Log(LogLevel.Noisy, "Reading {0} bytes from register {1} (0x{1:X})", count, regAddress);
var result = new byte[count];
readyPending.Value = false;
UpdateInterrupts();
for (var i = 0; i < result.Length; i++)
{
result[i] = RegistersCollection.Read((byte)regAddress);
this.Log(LogLevel.Noisy, "Read value {0}", result[i]);
RegistersAutoIncrement();
}
return(result);
}
public byte[] Read(int count)
{
if (registerAddress == Registers.Data0)
{
fifoP.TryDequeueNewSample();
fifoT.TryDequeueNewSample();
}
var result = new byte[registerAddress == Registers.Data0?6 : registerAddress == Registers.OSR?4 : registerAddress == Registers.Calib0?21 : 1];
for (var i = 0; i < result.Length; i++)
{
result[i] = RegistersCollection.Read((byte)registerAddress + i);
this.Log(LogLevel.Noisy, "Read value 0x{0:X} from register {1} (0x{1:X})", result[i], (Registers)registerAddress + i);
}
return(result);
}
public byte[] Read(int count)
{
this.Log(LogLevel.Debug, "Reading {0} bytes from register {1} (0x{1:X})", count, regAddress);
var result = new byte[count];
for (var i = 0; i < result.Length; i++)
{
if (regAddress == Registers.DataOutXH)
{
dataLock.Value = true;
}
result[i] = RegistersCollection.Read((byte)regAddress);
this.Log(LogLevel.Noisy, "Read value {0}", result[i]);
regAddress = (Registers)((int)regAddress + 1);
}
return(result);
}
public byte[] Read(int count)
{
parent.NoisyLog("OV2640: Reading from the device in state {0}", state);
switch (state)
{
case State.Processing:
{
var result = RegistersCollection.Read(address);
parent.NoisyLog("OV2640: Read 0x{0:X} from register {1}", result, DecodeRegister(address));
return(new [] { result });
}
default:
parent.Log(LogLevel.Error, "OV2640: Reading in an unexpected state: {0}", state);
return(new byte[0]);
}
}
public byte[] Read(int count)
{
if (registerAddress == Registers.RateXLSB)
{
fifo.TryDequeueNewSample();
}
// If registerAddress = 0x02 (xLSB) return 6 bytes (x,y,z)
// else return 1 byte i.e. the register
var result = new byte[registerAddress == Registers.RateXLSB?6:1];
for (var i = 0; i < result.Length; i++)
{
result[i] = RegistersCollection.Read((byte)registerAddress + i);
this.Log(LogLevel.Noisy, "Read value 0x{0:X} from register {1} (0x{1:X})", result[i], (Registers)registerAddress + i);
}
return(result);
}
public byte[] Read(int count = 1)
{
switch (address)
{
case (byte)Registers.OutputXLow:
{
// magnetic data is not queued
fifo.TryDequeueNewSample();
}
break;
}
var result = RegistersCollection.Read(address);
this.NoisyLog("Reading register {1} (0x{1:X}) from device: 0x{0:X}", result, (Registers)address);
TryIncrementAddress();
return(new byte [] { result });
}
public byte[] Read(int count = 0)
{
var ret = new byte[count];
for (int i = 0; i < count; i++)
{
ret[i] = RegistersCollection.Read(registerAddress);
this.Log(LogLevel.Noisy, "Reading from {0}: 0x{1:X}", (Registers)registerAddress, ret[i]);
if (registerAddress == (uint)(wrapAfterStatus.Value ? Registers.Status2 : Registers.ZoutMsb))
{
registerAddress = (byte)Registers.XoutLsb;
}
else
{
registerAddress++;
}
}
return(ret);
}
public byte[] Read(int count = 1)
{
byte[] result = null;
switch (state)
{
case State.Idle:
this.Log(LogLevel.Noisy, "Unexpected reading in Idle state");
result = new byte[] { };
break;
case State.Processing:
result = new byte[] { RegistersCollection.Read(address) };
address++;
break;
default:
throw new ArgumentException($"Unexpected state: {state}");
}
return(result);
}
public byte Transmit(byte data)
{
byte result = 0;
switch (state)
{
case State.Idle:
{
selectedRegister = (Registers)BitHelper.GetValue(data, 0, 7);
var isRead = BitHelper.IsBitSet(data, 7);
this.NoisyLog("Decoded register {0} (0x{0:X}) and isRead bit as {1}", selectedRegister, isRead);
state = isRead
? State.Reading
: State.Writing;
break;
}
case State.Reading:
this.NoisyLog("Reading register {0} (0x{0:X})", selectedRegister);
result = RegistersCollection.Read((long)selectedRegister);
break;
case State.Writing:
this.NoisyLog("Writing 0x{0:X} to register {1} (0x{1:X})", data, selectedRegister);
RegistersCollection.Write((long)selectedRegister, data);
UpdateDataAvailable();
break;
default:
this.Log(LogLevel.Error, "Received byte in an unexpected state: {0}", state);
break;
}
this.NoisyLog("Received byte 0x{0:X}, returning 0x{1:X}", data, result);
return(result);
}
public byte Transmit(byte b)
{
if (!chipSelected)
{
this.Log(LogLevel.Warning, "Received transmission, but CS pin is not selected");
return(0);
}
byte result = 0;
switch (state)
{
case State.Idle:
result = HandleIdle(b);
break;
case State.Reading:
this.NoisyLog("Reading register {0} (0x{0:X})", (Registers)address);
result = RegistersCollection.Read(address);
address++;
break;
case State.Writing:
this.NoisyLog("Writing 0x{0:X} to register {1} (0x{1:X})", b, (Registers)address);
RegistersCollection.Write(address, b);
address++;
break;
default:
this.Log(LogLevel.Error, "Received byte in an unexpected state!");
break;
}
this.Log(LogLevel.Noisy, "Transmitting - received 0x{0:X}, sending 0x{1:X} back", b, result);
return(result);
}
public ushort ReadWord(long offset)
{
return(RegistersCollection.Read(offset));
}
public byte ReadRegister(byte offset)
{
return(RegistersCollection.Read(offset));
}
public virtual byte ReadByte(long offset)
{
return(RegistersCollection.Read(offset));
}
public virtual uint ReadDoubleWord(long offset)
{
return(RegistersCollection.Read(offset));
}
public uint ReadDoubleWord(long offset)
{
return(memoryManager.TryReadDoubleWord(offset, out uint result)
? result
: RegistersCollection.Read(offset));
}