| public static Identity ( double literal ) : double | ||
| literal | double | The literal to return |
| return | double | |
/// <summary>
/// Read bits from buffer into the lower bits of an unsigned int.
/// The LSB contains the latest read bit of the stream.
/// (between 1 and 16, inclusive).
/// </summary>
public int GetBitsFromBuffer(int countBits)
{
int returnvalue = 0;
int sum = m_BitIndex + countBits;
// E.B
// There is a problem here, wordpointer could be -1 ?!
if (m_WordPointer < 0)
{
m_WordPointer = 0;
}
// E.B : End.
if (sum <= 32)
{
// all bits contained in *wordpointer
returnvalue = SupportClass.URShift(m_FrameBuffer[m_WordPointer], 32 - sum) & bitmask[countBits];
// returnvalue = (wordpointer[0] >> (32 - sum)) & bitmask[number_of_bits];
if ((m_BitIndex += countBits) == 32)
{
m_BitIndex = 0;
m_WordPointer++; // added by me!
}
return(returnvalue);
}
// Magouille a Voir
//((short[])&returnvalue)[0] = ((short[])wordpointer + 1)[0];
//wordpointer++; // Added by me!
//((short[])&returnvalue + 1)[0] = ((short[])wordpointer)[0];
int Right = m_FrameBuffer[m_WordPointer] & 0x0000FFFF;
m_WordPointer++;
int Left = m_FrameBuffer[m_WordPointer] & (int)SupportClass.Identity(0xFFFF0000);
returnvalue = ((Right << 16) & (int)SupportClass.Identity(0xFFFF0000)) |
(SupportClass.URShift(Left, 16) & 0x0000FFFF);
returnvalue = SupportClass.URShift(returnvalue, 48 - sum);
// returnvalue >>= 16 - (number_of_bits - (32 - bitindex))
returnvalue &= bitmask[countBits];
m_BitIndex = sum - 32;
return(returnvalue);
}
/// <summary> Performs the initialisation of the arrays that are used to store the
/// values used to write SOP and EPH markers
///
/// </summary>
private void initSOP_EPHArrays()
{
// Allocate and set first values of SOP marker as they will not be
// modified
sopMarker = new byte[CSJ2K.j2k.codestream.Markers.SOP_LENGTH];
sopMarker[0] = unchecked((byte) (CSJ2K.j2k.codestream.Markers.SOP >> 8));
sopMarker[1] = (byte) SupportClass.Identity(CSJ2K.j2k.codestream.Markers.SOP);
sopMarker[2] = (byte) 0x00;
sopMarker[3] = (byte) 0x04;
// Allocate and set values of EPH marker as they will not be
// modified
ephMarker = new byte[CSJ2K.j2k.codestream.Markers.EPH_LENGTH];
ephMarker[0] = unchecked((byte) (CSJ2K.j2k.codestream.Markers.EPH >> 8));
ephMarker[1] = (byte) SupportClass.Identity(CSJ2K.j2k.codestream.Markers.EPH);
}
//--------
//-------- Methods
//--------
//--------
//-------- Sensor I/O methods
//--------
/// <summary> Retrieves the 1-Wire device sensor state. This state is
/// returned as a byte array. Pass this byte array to the 'get'
/// and 'set' methods. If the device state needs to be changed then call
/// the 'writeDevice' to finalize the changes.
///
/// </summary>
/// <returns> 1-Wire device sensor state
///
/// </returns>
/// <throws> OneWireIOException on a 1-Wire communication error such as </throws>
/// <summary> reading an incorrect CRC from a 1-Wire device. This could be
/// caused by a physical interruption in the 1-Wire Network due to
/// shorts or a newly arriving 1-Wire device issuing a 'presence pulse'.
/// </summary>
/// <throws> OneWireException on a communication or setup error with the 1-Wire </throws>
/// <summary> adapter
/// </summary>
public virtual byte[] readDevice()
{
byte[] ret_buf = new byte[4];
if (doSpeedEnable)
{
doSpeed();
}
// read the status byte
byte[] tmp_buf = deviceOperation(READ_WRITE_STATUS_COMMAND, (byte)SupportClass.Identity(0x00FF), 2);
// extract the status byte
ret_buf[0] = tmp_buf[2];
return(ret_buf);
}
/// <summary> Reads the subkey requested with the given key name and password.
/// Note that this method allows for reading from the subkey data
/// only which starts at address 0x10 within a key. It does not allow
/// reading from any earlier address within a key because the device
/// cannot be force to allow reading the password. This is why the
/// subkey number is or-ed with 0x10 in creating the address in bytes
/// 1 and 2 of the sendBlock.
///
/// </summary>
/// <param name="data"> buffer of length 64 into which to write the data
/// </param>
/// <param name="key"> number indicating the key to be read: 0, 1, or 2
/// </param>
/// <param name="passwd"> password of destination subkey
///
///
/// </param>
/// <throws> IllegalArgumentException If key is out of range (0 to 2), or password is not 8 characters, or if </throws>
/// <summary> data does not have a length of 64
/// </summary>
/// <throws> OneWireIOException If device is not found on the 1-Wire network </throws>
/// <throws> OneWireException on a communication or setup error with the 1-Wire </throws>
/// <summary> adapter
/// </summary>
public virtual void readSubkey(byte[] data, int key, byte[] passwd)
{
//confirm key and passwd within legal parameters
if (key > 0x03)
{
throw new System.ArgumentException("Key out of range: 0 to 2.");
}
if (passwd.Length != 8)
{
throw new System.ArgumentException("Password must contain exactly 8 characters.");
}
if (data.Length != 64)
{
throw new System.ArgumentException("Data must be size 64.");
}
buffer[0] = READ_SUBKEY_COMMAND;
buffer[1] = (byte)((key << 6) | 0x10);
buffer[2] = (byte)(~buffer[1]);
//prepare buffer to receive
for (int i = 3; i < 67; i++)
{
buffer[i] = (byte)SupportClass.Identity(0xFF);
}
//insert password data
Array.Copy(passwd, 0, buffer, 11, 8);
//send command block
if (adapter.select(address))
{
adapter.dataBlock(buffer, 0, 67);
adapter.reset();
//create block to send back
Array.Copy(buffer, 3, data, 0, 64);
}
else
{
//device must not have been present
throw new OneWireIOException("MultiKey iButton " + this.AddressAsString + " not found on 1-Wire Network");
}
}
/// <summary>
/// Fill the header.
/// </summary>
public static int FourCC(string chunkName)
{
sbyte[] p = { 0x20, 0x20, 0x20, 0x20 };
SupportClass.GetSBytesFromString
(
chunkName,
0,
4,
ref p,
0
);
int ret = ((p[0] << 24) & (int)SupportClass.Identity(0xFF000000)) | ((p[1] << 16) & 0x00FF0000) | ((p[2] << 8) & 0x0000FF00) | (p[3] & 0x000000FF);
return(ret);
}
//--------
//-------- Custom Methods for this iButton Type
//--------
//-------------------------------------------------------------------------
/// <summary> Reads the Scratchpad of the DS18B20.
///
/// </summary>
/// <returns> 9-byte buffer representing the scratchpad
///
/// </returns>
/// <throws> OneWireIOException on a 1-Wire communication error such as </throws>
/// <summary> reading an incorrect CRC from this <code>OneWireContainer28</code>.
/// This could be caused by a physical interruption in the 1-Wire
/// Network due to shorts or a newly arriving 1-Wire device issuing a
/// 'presence pulse'.
/// </summary>
/// <throws> OneWireException on a communication or setup error with the 1-Wire </throws>
/// <summary> adapter
/// </summary>
public virtual byte[] readScratchpad()
{
byte[] result_block;
// select the device
if (adapter.select(address))
{
// create a block to send that reads the scratchpad
byte[] send_block = new byte[10];
// read scratchpad command
send_block[0] = (byte)READ_SCRATCHPAD_COMMAND;
// now add the read bytes for data bytes and crc8
for (int i = 1; i < 10; i++)
{
send_block[i] = (byte)SupportClass.Identity(0xFF);
}
// send the block
adapter.dataBlock(send_block, 0, send_block.Length);
// now, send_block contains the 9-byte Scratchpad plus READ_SCRATCHPAD_COMMAND byte
// convert the block to a 9-byte array representing Scratchpad (get rid of first byte)
result_block = new byte[9];
for (int i = 0; i < 9; i++)
{
result_block[i] = send_block[i + 1];
}
// see if CRC8 is correct
if (CRC8.compute(send_block, 1, 9) == 0)
{
return(result_block);
}
else
{
throw new OneWireIOException("OneWireContainer28-Error reading CRC8 from device.");
}
}
// device must not have been present
throw new OneWireIOException("OneWireContainer28-Device not found on 1-Wire Network");
}
/// <summary> Write to the Scratch Pad, which is a max of 8 bytes... Note that if
/// less than 8 bytes are written, the ending offset will still report
/// that a full eight bytes are on the buffer. This means that all 8 bytes
/// of the data in the scratchpad will be copied, not just the bytes user
/// wrote into it.
///
/// </summary>
/// <param name="addr"> the address to write the data to
/// </param>
/// <param name="out_buf"> byte array to write into scratch pad
/// </param>
/// <param name="offset"> offset into out_buf to write the data
/// </param>
/// <param name="len"> length of the write data
///
/// </param>
/// <throws> OneWireIOException </throws>
/// <throws> OneWireException </throws>
public virtual bool writeScratchpad(int addr, byte[] out_buf, int offset, int len)
{
byte[] send_block = new byte[14];
// protect send buffer
// since the scratchpad is only eight bytes, there is no reason to write
// more than eight bytes.. and we can optimize our send buffer's size.
if (len > 8)
{
len = 8;
}
// access the device
if (ib.adapter.select(ib.Address))
{
int cnt = 0;
// set data block up
// start by sending the write scratchpad command
send_block[cnt++] = WRITE_SCRATCHPAD_COMMAND;
// followed by the target address
send_block[cnt++] = (byte)(addr & 0x00FF);
send_block[cnt++] = (byte)((SupportClass.URShift((addr & 0x00FFFF), 8)) & 0x00FF);
// followed by the data to write to the scratchpad
Array.Copy(out_buf, offset, send_block, 3, len);
cnt += len;
// followed by two bytes for reading CRC16 value
send_block[cnt++] = (byte)SupportClass.Identity(0x00FF);
send_block[cnt++] = (byte)SupportClass.Identity(0x00FF);
// send the data
ib.adapter.dataBlock(send_block, 0, cnt);
// verify the CRC is correct
// if (CRC16.compute(send_block, 0, cnt) != 0x0000B001)
// throw new OneWireIOException("Invalid CRC16 in Writing Scratch Pad");
}
else
{
throw new OneWireIOException("Device select failed.");
}
return(true);
}
//--------
//-------- Bank specific methods
//--------
/// <summary> Reads the specified 8 byte page and returns the data in an array.
///
/// </summary>
/// <param name="page">the page number to read
///
/// </param>
/// <returns> eight byte array that make up the page
///
/// </returns>
/// <throws> OneWireIOException Error reading data </throws>
/// <throws> OneWireException Could not find part </throws>
/// <throws> IllegalArgumentException Bad parameters passed </throws>
protected internal virtual byte[] readRawPage(int page)
{
byte[] buffer = new byte[11];
byte[] result = new byte[8];
int crc8; // this device uses a crc 8
if (ib.adapter.select(ib.address))
{
/* recall memory to the scratchpad */
buffer[0] = RECALL_MEMORY_COMMAND;
buffer[1] = (byte)page;
ib.adapter.dataBlock(buffer, 0, 2);
/* perform the read scratchpad */
ib.adapter.select(ib.address);
buffer[0] = READ_SCRATCHPAD_COMMAND;
buffer[1] = (byte)page;
for (int i = 2; i < 11; i++)
{
buffer[i] = (byte)SupportClass.Identity(0x0ff);
}
ib.adapter.dataBlock(buffer, 0, 11);
/* do the crc check */
crc8 = CRC8.compute(buffer, 2, 9);
if (crc8 != 0x0)
{
throw new OneWireIOException("Bad CRC during page read " + crc8);
}
// copy the data into the result
Array.Copy(buffer, 2, result, 0, 8);
}
else
{
throw new OneWireIOException("Device not found during read page.");
}
return(result);
}
/* This function handles the increment and decrement operations,
* including the contingent reset. You do not need to call reset
* between consecutive unit change commands. Both operations issue
* the command byte and then recieve the new wiper position.
*/
//UPGRADE_NOTE: Synchronized keyword was removed from method 'unitChange'. Lock expression was added. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1027'"
private int unitChange(byte COMMAND, bool reselect)
{
lock (this)
{
if (reselect)
{
doSpeed(); //don't need to do this if we don't need to select
adapter.select(address);
}
buffer[0] = COMMAND;
buffer[1] = (byte)SupportClass.Identity(0x0ff);
adapter.dataBlock(buffer, 0, 2);
return(0x0ff & buffer[1]);
}
}
/// <summary> Copy the scratchpad page to memory.
///
/// </summary>
/// <param name="startAddr"> starting address
/// </param>
/// <param name="len"> length in bytes that was written already
///
/// </param>
/// <throws> OneWireIOException </throws>
/// <throws> OneWireException </throws>
public virtual void copyScratchpad(int startAddr, int len, bool WriteProtect)
{
int i, j;
if (WriteProtect)
{
i = 2;
}
else
{
i = 0;
}
for (j = 0; j < i; j++)
{
// select the device
if (!ib.adapter.select(ib.address))
{
forceVerify();
throw new OneWireIOException("Device select failed");
}
// build block to send
byte[] raw_buf = new byte[5];
raw_buf[0] = COPY_SCRATCHPAD_COMMAND;
raw_buf[1] = (byte)(startAddr & 0xFF);
raw_buf[2] = (byte)((SupportClass.URShift((startAddr & 0xFFFF), 8)) & 0xFF);
raw_buf[3] = (byte)((startAddr + len - 1) & 0x1F);
raw_buf[3] = (byte)((byte)raw_buf[3] | 0x80); // !!! added (byte)
raw_buf[4] = (byte)SupportClass.Identity(0xFF);
// send block (check copy indication complete)
ib.adapter.dataBlock(raw_buf, 0, 5);
if ((raw_buf[4] & 0x0F0) != 0)
{
forceVerify();
throw new OneWireIOException("Copy scratchpad complete not found");
}
}
}
/// <summary> Retrieves this <code>OneWireContainer10</code> state information.
/// The state information is returned as a byte array. Pass this byte
/// array to the '<code>get</code>' and '<code>set</code>' methods.
/// If the device state needs to be changed, then call the
/// <code>writeDevice()</code> to finalize the changes.
///
/// </summary>
/// <returns> <code>OneWireContainer10</code> state information.
/// Device state looks like this:
/// <pre>
/// 0 : temperature LSB
/// 1 : temperature MSB
/// 2 : trip high
/// 3 : trip low
/// 4 : reserved (put the resolution here, 0 for normal, 1 for max)
/// 5 : reserved
/// 6 : count remain
/// 7 : count per degree Celsius
/// 8 : an 8 bit CRC over the previous 8 bytes of data
/// </pre>
///
/// </returns>
/// <throws> OneWireIOException on a 1-Wire communication error such as </throws>
/// <summary> reading an incorrect CRC from this <code>OneWireContainer10</code>.
/// This could be caused by a physical interruption in the 1-Wire
/// Network due to shorts or a newly arriving 1-Wire device issuing a
/// 'presence pulse'.
/// </summary>
/// <throws> OneWireException on a communication or setup error with the 1-Wire </throws>
/// <summary> adapter
///
/// </summary>
/// <seealso cref="writeDevice">
/// </seealso>
public virtual byte[] readDevice()
{
byte[] data = new byte[8];
doSpeed();
// select the device
if (adapter.select(address))
{
// construct a block to read the scratchpad
byte[] buffer = new byte[10];
// read scratchpad command
buffer[0] = (byte)READ_SCRATCHPAD_COMMAND;
// now add the read bytes for data bytes and crc8
for (int i = 1; i < 10; i++)
{
buffer[i] = (byte)SupportClass.Identity(0x0FF);
}
// send the block
adapter.dataBlock(buffer, 0, buffer.Length);
// see if crc is correct
if (CRC8.compute(buffer, 1, 9) == 0)
{
Array.Copy(buffer, 1, data, 0, 8);
}
else
{
throw new OneWireIOException("OneWireContainer10-Error reading CRC8 from device.");
}
}
else
{
throw new OneWireIOException("OneWireContainer10-Device not found on 1-Wire Network");
}
//we are just reading normalResolution here, no need to synchronize
data[4] = (byte)(normalResolution?0:1);
return(data);
}
/// <summary> Retrieves the 1-Wire device sensor state. This state is
/// returned as a byte array. Pass this byte array to the 'get'
/// and 'set' methods. If the device state needs to be changed then call
/// the 'writeDevice' to finalize the changes.
///
/// </summary>
/// <returns> 1-Wire device sensor state
///
/// </returns>
/// <throws> OneWireIOException on a 1-Wire communication error such as </throws>
/// <summary> reading an incorrect CRC from a 1-Wire device. This could be
/// caused by a physical interruption in the 1-Wire Network due to
/// shorts or a newly arriving 1-Wire device issuing a 'presence pulse'.
/// </summary>
/// <throws> OneWireException on a communication or setup error with the 1-Wire </throws>
/// <summary> adapter
/// </summary>
public virtual byte[] readDevice()
{
byte[] buff = new byte[2];
buff[0] = (byte)SupportClass.Identity(0xF5); // PIO Access Read Command
buff[1] = (byte)SupportClass.Identity(0xFF); // Used to read the PIO Status Bit Assignment
// select the device
if (adapter.select(address))
{
adapter.dataBlock(buff, 0, 2);
}
else
{
throw new OneWireIOException("Device select failed");
}
return(buff);
}
//////////////////////////////////////////////////////////////////////
// Private Methods //
//////////////////////////////////////////////////////////////////////
/* This function handles reading of the registers for:
* 1. Finding the state of the charge pump
* 2. Finding the current location of the wiper
*
* Both of these operations send one command byte and receive two information bytes.
* The relevant information for both is stored in that second received byte.
*/
//UPGRADE_NOTE: Synchronized keyword was removed from method 'readRegisters'. Lock expression was added. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1027'"
private int readRegisters(byte COMMAND)
{
lock (this)
{
doSpeed();
if (!adapter.select(address))
{
throw new OneWireIOException("Could not select the part!");
}
buffer[0] = COMMAND;
buffer[1] = buffer[2] = (byte)SupportClass.Identity(0x0ff);
adapter.dataBlock(buffer, 0, 3);
return(0x0ff & buffer[2]);
}
}
/// <summary>Copy an array of Strings to bytes.</summary>
public static byte[] StringsToByteArray(String[] o, int maxLen)
{
byte[] res = new byte[o.Length * maxLen];
for (int i = 0; i < o.Length; i += 1)
{
byte[] bstr = SupportClass.ToByteArray(o[i]);
int cnt = bstr.Length;
if (cnt > maxLen)
{
cnt = maxLen;
}
Array.Copy(bstr, 0, res, i * maxLen, cnt);
for (int j = cnt; j < maxLen; j += 1)
{
res[i * maxLen + j] = (byte)SupportClass.Identity(' ');
}
}
return(res);
}
/// <summary> Retrieves the 1-Wire device sensor state. This state is
/// returned as a byte array. Pass this byte array to the static query
/// and set methods. If the device state needs to be changed then call
/// the <CODE>writeDevice</CODE> to finalize the one or more change.
///
/// </summary>
/// <returns> 1-Wire device sensor state
///
/// </returns>
/// <throws> OneWireIOException Data was not read correctly </throws>
/// <throws> OneWireException Could not find device </throws>
public virtual byte[] readDevice()
{
//format for the byte array is this:
//byte 0: Feature register
// (msb) bit 7 : Potentiometer resistance msb
// bit 6 : Potentiometer resistance lsb
// bit 5 : Number of Wiper Positions msb
// bit 4 : Number of Wiper Positions lsb
// bit 3 : Number of Potentiometers msb
// bit 2 : Number of Potentiometers lsb
// bit 1 : Wiper Setting Volatility
// (lsb) bit 0 : Potentiometer Characteristic (lin/log)
//byte 1: Control register
// (msb) bit 7 : Reserved
// bit 6 : Charge Pump Control
// bit 5 : Reserved
// bit 4 : Reserved
// bit 3 : Inverted Wiper Number msb
// bit 2 : Inverted Wiper Number lsb
// bit 1 : Wiper Number msb
// (lsb) bit 0 : Wiper Number lsb
byte[] state = new byte[2];
doSpeed();
if (!adapter.select(address))
{
throw new OneWireIOException("Could not select the part!");
}
byte[] buf = new byte[3];
buf[0] = READ_CONTROL;
buf[1] = buf[2] = (byte)SupportClass.Identity(0x0ff);
adapter.dataBlock(buf, 0, 3);
state[0] = buf[1]; //feature
state[1] = buf[2]; //control
return(state);
}
/// <summary> Read bits from buffer into the lower bits of an unsigned int.
/// The LSB contains the latest read bit of the stream.
/// (1 <= number_of_bits <= 16)
/// </summary>
public int get_bits(int number_of_bits)
{
int returnvalue = 0;
int sum = bitindex + number_of_bits;
// E.B
// There is a problem here, wordpointer could be -1 ?!
if (wordpointer < 0)
{
wordpointer = 0;
}
// E.B : End.
if (sum <= 32)
{
// all bits contained in *wordpointer
returnvalue = (SupportClass.URShift(framebuffer[wordpointer], (32 - sum))) & bitmask[number_of_bits];
// returnvalue = (wordpointer[0] >> (32 - sum)) & bitmask[number_of_bits];
if ((bitindex += number_of_bits) == 32)
{
bitindex = 0;
wordpointer++; // added by me!
}
return(returnvalue);
}
// Magouille a Voir
//((short[])&returnvalue)[0] = ((short[])wordpointer + 1)[0];
//wordpointer++; // Added by me!
//((short[])&returnvalue + 1)[0] = ((short[])wordpointer)[0];
int Right = (framebuffer[wordpointer] & 0x0000FFFF);
wordpointer++;
int Left = (framebuffer[wordpointer] & (int)SupportClass.Identity(0xFFFF0000));
returnvalue = ((Right << 16) & (int)SupportClass.Identity(0xFFFF0000)) | ((SupportClass.URShift(Left, 16)) & 0x0000FFFF);
returnvalue = SupportClass.URShift(returnvalue, 48 - sum); // returnvalue >>= 16 - (number_of_bits - (32 - bitindex))
returnvalue &= bitmask[number_of_bits];
bitindex = sum - 32;
return(returnvalue);
}
//--------
//-------- Constructor
//--------
/// <summary> Memory bank contstuctor. Requires reference to the OneWireContainer
/// this memory bank resides on. Requires reference to memory banks used
/// in OTP operations.
/// </summary>
public MemoryBankEEPROM(OneWireContainer ibutton, ScratchPad scratch)
{
// keep reference to ibutton where memory bank is
ib = ibutton;
// keep reference to scratchPad bank
sp = scratch;
// get references to MemoryBanks used in OTP operations, assume locking
mbLock = null;
lockPage_Renamed_Field = true;
// initialize attributes of this memory bank - DEFAULT: Main memory DS2431
generalPurposeMemory = true;
bankDescription = "Main memory";
numberPages = 4;
size = 128;
pageLength = 32;
maxPacketDataLength = 29;
readWrite = true;
writeOnce = false;
readOnly = false;
nonVolatile = true;
pageAutoCRC = false;
lockPage_Renamed_Field = true;
programPulse = false;
powerDelivery = true;
extraInfo = false;
extraInfoLength = 0;
extraInfoDescription = null;
writeVerification = false;
startPhysicalAddress = 0;
doSetSpeed = true;
scratchPadSize = 8;
// create the ffblock (used for faster 0xFF fills)
for (int i = 0; i < 500; i++)
{
ffBlock[i] = (byte)SupportClass.Identity(0xFF);
}
}
internal static int[] float_values(WavpackStream wps, int[] values, long num_values, int bufferStartPos)
{
int shift = wps.float_max_exp - wps.float_norm_exp + wps.float_shift;
int value_counter = bufferStartPos;
if (shift > 32)
{
shift = 32;
}
else if (shift < -32)
{
shift = -32;
}
while (num_values > 0)
{
if (shift > 0)
{
values[value_counter] <<= shift;
}
else if (shift < 0)
{
values[value_counter] >>= -shift;
}
if (values[value_counter] > 8388607L)
{
values[value_counter] = (int)SupportClass.Identity(8388607L);
}
else if (values[value_counter] < -8388608L)
{
values[value_counter] = (int)SupportClass.Identity(-8388608L);
}
value_counter++;
num_values--;
}
return(values);
}
//--------
//-------- Constructor
//--------
/// <summary> Memory bank contstuctor. Requires reference to the OneWireContainer
/// this memory bank resides on.
/// </summary>
public MemoryBankEE(OneWireContainer ibutton)
{
lock (this)
{
// keep reference to ibutton where memory bank is
ib = ibutton;
// create the ffblock (used for faster 0xFF fills)
ffBlock = new byte[50];
for (int i = 0; i < 50; i++)
{
ffBlock[i] = (byte)SupportClass.Identity(0xFF);
}
// defaults
writeVerification = true;
// indicate speed has not been set
doSetSpeed = true;
}
}
//--------
//-------- Constructor
//--------
/// <summary> Memory bank contstuctor. Requires reference to the OneWireContainer
/// this memory bank resides on.
/// </summary>
public MemoryBankScratch(OneWireContainer ibutton)
{
// keep reference to ibutton where memory bank is
ib = ibutton;
// initialize attributes of this memory bank - DEFAULT: DS199X scratchapd
bankDescription = "Scratchpad";
generalPurposeMemory = false;
startPhysicalAddress = 0;
size = 32;
readWrite = true;
writeOnce = false;
readOnly = false;
nonVolatile = false;
programPulse = false;
powerDelivery = false;
writeVerification = true;
numberPages = 1;
pageLength = 32;
maxPacketDataLength = 29;
pageAutoCRC = false;
extraInfo = true;
extraInfoLength = 3;
extraInfoDescription = "Target address, offset";
// create the ffblock (used for faster 0xFF fills)
ffBlock = new byte[96];
for (int i = 0; i < 96; i++)
{
ffBlock[i] = (byte)SupportClass.Identity(0xFF);
}
// default copy scratchpad command
COPY_SCRATCHPAD_COMMAND = (byte)0x55;
// indicate speed has not been set
doSetSpeed = true;
}
/// <summary>
/// Parses the data previously read with read_frame_data().
/// </summary>
internal void ParseFrame()
{
// Convert Bytes read to int
int b = 0;
sbyte[] byteread = m_FrameBytes;
int bytesize = m_FrameSize;
for (int k = 0; k < bytesize; k = k + 4)
{
sbyte b0 = 0;
sbyte b1 = 0;
sbyte b2 = 0;
sbyte b3 = 0;
b0 = byteread[k];
if (k + 1 < bytesize)
{
b1 = byteread[k + 1];
}
if (k + 2 < bytesize)
{
b2 = byteread[k + 2];
}
if (k + 3 < bytesize)
{
b3 = byteread[k + 3];
}
m_FrameBuffer[b++] = ((b0 << 24) & (int)SupportClass.Identity(0xFF000000)) | ((b1 << 16) & 0x00FF0000) |
((b2 << 8) & 0x0000FF00) | (b3 & 0x000000FF);
}
m_WordPointer = 0;
m_BitIndex = 0;
}
/// <summary> Updates the latch state for the 2 general purpose PIO pins. This
/// has the side-effect of also sampling the PIO pins level after updating
/// the latch, so the state buffer is updated with this new level information.
///
/// </summary>
/// <param name="state">1-Wire device sensor state
///
/// </param>
/// <throws> OneWireIOException on a 1-Wire communication error such as </throws>
/// <summary> reading an incorrect CRC from a 1-Wire device. This could be
/// caused by a physical interruption in the 1-Wire Network due to
/// shorts or a newly arriving 1-Wire device issuing a 'presence pulse'.
/// </summary>
/// <throws> OneWireException on a communication or setup error with the 1-Wire </throws>
/// <summary> adapter
/// </summary>
public virtual void writeDevice(byte[] state)
{
//channel Access Write
adapter.assertSelect(address);
byte[] buffer = new byte[5];
buffer[0] = PIO_ACCESS_WRITE;
buffer[1] = state[1];
buffer[2] = (byte)~state[1];
buffer[3] = (byte)SupportClass.Identity(0xFF);
buffer[4] = (byte)SupportClass.Identity(0xFF);
adapter.dataBlock(buffer, 0, 5);
if (buffer[3] != (byte)SupportClass.Identity(0x00AA))
{
throw new OneWireIOException("Failure to change latch state.");
}
// update sensed logic level in state.
state[0] = buffer[4];
}
//--------
//-------- Constructor
//--------
/// <summary> Memory bank contstuctor. Requires reference to the OneWireContainer
/// this memory bank resides on. DEFAULT: DS1993 main memory
///
/// </summary>
/// <param name="ibutton">ibutton container that this memory bank resides in
/// </param>
/// <param name="scratchPad">memory bank referece for scratchpad, used when writing
/// </param>
public MemoryBankNV(OneWireContainer ibutton, ScratchPad scratch)
{
// keep reference to ibutton where memory bank is
ib = ibutton;
// keep reference to scratchPad bank
sp = scratch;
// initialize attributes of this memory bank - DEFAULT: DS1993 main memory
bankDescription = "Main Memory";
generalPurposeMemory = true;
startPhysicalAddress = 0;
size = 512;
readWrite = true;
writeOnce = false;
readOnly = false;
nonVolatile = true;
programPulse = false;
powerDelivery = false;
writeVerification = true;
numberPages = 16;
pageLength = 32;
maxPacketDataLength = 29;
pageAutoCRC = false;
extraInfo = false;
extraInfoLength = 0;
extraInfoDescription = null;
// create the ffblock (used for faster 0xFF fills)
ffBlock = new byte[96];
for (int i = 0; i < 96; i++)
{
ffBlock[i] = (byte)SupportClass.Identity(0xFF);
}
}
/// <summary> Open a RIFF file.
/// </summary>
public virtual int Open(System.String Filename, int NewMode)
{
int retcode = DDC_SUCCESS;
if (fmode != RFM_UNKNOWN)
{
retcode = Close();
}
if (retcode == DDC_SUCCESS)
{
switch (NewMode)
{
case RFM_WRITE:
try
{
file = SupportClass.RandomAccessFileSupport.CreateRandomAccessFile(Filename, "rw");
try
{
// Write the RIFF header...
// We will have to come back later and patch it!
sbyte[] br = new sbyte[8];
br[0] = (sbyte)((SupportClass.URShift(riff_header.ckID, 24)) & 0x000000FF);
br[1] = (sbyte)((SupportClass.URShift(riff_header.ckID, 16)) & 0x000000FF);
br[2] = (sbyte)((SupportClass.URShift(riff_header.ckID, 8)) & 0x000000FF);
br[3] = (sbyte)(riff_header.ckID & 0x000000FF);
sbyte br4 = (sbyte)((SupportClass.URShift(riff_header.ckSize, 24)) & 0x000000FF);
sbyte br5 = (sbyte)((SupportClass.URShift(riff_header.ckSize, 16)) & 0x000000FF);
sbyte br6 = (sbyte)((SupportClass.URShift(riff_header.ckSize, 8)) & 0x000000FF);
sbyte br7 = (sbyte)(riff_header.ckSize & 0x000000FF);
br[4] = br7;
br[5] = br6;
br[6] = br5;
br[7] = br4;
file.Write(SupportClass.ToByteArray(br), 0, 8);
fmode = RFM_WRITE;
}
catch (System.IO.IOException ioe)
{
file.Close();
fmode = RFM_UNKNOWN;
}
}
catch (System.IO.IOException ioe)
{
fmode = RFM_UNKNOWN;
retcode = DDC_FILE_ERROR;
}
break;
case RFM_READ:
try
{
file = SupportClass.RandomAccessFileSupport.CreateRandomAccessFile(Filename, "r");
try
{
// Try to read the RIFF header...
sbyte[] br = new sbyte[8];
SupportClass.ReadInput(file, ref br, 0, 8);
fmode = RFM_READ;
riff_header.ckID = ((br[0] << 24) & (int)SupportClass.Identity(0xFF000000)) | ((br[1] << 16) & 0x00FF0000) | ((br[2] << 8) & 0x0000FF00) | (br[3] & 0x000000FF);
riff_header.ckSize = ((br[4] << 24) & (int)SupportClass.Identity(0xFF000000)) | ((br[5] << 16) & 0x00FF0000) | ((br[6] << 8) & 0x0000FF00) | (br[7] & 0x000000FF);
}
catch (System.IO.IOException ioe)
{
file.Close();
fmode = RFM_UNKNOWN;
}
}
catch (System.IO.IOException ioe)
{
fmode = RFM_UNKNOWN;
retcode = DDC_FILE_ERROR;
}
break;
default:
retcode = DDC_INVALID_CALL;
break;
}
}
return(retcode);
}
/// <summary> This method creates the tileparts from the buffered tile headers,
/// packet headers and packet data
///
/// </summary>
/// <exception cref="IOException">If an I/O error ocurred.
///
/// </exception>
private void createTileParts()
{
int i, prem, t, length;
int pIndex; // phIndex removed
int tppStart;
int tilePart;
int p, np, nomnp;
int numTileParts;
int numPackets;
System.IO.MemoryStream temp = new System.IO.MemoryStream();
byte[] tempByteArr;
// Create tile parts
tileParts = new byte[nt][][];
maxtp = 0;
for (t = 0; t < nt; t++)
{
// Calculate number of tile parts. If tileparts are not used,
// put all packets in the first tilepart
if (pptp == 0)
{
pptp = ppt[t];
}
prem = ppt[t];
//UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
numTileParts = (int)System.Math.Ceiling(((double)prem) / pptp);
numPackets = packetHeaders[t].Length;
maxtp = (numTileParts > maxtp)?numTileParts:maxtp;
tileParts[t] = new byte[numTileParts][];
// Create all the tile parts for tile t
tppStart = 0;
pIndex = 0;
p = 0;
//phIndex = 0;
for (tilePart = 0; tilePart < numTileParts; tilePart++)
{
// Calculate number of packets in this tilepart
nomnp = (pptp > prem)?prem:pptp;
np = nomnp;
// Write tile part header
if (tilePart == 0)
{
// Write original tile part header up to SOD marker
temp.Write(tileHeaders[t], 0, tileHeaders[t].Length - 2);
}
else
{
// Write empty header of length TP_HEAD_LEN-2
temp.Write(new byte[TP_HEAD_LEN - 2], 0, TP_HEAD_LEN - 2);
}
// Write PPT marker segments if PPT used
if (pptUsed)
{
int pptLength = 3; // Zppt and Lppt
int pptIndex = 0;
int phLength;
p = pIndex;
while (np > 0)
{
phLength = packetHeaders[t][p].Length;
// If the total legth of the packet headers is greater
// than MAX_LPPT, several PPT markers are needed
if (pptLength + phLength > CSJ2K.j2k.codestream.Markers.MAX_LPPT)
{
temp.WriteByte((System.Byte)SupportClass.URShift(CSJ2K.j2k.codestream.Markers.PPT, 8));
temp.WriteByte((System.Byte)(CSJ2K.j2k.codestream.Markers.PPT & 0x00FF));
temp.WriteByte((System.Byte)SupportClass.URShift(pptLength, 8));
temp.WriteByte((System.Byte)pptLength);
temp.WriteByte((System.Byte)pptIndex++);
for (i = pIndex; i < p; i++)
{
temp.Write(packetHeaders[t][i], 0, packetHeaders[t][i].Length);
}
pptLength = 3; // Zppt and Lppt
pIndex = p;
}
pptLength += phLength;
p++;
np--;
}
// Write last PPT marker
temp.WriteByte((System.Byte)SupportClass.URShift(CSJ2K.j2k.codestream.Markers.PPT, 8));
temp.WriteByte((System.Byte)(CSJ2K.j2k.codestream.Markers.PPT & 0x00FF));
temp.WriteByte((System.Byte)SupportClass.URShift(pptLength, 8));
temp.WriteByte((System.Byte)pptLength);
temp.WriteByte((System.Byte)pptIndex);
for (i = pIndex; i < p; i++)
{
temp.Write(packetHeaders[t][i], 0, packetHeaders[t][i].Length);
}
}
pIndex = p;
np = nomnp;
// Write SOD marker
temp.WriteByte((System.Byte)SupportClass.URShift(CSJ2K.j2k.codestream.Markers.SOD, 8));
temp.WriteByte((System.Byte)(CSJ2K.j2k.codestream.Markers.SOD & 0x00FF));
// Write packet data and packet headers if PPT and PPM not used
for (p = tppStart; p < tppStart + np; p++)
{
if (!tempSop)
{
temp.Write(sopMarkSeg[t][p], 0, CSJ2K.j2k.codestream.Markers.SOP_LENGTH);
}
if (!(ppmUsed || pptUsed))
{
temp.Write(packetHeaders[t][p], 0, packetHeaders[t][p].Length);
}
temp.Write(packetData[t][p], 0, packetData[t][p].Length);
}
tppStart += np;
// Edit tile part header
tempByteArr = temp.ToArray();
tileParts[t][tilePart] = tempByteArr;
length = (int)temp.Length;
if (tilePart == 0)
{
// Edit first tile part header
tempByteArr[6] = (byte)(SupportClass.URShift(length, 24)); // Psot
tempByteArr[7] = (byte)(SupportClass.URShift(length, 16));
tempByteArr[8] = (byte)(SupportClass.URShift(length, 8));
tempByteArr[9] = (byte)(length);
tempByteArr[10] = (byte)SupportClass.Identity((0)); // TPsot
tempByteArr[11] = (byte)(numTileParts); // TNsot
}
else
{
// Edit tile part header
tempByteArr[0] = (byte)(SupportClass.URShift(CSJ2K.j2k.codestream.Markers.SOT, 8)); // SOT
tempByteArr[1] = (byte)(CSJ2K.j2k.codestream.Markers.SOT & 0x00FF);
tempByteArr[2] = (byte)SupportClass.Identity((0)); // Lsot
tempByteArr[3] = (byte)SupportClass.Identity((10));
tempByteArr[4] = (byte)(SupportClass.URShift(t, 8)); // Isot
tempByteArr[5] = (byte)(t); //
tempByteArr[6] = (byte)(SupportClass.URShift(length, 24)); // Psot
tempByteArr[7] = (byte)(SupportClass.URShift(length, 16));
tempByteArr[8] = (byte)(SupportClass.URShift(length, 8));
tempByteArr[9] = (byte)(length);
tempByteArr[10] = (byte)(tilePart); //TPsot
tempByteArr[11] = (byte)(numTileParts); // TNsot
}
//UPGRADE_ISSUE: Method 'java.io.ByteArrayOutputStream.reset' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javaioByteArrayOutputStreamreset'"
//temp.reset();
temp.SetLength(0);
prem -= np;
}
}
temp.Dispose();
}
// Note that the input matrix uses 0 == white, 1 == black, while the output matrix uses
// 0 == black, 255 == white (i.e. an 8 bit greyscale bitmap).
private static ByteMatrix renderResult(QRCode code, int width, int height)
{
ByteMatrix input = code.Matrix;
int inputWidth = input.Width;
int inputHeight = input.Height;
int qrWidth = inputWidth + (QUIET_ZONE_SIZE << 1);
int qrHeight = inputHeight + (QUIET_ZONE_SIZE << 1);
int outputWidth = System.Math.Max(width, qrWidth);
int outputHeight = System.Math.Max(height, qrHeight);
int multiple = System.Math.Min(outputWidth / qrWidth, outputHeight / qrHeight);
// Padding includes both the quiet zone and the extra white pixels to accommodate the requested
// dimensions. For example, if input is 25x25 the QR will be 33x33 including the quiet zone.
// If the requested size is 200x160, the multiple will be 4, for a QR of 132x132. These will
// handle all the padding from 100x100 (the actual QR) up to 200x160.
int leftPadding = (outputWidth - (inputWidth * multiple)) / 2;
int topPadding = (outputHeight - (inputHeight * multiple)) / 2;
ByteMatrix output = new ByteMatrix(outputWidth, outputHeight);
sbyte[,] outputArray = output.Array;
// We could be tricky and use the first row in each set of multiple as the temporary storage,
// instead of allocating this separate array.
sbyte[] row = new sbyte[outputWidth];
// 1. Write the white lines at the top
for (int y = 0; y < topPadding; y++)
{
setRowColor(output.GetRow(y), (sbyte)SupportClass.Identity(255));
}
// 2. Expand the QR image to the multiple
sbyte[,] inputArray = input.Array;
for (int y = 0; y < inputHeight; y++)
{
// a. Write the white pixels at the left of each row
for (int x = 0; x < leftPadding; x++)
{
row[x] = (sbyte)SupportClass.Identity(255);
}
// b. Write the contents of this row of the barcode
int offset = leftPadding;
for (int x = 0; x < inputWidth; x++)
{
// Redivivus.in Java to c# Porting update - Type cased sbyte
// 30/01/2010
// sbyte value_Renamed = (inputArray[y][x] == 1)?0:(sbyte) SupportClass.Identity(255);
sbyte value_Renamed = (sbyte)((inputArray[y, x] == 1) ? 0 : SupportClass.Identity(255));
for (int z = 0; z < multiple; z++)
{
row[offset + z] = value_Renamed;
}
offset += multiple;
}
// c. Write the white pixels at the right of each row
offset = leftPadding + (inputWidth * multiple);
for (int x = offset; x < outputWidth; x++)
{
row[x] = (sbyte)SupportClass.Identity(255);
}
// d. Write the completed row multiple times
offset = topPadding + (y * multiple);
for (int z = 0; z < multiple; z++)
{
Array.Copy(row, 0, output.GetRow(offset + z), 0, outputWidth);
}
}
// 3. Write the white lines at the bottom
int offset2 = topPadding + (inputHeight * multiple);
for (int y = offset2; y < outputHeight; y++)
{
setRowColor(output.GetRow(y), (sbyte)SupportClass.Identity(255));
}
return(output);
}
internal Crc16()
{
_CRC = (short)SupportClass.Identity(0xFFFF);
}
static Crc16()
{
Polynomial = (short)SupportClass.Identity(0x8005);
}
private static System.String guessEncoding(sbyte[] bytes)
{
if (ASSUME_SHIFT_JIS)
{
return(SHIFT_JIS);
}
// Does it start with the UTF-8 byte order mark? then guess it's UTF-8
if (bytes.Length > 3 && bytes[0] == (sbyte)SupportClass.Identity(0xEF) && bytes[1] == (sbyte)SupportClass.Identity(0xBB) && bytes[2] == (sbyte)SupportClass.Identity(0xBF))
{
return(UTF8);
}
// For now, merely tries to distinguish ISO-8859-1, UTF-8 and Shift_JIS,
// which should be by far the most common encodings. ISO-8859-1
// should not have bytes in the 0x80 - 0x9F range, while Shift_JIS
// uses this as a first byte of a two-byte character. If we see this
// followed by a valid second byte in Shift_JIS, assume it is Shift_JIS.
// If we see something else in that second byte, we'll make the risky guess
// that it's UTF-8.
int length = bytes.Length;
bool canBeISO88591 = true;
bool canBeShiftJIS = true;
int maybeDoubleByteCount = 0;
int maybeSingleByteKatakanaCount = 0;
bool sawLatin1Supplement = false;
bool lastWasPossibleDoubleByteStart = false;
for (int i = 0; i < length && (canBeISO88591 || canBeShiftJIS); i++)
{
int value_Renamed = bytes[i] & 0xFF;
if ((value_Renamed == 0xC2 || value_Renamed == 0xC3) && i < length - 1)
{
// This is really a poor hack. The slightly more exotic characters people might want to put in
// a QR Code, by which I mean the Latin-1 supplement characters (e.g. u-umlaut) have encodings
// that start with 0xC2 followed by [0xA0,0xBF], or start with 0xC3 followed by [0x80,0xBF].
int nextValue = bytes[i + 1] & 0xFF;
if (nextValue <= 0xBF && ((value_Renamed == 0xC2 && nextValue >= 0xA0) || (value_Renamed == 0xC3 && nextValue >= 0x80)))
{
sawLatin1Supplement = true;
}
}
if (value_Renamed >= 0x7F && value_Renamed <= 0x9F)
{
canBeISO88591 = false;
}
if (value_Renamed >= 0xA1 && value_Renamed <= 0xDF)
{
// count the number of characters that might be a Shift_JIS single-byte Katakana character
if (!lastWasPossibleDoubleByteStart)
{
maybeSingleByteKatakanaCount++;
}
}
if (!lastWasPossibleDoubleByteStart && ((value_Renamed >= 0xF0 && value_Renamed <= 0xFF) || value_Renamed == 0x80 || value_Renamed == 0xA0))
{
canBeShiftJIS = false;
}
if (((value_Renamed >= 0x81 && value_Renamed <= 0x9F) || (value_Renamed >= 0xE0 && value_Renamed <= 0xEF)))
{
// These start double-byte characters in Shift_JIS. Let's see if it's followed by a valid
// second byte.
if (lastWasPossibleDoubleByteStart)
{
// If we just checked this and the last byte for being a valid double-byte
// char, don't check starting on this byte. If this and the last byte
// formed a valid pair, then this shouldn't be checked to see if it starts
// a double byte pair of course.
lastWasPossibleDoubleByteStart = false;
}
else
{
// ... otherwise do check to see if this plus the next byte form a valid
// double byte pair encoding a character.
lastWasPossibleDoubleByteStart = true;
if (i >= bytes.Length - 1)
{
canBeShiftJIS = false;
}
else
{
int nextValue = bytes[i + 1] & 0xFF;
if (nextValue < 0x40 || nextValue > 0xFC)
{
canBeShiftJIS = false;
}
else
{
maybeDoubleByteCount++;
}
// There is some conflicting information out there about which bytes can follow which in
// double-byte Shift_JIS characters. The rule above seems to be the one that matches practice.
}
}
}
else
{
lastWasPossibleDoubleByteStart = false;
}
}
// Distinguishing Shift_JIS and ISO-8859-1 can be a little tough. The crude heuristic is:
// - If we saw
// - at least three byte that starts a double-byte value (bytes that are rare in ISO-8859-1), or
// - over 5% of bytes that could be single-byte Katakana (also rare in ISO-8859-1),
// - and, saw no sequences that are invalid in Shift_JIS, then we conclude Shift_JIS
if (canBeShiftJIS && (maybeDoubleByteCount >= 3 || 20 * maybeSingleByteKatakanaCount > length))
{
return(SHIFT_JIS);
}
// Otherwise, we default to ISO-8859-1 unless we know it can't be
if (!sawLatin1Supplement && canBeISO88591)
{
return(ISO88591);
}
// Otherwise, we take a wild guess with UTF-8
return(UTF8);
}
/// <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
/// </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)
{
int i;
byte[] es_data = new byte[3];
byte[] scratchpad = new byte[8];
// return if nothing to do
if (len == 0)
{
return;
}
// attempt to put device at speed
checkSpeed();
// 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 && (((startPhysicalAddress + startAddr) != 137) && (len != 1)))
{
throw new OneWireException("Trying to write read-only memory bank");
}
if (((startPhysicalAddress + startAddr) == 137) && (len == 1))
{
ib.adapter.select(ib.address);
byte[] buffer = new byte[5];
buffer[0] = CHANNEL_ACCESS_WRITE;
buffer[1] = writeBuf[offset];
buffer[2] = (byte)~writeBuf[offset];
Array.Copy(ffBlock, 0, buffer, 3, 2);
ib.adapter.dataBlock(buffer, 0, 5);
if (buffer[3] != (byte)SupportClass.Identity(0x00AA))
{
//throw new OneWireIOException("Failure to change DS2408 latch state: buffer=" + Convert.toHexString(buffer));
throw new OneWireIOException("Failure to change DS2408 latch state: buffer=" + com.dalsemi.onewire.utils.Convert.toHexString(buffer)); // !!!
}
}
else if (((startPhysicalAddress + startAddr) > 138) && ((startPhysicalAddress + startAddr + len) < 143))
{
ib.adapter.select(ib.address);
byte[] buffer = new byte[6];
buffer[0] = (byte)SupportClass.Identity(0xCC);
buffer[1] = (byte)((startAddr + startPhysicalAddress) & 0xFF);
buffer[2] = (byte)((SupportClass.URShift(((startAddr + startPhysicalAddress) & 0xFFFF), 8)) & 0xFF);
Array.Copy(writeBuf, offset, buffer, 3, len);
ib.adapter.dataBlock(buffer, 0, len + 3);
}
else if (((startPhysicalAddress + startAddr) > 127) && ((startPhysicalAddress + startAddr + len) < 130))
{
byte[] buffer = new byte[8];
int addr = 128;
byte[] buff = new byte[11];
Array.Copy(ffBlock, 0, buff, 0, 11);
ib.adapter.select(ib.address);
buff[0] = READ_MEMORY_COMMAND;
// address 1
buff[1] = (byte)(addr & 0xFF);
// address 2
buff[2] = (byte)((SupportClass.URShift((addr & 0xFFFF), 8)) & 0xFF);
ib.adapter.dataBlock(buff, 0, 11);
// extract the data
Array.Copy(buff, 3, buffer, 0, 8);
Array.Copy(writeBuf, offset, buffer, 0, len);
// write the page of data to scratchpad
if (!writeScratchpad(startPhysicalAddress + startAddr, buffer, 0, 8))
{
throw new OneWireIOException("Invalid CRC16 in write");
}
if (!readScratchpad(scratchpad, 0, 8, es_data))
{
throw new OneWireIOException("Read scratchpad was not successful.");
}
if ((es_data[2] & 0x20) == 0x20)
{
throw new OneWireIOException("The write scratchpad command was not completed.");
}
else
{
for (i = 0; i < 8; i++)
{
if (scratchpad[i] != buffer[i])
{
throw new OneWireIOException("The read back of the data in the scratch pad did " + "not match.");
}
}
}
// Copy data from scratchpad into memory
copyScratchpad(es_data);
}
else
{
throw new OneWireIOException("Trying to write read-only memory.");
}
}