public void Write(byte[] data)
{
if (data.Length == 0)
{
this.Log(LogLevel.Warning, "Unexpected write with no data");
return;
}
this.Log(LogLevel.Noisy, "Write with {0} bytes of data: {1}", data.Length, Misc.PrettyPrintCollectionHex(data));
registerAddress = (Registers)data[0];
if (data.Length > 1)
{
// skip the first byte as it contains register address
foreach (var b in data.Skip(1))
{
this.Log(LogLevel.Noisy, "Writing 0x{0:X} to register {1} (0x{1:X})", b, registerAddress);
RegistersCollection.Write((byte)registerAddress, b);
}
}
else
{
this.Log(LogLevel.Noisy, "Preparing to read register {0} (0x{0:X})", registerAddress);
}
}
public void WriteDoubleWord(long offset, uint value)
{
lock (innerLock)
{
RegistersCollection.Write(offset, value);
}
}
public override void Reset()
{
enabled = false;
base.Reset();
RegistersCollection.Reset();
}
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 override void Reset()
{
receiveFifo.Clear();
enabled = false;
RegistersCollection.Reset();
UpdateInterrupts();
}
private void Write(byte b)
{
parent.NoisyLog("OV2640: Received byte 0x{0:X} in state {1}", b, state);
switch (state)
{
case State.Idle:
{
address = b;
state = State.Processing;
parent.NoisyLog("OV2640: Selected register {0}", DecodeRegister(address));
break;
}
case State.Processing:
{
parent.NoisyLog("OV2640: Writing 0x{0:X} to register {1}", b, DecodeRegister(address));
RegistersCollection.Write(address, b);
break;
}
default:
parent.Log(LogLevel.Error, "OV2640: Writing byte in an unexpected state: {0}", state);
break;
}
}
public void Reset()
{
RegistersCollection.Reset();
registerAddress = 0;
Int1.Unset();
this.Log(LogLevel.Noisy, "Reset registers");
}
public void Reset()
{
RegistersCollection.Reset();
chipSelected = false;
selectedRegister = 0x0;
state = State.Idle;
}
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 void Write(byte[] data)
{
if (data.Length == 0)
{
this.Log(LogLevel.Warning, "Unexpected write with no data");
return;
}
this.Log(LogLevel.Noisy, "Write with {0} bytes of data: {1}", data.Length, Misc.PrettyPrintCollectionHex(data));
registerAddress = (Registers)data[0];
if (data.Length > 1)
{
// Skip the first byte as it contains register address
// Must skip final byte, problem with I2C
for (var i = 1; i < data.Length - 1; i++)
{
this.Log(LogLevel.Noisy, "Writing 0x{0:X} to register {1} (0x{1:X})", data[i], registerAddress);
RegistersCollection.Write((byte)registerAddress, data[i]);
registerAddress++;
}
}
else
{
this.Log(LogLevel.Noisy, "Preparing to read register {0} (0x{0:X})", registerAddress);
}
}
public uint ReadDoubleWord(long offset)
{
lock (innerLock)
{
return(RegistersCollection.Read(offset));
}
}
public override void Reset()
{
RegisteredPeripheral?.Reset();
RegistersCollection.Reset();
irqManager.Reset();
internalBuffer.Clear();
}
public void Write(byte[] data)
{
if (data.Length == 0)
{
this.Log(LogLevel.Warning, "Unexpected write with no data");
return;
}
this.Log(LogLevel.Noisy, "Write with {0} bytes of data", data.Length);
regAddress = (Registers)data[0];
if (data.Length > 1)
{
// skip the first byte as it contains register address
foreach (var b in data.Skip(1))
{
this.Log(LogLevel.Debug, "Writing 0x{0:X} to register {1} (0x{1:X})", b, regAddress);
RegistersCollection.Write((byte)regAddress, b);
regAddress = (Registers)((int)regAddress + 1);
}
}
else
{
this.Log(LogLevel.Noisy, "Preparing to read register {0} (0x{0:X})", regAddress);
dataReady.Value = IsInSleepMode();
dataLock.Value = false;
}
}
public void WriteDoubleWord(long offset, uint value)
{
if (!memoryManager.TryWriteDoubleWord(offset, value))
{
RegistersCollection.Write(offset, value);
}
}
public override void Reset()
{
base.Reset();
RegistersCollection.Reset();
Array.Clear(buttonsPending, 0, buttonsPending.Length);
UpdateInterrupt();
}
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 void Reset()
{
memoryManager.ResetMemories();
RegistersCollection.Reset();
randomGenerator?.Reset();
isCompleted = false;
coreReset = false;
}
public void Reset()
{
RegistersCollection.Reset();
multipleOperation = false;
registerAddress = 0;
IRQ0.Unset();
IRQ1.Unset();
}
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 void Reset()
{
RegistersCollection.Reset();
address = 0;
addressAutoIncrement = true;
isFirstByte = true;
isSecondByte = false;
}
public void Reset()
{
RegistersCollection.Reset();
sensor.Reset();
chipSelected = false;
selectedRegister = Register.Test;
state = State.Idle;
}
public override void Reset()
{
continuousTransferInProgress = false;
selectedDevice = null;
sizeLeft = 0;
outputFifo.Clear();
RegistersCollection.Reset();
UpdateInterrupts();
}
public void Reset()
{
RegistersCollection.Reset();
magneticSensitivity = Sensitivity.Gauss4;
address = 0;
addressAutoIncrement = false;
state = State.Idle;
}
public void Write(byte[] data)
{
if (data.Length == 0)
{
this.Log(LogLevel.Warning, "Unexpected write with no data");
return;
}
this.Log(LogLevel.Noisy, "Write with {0} bytes of data", data.Length);
// Bits 6-0 represent the first register address
registerAddress = (Registers)(data[0] & 0x7F);
// The most significant bit means multiple read/write operation
multipleOperation = data[0] > 0x80;
if (data.Length > 1)
{
// skip the first byte as it contains register address
foreach (var b in data.Skip(1))
{
this.Log(LogLevel.Noisy, "Writing 0x{0:X} to register {1} (0x{1:X})", b, registerAddress);
RegistersCollection.Write((byte)registerAddress, b);
RegistersAutoIncrement();
}
}
else
{
this.Log(LogLevel.Noisy, "Preparing to read register {0} (0x{0:X})", registerAddress);
if (dataRate.Value == 0)
{
this.Log(LogLevel.Debug, "Power-down mode is set");
xyzDataAvailable.Value = false;
xDataAvailable.Value = false;
yDataAvailable.Value = false;
zDataAvailable.Value = false;
}
else
{
if (xAxisEnable.Value && yAxisEnable.Value && zAxisEnable.Value)
{
xyzDataAvailable.Value = true;
xDataAvailable.Value = false;
yDataAvailable.Value = false;
zDataAvailable.Value = false;
}
else
{
xyzDataAvailable.Value = false;
xDataAvailable.Value = xAxisEnable.Value;
yDataAvailable.Value = yAxisEnable.Value;
zDataAvailable.Value = zAxisEnable.Value;
}
}
UpdateInterrupts();
}
}
public override void Reset()
{
slaveToMasterBuffer.Clear();
masterToSlaveBuffer.Clear();
selectedSlave = null;
enabled = false;
RegistersCollection.Reset();
UpdateInterrupts();
}
public void Reset()
{
RegistersCollection.Reset();
state = State.Idle;
address = 0;
chipSelected = false;
AccelerationX = 0;
AccelerationY = 0;
AccelerationZ = 0;
}
public void Reset()
{
RegistersCollection.Reset();
angularRateSensitivity = AngularRateSensitivity.DPS245;
accelerationSensitivity = AccelerationSensitivity.G2;
address = 0;
currentReportedFifoDepth = 0;
state = State.Idle;
}
public override void Reset()
{
base.Reset();
RegistersCollection.Reset();
foreach (var pin in Pins)
{
pin.Reset();
}
}
public override void Reset()
{
RegistersCollection.Reset();
outputBuffer.Clear();
repeatCounter = 1;
dataBytesLeft = 0;
bytesToRead = 0;
state = State.WaitForCommand;
}
