/// <summary> /// Close Riff File. /// Length is written too. /// </summary> public virtual int Close() { int retcode = DDC_SUCCESS; switch (Fmode) { case RFM_WRITE: try { m_File.Seek(0, SeekOrigin.Begin); try { sbyte[] br = new sbyte[8]; br[0] = (sbyte)(SupportClass.URShift(m_RiffHeader.CkId, 24) & 0x000000FF); br[1] = (sbyte)(SupportClass.URShift(m_RiffHeader.CkId, 16) & 0x000000FF); br[2] = (sbyte)(SupportClass.URShift(m_RiffHeader.CkId, 8) & 0x000000FF); br[3] = (sbyte)(m_RiffHeader.CkId & 0x000000FF); br[7] = (sbyte)(SupportClass.URShift(m_RiffHeader.CkSize, 24) & 0x000000FF); br[6] = (sbyte)(SupportClass.URShift(m_RiffHeader.CkSize, 16) & 0x000000FF); br[5] = (sbyte)(SupportClass.URShift(m_RiffHeader.CkSize, 8) & 0x000000FF); br[4] = (sbyte)(m_RiffHeader.CkSize & 0x000000FF); m_File.Write(SupportClass.ToByteArray(br), 0, 8); m_File.Close(); } catch { retcode = DDC_FILE_ERROR; } } catch { retcode = DDC_FILE_ERROR; } break; case RFM_READ: try { m_File.Close(); } catch { retcode = DDC_FILE_ERROR; } break; } m_File = null; Fmode = RFM_UNKNOWN; return(retcode); }
public int next() { int t = x ^ (x << 11); x = y; y = z; z = w; return(w = (w ^ (SupportClass.URShift(w, 19)) ^ (t ^ (SupportClass.URShift(t, 8))))); }
/// <summary> Writes the EOC marker. /// /// </summary> /// <exception cref="IOException">If an error occurs while closing the underlying /// stream. /// /// </exception> public override void close() { // Write the EOC marker and close the codestream. // CONVERSION PROBLEM? out_Renamed.WriteByte((byte)SupportClass.URShift(CSJ2K.j2k.codestream.Markers.EOC, 8)); out_Renamed.WriteByte((byte)(CSJ2K.j2k.codestream.Markers.EOC & 0x00FF)); ndata += 2; // Add two to length of codestream for EOC marker }
/// <summary> Computes a linear congruential random number a random number /// of times. /// </summary> public static int compute2(int x) { int loops = (SupportClass.URShift(x, 4)) & 7; while (loops-- > 0) { x = (x * 2147483647) % 16807; } return(x); }
/// <summary> Returns 32-character hex representation of this objects hash /// /// </summary> /// <returns> String of this object's hash /// </returns> public static System.String toHex(sbyte[] hash) { char[] buf = new char[hash.Length * 2]; for (int i = 0, x = 0; i < hash.Length; i++) { buf[x++] = HEX_CHARS[(SupportClass.URShift(hash[i], 4)) & 0xf]; buf[x++] = HEX_CHARS[hash[i] & 0xf]; } return(new System.String(buf)); }
/// <summary> Read a complete memory page with CRC verification provided by the /// device. Not supported by all devices. See the method /// 'hasPageAutoCRC()'. /// /// </summary> /// <param name="page"> page number to read /// </param> /// <param name="readContinue"> if 'true' then device read is continued without /// re-selecting. This can only be used if the new /// readPagePacket() continious where the last one /// stopped and it is inside a /// 'beginExclusive/endExclusive' block. /// </param> /// <param name="readBuf"> byte array to put data read. Must have at least /// 'getMaxPacketDataLength()' elements. /// </param> /// <param name="offset"> offset into readBuf to place data /// /// </param> /// <throws> OneWireIOException </throws> /// <throws> OneWireException </throws> public virtual void readPageCRC(int page, bool readContinue, byte[] readBuf, int offset) { byte[] raw_buf = new byte[5 + PAGE_LENGTH]; int len; // attempt to put device at max desired speed if (!readContinue) { checkSpeed(); } // see if need to access the device if (!readContinue) { // select the device if (!ib.adapter.select(ib.address)) { forceVerify(); throw new OneWireIOException("Device select failed"); } // build start reading memory block with: command, address len = raw_buf.Length; Array.Copy(ffBlock, 0, raw_buf, 0, len); raw_buf[0] = READ_MEMORY_COMMAND; int addr = page * PAGE_LENGTH + startPhysicalAddress; raw_buf[1] = (byte)(addr & 0xFF); raw_buf[2] = (byte)((SupportClass.URShift((addr & 0xFFFF), 8)) & 0xFF); } else { len = PAGE_LENGTH + 2; Array.Copy(ffBlock, 0, raw_buf, 0, len); } // do the block ib.adapter.dataBlock(raw_buf, 0, len); // check the CRC if (CRC16.compute(raw_buf, 0, len, 0) != 0x0000B001) { forceVerify(); throw new OneWireIOException("Invalid CRC16 read from device"); } // extract the data to return Array.Copy(raw_buf, len - 2 - PAGE_LENGTH, readBuf, offset, PAGE_LENGTH); }
//-------- //-------- Information methods //-------- //-------- //-------- Custom Methods for this 1-Wire Device Type //-------- /// <summary> Read the counter value associated with a page on this /// 1-Wire Device. /// /// </summary> /// <param name="counterPage"> page number of the counter to read /// /// </param> /// <returns> 4 byte value counter stored in a long integer /// /// </returns> /// <throws> OneWireIOException on a 1-Wire communication error such as </throws> /// <summary> no 1-Wire device present. 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 long readCounter(int counterPage) { // check if counter page provided is valid if ((counterPage < 12) || (counterPage > 15)) { throw new OneWireException("OneWireContainer1D-invalid counter page"); } // select the device if (adapter.select(this.address)) { int crc16; // read memory command buffer[0] = READ_MEMORY_COMMAND; crc16 = CRC16.compute(READ_MEMORY_COMMAND); // address of last data byte before counter int address = (counterPage << 5) + 31; // append the address buffer[1] = (byte)address; crc16 = CRC16.compute(buffer[1], crc16); buffer[2] = (byte)(SupportClass.URShift(address, 8)); crc16 = CRC16.compute(buffer[2], crc16); // now add the read bytes for data byte,counter,zero bits, crc16 for (int i = 3; i < 14; i++) { buffer[i] = (byte)SupportClass.Identity(0xFF); } // send the block adapter.dataBlock(buffer, 0, 14); // calculate the CRC16 on the result and check if correct if (CRC16.compute(buffer, 3, 11, crc16) == 0xB001) { // extract the counter out of this verified packet ulong return_count = 0; for (int i = 4; i >= 1; i--) { return_count <<= 8; return_count |= (byte)(buffer[i + 3] & (byte)0xFF); } // return the result count return((long)return_count); } } // device must not have been present throw new OneWireIOException("OneWireContainer1D-device not present"); }
// Return the position of the most significant bit set (to one) in the "value". The most // significant bit is position 32. If there is no bit set, return 0. Examples: // - findMSBSet(0) => 0 // - findMSBSet(1) => 1 // - findMSBSet(255) => 8 public static int FindMsbSet(int value_Renamed) { int numDigits = 0; while (value_Renamed != 0) { value_Renamed = SupportClass.URShift(value_Renamed, 1); ++numDigits; } return(numDigits); }
/// <summary> This method constructs a Lbyte byte array with specified length from an int. /// /// </summary> /// <param name="intVal">the int value to convert to a byte array. /// </param> /// <param name="byteArray">Lbyte first byte array, holds bytes from int /// </param> /// <param name="offset">byte offset into the array /// </param> /// <param name="len">number of bytes to get /// </param> public static void toByteArray(int intVal, byte[] byteArray, int offset, int len) { int max = offset + len; // Concatanate the byte array into one variable. for (int i = offset; i < max; i++) { byteArray[i] = (byte)intVal; intVal = SupportClass.URShift(intVal, 8); } }
// Return the position of the most significant bit set (to one) in the "value". The most // significant bit is position 32. If there is no bit set, return 0. Examples: // - findMSBSet(0) => 0 // - findMSBSet(1) => 1 // - findMSBSet(255) => 8 internal static int findMSBSet(int value_Renamed) { int numDigits = 0; while (value_Renamed != 0) { value_Renamed = SupportClass.URShift(value_Renamed, 1); ++numDigits; } return(numDigits); }
/// <summary> Writes the long value of <tt>v</tt> (i.e., the 64 bits) to the /// output. Prior to writing, the output should be realigned at the byte /// level. /// /// </summary> /// <param name="v">The value to write to the output /// /// </param> /// <exception cref="java.io.IOException">If an I/O error ocurred. /// /// </exception> public override void writeLong(long v) { write((int)(SupportClass.URShift(v, 56))); write((int)(SupportClass.URShift(v, 48))); write((int)(SupportClass.URShift(v, 40))); write((int)(SupportClass.URShift(v, 32))); write((int)(SupportClass.URShift(v, 24))); write((int)(SupportClass.URShift(v, 16))); write((int)(SupportClass.URShift(v, 8))); write((int)v); }
// Reverse the first len bits of a code, using straightforward code (a faster // method would use a table) // IN assertion: 1 <= len <= 15 internal static int bi_reverse(int code, int len) { int res = 0; do { res |= code & 1; code = SupportClass.URShift(code, 1); res <<= 1; }while (--len > 0); return(SupportClass.URShift(res, 1)); }
//-------- //-------- 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 physical address /// </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) { int i; // attempt to put device at max desired speed if (!readContinue) { sp.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 (!ib.adapter.select(ib.address)) { sp.forceVerify(); 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_COMMAND; raw_buf[1] = (byte)(addr & 0xFF); raw_buf[2] = (byte)((SupportClass.URShift((addr & 0xFFFF), 8)) & 0xFF); // do the first block for command, address ib.adapter.dataBlock(raw_buf, 0, 3); } // pre-fill readBuf with 0xFF int pgs = len / pageLength; int extra = len % pageLength; for (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 ib.adapter.dataBlock(readBuf, offset, len); }
/// <summary> Close Riff File. /// Length is written too. /// </summary> public virtual int Close() { int retcode = DDC_SUCCESS; switch (fmode) { case RFM_WRITE: try { file.Seek(0, System.IO.SeekOrigin.Begin); try { 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); br[7] = (sbyte)((SupportClass.URShift(riff_header.ckSize, 24)) & 0x000000FF); br[6] = (sbyte)((SupportClass.URShift(riff_header.ckSize, 16)) & 0x000000FF); br[5] = (sbyte)((SupportClass.URShift(riff_header.ckSize, 8)) & 0x000000FF); br[4] = (sbyte)(riff_header.ckSize & 0x000000FF); file.Write(SupportClass.ToByteArray(br), 0, 8); file.Close(); } catch (System.IO.IOException ioe) { retcode = DDC_FILE_ERROR; } } catch (System.IO.IOException ioe) { retcode = DDC_FILE_ERROR; } break; case RFM_READ: try { file.Close(); } catch (System.IO.IOException ioe) { retcode = DDC_FILE_ERROR; } break; } file = null; fmode = RFM_UNKNOWN; return(retcode); }
internal static int numBitsDiffering(int a, int b) { a ^= b; // a now has a 1 bit exactly where its bit differs with b's // Count bits set quickly with a series of lookups: return(BITS_SET_IN_HALF_BYTE[a & 0x0F] + BITS_SET_IN_HALF_BYTE[(SupportClass.URShift(a, 4) & 0x0F)] + BITS_SET_IN_HALF_BYTE[(SupportClass.URShift(a, 8) & 0x0F)] + BITS_SET_IN_HALF_BYTE[(SupportClass.URShift(a, 12) & 0x0F)] + BITS_SET_IN_HALF_BYTE[(SupportClass.URShift(a, 16) & 0x0F)] + BITS_SET_IN_HALF_BYTE[(SupportClass.URShift(a, 20) & 0x0F)] + BITS_SET_IN_HALF_BYTE[(SupportClass.URShift(a, 24) & 0x0F)] + BITS_SET_IN_HALF_BYTE[(SupportClass.URShift(a, 28) & 0x0F)]); }
public bool isSyncMark(int headerstring, int syncmode, int word) { bool sync = false; if (syncmode == INITIAL_SYNC) { //sync = ((headerstring & 0xFFF00000) == 0xFFF00000); sync = (headerstring & 0xFFE00000) == 0xFFE00000; // SZD: MPEG 2.5 } else { //sync = ((headerstring & 0xFFF80C00) == word) sync = (headerstring & 0xFFE00000) == 0xFFE00000 && // ROB -- THIS IS PROBABLY WRONG. A WEAKER CHECK. (headerstring & 0x000000C0) == 0x000000C0 == single_ch_mode; } // filter out invalid sample rate if (sync) { sync = (SupportClass.URShift(headerstring, 10) & 3) != 3; if (!sync) { Log.Trace("Bitstream: INVALID SAMPLE RATE DETECTED"); } } // filter out invalid layer if (sync) { sync = (SupportClass.URShift(headerstring, 17) & 3) != 0; if (!sync) { Log.Trace("Bitstream: INVALID LAYER DETECTED"); } } // filter out invalid version if (sync) { sync = (SupportClass.URShift(headerstring, 19) & 3) != 1; if (!sync) { Log.Trace("Bitstream: INVALID VERSION DETECTED"); } } return(sync); }
//-------- //-------- 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 physical address /// </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) { byte[] buff = new byte[150]; Array.Copy(ffBlock, 0, buff, 0, 150); // check if read exceeds memory if ((startAddr + len) > (pageLength * numberPages)) { throw new OneWireException("Read exceeds memory bank end"); } if (len < 0) { throw new OneWireException("Invalid length"); } // attempt to put device at max desired speed if (!readContinue) { sp.checkSpeed(); // select the device if (ib.adapter.select(ib.address)) { buff[0] = READ_MEMORY_COMMAND; // address 1 buff[1] = (byte)((startAddr + startPhysicalAddress) & 0xFF); // address 2 buff[2] = (byte)((SupportClass.URShift(((startAddr + startPhysicalAddress) & 0xFFFF), 8)) & 0xFF); ib.adapter.dataBlock(buff, 0, len + 3); // extract the data Array.Copy(buff, 3, readBuf, offset, len); } else { throw new OneWireIOException("Device select failed"); } } else { ib.adapter.dataBlock(buff, 0, len); // extract the data Array.Copy(buff, 0, readBuf, offset, len); } }
protected internal virtual sbyte[] toByteArray(short[] samples, int offs, int len) { sbyte[] b = getByteArray(len * 2); int idx = 0; short s; while (len-- > 0) { s = samples[offs++]; b[idx++] = (sbyte)s; b[idx++] = (sbyte)(SupportClass.URShift(s, 8)); } return(b); }
// Return the mask bit for "getMaskPattern" at "x" and "y". See 8.8 of JISX0510:2004 for mask // pattern conditions. internal static bool getDataMaskBit(int maskPattern, int x, int y) { if (!QRCodeInternal.isValidMaskPattern(maskPattern)) { throw new System.ArgumentException("Invalid mask pattern"); } int intermediate, temp; switch (maskPattern) { case 0: intermediate = (y + x) & 0x1; break; case 1: intermediate = y & 0x1; break; case 2: intermediate = x % 3; break; case 3: intermediate = (y + x) % 3; break; case 4: intermediate = ((SupportClass.URShift(y, 1)) + (x / 3)) & 0x1; break; case 5: temp = y * x; intermediate = (temp & 0x1) + (temp % 3); break; case 6: temp = y * x; intermediate = (((temp & 0x1) + (temp % 3)) & 0x1); break; case 7: temp = y * x; intermediate = (((temp % 3) + ((y + x) & 0x1)) & 0x1); break; default: throw new System.ArgumentException("Invalid mask pattern: " + maskPattern); } return(intermediate == 0); }
/// <summary> Writes the contents of the bit buffer and byte aligns the output by /// filling bits with an alternating sequence of 0's and 1's. /// /// </summary> internal virtual void flush() { if (delFF) { // There was a bit stuffing if (bpos != 6) { // Bit buffer is not empty // Output delayed 0xFF out_Renamed.write(0xFF); nb++; delFF = false; // Pad to byte boundary with an alternating sequence of 0's // and 1's. bbuf |= (SupportClass.URShift(PAD_SEQ, (6 - bpos))); // Output the bit buffer out_Renamed.write(bbuf); nb++; bpos = 7; bbuf = 0; } else if (isPredTerm) { out_Renamed.write(0xFF); nb++; out_Renamed.write(0x2A); nb++; bpos = 7; bbuf = 0; delFF = false; } } else { // There was no bit stuffing if (bpos != 7) { // Bit buffer is not empty // Pad to byte boundary with an alternating sequence of 0's and // 1's. bbuf |= (SupportClass.URShift(PAD_SEQ, (6 - bpos))); // Output the bit buffer (bbuf can not be 0xFF) out_Renamed.write(bbuf); nb++; bpos = 7; bbuf = 0; } } }
//-------- //-------- ScratchPad methods //-------- /// <summary> Write to the scratchpad page of memory a NVRAM device. /// /// </summary> /// <param name="startAddr"> starting address /// </param> /// <param name="writeBuf"> byte array containing data to write /// </param> /// <param name="offset"> offset into readBuf to place data /// </param> /// <param name="len"> length in bytes to write /// /// </param> /// <throws> OneWireIOException </throws> /// <throws> OneWireException </throws> public override void writeScratchpad(int startAddr, byte[] writeBuf, int offset, int len) { bool calcCRC = false; if (len > pageLength) { throw new OneWireException("Write exceeds memory bank end"); } // 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[pageLength + 5]; //[37]; raw_buf[0] = WRITE_SCRATCHPAD_COMMAND; raw_buf[1] = (byte)(startAddr & 0xFF); raw_buf[2] = (byte)((SupportClass.URShift((startAddr & 0xFFFF), 8)) & 0xFF); Array.Copy(writeBuf, offset, raw_buf, 3, len); // check if full page (can utilize CRC) if (((startAddr + len) % pageLength) == 0) { Array.Copy(ffBlock, 0, raw_buf, len + 3, 2); calcCRC = true; } // send block, return result ib.adapter.dataBlock(raw_buf, 0, len + 3 + ((calcCRC)?2:0)); //System.out.println("WriteScratchpad: " + com.dalsemi.onewire.utils.Convert.toHexString(raw_buf)); // check crc if (calcCRC) { if (CRC16.compute(raw_buf, 0, len + 5, 0) != 0x0000B001) { forceVerify(); throw new OneWireIOException("Invalid CRC16 read from device"); } } }
/// <summary> Write the bit state in a byte array. /// /// </summary> /// <param name="state">new state of the bit 1, 0 /// </param> /// <param name="index">bit index into byte array /// </param> /// <param name="offset">byte offset into byte array to start /// </param> /// <param name="buf">byte array to manipulate /// </param> public static void arrayWriteBit(int state, int index, int offset, byte[] buf) { int nbyt = (SupportClass.URShift(index, 3)); int nbit = index - (nbyt << 3); if (state == 1) { buf[nbyt + offset] |= (byte)((0x01 << nbit)); } else { //buf[nbyt + offset] &= ~ (0x01 << nbit); buf[nbyt + offset] &= (byte)~(0x01 << nbit); // !!! } }
/// <since> 1.5 /// </since> public static int hashCode(long[] a) { if (a == null) { return(0); } int hash = 1; for (int i = 0; i < a.Length; i++) { long e = a[i]; hash = 31 * hash + (int)(e ^ (SupportClass.URShift(e, 32))); } return(hash); }
/// <summary> Writes the IEEE float value <tt>v</tt> (i.e., 32 bits) to the /// output. Prior to writing, the output should be realigned at the byte /// level. /// /// </summary> /// <param name="v">The value to write to the output /// /// </param> /// <exception cref="java.io.IOException">If an I/O error ocurred. /// /// </exception> public override void writeFloat(float v) { // CONVERSION PROBLEM? OPTIMIZE!!! //byte[] floatbytes = BitConverter.GetBytes(v); //for (int i = floatbytes.Length-1; i >= 0 ; i--) write(floatbytes[i]); //UPGRADE_ISSUE: Method 'java.lang.Float.floatToIntBits' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javalangFloatfloatToIntBits_float'" //int intV = Float.floatToIntBits(v); int intV = BitConverter.ToInt32(BitConverter.GetBytes(v), 0); write(SupportClass.URShift(intV, 24)); write(SupportClass.URShift(intV, 16)); write(SupportClass.URShift(intV, 8)); write(intV); }
private static sbyte[] encode(int[] input, int len) { int i, j; sbyte[] out_Renamed; out_Renamed = new sbyte[len]; for (i = j = 0; j < len; i++, j += 4) { out_Renamed[j] = (sbyte)(input[i] & 0xff); out_Renamed[j + 1] = (sbyte)((SupportClass.URShift(input[i], 8)) & 0xff); out_Renamed[j + 2] = (sbyte)((SupportClass.URShift(input[i], 16)) & 0xff); out_Renamed[j + 3] = (sbyte)((SupportClass.URShift(input[i], 24)) & 0xff); } return(out_Renamed); }
/// <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> /// Feed a bitstring to the crc calculation (length between 0 and 32, not inclusive). /// </summary> public void add_bits(int bitstring, int length) { int bitmask = 1 << (length - 1); do { if (((m_Crc & 0x8000) == 0) ^ ((bitstring & bitmask) == 0)) { m_Crc <<= 1; m_Crc ^= Polynomial; } else { m_Crc <<= 1; } } while ((bitmask = SupportClass.URShift(bitmask, 1)) != 0); }
/// <summary> /// Feed a bitstring to the crc calculation (length between 0 and 32, not inclusive). /// </summary> internal void AddBits(int bitstring, int length) { int bitmask = 1 << (length - 1); do { if (((_CRC & 0x8000) == 0) ^ ((bitstring & bitmask) == 0)) { _CRC <<= 1; _CRC ^= Polynomial; } else { _CRC <<= 1; } }while ((bitmask = SupportClass.URShift(bitmask, 1)) != 0); }
private System.String rwxString(int v, int r) { v = SupportClass.URShift(v, r); System.String rwx = ((((v & 0x04) != 0)?"r":"-") + (((v & 0x02) != 0)?"w":"-")); if (((r == 6) && ((permissions & S_ISUID) == S_ISUID)) || ((r == 3) && ((permissions & S_ISGID) == S_ISGID))) { rwx += (((v & 0x01) != 0)?"s":"S"); } else { rwx += (((v & 0x01) != 0)?"x":"-"); } return(rwx); }
/// <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); }