/// <summary> Write memory in the current bank. It is recommended that
/// when writing data that some structure in the data is created
/// to provide error free reading back with read(). Or the
/// method 'writePagePacket()' could be used which automatically
/// wraps the data in a length and CRC.
///
/// When using on Write-Once devices care must be taken to write into
/// into empty space. If write() is used to write over an unlocked
/// page on a Write-Once device it will fail. If write verification
/// is turned off with the method 'setWriteVerification(false)' then
/// the result will be an 'AND' of the existing data and the new data.
///
/// </summary>
/// <param name="startAddr"> starting address, relative to the starting physical address
/// of this memory bank
/// </param>
/// <param name="writeBuf"> byte array containing data to write
/// </param>
/// <param name="offset"> offset into writeBuf to get data
/// </param>
/// <param name="len"> length in bytes to write
///
/// </param>
/// <throws> OneWireIOException </throws>
/// <throws> OneWireException </throws>
public virtual void write(int startAddr, byte[] writeBuf, int offset, int len)
{
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
if (DEBUG)
{
Debug.debug("-----------------------------------------------------------");
Debug.debug("MemoryBankSHAEE.write(int,byte[],int,int) called");
Debug.debug(" startAddr=0x" + Convert.toHexString((byte)startAddr));
Debug.debug(" writeBuf", writeBuf, offset, len);
Debug.debug(" startPhysicalAddress=0x" + Convert.toHexString((byte)startPhysicalAddress));
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
int room_left;
if (!checked_Renamed)
{
checked_Renamed = ib.checkStatus();
}
// return if nothing to do
if (len == 0)
{
return;
}
// attempt to put device at speed
checkSpeed();
// check to see if secret is set
if (!ib.ContainerSecretSet)
{
throw new OneWireException("Secret is not set.");
}
// check if write exceeds memory
if ((startAddr + len) > size)
{
throw new OneWireException("Write exceeds memory bank end");
}
// check if trying to write read only bank
if (ReadOnly)
{
throw new OneWireException("Trying to write read-only memory bank");
}
// loop while still have pages to write
int startx = 0, nextx = 0; // (start and next index into writeBuf)
byte[] raw_buf = new byte[8];
byte[] memory = new byte[(size - (startAddr & 0xE0))]; // till end of memory
int abs_addr = startPhysicalAddress + startAddr;
int pl = 8;
read(startAddr & 0xE0, false, memory, 0, memory.Length);
if (abs_addr >= 128)
{
ib.getContainerSecret(memory, 0);
}
do
{
// calculate room left in current page
room_left = pl - ((abs_addr + startx) % pl);
// check if block left will cross end of page
if ((len - startx) > room_left)
{
nextx = startx + room_left;
}
else
{
nextx = len;
}
// bug fix, if updating pages two and three in the same write op
// this used to fail, was (startAddr>=pageLength)
if ((startx + startAddr) >= pageLength)
{
Array.Copy(memory, (((startx + startAddr) / 8) * 8) - 32, raw_buf, 0, 8);
}
else
{
Array.Copy(memory, (((startx + startAddr) / 8) * 8), raw_buf, 0, 8);
}
if ((nextx - startx) == 8)
{
Array.Copy(writeBuf, offset + startx, raw_buf, 0, 8);
}
else if (((startAddr + nextx) % 8) == 0)
{
Array.Copy(writeBuf, offset + startx, raw_buf, ((startAddr + startx) % 8), 8 - ((startAddr + startx) % 8));
}
else
{
Array.Copy(writeBuf, offset + startx, raw_buf, ((startAddr + startx) % 8), ((startAddr + nextx) % 8) - ((startAddr + startx) % 8));
}
// write the page of data to scratchpad
scratchpad.writeScratchpad(abs_addr + startx + room_left - 8, raw_buf, 0, 8);
// Copy data from scratchpad into memory
scratchpad.copyScratchpad(abs_addr + startx + room_left - 8, raw_buf, 0, memory, 0);
// bug fix, if updating pages two and three in the same write op
// this used to fail, was (startAddr>=pageLength)
if ((startx + startAddr) >= pageLength)
{
Array.Copy(raw_buf, 0, memory, (((startx + startAddr) / 8) * 8) - 32, 8);
}
else
{
Array.Copy(raw_buf, 0, memory, (((startx + startAddr) / 8) * 8), 8);
}
// point to next index
startx = nextx;
}while (nextx < len);
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
if (DEBUG)
{
Debug.debug("-----------------------------------------------------------");
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
}
//--------
//-------- MemoryBank I/O methods
//--------
/// <summary> Read memory in the current bank with no CRC checking (device or
/// data). The resulting data from this API may or may not be what is on
/// the 1-Wire device. It is recommends that the data contain some kind
/// of checking (CRC) like in the readPagePacket() method or have
/// the 1-Wire device provide the CRC as in readPageCRC(). readPageCRC()
/// however is not supported on all memory types, see 'hasPageAutoCRC()'.
/// If neither is an option then this method could be called more
/// then once to at least verify that the same thing is read consistantly.
///
/// </summary>
/// <param name="startAddr"> starting address, relative to physical address for
/// this memory bank.
/// </param>
/// <param name="readContinue"> if 'true' then device read is continued without
/// re-selecting. This can only be used if the new
/// read() continious where the last one led off
/// and it is inside a 'beginExclusive/endExclusive'
/// block.
/// </param>
/// <param name="readBuf"> byte array to place read data into
/// </param>
/// <param name="offset"> offset into readBuf to place data
/// </param>
/// <param name="len"> length in bytes to read
///
/// </param>
/// <throws> OneWireIOException </throws>
/// <throws> OneWireException </throws>
public virtual void read(int startAddr, bool readContinue, byte[] readBuf, int offset, int len)
{
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
if (DEBUG)
{
Debug.debug("-----------------------------------------------------------");
Debug.debug("MemoryBankSHAEE.read(int, boolean, byte[], int, int) called");
Debug.debug(" startAddr=0x" + Convert.toHexString((byte)startAddr));
Debug.debug(" readContinue=" + readContinue);
Debug.debug(" offset=" + offset);
Debug.debug(" len=" + len);
Debug.debug(" this.startPhysicalAddress=0x" + Convert.toHexString((byte)startPhysicalAddress));
Debug.debug(" this.pageLength=" + this.pageLength);
Debug.debug(" this.numberPages=" + this.numberPages);
Debug.stackTrace();
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
// attempt to put device at max desired speed
if (!readContinue && ib.adapterSet())
{
checkSpeed();
}
// check if read exceeds memory
if ((startAddr + len) > (pageLength * numberPages))
{
throw new OneWireException("Read exceeds memory bank end.");
}
// see if need to access the device
if (!readContinue)
{
// select the device
if (!adapter.select(ib.Address))
{
throw new OneWireIOException("Device select failed.");
}
// build start reading memory block
int addr = startAddr + startPhysicalAddress;
byte[] raw_buf = new byte[3];
raw_buf[0] = READ_MEMORY;
raw_buf[1] = (byte)(addr & 0xFF);
raw_buf[2] = (byte)((SupportClass.URShift((addr & 0xFFFF), 8)) & 0xFF);
// do the first block for command, address
adapter.dataBlock(raw_buf, 0, 3);
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
if (DEBUG)
{
Debug.debug(" raw_buf", raw_buf, 0, 3);
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
}
// pre-fill readBuf with 0xFF
int pgs = len / pageLength;
int extra = len % pageLength;
for (int i = 0; i < pgs; i++)
{
Array.Copy(ffBlock, 0, readBuf, offset + i * pageLength, pageLength);
}
Array.Copy(ffBlock, 0, readBuf, offset + pgs * pageLength, extra);
// send second block to read data, return result
adapter.dataBlock(readBuf, offset, len);
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
if (DEBUG)
{
Debug.debug(" readBuf", readBuf, offset, len);
Debug.debug("-----------------------------------------------------------");
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
}
