Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5 | f9daq | 1 | |
2 | // libxxusb.cpp : Defines the entry point for the DLL application. |
||
3 | // |
||
4 | |||
5 | |||
6 | |||
7 | #include <string.h> |
||
8 | #include <malloc.h> |
||
9 | #include "usb.h" |
||
10 | #include "libxxusb.h" |
||
11 | #include <time.h> |
||
12 | #include "stdio.h" |
||
13 | |||
14 | |||
15 | |||
16 | // 03/09/06 Release 3.00 changes |
||
17 | // 07/28/06 correction CAMAC write for F to be in range 16...23 |
||
18 | // 10/09/06 correction CAMAC read for F to be in range <16 OR >23 |
||
19 | // 10/16/06 CAMAC DGG corrected |
||
20 | // 12/28/07 Open corrected for bug when calling register after opening |
||
21 | /* |
||
22 | ******** xxusb_longstack_execute ************************ |
||
23 | |||
24 | Executes stack array passed to the function and returns the data read from the VME bus |
||
25 | |||
26 | Paramters: |
||
27 | hdev: USB device handle returned from an open function |
||
28 | DataBuffer: pointer to the dual use buffer |
||
29 | when calling , DataBuffer contains (unsigned short) stack data, with first word serving |
||
30 | as a placeholder |
||
31 | upon successful return, DataBuffer contains (unsigned short) VME data |
||
32 | lDataLen: The number of bytes to be fetched from VME bus - not less than the actual number |
||
33 | expected, or the function will return -5 code. For stack consisting only of write operations, |
||
34 | lDataLen may be set to 1. |
||
35 | timeout: The time in ms that should be spent tryimg to write data. |
||
36 | |||
37 | Returns: |
||
38 | When Successful, the number of bytes read from xxusb. |
||
39 | Upon failure, a negative number |
||
40 | |||
41 | Note: |
||
42 | The function must pass a pointer to an array of unsigned integer stack data, in which the first word |
||
43 | is left empty to serve as a placeholder. |
||
44 | The function is intended for executing Uint32_t stacks, up to 4 MBytes Uint32_t, both "write" and "read" |
||
45 | oriented, such as using multi-block transfer operations. |
||
46 | Structure upon call: |
||
47 | DataBuffer(0) = 0(don't care place holder) |
||
48 | DataBuffer(1) = (unsigned short)StackLength bits 0-15 |
||
49 | DataBuffer(2) = (unsigned short)StackLength bits 16-20 |
||
50 | DataBuffer(3 - StackLength +2) (unsigned short) stack data |
||
51 | StackLength represents the number of words following DataBuffer(1) word, thus the total number |
||
52 | of words is StackLength+2 |
||
53 | Structure upon return: |
||
54 | DataBuffer(0 - (ReturnValue/2-1)) - (unsigned short)array of returned data when ReturnValue>0 |
||
55 | */ |
||
56 | |||
57 | int xxusb_longstack_execute(usb_dev_handle *hDev, void *DataBuffer, int lDataLen, int timeout) |
||
58 | { |
||
59 | int ret; |
||
60 | char *cbuf; |
||
61 | unsigned short *usbuf; |
||
62 | int bufsize; |
||
63 | |||
64 | cbuf = (char *)DataBuffer; |
||
65 | usbuf = (unsigned short *)DataBuffer; |
||
66 | cbuf[0]=12; |
||
67 | cbuf[1]=0; |
||
68 | bufsize = 2*(usbuf[1]+0x10000*usbuf[2])+4; |
||
69 | ret=usb_bulk_write(hDev, XXUSB_ENDPOINT_OUT, cbuf, bufsize, timeout); |
||
70 | if (ret>0) |
||
71 | ret=usb_bulk_read(hDev, XXUSB_ENDPOINT_IN, cbuf, lDataLen, timeout); |
||
72 | |||
73 | return ret; |
||
74 | } |
||
75 | |||
76 | /* |
||
77 | ******** xxusb_bulk_read ************************ |
||
78 | |||
79 | Reads the content of the usbfifo whenever "FIFO full" flag is set, |
||
80 | otherwise times out. |
||
81 | |||
82 | Paramters: |
||
83 | hdev: USB device handle returned from an open function |
||
84 | DataBuffer: pointer to an array to store data that is read from the VME bus; |
||
85 | the array may be declared as byte, unsigned short, or unsigned Uint32_t |
||
86 | lDatalen: The number of bytes to read from xxusb |
||
87 | timeout: The time in ms that should be spent waiting for data. |
||
88 | |||
89 | Returns: |
||
90 | When Successful, the number of bytes read from xxusb. |
||
91 | Upon failure, a negative number |
||
92 | |||
93 | Note: |
||
94 | Depending upon the actual need, the function may be used to return the data in a form |
||
95 | of an array of bytes, unsigned short integers (16 bits), or unsigned Uint32_t integers (32 bits). |
||
96 | The latter option of passing a pointer to an array of unsigned Uint32_t integers is meaningful when |
||
97 | xxusb data buffering option is used (bit 7=128 of the global register) that requires data |
||
98 | 32-bit data alignment. |
||
99 | |||
100 | */ |
||
101 | int xxusb_bulk_read(usb_dev_handle *hDev, void *DataBuffer, int lDataLen, int timeout) |
||
102 | { |
||
103 | int ret; |
||
104 | char *cbuf; |
||
105 | cbuf = (char *)DataBuffer; |
||
106 | ret = usb_bulk_read(hDev, XXUSB_ENDPOINT_IN, cbuf, lDataLen, timeout); |
||
107 | return ret; |
||
108 | } |
||
109 | |||
110 | /* |
||
111 | ******** xxusb_bulk_write ************************ |
||
112 | |||
113 | Writes the content of an array of bytes, unsigned short integers, or unsigned Uint32_t integers |
||
114 | to the USB port fifo; times out when the USB fifo is full (e.g., when xxusb is busy). |
||
115 | |||
116 | Paramters: |
||
117 | hdev: USB device handle returned from an open function |
||
118 | DataBuffer: pointer to an array storing the data to be sent; |
||
119 | the array may be declared as byte, unsigned short, or unsigned Uint32_t |
||
120 | lDatalen: The number of bytes to to send to xxusb |
||
121 | timeout: The time in ms that should be spent waiting for data. |
||
122 | |||
123 | Returns: |
||
124 | When Successful, the number of bytes passed to xxusb. |
||
125 | Upon failure, a negative number |
||
126 | |||
127 | Note: |
||
128 | Depending upon the actual need, the function may be used to pass to xxusb the data in a form |
||
129 | of an array of bytes, unsigned short integers (16 bits), or unsigned Uint32_t integers (32 bits). |
||
130 | */ |
||
131 | int xxusb_bulk_write(usb_dev_handle *hDev, void *DataBuffer, int lDataLen, int timeout) |
||
132 | { |
||
133 | int ret; |
||
134 | char *cbuf; |
||
135 | cbuf = (char *)DataBuffer; |
||
136 | ret = usb_bulk_write(hDev, XXUSB_ENDPOINT_OUT, cbuf, lDataLen, timeout); |
||
137 | return ret; |
||
138 | } |
||
139 | |||
140 | /* |
||
141 | ******** xxusb_usbfifo_read ************************ |
||
142 | |||
143 | Reads data stored in the xxusb fifo and packs them in an array of Uint32_t integers. |
||
144 | |||
145 | Paramters: |
||
146 | hdev: USB device handle returned from an open function |
||
147 | DataBuffer: pointer to an array of Uint32_t to store data that is read |
||
148 | the data occupy only the least significant 16 bits of the 32-bit data words |
||
149 | lDatalen: The number of bytes to read from the xxusb |
||
150 | timeout: The time in ms that should be spent waiting for data. |
||
151 | |||
152 | Returns: |
||
153 | When Successful, the number of bytes read from xxusb. |
||
154 | Upon failure, a negative number |
||
155 | |||
156 | Note: |
||
157 | The function is not economical as it wastes half of the space required for storing |
||
158 | the data received. Also, it is relatively slow, as it performs extensive data repacking. |
||
159 | It is recommended to use xxusb_bulk_read with a pointer to an array of unsigned short |
||
160 | integers. |
||
161 | */ |
||
162 | int xxusb_usbfifo_read(usb_dev_handle *hDev, int *DataBuffer, int lDataLen, int timeout) |
||
163 | { |
||
164 | int ret; |
||
165 | char *cbuf; |
||
166 | unsigned short *usbuf; |
||
167 | int i; |
||
168 | |||
169 | cbuf = (char *)DataBuffer; |
||
170 | usbuf = (unsigned short *)DataBuffer; |
||
171 | |||
172 | ret = usb_bulk_read(hDev, XXUSB_ENDPOINT_IN, cbuf, lDataLen, timeout); |
||
173 | if (ret > 0) |
||
174 | for (i=ret/2-1; i >= 0; i=i-1) |
||
175 | { |
||
176 | usbuf[i*2]=usbuf[i]; |
||
177 | usbuf[i*2+1]=0; |
||
178 | } |
||
179 | return ret; |
||
180 | } |
||
181 | |||
182 | |||
183 | //******************************************************// |
||
184 | //******************* GENERAL XX_USB *******************// |
||
185 | //******************************************************// |
||
186 | // The following are functions used for both VM_USB & CC_USB |
||
187 | |||
188 | |||
189 | /* |
||
190 | ******** xxusb_register_write ************************ |
||
191 | |||
192 | Writes Data to the xxusb register selected by RedAddr. For |
||
193 | acceptable values for RegData and RegAddr see the manual |
||
194 | the module you are using. |
||
195 | |||
196 | Parameters: |
||
197 | hdev: usb device handle returned from open device |
||
198 | RegAddr: The internal address if the xxusb |
||
199 | RegData: The Data to be written to the register |
||
200 | |||
201 | Returns: |
||
202 | Number of bytes sent to xxusb if successful |
||
203 | |||
204 | Negative numbers if the call fails |
||
205 | */ |
||
206 | short xxusb_register_write(usb_dev_handle *hDev, short RegAddr, Uint32_t RegData) |
||
207 | { |
||
208 | Uint32_t RegD; |
||
209 | char buf[8]={5,0,0,0,0,0,0,0}; |
||
210 | int ret; |
||
211 | int lDataLen; |
||
212 | int timeout; |
||
213 | if ((RegAddr==0) || (RegAddr==12) || (RegAddr==15)) |
||
214 | return 0; |
||
215 | buf[2]=(char)(RegAddr & 15); |
||
216 | buf[4]=(char)(RegData & 255); |
||
217 | |||
218 | RegD = RegData >> 8; |
||
219 | buf[5]=(char)(RegD & 255); |
||
220 | RegD = RegD >>8; |
||
221 | if (RegAddr==8) |
||
222 | { |
||
223 | buf[6]=(char)(RegD & 255); |
||
224 | lDataLen=8; |
||
225 | } |
||
226 | else |
||
227 | lDataLen=6; |
||
228 | timeout=10; |
||
229 | ret=xxusb_bulk_write(hDev, buf, lDataLen, timeout); |
||
230 | return ret; |
||
231 | } |
||
232 | |||
233 | /* |
||
234 | ******** xxusb_stack_write ************************ |
||
235 | |||
236 | Writes a stack of VME/CAMAC calls to the VM_USB/CC_USB |
||
237 | to be executed upon trigger. |
||
238 | |||
239 | Parameters: |
||
240 | hdev: usb device handle returned from an open function |
||
241 | StackAddr: internal register to which the stack should be written |
||
242 | lpStackData: Pointer to an array holding the stack |
||
243 | |||
244 | Returns: |
||
245 | The number of Bytes written to the xxusb when successful |
||
246 | A negative number upon failure |
||
247 | */ |
||
248 | short xxusb_stack_write(usb_dev_handle *hDev, short StackAddr, Uint32_t *intbuf) |
||
249 | { |
||
250 | int timeout; |
||
251 | short ret; |
||
252 | short lDataLen; |
||
253 | char buf[2000]; |
||
254 | short i; |
||
255 | int bufsize; |
||
256 | |||
257 | buf[0]=(char)((StackAddr & 51) + 4); |
||
258 | buf[1]=0; |
||
259 | lDataLen=(short)(intbuf[0] & 0xFFF); |
||
260 | buf[2]=(char)(lDataLen & 255); |
||
261 | lDataLen = lDataLen >> 8; |
||
262 | buf[3] = (char)(lDataLen & 255); |
||
263 | bufsize=intbuf[0]*2+4; |
||
264 | if (intbuf[0]==0) |
||
265 | return 0; |
||
266 | for (i=1; i <= intbuf[0]; i++) |
||
267 | { |
||
268 | buf[2+2*i] = (char)(intbuf[i] & 255); |
||
269 | buf[3+2*i] = (char)((intbuf[i] >>8) & 255); |
||
270 | } |
||
271 | timeout=50; |
||
272 | ret=usb_bulk_write(hDev, XXUSB_ENDPOINT_OUT, buf, bufsize, timeout); |
||
273 | return ret; |
||
274 | } |
||
275 | |||
276 | /* |
||
277 | ******** xxusb_stack_execute ********************** |
||
278 | |||
279 | Writes, executes and returns the value of a DAQ stack. |
||
280 | |||
281 | Parameters: |
||
282 | hdev: USB device handle returned from an open function |
||
283 | intbuf: Pointer to an array holding the values stack. Upon return |
||
284 | Pointer value is the Data returned from the stack. |
||
285 | |||
286 | Returns: |
||
287 | When successful, the number of Bytes read from xxusb |
||
288 | Upon Failure, a negative number. |
||
289 | */ |
||
290 | short xxusb_stack_execute(usb_dev_handle *hDev, Uint32_t *intbuf) |
||
291 | { |
||
292 | int timeout; |
||
293 | short ret; |
||
294 | short lDataLen; |
||
295 | char buf[26700]; |
||
296 | short i; |
||
297 | int bufsize; |
||
298 | int ii = 0; |
||
299 | |||
300 | buf[0]=12; |
||
301 | buf[1]=0; |
||
302 | lDataLen=(short)(intbuf[0] & 0xFFF); |
||
303 | buf[2]=(char)(lDataLen & 255); |
||
304 | lDataLen = lDataLen >> 8; |
||
305 | buf[3] = (char)(lDataLen & 15); |
||
306 | bufsize=intbuf[0]*2+4; |
||
307 | if (intbuf[0]==0) |
||
308 | return 0; |
||
309 | for (i=1; i <= intbuf[0]; i++) |
||
310 | { |
||
311 | buf[2+2*i] = (char)(intbuf[i] & 255); |
||
312 | buf[3+2*i] = (char)((intbuf[i] >>8) & 255); |
||
313 | } |
||
314 | timeout=2000; |
||
315 | ret=usb_bulk_write(hDev, XXUSB_ENDPOINT_OUT, buf, bufsize, timeout); |
||
316 | if (ret>0) |
||
317 | { |
||
318 | lDataLen=26700; |
||
319 | timeout=6000; |
||
320 | ret=usb_bulk_read(hDev, XXUSB_ENDPOINT_IN, buf, lDataLen, timeout); |
||
321 | if (ret>0) |
||
322 | for (i=0; i < ret; i=i+2) |
||
323 | intbuf[ii++]=(UCHAR)(buf[i]) +(UCHAR)( buf[i+1])*256; |
||
324 | } |
||
325 | return ret; |
||
326 | } |
||
327 | |||
328 | /* |
||
329 | ******** xxusb_stack_read ************************ |
||
330 | |||
331 | Reads the current DAQ stack stored by xxusb |
||
332 | |||
333 | Parameters: |
||
334 | hdev: USB device handle returned by an open function |
||
335 | StackAddr: Indicates which stack to read, primary or secondary |
||
336 | intbuf: Pointer to a array where the stack can be stored |
||
337 | |||
338 | Returns: |
||
339 | Number of bytes read from xxusb when successful |
||
340 | Upon failure, a negative number |
||
341 | */ |
||
342 | short xxusb_stack_read(usb_dev_handle *hDev, short StackAddr, Uint32_t *intbuf) |
||
343 | { |
||
344 | int timeout; |
||
345 | short ret; |
||
346 | short lDataLen; |
||
347 | short bufsize; |
||
348 | char buf[1600]; |
||
349 | int i; |
||
350 | |||
351 | buf[0]=(char)(StackAddr & 51); |
||
352 | buf[1]=0; |
||
353 | lDataLen = 2; |
||
354 | timeout=100; |
||
355 | ret=usb_bulk_write(hDev, XXUSB_ENDPOINT_OUT, buf, lDataLen, timeout); |
||
356 | if (ret < 0) |
||
357 | return ret; |
||
358 | else |
||
359 | bufsize=1600; |
||
360 | int ii=0; |
||
361 | { |
||
362 | ret=usb_bulk_read(hDev, XXUSB_ENDPOINT_IN, buf, bufsize, timeout); |
||
363 | if (ret>0) |
||
364 | for (i=0; i < ret; i=i+2) |
||
365 | intbuf[ii++]=(UCHAR)(buf[i]) + (UCHAR)(buf[i+1])*256; |
||
366 | return ret; |
||
367 | |||
368 | } |
||
369 | } |
||
370 | |||
371 | /* |
||
372 | ******** xxusb_register_read ************************ |
||
373 | |||
374 | Reads the current contents of an internal xxusb register |
||
375 | |||
376 | Parameters: |
||
377 | hdev: USB device handle returned from an open function |
||
378 | RegAddr: The internal address of the register from which to read |
||
379 | RegData: Pointer to a Uint32_t to hold the data. |
||
380 | |||
381 | Returns: |
||
382 | When Successful, the number of bytes read from xxusb. |
||
383 | Upon failure, a negative number |
||
384 | */ |
||
385 | short xxusb_register_read(usb_dev_handle *hDev, short RegAddr, Uint32_t *RegData) |
||
386 | { |
||
387 | //Uint32_t RegD; |
||
388 | int timeout; |
||
389 | char buf[4]={1,0,0,0}; |
||
390 | int ret; |
||
391 | int lDataLen; |
||
392 | |||
393 | buf[2]=(char)(RegAddr & 15); |
||
394 | timeout=10; |
||
395 | lDataLen=4; |
||
396 | ret=xxusb_bulk_write(hDev, buf, lDataLen, timeout); |
||
397 | if (ret < 0) |
||
398 | return (short)ret; |
||
399 | else |
||
400 | { |
||
401 | lDataLen=8; |
||
402 | timeout=100; |
||
403 | ret=xxusb_bulk_read(hDev, buf, lDataLen, timeout); |
||
404 | if (ret<0) |
||
405 | return (short)ret; |
||
406 | else |
||
407 | { |
||
408 | *RegData=(UCHAR)(buf[0])+256*(UCHAR)(buf[1]); |
||
409 | if (ret==4) |
||
410 | *RegData=*RegData+0x10000*(UCHAR)(buf[2]); |
||
411 | return (short)ret; |
||
412 | } |
||
413 | } |
||
414 | } |
||
415 | |||
416 | /* |
||
417 | ******** xxusb_reset_toggle ************************ |
||
418 | |||
419 | Toggles the reset state of the FPGA while the xxusb in programming mode |
||
420 | |||
421 | Parameters |
||
422 | hdev: US B device handle returned from an open function |
||
423 | |||
424 | Returns: |
||
425 | Upon failure, a negative number |
||
426 | */ |
||
427 | short xxusb_reset_toggle(usb_dev_handle *hDev) |
||
428 | { |
||
429 | short ret; |
||
430 | char buf[2] = {(char)255,(char)255}; |
||
431 | int lDataLen=2; |
||
432 | int timeout=1000; |
||
433 | ret = usb_bulk_write(hDev, XXUSB_ENDPOINT_OUT, buf,lDataLen, timeout); |
||
434 | return (short)ret; |
||
435 | } |
||
436 | |||
437 | /* |
||
438 | ******** xxusb_devices_find ************************ |
||
439 | |||
440 | Determines the number and parameters of all xxusb devices attched to |
||
441 | the computer. |
||
442 | |||
443 | Parameters: |
||
444 | xxdev: pointer to an array on which the device parameters are stored |
||
445 | |||
446 | Returns: |
||
447 | Upon success, returns the number of devices found |
||
448 | Upon Failure returns a negative number |
||
449 | */ |
||
450 | short xxusb_devices_find(xxusb_device_type *xxdev) |
||
451 | { |
||
452 | short DevFound = 0; |
||
453 | usb_dev_handle *udev; |
||
454 | struct usb_bus *bus; |
||
455 | struct usb_device *dev; |
||
456 | struct usb_bus *usb_busses; |
||
457 | char string[256]; |
||
458 | short ret; |
||
459 | usb_init(); |
||
460 | usb_find_busses(); |
||
461 | usb_busses=usb_get_busses(); |
||
462 | usb_find_devices(); |
||
463 | for (bus=usb_busses; bus; bus = bus->next) |
||
464 | { |
||
465 | for (dev = bus->devices; dev; dev= dev->next) |
||
466 | { |
||
467 | if (dev->descriptor.idVendor==XXUSB_WIENER_VENDOR_ID) |
||
468 | { |
||
469 | udev = usb_open(dev); |
||
470 | if (udev) |
||
471 | { |
||
472 | ret = usb_get_string_simple(udev, dev->descriptor.iSerialNumber, string, sizeof(string)); |
||
473 | if (ret >0 ) |
||
474 | { |
||
475 | xxdev[DevFound].usbdev=dev; |
||
476 | strcpy(xxdev[DevFound].SerialString, string); |
||
477 | DevFound++; |
||
478 | } |
||
479 | usb_close(udev); |
||
480 | } |
||
481 | else return -1; |
||
482 | } |
||
483 | } |
||
484 | } |
||
485 | return DevFound; |
||
486 | } |
||
487 | |||
488 | /* |
||
489 | ******** xxusb_device_close ************************ |
||
490 | |||
491 | Closes an xxusb device |
||
492 | |||
493 | Parameters: |
||
494 | hdev: USB device handle returned from an open function |
||
495 | |||
496 | Returns: 1 |
||
497 | */ |
||
498 | short xxusb_device_close(usb_dev_handle *hDev) |
||
499 | { |
||
500 | short ret; |
||
501 | ret=usb_release_interface(hDev,0); |
||
502 | usb_close(hDev); |
||
503 | return 1; |
||
504 | } |
||
505 | |||
506 | /* |
||
507 | ******** xxusb_device_open ************************ |
||
508 | |||
509 | Opens an xxusb device found by xxusb_device_find |
||
510 | |||
511 | Parameters: |
||
512 | dev: a usb device |
||
513 | |||
514 | Returns: |
||
515 | A USB device handle |
||
516 | */ |
||
517 | usb_dev_handle* xxusb_device_open(struct usb_device *dev) |
||
518 | { |
||
519 | short ret; |
||
520 | Uint32_t val; |
||
521 | int count =0; |
||
522 | usb_dev_handle *udev; |
||
523 | udev = usb_open(dev); |
||
524 | ret = usb_set_configuration(udev,1); |
||
525 | ret = usb_claim_interface(udev,0); |
||
526 | // RESET USB (added 10/16/06 Andreas Ruben) |
||
527 | ret=xxusb_register_write(udev, 10, 0x04); |
||
528 | // Loop to find known state (added 12/28/07 TH / AR) |
||
529 | ret =-1; |
||
530 | while ((ret <0) && (count <10)) |
||
531 | { |
||
532 | xxusb_register_read(udev, 0, &val); |
||
533 | count++; |
||
534 | } |
||
535 | |||
536 | return udev; |
||
537 | } |
||
538 | |||
539 | /* |
||
540 | ******** xxusb_flash_program ************************ |
||
541 | |||
542 | --Untested and therefore uncommented-- |
||
543 | */ |
||
544 | short xxusb_flash_program(usb_dev_handle *hDev, char *config, short nsect) |
||
545 | { |
||
546 | int i=0; |
||
547 | int k=0; |
||
548 | short ret=0; |
||
549 | time_t t1,t2; |
||
550 | |||
551 | char *pconfig; |
||
552 | char *pbuf; |
||
553 | pconfig=config; |
||
554 | char buf[518] ={(char)0xAA,(char)0xAA,(char)0x55,(char)0x55,(char)0xA0,(char)0xA0}; |
||
555 | while (*pconfig++ != -1); |
||
556 | for (i=0; i<nsect; i++) |
||
557 | { |
||
558 | pbuf=buf+6; |
||
559 | for (k=0; k<256; k++) |
||
560 | { |
||
561 | *(pbuf++)=*(pconfig); |
||
562 | *(pbuf++)=*(pconfig++); |
||
563 | } |
||
564 | ret = usb_bulk_write(hDev, XXUSB_ENDPOINT_OUT, buf, 518, 2000); |
||
565 | if (ret<0) |
||
566 | return ret; |
||
567 | t1=clock()+(time_t)(0.03*CLOCKS_PER_SEC); |
||
568 | while (t1>clock()); |
||
569 | t2=clock(); |
||
570 | } |
||
571 | return ret; |
||
572 | } |
||
573 | |||
574 | /* |
||
575 | ******** xxusb_flashblock_program ************************ |
||
576 | |||
577 | --Untested and therefore uncommented-- |
||
578 | */ |
||
579 | short xxusb_flashblock_program(usb_dev_handle *hDev, UCHAR *config) |
||
580 | { |
||
581 | int k=0; |
||
582 | short ret=0; |
||
583 | |||
584 | UCHAR *pconfig; |
||
585 | char *pbuf; |
||
586 | pconfig=config; |
||
587 | char buf[518] ={(char)0xAA,(char)0xAA,(char)0x55,(char)0x55,(char)0xA0,(char)0xA0}; |
||
588 | pbuf=buf+6; |
||
589 | for (k=0; k<256; k++) |
||
590 | { |
||
591 | *(pbuf++)=(UCHAR)(*(pconfig)); |
||
592 | *(pbuf++)=(UCHAR)(*(pconfig++)); |
||
593 | } |
||
594 | ret = usb_bulk_write(hDev, XXUSB_ENDPOINT_OUT, buf, 518, 2000); |
||
595 | return ret; |
||
596 | } |
||
597 | |||
598 | /* |
||
599 | ******** xxusb_serial_open ************************ |
||
600 | |||
601 | Opens a xxusb device whose serial number is given |
||
602 | |||
603 | Parameters: |
||
604 | SerialString: a char string that gives the serial number of |
||
605 | the device you wish to open. It takes the form: |
||
606 | VM0009 - for a vm_usb with serial number 9 or |
||
607 | CC0009 - for a cc_usb with serial number 9 |
||
608 | |||
609 | Returns: |
||
610 | A USB device handle |
||
611 | */ |
||
612 | usb_dev_handle* xxusb_serial_open(char *SerialString) |
||
613 | { |
||
614 | short DevFound = 0; |
||
615 | usb_dev_handle *udev = NULL; |
||
616 | struct usb_bus *bus; |
||
617 | struct usb_device *dev; |
||
618 | struct usb_bus *usb_busses; |
||
619 | char string[20]; |
||
620 | short ret; |
||
621 | //usb_set_debug(4); |
||
622 | usb_init(); |
||
623 | usb_find_busses(); |
||
624 | usb_busses=usb_get_busses(); |
||
625 | usb_find_devices(); |
||
626 | for (bus=usb_busses; bus; bus = bus->next) |
||
627 | { |
||
628 | for (dev = bus->devices; dev; dev= dev->next) |
||
629 | { |
||
630 | if (dev->descriptor.idVendor==XXUSB_WIENER_VENDOR_ID) |
||
631 | { |
||
632 | printf("id %04x\n",dev->descriptor.idVendor); |
||
633 | udev = xxusb_device_open(dev); |
||
634 | if (udev) |
||
635 | { |
||
636 | ret = usb_get_string_simple(udev, dev->descriptor.iSerialNumber, string, sizeof(string)); |
||
637 | printf("iSerial %04x string %s\n",dev->descriptor.iSerialNumber,string); |
||
638 | if (ret >0 ) |
||
639 | { |
||
640 | printf(" Device with %s\n",SerialString); |
||
641 | |||
642 | if (strcmp(string,SerialString)==0){ |
||
643 | printf(" Device with %s found\n",SerialString); |
||
644 | return udev; |
||
645 | } |
||
646 | } else { |
||
647 | printf(" Device returned %d\n",ret); |
||
648 | } |
||
649 | usb_close(udev); |
||
650 | } |
||
651 | } |
||
652 | } |
||
653 | } |
||
654 | udev = NULL; |
||
655 | return udev; |
||
656 | } |
||
657 | |||
658 | |||
659 | //******************************************************// |
||
660 | //****************** EZ_VME Functions ******************// |
||
661 | //******************************************************// |
||
662 | // The following are functions used to perform simple |
||
663 | // VME Functions with the VM_USB |
||
664 | |||
665 | /* |
||
666 | ******** VME_write_32 ************************ |
||
667 | |||
668 | Writes a 32 bit data word to the VME bus |
||
669 | |||
670 | Parameters: |
||
671 | hdev: USB devcie handle returned from an open function |
||
672 | Address_Modifier: VME address modifier for the VME call |
||
673 | VME_Address: Address to write the data to |
||
674 | Data: 32 bit data word to be written to VME_Address |
||
675 | |||
676 | Returns: |
||
677 | Number of bytes read from xxusb when successful |
||
678 | Upon failure, a negative number |
||
679 | */ |
||
680 | short VME_write_32(usb_dev_handle *hdev, short Address_Modifier, Uint32_t VME_Address, Uint32_t Data) |
||
681 | { |
||
682 | Uint32_t intbuf[1000]; |
||
683 | short ret; |
||
684 | intbuf[0]=7; |
||
685 | intbuf[1]=0; |
||
686 | intbuf[2]=Address_Modifier; |
||
687 | intbuf[3]=0; |
||
688 | intbuf[4]=(VME_Address & 0xffff); |
||
689 | intbuf[5]=((VME_Address >>16) & 0xffff); |
||
690 | intbuf[6]=(Data & 0xffff); |
||
691 | intbuf[7]=((Data >> 16) & 0xffff); |
||
692 | ret = xxusb_stack_execute(hdev, intbuf); |
||
693 | return ret; |
||
694 | } |
||
695 | |||
696 | /* |
||
697 | ******** VME_read_32 ************************ |
||
698 | |||
699 | |||
700 | Reads a 32 bit data word from a VME address |
||
701 | |||
702 | Parameters: |
||
703 | hdev: USB devcie handle returned from an open function |
||
704 | Address_Modifier: VME address modifier for the VME call |
||
705 | VME_Address: Address to read the data from |
||
706 | Data: 32 bit data word read from VME_Address |
||
707 | |||
708 | Returns: |
||
709 | Number of bytes read from xxusb when successful |
||
710 | Upon failure, a negative number |
||
711 | */ |
||
712 | short VME_read_32(usb_dev_handle *hdev, short Address_Modifier, Uint32_t VME_Address, Uint32_t *Data) |
||
713 | { |
||
714 | Uint32_t intbuf[1000]; |
||
715 | short ret; |
||
716 | intbuf[0]=5; |
||
717 | intbuf[1]=0; |
||
718 | intbuf[2]=Address_Modifier +0x100; |
||
719 | intbuf[3]=0; |
||
720 | intbuf[4]=(VME_Address & 0xffff); |
||
721 | intbuf[5]=((VME_Address >>16) & 0xffff); |
||
722 | ret = xxusb_stack_execute(hdev, intbuf); |
||
723 | *Data=intbuf[0] + (intbuf[1] * 0x10000); |
||
724 | return ret; |
||
725 | } |
||
726 | |||
727 | /* |
||
728 | ******** VME_write_16 ************************ |
||
729 | |||
730 | Writes a 16 bit data word to the VME bus |
||
731 | |||
732 | Parameters: |
||
733 | hdev: USB devcie handle returned from an open function |
||
734 | Address_Modifier: VME address modifier for the VME call |
||
735 | VME_Address: Address to write the data to |
||
736 | Data: word to be written to VME_Address |
||
737 | |||
738 | Returns: |
||
739 | Number of bytes read from xxusb when successful |
||
740 | Upon failure, a negative number |
||
741 | */ |
||
742 | short VME_write_16(usb_dev_handle *hdev, short Address_Modifier, Uint32_t VME_Address, Uint32_t Data) |
||
743 | { |
||
744 | Uint32_t intbuf[1000]; |
||
745 | short ret; |
||
746 | intbuf[0]=7; |
||
747 | intbuf[1]=0; |
||
748 | intbuf[2]=Address_Modifier; |
||
749 | intbuf[3]=0; |
||
750 | intbuf[4]=(VME_Address & 0xffff)+ 0x01; |
||
751 | intbuf[5]=((VME_Address >>16) & 0xffff); |
||
752 | intbuf[6]=(Data & 0xffff); |
||
753 | intbuf[7]=0; |
||
754 | ret = xxusb_stack_execute(hdev, intbuf); |
||
755 | return ret; |
||
756 | } |
||
757 | |||
758 | /* |
||
759 | ******** VME_read_16 ************************ |
||
760 | |||
761 | Reads a 16 bit data word from a VME address |
||
762 | |||
763 | Parameters: |
||
764 | hdev: USB devcie handle returned from an open function |
||
765 | Address_Modifier: VME address modifier for the VME call |
||
766 | VME_Address: Address to read the data from |
||
767 | Data: word read from VME_Address |
||
768 | |||
769 | Returns: |
||
770 | Number of bytes read from xxusb when successful |
||
771 | Upon failure, a negative number |
||
772 | */ |
||
773 | short VME_read_16(usb_dev_handle *hdev,short Address_Modifier, Uint32_t VME_Address, Uint32_t *Data) |
||
774 | { |
||
775 | Uint32_t intbuf[1000]; |
||
776 | short ret; |
||
777 | intbuf[0]=5; |
||
778 | intbuf[1]=0; |
||
779 | intbuf[2]=Address_Modifier +0x100; |
||
780 | intbuf[3]=0; |
||
781 | intbuf[4]=(VME_Address & 0xffff)+ 0x01; |
||
782 | intbuf[5]=((VME_Address >>16) & 0xffff); |
||
783 | ret = xxusb_stack_execute(hdev, intbuf); |
||
784 | *Data=intbuf[0]; |
||
785 | return ret; |
||
786 | } |
||
787 | |||
788 | /* |
||
789 | ******** VME_BLT_read_32 ************************ |
||
790 | |||
791 | Performs block transfer of 32 bit words from a VME address |
||
792 | |||
793 | Parameters: |
||
794 | hdev: USB devcie handle returned from an open function |
||
795 | Address_Modifier: VME address modifier for the VME call |
||
796 | count: number of data words to read |
||
797 | VME_Address: Address to read the data from |
||
798 | Data: pointer to an array to hold the data words |
||
799 | |||
800 | Returns: |
||
801 | Number of bytes read from xxusb when successful |
||
802 | Upon failure, a negative number |
||
803 | */ |
||
804 | short VME_BLT_read_32(usb_dev_handle *hdev, short Adress_Modifier, int count, Uint32_t VME_Address, Uint32_t Data[]) |
||
805 | { |
||
806 | Uint32_t intbuf[1000]; |
||
807 | short ret; |
||
808 | int i=0; |
||
809 | if (count > 255) return -1; |
||
810 | intbuf[0]=5; |
||
811 | intbuf[1]=0; |
||
812 | intbuf[2]=Adress_Modifier +0x100; |
||
813 | intbuf[3]=(count << 8); |
||
814 | intbuf[4]=(VME_Address & 0xffff); |
||
815 | intbuf[5]=((VME_Address >>16) & 0xffff); |
||
816 | ret = xxusb_stack_execute(hdev, intbuf); |
||
817 | int j=0; |
||
818 | for (i=0;i<(2*count);i=i+2) |
||
819 | { |
||
820 | Data[j]=intbuf[i] + (intbuf[i+1] * 0x10000); |
||
821 | j++; |
||
822 | } |
||
823 | return ret; |
||
824 | } |
||
825 | |||
826 | //******************************************************// |
||
827 | //****************** VM_USB Registers ******************// |
||
828 | //******************************************************// |
||
829 | // The following are functions used to set the registers |
||
830 | // in the VM_USB |
||
831 | |||
832 | /* |
||
833 | ******** VME_register_write ************************ |
||
834 | |||
835 | Writes to the vmusb registers that are accessible through |
||
836 | VME style calls |
||
837 | |||
838 | Parameters: |
||
839 | hdev: USB devcie handle returned from an open function |
||
840 | VME_Address: The VME Address of the internal register |
||
841 | Data: Data to be written to VME_Address |
||
842 | |||
843 | Returns: |
||
844 | Number of bytes read from xxusb when successful |
||
845 | Upon failure, a negative number |
||
846 | */ |
||
847 | short VME_register_write(usb_dev_handle *hdev, Uint32_t VME_Address, Uint32_t Data) |
||
848 | { |
||
849 | Uint32_t intbuf[1000]; |
||
850 | short ret; |
||
851 | |||
852 | intbuf[0]=7; |
||
853 | intbuf[1]=0; |
||
854 | intbuf[2]=0x1000; |
||
855 | intbuf[3]=0; |
||
856 | intbuf[4]=(VME_Address & 0xffff); |
||
857 | intbuf[5]=((VME_Address >>16) & 0xffff); |
||
858 | intbuf[6]=(Data & 0xffff); |
||
859 | intbuf[7]=((Data >> 16) & 0xffff); |
||
860 | ret = xxusb_stack_execute(hdev, intbuf); |
||
861 | return ret; |
||
862 | } |
||
863 | |||
864 | /* |
||
865 | ******** VME_register_read ************************ |
||
866 | |||
867 | Reads from the vmusb registers that are accessible trough VME style calls |
||
868 | |||
869 | Parameters: |
||
870 | hdev: USB devcie handle returned from an open function |
||
871 | VME_Address: The VME Address of the internal register |
||
872 | Data: Data read from VME_Address |
||
873 | |||
874 | Returns: |
||
875 | Number of bytes read from xxusb when successful |
||
876 | Upon failure, a negative number |
||
877 | */ |
||
878 | short VME_register_read(usb_dev_handle *hdev, Uint32_t VME_Address, Uint32_t *Data) |
||
879 | { |
||
880 | Uint32_t intbuf[1000]; |
||
881 | short ret; |
||
882 | |||
883 | intbuf[0]=5; |
||
884 | intbuf[1]=0; |
||
885 | intbuf[2]=0x1100; |
||
886 | intbuf[3]=0; |
||
887 | intbuf[4]=(VME_Address & 0xffff); |
||
888 | intbuf[5]=((VME_Address >>16) & 0xffff); |
||
889 | ret = xxusb_stack_execute(hdev, intbuf); |
||
890 | *Data=intbuf[0] + (intbuf[1] * 0x10000); |
||
891 | return ret; |
||
892 | } |
||
893 | |||
894 | /* |
||
895 | ******** VME_LED_settings ************************ |
||
896 | |||
897 | Sets the vmusb LED's |
||
898 | |||
899 | Parameters: |
||
900 | hdev: USB devcie handle returned from an open function |
||
901 | LED: The number which corresponds to an LED values are: |
||
902 | |||
903 | 1 - for RED LED |
||
904 | 2 - for GREEN LED |
||
905 | 3 - for Bottom YELLOW LED |
||
906 | code: The LED aource selector code, valid values for each LED |
||
907 | are listed in the manual |
||
908 | invert: to invert the LED lighting |
||
909 | latch: sets LED latch bit |
||
910 | |||
911 | Returns: |
||
912 | Number of bytes read from xxusb when successful |
||
913 | Upon failure, a negative number |
||
914 | */ |
||
915 | short VME_LED_settings(usb_dev_handle *hdev, int LED, int code, int invert, int latch) |
||
916 | { |
||
917 | short ret; |
||
918 | // Uint32_t internal; |
||
919 | Uint32_t Data; |
||
920 | |||
921 | if( (LED <0) ||(LED > 3) || (code < 0) || (code > 7)) return -1; |
||
922 | |||
923 | VME_register_read(hdev,0xc,&Data); |
||
924 | if(LED == 0) |
||
925 | { |
||
926 | Data = Data & 0xFFFFFF00; |
||
927 | Data = Data | code; |
||
928 | if (invert == 1 && latch == 1) Data = Data | 0x18; |
||
929 | if (invert == 1 && latch == 0) Data = Data | 0x08; |
||
930 | if (invert == 0 && latch == 1) Data = Data | 0x10; |
||
931 | } |
||
932 | if(LED == 1) |
||
933 | { |
||
934 | Data = Data & 0xFFFF00FF; |
||
935 | Data = Data | (code * 0x0100); |
||
936 | if (invert == 1 && latch == 1) Data = Data | 0x1800; |
||
937 | if (invert == 1 && latch == 0) Data = Data | 0x0800; |
||
938 | if (invert == 0 && latch == 1) Data = Data | 0x1000; |
||
939 | } |
||
940 | if(LED == 2) |
||
941 | { |
||
942 | Data = Data & 0xFF00FFFF; |
||
943 | Data = Data | (code * 0x10000); |
||
944 | if (invert == 1 && latch == 1) Data = Data | 0x180000; |
||
945 | if (invert == 1 && latch == 0) Data = Data | 0x080000; |
||
946 | if (invert == 0 && latch == 1) Data = Data | 0x100000; |
||
947 | } |
||
948 | if(LED == 3) |
||
949 | { |
||
950 | Data = Data & 0x00FFFFFF; |
||
951 | Data = Data | (code * 0x10000); |
||
952 | if (invert == 1 && latch == 1) Data = Data | 0x18000000; |
||
953 | if (invert == 1 && latch == 0) Data = Data | 0x08000000; |
||
954 | if (invert == 0 && latch == 1) Data = Data | 0x10000000; |
||
955 | } |
||
956 | ret = VME_register_write(hdev, 0xc, Data); |
||
957 | return ret; |
||
958 | } |
||
959 | |||
960 | /* |
||
961 | ******** VME_DGG ************************ |
||
962 | |||
963 | Sets the parameters for Gate & Delay channel A of vmusb |
||
964 | |||
965 | Parameters: |
||
966 | hdev: USB devcie handle returned from an open function |
||
967 | channel: Which DGG channel to use Valid Values are: |
||
968 | |||
969 | 1 - For DGG B |
||
970 | trigger: Determines what triggers the start of the DGG Valid values are: |
||
971 | |||
972 | 1 - NIM input 1 |
||
973 | 2 - NIM input 2 |
||
974 | 3 - Event Trigger |
||
975 | 4 - End of Event |
||
976 | 5 - USB Trigger |
||
977 | 6 - Pulser |
||
978 | output: Determines which NIM output to use for the channel, Vaild values are: |
||
979 | |||
980 | 1 - for NIM O2 |
||
981 | delay: 32 bit word consisting of |
||
982 | lower 16 bits: Delay_fine in steps of 12.5ns between trigger and start of gate |
||
983 | upper 16 bits: Delay_coarse in steps of 81.7us between trigger and start of gate |
||
984 | gate: the time the gate should stay open in steps of 12.5ns |
||
985 | invert: is 1 if you wish to invert the DGG channel output |
||
986 | latch: is 1 if you wish to run the DGG channel latched |
||
987 | |||
988 | Returns: |
||
989 | Returns 1 when successful |
||
990 | Upon failure, a negative number |
||
991 | */ |
||
992 | short VME_DGG(usb_dev_handle *hdev, unsigned short channel, unsigned short trigger, unsigned short output, |
||
993 | Uint32_t delay, unsigned short gate, unsigned short invert, unsigned short latch) |
||
994 | { |
||
995 | Uint32_t Data, DGData, Delay_ext; |
||
996 | Uint32_t internal; |
||
997 | short ret; |
||
998 | |||
999 | |||
1000 | ret = VME_register_read(hdev, 0x10, &Data); |
||
1001 | // check and correct values |
||
1002 | if(ret<=0) return -1; |
||
1003 | |||
1004 | if(channel >1) channel =1; |
||
1005 | if(invert >1) invert =1; |
||
1006 | if(latch >1) latch =1; |
||
1007 | if(output >1) output =1; |
||
1008 | if(trigger >6) trigger =0; |
||
1009 | |||
1010 | // define Delay and Gate data |
||
1011 | DGData = gate * 0x10000; |
||
1012 | DGData += (unsigned short) delay; |
||
1013 | |||
1014 | // Set channel, output, invert, latch |
||
1015 | if (output == 0) |
||
1016 | { |
||
1017 | Data = Data & 0xFFFFFF00; |
||
1018 | Data += 0x04 + channel +0x08*invert + 0x10*latch; |
||
1019 | } |
||
1020 | if (output == 1) |
||
1021 | { |
||
1022 | Data = Data & 0xFFFF00FF; |
||
1023 | Data += (0x04 + channel +0x08*invert + 0x10*latch)*0x100; |
||
1024 | } |
||
1025 | |||
1026 | // Set trigger, delay, gate |
||
1027 | |||
1028 | if(channel ==0) // CHANNEL DGG_A |
||
1029 | { |
||
1030 | internal = (trigger * 0x1000000) ; |
||
1031 | Data= Data & 0xF0FFFFFF; |
||
1032 | Data += internal; |
||
1033 | ret = VME_register_write(hdev,0x10,Data); |
||
1034 | if(ret<=0) return -1; |
||
1035 | ret=VME_register_write(hdev,0x14,DGData); |
||
1036 | if(ret<=0) return -1; |
||
1037 | // Set coarse delay in DGG_Extended register |
||
1038 | ret = VME_register_read(hdev,0x38,&Data); |
||
1039 | Delay_ext= (Data & 0xffff0000); |
||
1040 | Delay_ext+= ((delay/0x10000) & 0xffff); |
||
1041 | ret = VME_register_write(hdev,0x38,Delay_ext); |
||
1042 | } |
||
1043 | if( channel ==1) // CHANNEL DGG_B |
||
1044 | { |
||
1045 | internal = (trigger * 0x10000000) ; |
||
1046 | Data= Data & 0x0FFFFFFF; |
||
1047 | Data += internal; |
||
1048 | ret = VME_register_write(hdev,0x10,Data); |
||
1049 | if(ret<=0) return -1; |
||
1050 | ret=VME_register_write(hdev,0x18,DGData); |
||
1051 | if(ret<=0) return -1; |
||
1052 | // Set coarse delay in DGG_Extended register |
||
1053 | ret = VME_register_read(hdev,0x38,&Data); |
||
1054 | Delay_ext= (Data & 0x0000ffff); |
||
1055 | Delay_ext+= (delay & 0xffff0000); |
||
1056 | ret = VME_register_write(hdev,0x38,Delay_ext); |
||
1057 | } |
||
1058 | return 1; |
||
1059 | |||
1060 | } |
||
1061 | |||
1062 | /* |
||
1063 | ******** VME_Output_settings ************************ |
||
1064 | |||
1065 | Sets the vmusb NIM output register |
||
1066 | |||
1067 | Parameters: |
||
1068 | hdev: USB devcie handle returned from an open function |
||
1069 | Channel: The number which corresponds to an output: |
||
1070 | 1 - for Output 1 |
||
1071 | 2 - for Output 2 |
||
1072 | code: The Output selector code, valid values |
||
1073 | are listed in the manual |
||
1074 | invert: to invert the output |
||
1075 | latch: sets latch bit |
||
1076 | |||
1077 | Returns: |
||
1078 | Number of bytes read from xxusb when successful |
||
1079 | Upon failure, a negative number |
||
1080 | */ |
||
1081 | short VME_Output_settings(usb_dev_handle *hdev, int Channel, int code, int invert, int latch) |
||
1082 | { |
||
1083 | |||
1084 | short ret; |
||
1085 | // Uint32_t internal; |
||
1086 | Uint32_t Data; |
||
1087 | |||
1088 | if( (Channel <1) ||(Channel > 2) || (code < 0) || (code > 7)) return -1; |
||
1089 | VME_register_read(hdev,0x10,&Data); |
||
1090 | if(Channel == 1) |
||
1091 | { |
||
1092 | Data = Data & 0xFFFF00; |
||
1093 | Data = Data | code; |
||
1094 | if (invert == 1 && latch == 1) Data = Data | 0x18; |
||
1095 | if (invert == 1 && latch == 0) Data = Data | 0x08; |
||
1096 | if (invert == 0 && latch == 1) Data = Data | 0x10; |
||
1097 | } |
||
1098 | if(Channel == 2) |
||
1099 | { |
||
1100 | Data = Data & 0xFF00FF; |
||
1101 | Data = Data | (code * 0x0100); |
||
1102 | if (invert == 1 && latch == 1) Data = Data | 0x1800; |
||
1103 | if (invert == 1 && latch == 0) Data = Data | 0x0800; |
||
1104 | if (invert == 0 && latch == 1) Data = Data | 0x1000; |
||
1105 | } |
||
1106 | ret = VME_register_write(hdev, 0x10, Data); |
||
1107 | return ret; |
||
1108 | } |
||
1109 | |||
1110 | |||
1111 | //******************************************************// |
||
1112 | //****************** CC_USB Registers ******************// |
||
1113 | //******************************************************// |
||
1114 | // The following are functions used to set the registers |
||
1115 | // in the CAMAC_USB |
||
1116 | |||
1117 | /* |
||
1118 | ******** CAMAC_register_write ***************** |
||
1119 | |||
1120 | Performs a CAMAC write to CC_USB register |
||
1121 | |||
1122 | Parameters: |
||
1123 | hdev: USB device handle returned from an open function |
||
1124 | A: CAMAC Subaddress |
||
1125 | F: CAMAC Function |
||
1126 | Data: data to be written |
||
1127 | |||
1128 | Returns: |
||
1129 | Number of bytes written to xxusb when successful |
||
1130 | Upon failure, a negative number |
||
1131 | */ |
||
1132 | short CAMAC_register_write(usb_dev_handle *hdev, int A, Uint32_t Data) |
||
1133 | { |
||
1134 | int F = 16; |
||
1135 | int N = 25; |
||
1136 | Uint32_t intbuf[4]; |
||
1137 | int ret; |
||
1138 | |||
1139 | intbuf[0]=1; |
||
1140 | intbuf[1]=(Uint32_t)(F+A*32+N*512 + 0x4000); |
||
1141 | intbuf[0]=3; |
||
1142 | intbuf[2]=(Data & 0xffff); |
||
1143 | intbuf[3]=((Data >>16) & 0xffff); |
||
1144 | ret = xxusb_stack_execute(hdev, intbuf); |
||
1145 | |||
1146 | return ret; |
||
1147 | } |
||
1148 | |||
1149 | /* |
||
1150 | ******** CAMAC_register_read ************************ |
||
1151 | |||
1152 | Performs a CAMAC read from CC_USB register |
||
1153 | |||
1154 | Parameters: |
||
1155 | hdev: USB device handle returned from an open function |
||
1156 | N: CAMAC Station Number |
||
1157 | A: CAMAC Subaddress |
||
1158 | F: CAMAC Function |
||
1159 | Q: The Q response from the CAMAC dataway |
||
1160 | X: The comment accepted response from CAMAC dataway |
||
1161 | |||
1162 | Returns: |
||
1163 | Number of bytes read from xxusb when successful |
||
1164 | Upon failure, a negative number |
||
1165 | */ |
||
1166 | short CAMAC_register_read(usb_dev_handle *hdev, int A, Uint32_t *Data) |
||
1167 | { |
||
1168 | int F = 0; |
||
1169 | int N = 25; |
||
1170 | Uint32_t intbuf[4]; |
||
1171 | int ret; |
||
1172 | |||
1173 | intbuf[0]=1; |
||
1174 | intbuf[1]=(Uint32_t)(F+A*32+N*512 + 0x4000); |
||
1175 | ret = xxusb_stack_execute(hdev, intbuf); |
||
1176 | *Data=intbuf[0] + (intbuf[1] * 0x10000); |
||
1177 | |||
1178 | return ret; |
||
1179 | } |
||
1180 | |||
1181 | /* |
||
1182 | ******** CAMAC_DGG ************************ |
||
1183 | |||
1184 | Sets the parameters for Gate & Delay channel A of CC_USB |
||
1185 | |||
1186 | Parameters: |
||
1187 | hdev: USB devcie handle returned from an open function |
||
1188 | channel: Which DGG channel to use Valid Values are: |
||
1189 | |||
1190 | 1 - For DGG B |
||
1191 | trigger: Determines what triggers the start of the DGG Valid values are: |
||
1192 | |||
1193 | 1 - NIM input 1 |
||
1194 | 2 - NIM input 2 |
||
1195 | 3 - NIM input 2 |
||
1196 | 4 - Event Trigger |
||
1197 | 5 - End of Event |
||
1198 | 6 - USB Trigger |
||
1199 | 7 - Pulser |
||
1200 | output: Determines which NIM output to use for the channel, Vaild values are: |
||
1201 | 1 - for NIM O1 |
||
1202 | 2 - for NIM O2 |
||
1203 | 3 - for NIM O3 |
||
1204 | delay: Delay in steps of 12.5ns between trigger and start of gate |
||
1205 | gate: the time the gate should stay open in steps of 12.5ns |
||
1206 | invert: is 1 if you wish to invert the DGG channel output |
||
1207 | latch: is 1 if you wish to run the DGG channel latched |
||
1208 | |||
1209 | Returns: |
||
1210 | Returns 1 when successful |
||
1211 | Upon failure, a negative number |
||
1212 | */ |
||
1213 | short CAMAC_DGG(usb_dev_handle *hdev, short channel, short trigger, short output, |
||
1214 | int delay, int gate, short invert, short latch) |
||
1215 | |||
1216 | |||
1217 | |||
1218 | { |
||
1219 | // short channel_ID; |
||
1220 | Uint32_t Data; |
||
1221 | Uint32_t internal; |
||
1222 | short ret; |
||
1223 | Uint32_t Delay_ext; |
||
1224 | |||
1225 | ret = CAMAC_register_read(hdev,5,&Data); |
||
1226 | //Set trigger |
||
1227 | if((output < 1 ) || (output >3) || (channel < 0 ) || (channel > 1)) |
||
1228 | return -1; |
||
1229 | if(output ==1) |
||
1230 | { |
||
1231 | if(channel ==0) |
||
1232 | { |
||
1233 | internal = 0x03; |
||
1234 | } else { |
||
1235 | internal = 0x04; |
||
1236 | } |
||
1237 | } |
||
1238 | if(output ==2) |
||
1239 | { |
||
1240 | if(channel ==0) |
||
1241 | { |
||
1242 | internal = 0x04; |
||
1243 | } else { |
||
1244 | internal = 0x05; |
||
1245 | } |
||
1246 | } |
||
1247 | if(output ==3) |
||
1248 | { |
||
1249 | if(channel ==0) |
||
1250 | { |
||
1251 | internal = 0x05; |
||
1252 | } else { |
||
1253 | internal = 0x06; |
||
1254 | } |
||
1255 | } |
||
1256 | |||
1257 | |||
1258 | // Set invert bit |
||
1259 | if(invert ==1) |
||
1260 | internal = internal | 0x10; |
||
1261 | else |
||
1262 | internal = internal & 0x0F; |
||
1263 | // Set Latch Bit |
||
1264 | if(latch==1) |
||
1265 | internal = internal | 0x20; |
||
1266 | else |
||
1267 | internal = internal & 0x1F; |
||
1268 | // Add new data to old |
||
1269 | if(output == 1) |
||
1270 | { |
||
1271 | Data = Data & 0xFFFF00; |
||
1272 | Data = Data | internal; |
||
1273 | } |
||
1274 | if(output == 2) |
||
1275 | { |
||
1276 | Data = Data & 0xFF00FF; |
||
1277 | Data = Data |(internal * 0x100); |
||
1278 | } |
||
1279 | if(output == 3) |
||
1280 | { |
||
1281 | Data = Data & 0x00FFFF; |
||
1282 | Data = Data | (internal * 0x10000) ; |
||
1283 | } |
||
1284 | CAMAC_register_write(hdev, 5, Data); |
||
1285 | ret = CAMAC_register_read(hdev,6,&Data); |
||
1286 | //Set Trigger |
||
1287 | if(trigger <0 || trigger > 7) |
||
1288 | return -1; |
||
1289 | if(channel ==0) |
||
1290 | { |
||
1291 | Data = Data & 0xFF00FFFF; |
||
1292 | internal = trigger * 0x10000; |
||
1293 | Data = Data | internal; |
||
1294 | } else { |
||
1295 | Data = Data & 0x00FFFFFF; |
||
1296 | internal = trigger * 0x1000000; |
||
1297 | Data = Data | internal; |
||
1298 | } |
||
1299 | ret = CAMAC_register_write(hdev, 6, Data); |
||
1300 | if(channel == 0) |
||
1301 | { |
||
1302 | // Write Delay and Gate info |
||
1303 | ret = CAMAC_register_read(hdev,13,&Data); |
||
1304 | Delay_ext= (Data & 0xffff0000); |
||
1305 | Delay_ext+= ((delay/0x10000) & 0xffff); |
||
1306 | internal = gate * 0x10000; |
||
1307 | Data = internal + (delay & 0xffff); |
||
1308 | ret=CAMAC_register_write(hdev,7,Data); |
||
1309 | // Set coarse delay in DGG_Extended register |
||
1310 | ret=CAMAC_register_write(hdev,13,Delay_ext); |
||
1311 | } |
||
1312 | else |
||
1313 | { |
||
1314 | ret=CAMAC_register_write(hdev,8,Data); |
||
1315 | ret = CAMAC_register_read(hdev,13,&Data); |
||
1316 | Delay_ext= (Data & 0x0000ffff); |
||
1317 | Delay_ext+= (delay & 0xffff0000); |
||
1318 | internal = gate * 0x10000; |
||
1319 | Data = internal + (delay & 0xffff); |
||
1320 | // Set coarse delay in DGG_Extended register |
||
1321 | ret=CAMAC_register_write(hdev,13,Delay_ext); |
||
1322 | } |
||
1323 | return 1; |
||
1324 | } |
||
1325 | |||
1326 | /* |
||
1327 | ******** CAMAC_LED_settings ************************ |
||
1328 | |||
1329 | Writes a data word to the vmusb LED register |
||
1330 | |||
1331 | Parameters: |
||
1332 | hdev: USB devcie handle returned from an open function |
||
1333 | LED: The number which corresponds to an LED values are: |
||
1334 | 1 - for RED LED |
||
1335 | 2 - for GREEN LED |
||
1336 | 3 - for Yellow LED |
||
1337 | code: The LED aource selector code, valid values for each LED |
||
1338 | are listed in the manual |
||
1339 | invert: to invert the LED lighting |
||
1340 | latch: sets LED latch bit |
||
1341 | |||
1342 | Returns: |
||
1343 | Number of bytes read from xxusb when successful |
||
1344 | Upon failure, a negative number |
||
1345 | */ |
||
1346 | short CAMAC_LED_settings(usb_dev_handle *hdev, int LED, int code, int invert, int latch) |
||
1347 | { |
||
1348 | |||
1349 | short ret; |
||
1350 | // Uint32_t internal; |
||
1351 | Uint32_t Data; |
||
1352 | |||
1353 | if( (LED <1) ||(LED > 3) || (code < 0) || (code > 7)) |
||
1354 | return -1; |
||
1355 | |||
1356 | CAMAC_register_read(hdev,4,&Data); |
||
1357 | |||
1358 | if(LED == 1) |
||
1359 | { |
||
1360 | Data = Data & 0xFFFF00; |
||
1361 | Data = Data | code; |
||
1362 | if (invert == 1 && latch == 1) |
||
1363 | Data = Data | 0x30; |
||
1364 | if (invert == 1 && latch == 0) |
||
1365 | Data = Data | 0x10; |
||
1366 | if (invert == 0 && latch == 1) |
||
1367 | Data = Data | 0x20; |
||
1368 | } |
||
1369 | if(LED == 2) |
||
1370 | { |
||
1371 | Data = Data & 0xFF00FF; |
||
1372 | Data = Data | (code * 0x0100); |
||
1373 | if (invert == 1 && latch == 1) |
||
1374 | Data = Data | 0x3000; |
||
1375 | if (invert == 1 && latch == 0) |
||
1376 | Data = Data | 0x1000; |
||
1377 | if (invert == 0 && latch == 1) |
||
1378 | Data = Data | 0x2000; |
||
1379 | } |
||
1380 | if(LED == 3) |
||
1381 | { |
||
1382 | Data = Data & 0x00FFFF; |
||
1383 | Data = Data | (code * 0x10000); |
||
1384 | if (invert == 1 && latch == 1) |
||
1385 | Data = Data | 0x300000; |
||
1386 | if (invert == 1 && latch == 0) |
||
1387 | Data = Data | 0x100000; |
||
1388 | if (invert == 0 && latch == 1) |
||
1389 | Data = Data | 0x200000; |
||
1390 | } |
||
1391 | ret = CAMAC_register_write(hdev, 4, Data); |
||
1392 | return ret; |
||
1393 | } |
||
1394 | |||
1395 | /* |
||
1396 | ******** CAMAC_Output_settings ************************ |
||
1397 | |||
1398 | Writes a data word to the vmusb LED register |
||
1399 | |||
1400 | Parameters: |
||
1401 | hdev: USB devcie handle returned from an open function |
||
1402 | Channel: The number which corresponds to an output: |
||
1403 | 1 - for Output 1 |
||
1404 | 2 - for Output 2 |
||
1405 | 3 - for Output 3 |
||
1406 | code: The Output selector code, valid values |
||
1407 | are listed in the manual |
||
1408 | invert: to invert the output |
||
1409 | latch: sets latch bit |
||
1410 | |||
1411 | Returns: |
||
1412 | Number of bytes read from xxusb when successful |
||
1413 | Upon failure, a negative number |
||
1414 | */ |
||
1415 | short CAMAC_Output_settings(usb_dev_handle *hdev, int Channel, int code, int invert, int latch) |
||
1416 | { |
||
1417 | short ret; |
||
1418 | // Uint32_t internal; |
||
1419 | Uint32_t Data; |
||
1420 | |||
1421 | if( (Channel <1) ||(Channel > 3) || (code < 0) || (code > 7)) |
||
1422 | return -1; |
||
1423 | |||
1424 | CAMAC_register_read(hdev,5,&Data); |
||
1425 | |||
1426 | if(Channel == 1) |
||
1427 | { |
||
1428 | Data = Data & 0xFFFF00; |
||
1429 | Data = Data | code; |
||
1430 | if (invert == 1 && latch == 1) |
||
1431 | Data = Data | 0x30; |
||
1432 | if (invert == 1 && latch == 0) |
||
1433 | Data = Data | 0x10; |
||
1434 | if (invert == 0 && latch == 1) |
||
1435 | Data = Data | 0x20; |
||
1436 | } |
||
1437 | if(Channel == 2) |
||
1438 | { |
||
1439 | Data = Data & 0xFF00FF; |
||
1440 | Data = Data | (code * 0x0100); |
||
1441 | if (invert == 1 && latch == 1) |
||
1442 | Data = Data | 0x3000; |
||
1443 | if (invert == 1 && latch == 0) |
||
1444 | Data = Data | 0x1000; |
||
1445 | if (invert == 0 && latch == 1) |
||
1446 | Data = Data | 0x2000; |
||
1447 | } |
||
1448 | if(Channel == 3) |
||
1449 | { |
||
1450 | Data = Data & 0x00FFFF; |
||
1451 | Data = Data | (code * 0x10000); |
||
1452 | if (invert == 1 && latch == 1) |
||
1453 | Data = Data | 0x300000; |
||
1454 | if (invert == 1 && latch == 0) |
||
1455 | Data = Data | 0x100000; |
||
1456 | if (invert == 0 && latch == 1) |
||
1457 | Data = Data | 0x200000; |
||
1458 | } |
||
1459 | ret = CAMAC_register_write(hdev, 5, Data); |
||
1460 | return ret; |
||
1461 | } |
||
1462 | |||
1463 | /* |
||
1464 | ******** CAMAC_write_LAM_mask ************************ |
||
1465 | |||
1466 | Writes the data word to the LAM mask register |
||
1467 | |||
1468 | Parameters: |
||
1469 | hdev: USB devcie handle returned from an open function |
||
1470 | Data: LAM mask to write |
||
1471 | |||
1472 | Returns: |
||
1473 | Number of bytes read from xxusb when successful |
||
1474 | Upon failure, a negative number |
||
1475 | */ |
||
1476 | short CAMAC_write_LAM_mask(usb_dev_handle *hdev, Uint32_t Data) |
||
1477 | { |
||
1478 | short ret; |
||
1479 | ret = CAMAC_register_write(hdev, 9, Data); |
||
1480 | |||
1481 | return ret; |
||
1482 | } |
||
1483 | |||
1484 | /* |
||
1485 | ******** CAMAC_read_LAM_mask ************************ |
||
1486 | |||
1487 | Writes the data word to the LAM mask register |
||
1488 | |||
1489 | Parameters: |
||
1490 | hdev: USB devcie handle returned from an open function |
||
1491 | Data: LAM mask to write |
||
1492 | |||
1493 | Returns: |
||
1494 | Number of bytes read from xxusb when successful |
||
1495 | Upon failure, a negative number |
||
1496 | */ |
||
1497 | short CAMAC_read_LAM_mask(usb_dev_handle *hdev, Uint32_t *Data) |
||
1498 | { |
||
1499 | Uint32_t intbuf[4]; |
||
1500 | int ret; |
||
1501 | int N = 25; |
||
1502 | int F = 0; |
||
1503 | int A = 9; |
||
1504 | |||
1505 | // CAMAC direct read function |
||
1506 | intbuf[0]=1; |
||
1507 | intbuf[1]=(Uint32_t)(F+A*32+N*512 + 0x4000); |
||
1508 | ret = xxusb_stack_execute(hdev, intbuf); |
||
1509 | *Data=intbuf[0] + (intbuf[1] & 255) * 0x10000; |
||
1510 | return ret; |
||
1511 | } |
||
1512 | |||
1513 | |||
1514 | //******************************************************// |
||
1515 | //**************** EZ_CAMAC Functions ******************// |
||
1516 | //******************************************************// |
||
1517 | // The following are functions used to perform simple |
||
1518 | // CAMAC Functions with the CC_USB |
||
1519 | |||
1520 | |||
1521 | /* |
||
1522 | ******** CAMAC_write ************************ |
||
1523 | |||
1524 | Performs a CAMAC write using NAF comments |
||
1525 | |||
1526 | Parameters: |
||
1527 | hdev: USB device handle returned from an open function |
||
1528 | N: CAMAC Station Number |
||
1529 | A: CAMAC Subaddress |
||
1530 | F: CAMAC Function (16...23) |
||
1531 | Q: The Q response from the CAMAC dataway |
||
1532 | X: The comment accepted response from CAMAC dataway |
||
1533 | |||
1534 | Returns: |
||
1535 | Number of bytes written to xxusb when successful |
||
1536 | Upon failure, a negative number |
||
1537 | */ |
||
1538 | short CAMAC_write(usb_dev_handle *hdev, int N, int A, int F, Uint32_t Data, int *Q, int *X) |
||
1539 | { |
||
1540 | Uint32_t intbuf[4]; |
||
1541 | int ret; |
||
1542 | // CAMAC direct write function |
||
1543 | intbuf[0]=1; |
||
1544 | intbuf[1]=(Uint32_t)(F+A*32+N*512 + 0x4000); |
||
1545 | if ((F > 15) && (F < 24)) |
||
1546 | { |
||
1547 | intbuf[0]=3; |
||
1548 | intbuf[2]=(Data & 0xffff); |
||
1549 | intbuf[3]=((Data >>16) & 255); |
||
1550 | ret = xxusb_stack_execute(hdev, intbuf); |
||
1551 | *Q = (intbuf[0] & 1); |
||
1552 | *X = ((intbuf[0] >> 1) & 1); |
||
1553 | } |
||
1554 | return ret; |
||
1555 | } |
||
1556 | |||
1557 | /* |
||
1558 | ******** CAMAC_read ************************ |
||
1559 | |||
1560 | Performs a CAMAC read using NAF comments |
||
1561 | |||
1562 | Parameters: |
||
1563 | hdev: USB device handle returned from an open function |
||
1564 | N: CAMAC Station Number |
||
1565 | A: CAMAC Subaddress |
||
1566 | F: CAMAC Function (F<16 or F>23) |
||
1567 | Q: The Q response from the CAMAC dataway |
||
1568 | X: The comment accepted response from CAMAC dataway |
||
1569 | |||
1570 | Returns: |
||
1571 | Number of bytes read from xxusb when successful |
||
1572 | Upon failure, a negative number |
||
1573 | */ |
||
1574 | short CAMAC_read(usb_dev_handle *hdev, int N, int A, int F, Uint32_t *Data, int *Q, int *X) |
||
1575 | { |
||
1576 | Uint32_t intbuf[4]; |
||
1577 | int ret; |
||
1578 | // CAMAC direct read function |
||
1579 | intbuf[0]=1; |
||
1580 | intbuf[1]=(Uint32_t)(F+A*32+N*512 + 0x4000); |
||
1581 | ret = xxusb_stack_execute(hdev, intbuf); |
||
1582 | if ((F < 16) || (F >23)) |
||
1583 | { |
||
1584 | *Data=intbuf[0] + (intbuf[1] & 255) * 0x10000; //24-bit word |
||
1585 | *Q = ((intbuf[1] >> 8) & 1); |
||
1586 | *X = ((intbuf[1] >> 9) & 1); |
||
1587 | } |
||
1588 | return ret; |
||
1589 | } |
||
1590 | |||
1591 | /* |
||
1592 | ******** CAMAC_Z ************************ |
||
1593 | |||
1594 | Performs a CAMAC init |
||
1595 | |||
1596 | Parameters: |
||
1597 | hdev: USB device handle returned from an open function |
||
1598 | |||
1599 | Returns: |
||
1600 | Number of bytes written to xxusb when successful |
||
1601 | Upon failure, a negative number |
||
1602 | */ |
||
1603 | short CAMAC_Z(usb_dev_handle *hdev) |
||
1604 | { |
||
1605 | Uint32_t intbuf[4]; |
||
1606 | int ret; |
||
1607 | // CAMAC Z = N(28) A(8) F(29) |
||
1608 | intbuf[0]=1; |
||
1609 | intbuf[1]=(Uint32_t)(29+8*32+28*512 + 0x4000); |
||
1610 | ret = xxusb_stack_execute(hdev, intbuf); |
||
1611 | return ret; |
||
1612 | } |
||
1613 | |||
1614 | /* |
||
1615 | ******** CAMAC_C ************************ |
||
1616 | |||
1617 | Performs a CAMAC clear |
||
1618 | |||
1619 | Parameters: |
||
1620 | hdev: USB device handle returned from an open function |
||
1621 | |||
1622 | Returns: |
||
1623 | Number of bytes written to xxusb when successful |
||
1624 | Upon failure, a negative number |
||
1625 | */ |
||
1626 | short CAMAC_C(usb_dev_handle *hdev) |
||
1627 | { |
||
1628 | Uint32_t intbuf[4]; |
||
1629 | int ret; |
||
1630 | intbuf[0]=1; |
||
1631 | intbuf[1]=(Uint32_t)(29+9*32+28*512 + 0x4000); |
||
1632 | ret = xxusb_stack_execute(hdev, intbuf); |
||
1633 | return ret; |
||
1634 | } |
||
1635 | |||
1636 | /* |
||
1637 | ******** CAMAC_I ************************ |
||
1638 | |||
1639 | Set CAMAC inhibit |
||
1640 | |||
1641 | Parameters: |
||
1642 | hdev: USB device handle returned from an open function |
||
1643 | |||
1644 | Returns: |
||
1645 | Number of bytes written to xxusb when successful |
||
1646 | Upon failure, a negative number |
||
1647 | */ |
||
1648 | short CAMAC_I(usb_dev_handle *hdev, int inhibit) |
||
1649 | { |
||
1650 | Uint32_t intbuf[4]; |
||
1651 | int ret; |
||
1652 | intbuf[0]=1; |
||
1653 | if (inhibit) intbuf[1]=(Uint32_t)(24+9*32+29*512 + 0x4000); |
||
1654 | else intbuf[1]=(Uint32_t)(26+9*32+29*512 + 0x4000); |
||
1655 | ret = xxusb_stack_execute(hdev, intbuf); |
||
1656 | return ret; |
||
1657 | } |
||
1658 | |||
1659 |