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 tAI extends tSystem
009 {
010
011 public tAI(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 = 2;
033 public final int m_SystemIndex;
034
035
036
037
038
039
040
041
042
043
044
045 //////////////////////////////////////////////////////////////////////////////////////////////////
046 // Accessors for Config
047 //////////////////////////////////////////////////////////////////////////////////////////////////
048 private static final int kConfig_ScanSize_BitfieldMask = 0x1C000000;
049 private static final int kConfig_ScanSize_BitfieldOffset = 26;
050 private static final int kConfig_ConvertRate_BitfieldMask = 0x03FFFFFF;
051 private static final int kConfig_ConvertRate_BitfieldOffset = 0;
052 private static final int kAI0_Config_Address = 0x8154;
053 private static final int kAI1_Config_Address = 0x8168;
054 private static final int kConfig_Addresses [] =
055 {
056 kAI0_Config_Address,
057 kAI1_Config_Address,
058 };
059
060 public void writeConfig(final int value)
061 {
062
063 NiFpga.writeU32(m_DeviceHandle, kConfig_Addresses[m_SystemIndex], value, status);
064 }
065 public void writeConfig_ScanSize(final int value)
066 {
067
068 int regValue = NiFpga.readU32(m_DeviceHandle, kConfig_Addresses[m_SystemIndex], status);
069 regValue &= ~kConfig_ScanSize_BitfieldMask;
070 regValue |= ((value) << kConfig_ScanSize_BitfieldOffset) & kConfig_ScanSize_BitfieldMask;
071 NiFpga.writeU32(m_DeviceHandle, kConfig_Addresses[m_SystemIndex], regValue, status);
072 }
073 public void writeConfig_ConvertRate(final int value)
074 {
075
076 int regValue = NiFpga.readU32(m_DeviceHandle, kConfig_Addresses[m_SystemIndex], status);
077 regValue &= ~kConfig_ConvertRate_BitfieldMask;
078 regValue |= ((value) << kConfig_ConvertRate_BitfieldOffset) & kConfig_ConvertRate_BitfieldMask;
079 NiFpga.writeU32(m_DeviceHandle, kConfig_Addresses[m_SystemIndex], regValue, status);
080 }
081 public int readConfig()
082 {
083
084 int result = NiFpga.readU32(m_DeviceHandle, kConfig_Addresses[m_SystemIndex], status);
085 int regValue = result ;
086 return (int)(regValue);
087 }
088 public byte readConfig_ScanSize()
089 {
090
091 int result = NiFpga.readU32(m_DeviceHandle, kConfig_Addresses[m_SystemIndex], status);
092 int regValue = result ;
093 int bitfieldValue = ((regValue & kConfig_ScanSize_BitfieldMask) >>> kConfig_ScanSize_BitfieldOffset);
094 return (byte)((bitfieldValue) & 0x00000007);
095 }
096 public int readConfig_ConvertRate()
097 {
098
099 int result = NiFpga.readU32(m_DeviceHandle, kConfig_Addresses[m_SystemIndex], status);
100 int regValue = result ;
101 int bitfieldValue = ((regValue & kConfig_ConvertRate_BitfieldMask) >>> kConfig_ConvertRate_BitfieldOffset);
102 return (int)((bitfieldValue) & 0x03FFFFFF);
103 }
104
105 //////////////////////////////////////////////////////////////////////////////////////////////////
106 // Accessors for LoopTiming
107 //////////////////////////////////////////////////////////////////////////////////////////////////
108 private static final int kAI0_LoopTiming_Address = 0x8164;
109 private static final int kAI1_LoopTiming_Address = 0x8178;
110 private static final int kLoopTiming_Addresses [] =
111 {
112 kAI0_LoopTiming_Address,
113 kAI1_LoopTiming_Address,
114 };
115
116 public long readLoopTiming()
117 {
118
119 return (long)((NiFpga.readU32(m_DeviceHandle, kLoopTiming_Addresses[m_SystemIndex], status)) & 0xFFFFFFFFl);
120 }
121
122 //////////////////////////////////////////////////////////////////////////////////////////////////
123 // Accessors for OversampleBits
124 //////////////////////////////////////////////////////////////////////////////////////////////////
125 public static final int kOversampleBits_NumElements = 8;
126 public static final int kOversampleBits_ElementSize = 4;
127 public static final int kOversampleBits_ElementMask = 0xF;
128 private static final int kAI0_OversampleBits_Address = 0x815C;
129 private static final int kAI1_OversampleBits_Address = 0x8170;
130 private static final int kOversampleBits_Addresses [] =
131 {
132 kAI0_OversampleBits_Address,
133 kAI1_OversampleBits_Address,
134 };
135
136 public void writeOversampleBits(final int bitfield_index, final int value)
137 {
138 if (status.isNotFatal() && bitfield_index >= kOversampleBits_NumElements)
139 {
140 status.setStatus(NiRioStatus.kRIOStatusBadSelector);
141 }
142
143 int regValue = NiFpga.readU32(m_DeviceHandle, kOversampleBits_Addresses[m_SystemIndex], status);
144 regValue &= ~(kOversampleBits_ElementMask << ((kOversampleBits_NumElements - 1 - bitfield_index) * kOversampleBits_ElementSize));
145 regValue |= ((value & kOversampleBits_ElementMask) << ((kOversampleBits_NumElements - 1 - bitfield_index) * kOversampleBits_ElementSize));
146 NiFpga.writeU32(m_DeviceHandle, kOversampleBits_Addresses[m_SystemIndex], regValue, status);
147 }
148 public byte readOversampleBits(final int bitfield_index)
149 {
150 if (status.isNotFatal() && bitfield_index >= kOversampleBits_NumElements)
151 {
152 status.setStatus(NiRioStatus.kRIOStatusBadSelector);
153 }
154
155 int result = NiFpga.readU32(m_DeviceHandle, kOversampleBits_Addresses[m_SystemIndex], status);
156 int arrayElementValue = ((result)
157 >>> ((kOversampleBits_NumElements - 1 - bitfield_index) * kOversampleBits_ElementSize)) & kOversampleBits_ElementMask;
158 return (byte)((arrayElementValue) & 0x0000000F);
159 }
160
161 //////////////////////////////////////////////////////////////////////////////////////////////////
162 // Accessors for AverageBits
163 //////////////////////////////////////////////////////////////////////////////////////////////////
164 public static final int kAverageBits_NumElements = 8;
165 public static final int kAverageBits_ElementSize = 4;
166 public static final int kAverageBits_ElementMask = 0xF;
167 private static final int kAI0_AverageBits_Address = 0x8160;
168 private static final int kAI1_AverageBits_Address = 0x8174;
169 private static final int kAverageBits_Addresses [] =
170 {
171 kAI0_AverageBits_Address,
172 kAI1_AverageBits_Address,
173 };
174
175 public void writeAverageBits(final int bitfield_index, final int value)
176 {
177 if (status.isNotFatal() && bitfield_index >= kAverageBits_NumElements)
178 {
179 status.setStatus(NiRioStatus.kRIOStatusBadSelector);
180 }
181
182 int regValue = NiFpga.readU32(m_DeviceHandle, kAverageBits_Addresses[m_SystemIndex], status);
183 regValue &= ~(kAverageBits_ElementMask << ((kAverageBits_NumElements - 1 - bitfield_index) * kAverageBits_ElementSize));
184 regValue |= ((value & kAverageBits_ElementMask) << ((kAverageBits_NumElements - 1 - bitfield_index) * kAverageBits_ElementSize));
185 NiFpga.writeU32(m_DeviceHandle, kAverageBits_Addresses[m_SystemIndex], regValue, status);
186 }
187 public byte readAverageBits(final int bitfield_index)
188 {
189 if (status.isNotFatal() && bitfield_index >= kAverageBits_NumElements)
190 {
191 status.setStatus(NiRioStatus.kRIOStatusBadSelector);
192 }
193
194 int result = NiFpga.readU32(m_DeviceHandle, kAverageBits_Addresses[m_SystemIndex], status);
195 int arrayElementValue = ((result)
196 >>> ((kAverageBits_NumElements - 1 - bitfield_index) * kAverageBits_ElementSize)) & kAverageBits_ElementMask;
197 return (byte)((arrayElementValue) & 0x0000000F);
198 }
199
200 //////////////////////////////////////////////////////////////////////////////////////////////////
201 // Accessors for ScanList
202 //////////////////////////////////////////////////////////////////////////////////////////////////
203 public static final int kScanList_NumElements = 8;
204 public static final int kScanList_ElementSize = 3;
205 public static final int kScanList_ElementMask = 0x7;
206 private static final int kAI0_ScanList_Address = 0x8158;
207 private static final int kAI1_ScanList_Address = 0x816C;
208 private static final int kScanList_Addresses [] =
209 {
210 kAI0_ScanList_Address,
211 kAI1_ScanList_Address,
212 };
213
214 public void writeScanList(final int bitfield_index, final int value)
215 {
216 if (status.isNotFatal() && bitfield_index >= kScanList_NumElements)
217 {
218 status.setStatus(NiRioStatus.kRIOStatusBadSelector);
219 }
220
221 int regValue = NiFpga.readU32(m_DeviceHandle, kScanList_Addresses[m_SystemIndex], status);
222 regValue &= ~(kScanList_ElementMask << ((kScanList_NumElements - 1 - bitfield_index) * kScanList_ElementSize));
223 regValue |= ((value & kScanList_ElementMask) << ((kScanList_NumElements - 1 - bitfield_index) * kScanList_ElementSize));
224 NiFpga.writeU32(m_DeviceHandle, kScanList_Addresses[m_SystemIndex], regValue, status);
225 }
226 public byte readScanList(final int bitfield_index)
227 {
228 if (status.isNotFatal() && bitfield_index >= kScanList_NumElements)
229 {
230 status.setStatus(NiRioStatus.kRIOStatusBadSelector);
231 }
232
233 int result = NiFpga.readU32(m_DeviceHandle, kScanList_Addresses[m_SystemIndex], status);
234 int arrayElementValue = ((result)
235 >>> ((kScanList_NumElements - 1 - bitfield_index) * kScanList_ElementSize)) & kScanList_ElementMask;
236 return (byte)((arrayElementValue) & 0x00000007);
237 }
238
239
240 //////////////////////////////////////////////////////////////////////////////////////////////////
241 // Accessors for Output
242 //////////////////////////////////////////////////////////////////////////////////////////////////
243 private static final int kAI_Output_Address = 0x8150;
244
245 public static int readOutput()
246 {
247
248 return (int)(NiFpga.readU32(m_DeviceHandle, kAI_Output_Address, status));
249 }
250
251 //////////////////////////////////////////////////////////////////////////////////////////////////
252 // Accessors for LatchOutput
253 //////////////////////////////////////////////////////////////////////////////////////////////////
254 private static final int kAI_LatchOutput_Address = 0x814C;
255
256 public static void strobeLatchOutput()
257 {
258
259 NiFpga.writeU32(m_DeviceHandle, kAI_LatchOutput_Address, 1, status);
260 }
261
262 //////////////////////////////////////////////////////////////////////////////////////////////////
263 // Accessors for ReadSelect
264 //////////////////////////////////////////////////////////////////////////////////////////////////
265 private static final int kReadSelect_Channel_BitfieldMask = 0x0000001C;
266 private static final int kReadSelect_Channel_BitfieldOffset = 2;
267 private static final int kReadSelect_Module_BitfieldMask = 0x00000002;
268 private static final int kReadSelect_Module_BitfieldOffset = 1;
269 private static final int kReadSelect_Averaged_BitfieldMask = 0x00000001;
270 private static final int kReadSelect_Averaged_BitfieldOffset = 0;
271 private static final int kAI_ReadSelect_Address = 0x8148;
272
273 public static void writeReadSelect(final int value)
274 {
275
276 NiFpga.writeU32(m_DeviceHandle, kAI_ReadSelect_Address, value, status);
277 }
278 public static void writeReadSelect_Channel(final int value)
279 {
280
281 int regValue = NiFpga.readU32(m_DeviceHandle, kAI_ReadSelect_Address, status);
282 regValue &= ~kReadSelect_Channel_BitfieldMask;
283 regValue |= ((value) << kReadSelect_Channel_BitfieldOffset) & kReadSelect_Channel_BitfieldMask;
284 NiFpga.writeU32(m_DeviceHandle, kAI_ReadSelect_Address, regValue, status);
285 }
286 public static void writeReadSelect_Module(final int value)
287 {
288
289 int regValue = NiFpga.readU32(m_DeviceHandle, kAI_ReadSelect_Address, status);
290 regValue &= ~kReadSelect_Module_BitfieldMask;
291 regValue |= ((value) << kReadSelect_Module_BitfieldOffset) & kReadSelect_Module_BitfieldMask;
292 NiFpga.writeU32(m_DeviceHandle, kAI_ReadSelect_Address, regValue, status);
293 }
294 public static void writeReadSelect_Averaged(final boolean value)
295 {
296
297 int regValue = NiFpga.readU32(m_DeviceHandle, kAI_ReadSelect_Address, status);
298 regValue &= ~kReadSelect_Averaged_BitfieldMask;
299 regValue |= (((value ? 1 : 0)) << kReadSelect_Averaged_BitfieldOffset) & kReadSelect_Averaged_BitfieldMask;
300 NiFpga.writeU32(m_DeviceHandle, kAI_ReadSelect_Address, regValue, status);
301 }
302 public static int readReadSelect()
303 {
304
305 int result = NiFpga.readU32(m_DeviceHandle, kAI_ReadSelect_Address, status);
306 int regValue = result ;
307 return (int)(regValue);
308 }
309 public static byte readReadSelect_Channel()
310 {
311
312 int result = NiFpga.readU32(m_DeviceHandle, kAI_ReadSelect_Address, status);
313 int regValue = result ;
314 int bitfieldValue = ((regValue & kReadSelect_Channel_BitfieldMask) >>> kReadSelect_Channel_BitfieldOffset);
315 return (byte)((bitfieldValue) & 0x00000007);
316 }
317 public static byte readReadSelect_Module()
318 {
319
320 int result = NiFpga.readU32(m_DeviceHandle, kAI_ReadSelect_Address, status);
321 int regValue = result ;
322 int bitfieldValue = ((regValue & kReadSelect_Module_BitfieldMask) >>> kReadSelect_Module_BitfieldOffset);
323 return (byte)((bitfieldValue) & 0x00000001);
324 }
325 public static boolean readReadSelect_Averaged()
326 {
327
328 int result = NiFpga.readU32(m_DeviceHandle, kAI_ReadSelect_Address, status);
329 int regValue = result ;
330 int bitfieldValue = ((regValue & kReadSelect_Averaged_BitfieldMask) >>> kReadSelect_Averaged_BitfieldOffset);
331 return ((bitfieldValue) != 0 ? true : false);
332 }
333
334
335
336
337 }