001 // Copyright (c) National Instruments 2009. All Rights Reserved.
002 // Do Not Edit... this file is generated!
003
004 package edu.wpi.first.wpilibj.fpga;
005
006 import com.ni.rio.*;
007
008 public class tAnalogTrigger extends tSystem
009 {
010
011 public tAnalogTrigger(final int sys_index)
012 {
013 super();
014 m_SystemIndex = sys_index;
015 if (status.isNotFatal() && m_SystemIndex >= kNumSystems)
016 {
017 status.setStatus(NiRioStatus.kRIOStatusBadSelector);
018 }
019
020 }
021
022 protected void finalize()
023 {
024 super.finalize();
025 }
026
027 public int getSystemIndex()
028 {
029 return m_SystemIndex;
030 }
031
032 public static final int kNumSystems = 8;
033 public final int m_SystemIndex;
034
035
036
037
038
039
040
041 //////////////////////////////////////////////////////////////////////////////////////////////////
042 // Accessors for SourceSelect
043 //////////////////////////////////////////////////////////////////////////////////////////////////
044 private static final int kSourceSelect_Channel_BitfieldMask = 0x00007000;
045 private static final int kSourceSelect_Channel_BitfieldOffset = 12;
046 private static final int kSourceSelect_Module_BitfieldMask = 0x00000800;
047 private static final int kSourceSelect_Module_BitfieldOffset = 11;
048 private static final int kSourceSelect_Averaged_BitfieldMask = 0x00000400;
049 private static final int kSourceSelect_Averaged_BitfieldOffset = 10;
050 private static final int kSourceSelect_Filter_BitfieldMask = 0x00000200;
051 private static final int kSourceSelect_Filter_BitfieldOffset = 9;
052 private static final int kSourceSelect_FloatingRollover_BitfieldMask = 0x00000100;
053 private static final int kSourceSelect_FloatingRollover_BitfieldOffset = 8;
054 private static final int kSourceSelect_RolloverLimit_BitfieldMask = 0x000000FF;
055 private static final int kSourceSelect_RolloverLimit_BitfieldOffset = 0;
056 private static final int kSourceSelect_RolloverLimit_FixedPointIntegerShift = 4;
057 private static final int kAnalogTrigger0_SourceSelect_Address = 0x81A0;
058 private static final int kAnalogTrigger1_SourceSelect_Address = 0x81AC;
059 private static final int kAnalogTrigger2_SourceSelect_Address = 0x81B8;
060 private static final int kAnalogTrigger3_SourceSelect_Address = 0x81C4;
061 private static final int kAnalogTrigger4_SourceSelect_Address = 0x81D0;
062 private static final int kAnalogTrigger5_SourceSelect_Address = 0x81DC;
063 private static final int kAnalogTrigger6_SourceSelect_Address = 0x81E8;
064 private static final int kAnalogTrigger7_SourceSelect_Address = 0x81F4;
065 private static final int kSourceSelect_Addresses [] =
066 {
067 kAnalogTrigger0_SourceSelect_Address,
068 kAnalogTrigger1_SourceSelect_Address,
069 kAnalogTrigger2_SourceSelect_Address,
070 kAnalogTrigger3_SourceSelect_Address,
071 kAnalogTrigger4_SourceSelect_Address,
072 kAnalogTrigger5_SourceSelect_Address,
073 kAnalogTrigger6_SourceSelect_Address,
074 kAnalogTrigger7_SourceSelect_Address,
075 };
076
077 public void writeSourceSelect(final int value)
078 {
079
080 NiFpga.writeU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], value, status);
081 }
082 public void writeSourceSelect_Channel(final int value)
083 {
084
085 int regValue = NiFpga.readU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], status);
086 regValue &= ~kSourceSelect_Channel_BitfieldMask;
087 regValue |= ((value) << kSourceSelect_Channel_BitfieldOffset) & kSourceSelect_Channel_BitfieldMask;
088 NiFpga.writeU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], regValue, status);
089 }
090 public void writeSourceSelect_Module(final int value)
091 {
092
093 int regValue = NiFpga.readU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], status);
094 regValue &= ~kSourceSelect_Module_BitfieldMask;
095 regValue |= ((value) << kSourceSelect_Module_BitfieldOffset) & kSourceSelect_Module_BitfieldMask;
096 NiFpga.writeU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], regValue, status);
097 }
098 public void writeSourceSelect_Averaged(final boolean value)
099 {
100
101 int regValue = NiFpga.readU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], status);
102 regValue &= ~kSourceSelect_Averaged_BitfieldMask;
103 regValue |= (((value ? 1 : 0)) << kSourceSelect_Averaged_BitfieldOffset) & kSourceSelect_Averaged_BitfieldMask;
104 NiFpga.writeU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], regValue, status);
105 }
106 public void writeSourceSelect_Filter(final boolean value)
107 {
108
109 int regValue = NiFpga.readU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], status);
110 regValue &= ~kSourceSelect_Filter_BitfieldMask;
111 regValue |= (((value ? 1 : 0)) << kSourceSelect_Filter_BitfieldOffset) & kSourceSelect_Filter_BitfieldMask;
112 NiFpga.writeU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], regValue, status);
113 }
114 public void writeSourceSelect_FloatingRollover(final boolean value)
115 {
116
117 int regValue = NiFpga.readU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], status);
118 regValue &= ~kSourceSelect_FloatingRollover_BitfieldMask;
119 regValue |= (((value ? 1 : 0)) << kSourceSelect_FloatingRollover_BitfieldOffset) & kSourceSelect_FloatingRollover_BitfieldMask;
120 NiFpga.writeU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], regValue, status);
121 }
122 public void writeSourceSelect_RolloverLimit(final int value)
123 {
124
125 int regValue = NiFpga.readU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], status);
126 regValue &= ~kSourceSelect_RolloverLimit_BitfieldMask;
127 regValue |= ((value >>> kSourceSelect_RolloverLimit_FixedPointIntegerShift) << kSourceSelect_RolloverLimit_BitfieldOffset) & kSourceSelect_RolloverLimit_BitfieldMask;
128 NiFpga.writeU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], regValue, status);
129 }
130 public int readSourceSelect()
131 {
132
133 int result = NiFpga.readU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], status);
134 int regValue = result ;
135 return (int)(regValue);
136 }
137 public byte readSourceSelect_Channel()
138 {
139
140 int result = NiFpga.readU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], status);
141 int regValue = result ;
142 int bitfieldValue = ((regValue & kSourceSelect_Channel_BitfieldMask) >>> kSourceSelect_Channel_BitfieldOffset);
143 return (byte)((bitfieldValue) & 0x00000007);
144 }
145 public byte readSourceSelect_Module()
146 {
147
148 int result = NiFpga.readU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], status);
149 int regValue = result ;
150 int bitfieldValue = ((regValue & kSourceSelect_Module_BitfieldMask) >>> kSourceSelect_Module_BitfieldOffset);
151 return (byte)((bitfieldValue) & 0x00000001);
152 }
153 public boolean readSourceSelect_Averaged()
154 {
155
156 int result = NiFpga.readU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], status);
157 int regValue = result ;
158 int bitfieldValue = ((regValue & kSourceSelect_Averaged_BitfieldMask) >>> kSourceSelect_Averaged_BitfieldOffset);
159 return ((bitfieldValue) != 0 ? true : false);
160 }
161 public boolean readSourceSelect_Filter()
162 {
163
164 int result = NiFpga.readU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], status);
165 int regValue = result ;
166 int bitfieldValue = ((regValue & kSourceSelect_Filter_BitfieldMask) >>> kSourceSelect_Filter_BitfieldOffset);
167 return ((bitfieldValue) != 0 ? true : false);
168 }
169 public boolean readSourceSelect_FloatingRollover()
170 {
171
172 int result = NiFpga.readU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], status);
173 int regValue = result ;
174 int bitfieldValue = ((regValue & kSourceSelect_FloatingRollover_BitfieldMask) >>> kSourceSelect_FloatingRollover_BitfieldOffset);
175 return ((bitfieldValue) != 0 ? true : false);
176 }
177 public short readSourceSelect_RolloverLimit()
178 {
179
180 int result = NiFpga.readU32(m_DeviceHandle, kSourceSelect_Addresses[m_SystemIndex], status);
181 int regValue = result ;
182 int bitfieldValue = ((regValue & kSourceSelect_RolloverLimit_BitfieldMask) >>> kSourceSelect_RolloverLimit_BitfieldOffset) << kSourceSelect_RolloverLimit_FixedPointIntegerShift;
183 // Sign extension
184 bitfieldValue <<= 20;
185 bitfieldValue >>= 20;
186 return (short)(bitfieldValue);
187 }
188
189 //////////////////////////////////////////////////////////////////////////////////////////////////
190 // Accessors for UpperLimit
191 //////////////////////////////////////////////////////////////////////////////////////////////////
192 private static final int kAnalogTrigger0_UpperLimit_Address = 0x81A4;
193 private static final int kAnalogTrigger1_UpperLimit_Address = 0x81B0;
194 private static final int kAnalogTrigger2_UpperLimit_Address = 0x81BC;
195 private static final int kAnalogTrigger3_UpperLimit_Address = 0x81C8;
196 private static final int kAnalogTrigger4_UpperLimit_Address = 0x81D4;
197 private static final int kAnalogTrigger5_UpperLimit_Address = 0x81EC;
198 private static final int kAnalogTrigger6_UpperLimit_Address = 0x81E0;
199 private static final int kAnalogTrigger7_UpperLimit_Address = 0x81F8;
200 private static final int kUpperLimit_Addresses [] =
201 {
202 kAnalogTrigger0_UpperLimit_Address,
203 kAnalogTrigger1_UpperLimit_Address,
204 kAnalogTrigger2_UpperLimit_Address,
205 kAnalogTrigger3_UpperLimit_Address,
206 kAnalogTrigger4_UpperLimit_Address,
207 kAnalogTrigger5_UpperLimit_Address,
208 kAnalogTrigger6_UpperLimit_Address,
209 kAnalogTrigger7_UpperLimit_Address,
210 };
211
212 public void writeUpperLimit(final int value)
213 {
214
215 NiFpga.writeU32(m_DeviceHandle, kUpperLimit_Addresses[m_SystemIndex], value, status);
216 }
217 public int readUpperLimit()
218 {
219
220 return (int)(NiFpga.readU32(m_DeviceHandle, kUpperLimit_Addresses[m_SystemIndex], status));
221 }
222
223 //////////////////////////////////////////////////////////////////////////////////////////////////
224 // Accessors for LowerLimit
225 //////////////////////////////////////////////////////////////////////////////////////////////////
226 private static final int kAnalogTrigger0_LowerLimit_Address = 0x81A8;
227 private static final int kAnalogTrigger1_LowerLimit_Address = 0x81B4;
228 private static final int kAnalogTrigger2_LowerLimit_Address = 0x81C0;
229 private static final int kAnalogTrigger3_LowerLimit_Address = 0x81CC;
230 private static final int kAnalogTrigger4_LowerLimit_Address = 0x81D8;
231 private static final int kAnalogTrigger5_LowerLimit_Address = 0x81F0;
232 private static final int kAnalogTrigger6_LowerLimit_Address = 0x81E4;
233 private static final int kAnalogTrigger7_LowerLimit_Address = 0x81FC;
234 private static final int kLowerLimit_Addresses [] =
235 {
236 kAnalogTrigger0_LowerLimit_Address,
237 kAnalogTrigger1_LowerLimit_Address,
238 kAnalogTrigger2_LowerLimit_Address,
239 kAnalogTrigger3_LowerLimit_Address,
240 kAnalogTrigger4_LowerLimit_Address,
241 kAnalogTrigger5_LowerLimit_Address,
242 kAnalogTrigger6_LowerLimit_Address,
243 kAnalogTrigger7_LowerLimit_Address,
244 };
245
246 public void writeLowerLimit(final int value)
247 {
248
249 NiFpga.writeU32(m_DeviceHandle, kLowerLimit_Addresses[m_SystemIndex], value, status);
250 }
251 public int readLowerLimit()
252 {
253
254 return (int)(NiFpga.readU32(m_DeviceHandle, kLowerLimit_Addresses[m_SystemIndex], status));
255 }
256
257
258 //////////////////////////////////////////////////////////////////////////////////////////////////
259 // Accessors for Output
260 //////////////////////////////////////////////////////////////////////////////////////////////////
261 public static final int kOutput_NumElements = 8;
262 public static final int kOutput_ElementSize = 4;
263 public static final int kOutput_ElementMask = 0xF;
264 private static final int kOutput_InHysteresis_BitfieldMask = 0x00000008;
265 private static final int kOutput_InHysteresis_BitfieldOffset = 3;
266 private static final int kOutput_OverLimit_BitfieldMask = 0x00000004;
267 private static final int kOutput_OverLimit_BitfieldOffset = 2;
268 private static final int kOutput_Rising_BitfieldMask = 0x00000002;
269 private static final int kOutput_Rising_BitfieldOffset = 1;
270 private static final int kOutput_Falling_BitfieldMask = 0x00000001;
271 private static final int kOutput_Falling_BitfieldOffset = 0;
272 private static final int kAnalogTrigger_Output_Address = 0x819C;
273
274 public static int readOutput(final int bitfield_index)
275 {
276 if (status.isNotFatal() && bitfield_index >= kOutput_NumElements)
277 {
278 status.setStatus(NiRioStatus.kRIOStatusBadSelector);
279 }
280
281 int result = NiFpga.readU32(m_DeviceHandle, kAnalogTrigger_Output_Address, status);
282 int regValue = result >>> ((kOutput_NumElements - 1 - bitfield_index) * kOutput_ElementSize);
283 return (int)(regValue);
284 }
285 public static boolean readOutput_InHysteresis(final int bitfield_index)
286 {
287 if (status.isNotFatal() && bitfield_index >= kOutput_NumElements)
288 {
289 status.setStatus(NiRioStatus.kRIOStatusBadSelector);
290 }
291
292 int result = NiFpga.readU32(m_DeviceHandle, kAnalogTrigger_Output_Address, status);
293 int regValue = result >>> ((kOutput_NumElements - 1 - bitfield_index) * kOutput_ElementSize);
294 int bitfieldValue = ((regValue & kOutput_InHysteresis_BitfieldMask) >>> kOutput_InHysteresis_BitfieldOffset);
295 return ((bitfieldValue) != 0 ? true : false);
296 }
297 public static boolean readOutput_OverLimit(final int bitfield_index)
298 {
299 if (status.isNotFatal() && bitfield_index >= kOutput_NumElements)
300 {
301 status.setStatus(NiRioStatus.kRIOStatusBadSelector);
302 }
303
304 int result = NiFpga.readU32(m_DeviceHandle, kAnalogTrigger_Output_Address, status);
305 int regValue = result >>> ((kOutput_NumElements - 1 - bitfield_index) * kOutput_ElementSize);
306 int bitfieldValue = ((regValue & kOutput_OverLimit_BitfieldMask) >>> kOutput_OverLimit_BitfieldOffset);
307 return ((bitfieldValue) != 0 ? true : false);
308 }
309 public static boolean readOutput_Rising(final int bitfield_index)
310 {
311 if (status.isNotFatal() && bitfield_index >= kOutput_NumElements)
312 {
313 status.setStatus(NiRioStatus.kRIOStatusBadSelector);
314 }
315
316 int result = NiFpga.readU32(m_DeviceHandle, kAnalogTrigger_Output_Address, status);
317 int regValue = result >>> ((kOutput_NumElements - 1 - bitfield_index) * kOutput_ElementSize);
318 int bitfieldValue = ((regValue & kOutput_Rising_BitfieldMask) >>> kOutput_Rising_BitfieldOffset);
319 return ((bitfieldValue) != 0 ? true : false);
320 }
321 public static boolean readOutput_Falling(final int bitfield_index)
322 {
323 if (status.isNotFatal() && bitfield_index >= kOutput_NumElements)
324 {
325 status.setStatus(NiRioStatus.kRIOStatusBadSelector);
326 }
327
328 int result = NiFpga.readU32(m_DeviceHandle, kAnalogTrigger_Output_Address, status);
329 int regValue = result >>> ((kOutput_NumElements - 1 - bitfield_index) * kOutput_ElementSize);
330 int bitfieldValue = ((regValue & kOutput_Falling_BitfieldMask) >>> kOutput_Falling_BitfieldOffset);
331 return ((bitfieldValue) != 0 ? true : false);
332 }
333
334
335
336
337 }