private List <int> RegToIntList(uint rtReg) { ushort enValue; enValue = ReadShortReg(rtReg); return(RTConverters.UInt16ToIntList(enValue)); }
private void IntListToReg(uint rtReg, List <int> setBits) { ushort wValue; wValue = RTConverters.IntListToUInt16(setBits); WriteShortReg(rtReg, wValue); }
/// <summary> /// Read the sample data from the tag using specified antenna. /// </summary> /// <param name="fromAntenna">The antenna to use. If the value is -1 the the antenna selection is made by the module.</param> /// <returns>Return the sample data from the tag if available.</returns> /// <exception cref="FormatException">Exception can be thrown if there is no sample data available.</exception> public RTConst.SAMPLEDATA GetSamples(int fromAntenna) { ushort[] tmp; List <double> dTemp; RTConst.SAMPLEDATA ret; dTemp = new List <double>(); tmp = GetRawSamples(fromAntenna); if (tmp == null || tmp.Length == 0) { throw new FormatException("RT0005::GetAllSamples: no samples found"); } // The application needs to catch if invalid value is found... foreach (ushort w in tmp) { dTemp.Add(RTConverters.FixedToDouble(w)); } ret = new RTConst.SAMPLEDATA(); ret.values = dTemp.ToArray(); ret.min = RTConverters.FindMinTemp(ret.values); ret.max = RTConverters.FindMaxTemp(ret.values); return(ret); }
private void ByteArrToUshort(byte[] src, ushort[] dest, int destOffset) { int i; for (i = 0; i < src.Length; i += 2) { dest[destOffset++] = RTConverters.BytesToUInt16(src, i); } }
/// <summary> /// Read a 32-bit register value. /// </summary> /// <param name="rtReg">Register pair's (2 x 16-bit register) address</param> /// <returns>The 32-bit register value.</returns> /// <remarks>The result is in little-endian format so there is no need to do any additional conversions.</remarks> /// <exception cref="NurApiException"> /// <para>This exception is thrown when the underlying physical read fails.</para> /// <para>Exception can also be thrown if the tag reports an error e.g. "out of range"</para> /// </exception> /// <exception cref="IndexOutOfRangeException">This exception is thrown if the read is out of the register address space.</exception> public uint ReadUInt32Reg(uint rtReg) { RTConst.RegRangeCheck(rtReg, "ReadUInt32Reg", RTConst.RW_32BIT); byte[] b; b = ReadTag(mPassword, mSecured, NurApi.BANK_USER, rtReg, 4); return(RTConverters.BytesToUInt32(b)); }
/// <summary> /// Write a single 16-bit register. /// </summary> /// <param name="rtReg">Register to write, <seealso cref="RTRegs"/>.</param> /// <param name="wValue">Value to write.</param> /// <remarks> /// <para>See also: <seealso cref="Secured"/>, <seealso cref="Password"/></para> /// <para>The data to write is internally converted to the tag's big-endian format so there is no need for additional conversions.</para> /// </remarks> /// <exception cref="NurApiException"> /// <para>This exception is thrown when the underlying physical write fails.</para> /// <para>Exception can also be thrown if the tag reports an error e.g. "out of range"</para> /// </exception> public void WriteShortReg(uint rtReg, ushort wValue) { RTConst.RegRangeCheck(rtReg, "WriteShortReg", RTConst.RW_16BIT); byte[] b; b = RTConverters.UInt16ToBytes(wValue); WriteTag(mPassword, mSecured, NurApi.BANK_USER, rtReg, b); }
/// <summary> /// Read a 16-bit register. /// </summary> /// <param name="rtReg">Register value to read, <seealso cref="RTRegs"/>.</param> /// <returns>This call returns the 16-bit value of the register.</returns> /// <remarks>NOTE: this result is internally converted to little-endian format; no need to re-convert.</remarks> /// <exception cref="NurApiException"> /// <para>This exception is thrown when the underlying physical read fails.</para> /// <para>Exception can also be thrown if the tag reports an error e.g. "out of range"</para> /// </exception> public ushort ReadShortReg(uint rtReg) { RTConst.RegRangeCheck(rtReg, "ReadShortReg", RTConst.RW_16BIT); byte[] b; b = ReadTag(mPassword, mSecured, NurApi.BANK_USER, rtReg, 2); return(RTConverters.BytesToUInt16(b)); }
/// <summary> /// Read multiple 16-bit registers at once. /// </summary> /// <param name="firstAddr">First register to read, <seealso cref="RTRegs"/>.</param> /// <param name="regCount">Number of registers to read.</param> /// <returns>An array of unsigned 16-bit register that were read.</returns> /// <remarks></remarks> /// <exception cref="NurApiException">This exception is thrown when the underlying physical read fails.</exception> /// <exception cref="RTException"> /// <para>This exception is thrown when the number of registers is out of range, <seealso cref="RTConst.MIN_RD_COUNT"/>, <seealso cref="RTConst.MAX_RD_COUNT"/>.</para> /// </exception> /// <exception cref="RTException"> /// <para>This exception is thrown if the total reading exceeds the last memory position, <seealso cref="RTConst.LOG_AREA_LAST"/></para> /// </exception> public ushort [] ReadMultipleRegs(uint firstAddr, int regCount) { RTConst.RegRangeCheck(firstAddr, "ReadMultipleRegs", RTConst.RW_16BIT); RTConst.RegRangeCheck((uint)(firstAddr + regCount), "ReadMultipleRegs: read length is out of range.", RTConst.RW_16BIT); RTConst.RWCountCheck(regCount, "ReadMultipleRegs"); byte [] data; data = ReadTag(mPassword, mSecured, NurApi.BANK_USER, firstAddr, (regCount * 2)); return(RTConverters.BytesToUInt16Arr(data)); }
/// <summary> /// /// </summary> /// <param name="startDelay"></param> /// <param name="samplingInterval"></param> public void StartSimpleLog(RTConst.LOGINTERVAL startDelay, RTConst.LOGINTERVAL samplingInterval) { ushort wIntVal = 0; ushort wDelay = 0; List <int> enList = new List <int>(); if (samplingInterval == RTConst.LOGINTERVAL.INT_NONE) { throw new RTException("StartSimpleLog: interval cannot be 0."); } wIntVal = RTConverters.IntervalToUIn16(samplingInterval); wDelay = RTConverters.IntervalToUIn16(startDelay); ResetAll(); try { BINLimit[0] = RTConst.FIXED_70LIM; BINThreshold[0] = RTConst.FIXED_MINUS20LIM; BINSampleTime[0] = wIntVal; } catch { throw new RTException("StartSimpleLog: BIN setup failed."); } enList.Add(0); try { BINEnable = enList; BINEnableSample = enList; } catch { throw new RTException("StartSimpleLog: BIN enable failed."); } /* Disable time stamp store */ try { WriteShortReg(RTRegs.BIN_ENA_TIME_STORE, 0); } catch { throw new RTException("StartSimpleLog: timestamp store disable failed."); } try { /* Setup delay time */ if (wDelay == 0) // Disable ? { int dummy = RTConst.CTL_DLYEN_MASK; dummy = ~dummy; ControlRegister &= (ushort)(dummy); } else { ControlRegister |= RTConst.CTL_DLYEN_MASK; } } catch { throw new RTException("StartSimpleLog: start delay control failed."); } try { WriteShortReg(RTRegs.SAMPLING_DELAY, wDelay); } catch { throw new RTException("StartSimpleLog: writing sampling delay failed."); } /* Start logging. */ try { ResetStart(); } catch { throw new RTException("StartSimpleLog: reset + start failed."); } }
/// <summary> /// /// </summary> /// <param name="offset"></param> /// <param name="wData"></param> public void SetReservedExtra(uint offset, ushort wData) { byte[] bData = RTConverters.UInt16ToBytes(wData); WriteTag(mPassword, mSecured, NurApi.BANK_PASSWD, RTConst.PASSWD_EXTRA_ADDR + offset, bData); }
/// <summary> /// /// </summary> /// <param name="offset"></param> /// <returns></returns> public ushort GetReservedExtra(uint offset) { byte [] bData = ReadTag(mPassword, mSecured, NurApi.BANK_PASSWD, RTConst.PASSWD_EXTRA_ADDR + offset, 2); return(RTConverters.BytesToUInt16(bData)); }