d87d9ac7955c643ba261b6d6c5d51190daf50b60
[rigol] / usbtmc.c
1 #include <string.h>
2 #include <stdio.h>
3 #include <stdint.h>
4 #include <usb.h>
5 #include <arpa/inet.h>
6
7 #include "scope.h"
8 #include "usbtmc.h"
9
10 #define USB_TIMEOUT 10000
11 #define USBTMC_IN_TRANSFERSIZE 0x800
12
13 #if BYTE_ORDER == LITTLE_ENDIAN
14 #define LE32(x) x
15 #elif BYTE_ORDER == BIG_ENDIAN
16 #define LE32(x) ((uint32_t)((((uint32_t)x)>>24) | ((((uint32_t)x)>>8) & 0xff00) | ((((uint32_t)x)<<8) & 0xff0000) | (((uint32_t)x)<<24)))
17 #else
18 #error BYTE_ORDER not defined/known!
19 #endif
20
21 /* TODO: fix memory leak here: */
22 #define USB_ERROR(s, x) do { if (x < 0) { fprintf(stderr, "usb %s: %s\n", s, usb_strerror()); usbtmc_clear(sc); return 0; } } while(0)
23
24 /* This routine locates a scope by VID/PID and returns a struct scope* for it */
25 static struct scope* usbtmc_find_scope() {
26 struct usb_bus *bus;
27 struct usb_device *dev=NULL;
28 struct usb_dev_handle *devh;
29
30 struct scope *sc;
31
32 usb_find_busses();
33 usb_find_devices();
34
35 for (bus=usb_busses; bus; bus=bus->next) {
36 for (dev=bus->devices; dev; dev=dev->next) {
37 if (dev->descriptor.idVendor == 0x400 && dev->descriptor.idProduct == 0x5dc) {
38 devh = usb_open(dev);
39 if (devh == NULL)
40 return NULL;
41
42 sc = calloc(1, sizeof(struct scope));
43 if (sc == NULL) {
44 perror("calloc");
45 exit(EXIT_FAILURE);
46 }
47
48 sc->usb.dev = devh;
49
50 /* TODO: FIXME */
51 sc->usb.brokenRigol = 1;
52 sc->usb.ep_bulk_out = 0x01;
53 sc->usb.ep_bulk_in = 0x82;
54 sc->usb.wMaxPacketSize_in = 0x40;
55
56 return sc;
57 }
58 }
59 }
60
61 return NULL;
62 }
63
64 static unsigned char usb488_status(struct scope *sc)
65 {
66 int r;
67 unsigned char status[3];
68
69 sc->usb.bTag++;
70
71 r = usb_control_msg(sc->usb.dev, 0xA1,
72 USB488_CTL_READ_STATUS_BYTE,
73 (sc->usb.bTag & 0x7f), 0, (char*)status, 3,
74 USB_TIMEOUT);
75
76 if ((r != 3) || (status[0] != USBTMC_STATUS_SUCCESS) || (status[1] != (sc->usb.bTag & 0x7f))) {
77 printf("READ_STATUS_BYTE failed: %d 0x%x 0x%x 0x%x\n", r, status[0], status[1], status[2]);
78 return 0xff;
79 }
80
81 return status[2];
82 }
83
84 static struct usbtmc_capabilities* usbtmc_get_capabilities(struct scope *sc)
85 {
86 int r;
87 static struct usbtmc_capabilities res;
88
89 r = usb_control_msg(sc->usb.dev, 0xA1,
90 USBTMC_CTL_GET_CAPABILITIES,
91 0, 0, (char*)&res, sizeof(struct usbtmc_capabilities),
92 USB_TIMEOUT);
93 if (r != sizeof(struct usbtmc_capabilities)) {
94 printf("GET_CAPABILITIES failed: %s\n", usb_strerror());
95 return NULL;
96 }
97
98 printf("USBTMC Version %02x.%02x Capabilities:\n", res.bcdUSBTMC[0], res.bcdUSBTMC[1]);
99 if (res.USBTMCIFcapabilities & USBTMC_CAP_IF_INDICATOR_PULSE)
100 printf("\tInterface supports indicator pulse\n");
101
102 if (res.USBTMCIFcapabilities & USBTMC_CAP_IF_TALKONLY)
103 printf("\tInterface is talk only\n");
104
105 if (res.USBTMCIFcapabilities & USBTMC_CAP_IF_LISTENONLY)
106 printf("\tInterface is listen only\n");
107
108 if (res.USBTMCDEVcapabilities & USBTMC_CAP_DEV_TERMCHAR_SUPP)
109 printf("\tDevice supports Termchar\n");
110
111 printf("USB488 Version %02x.%02x Capabilities:\n", res.bcdUSB488[0], res.bcdUSB488[1]);
112
113 if (res.USB488IFcapabilities & USB488_CAP_IF_4882)
114 printf("\tInterface is 488.2 compliant\n");
115
116 if (res.USB488IFcapabilities & USB488_CAP_IF_LOCKOUT)
117 printf("\tInterface supports local lockout\n");
118
119 if (res.USB488IFcapabilities & USB488_CAP_IF_TRIGGER)
120 printf("\tInterface supports TRIGGER\n");
121
122 if (res.USB488DEVcapabilities & USB488_CAP_DEV_SCPI)
123 printf("\tDevice is SCPI compliant\n");
124
125 if (res.USB488DEVcapabilities & USB488_CAP_DEV_SR1)
126 printf("\tDevice is SR1 capable\n");
127
128 if (res.USB488DEVcapabilities & USB488_CAP_DEV_RL1)
129 printf("\tDevice is RL1 capable\n");
130
131 if (res.USB488DEVcapabilities & USB488_CAP_DEV_DT1)
132 printf("\tDevice is DT1 capable\n");
133
134 return &res;
135 }
136
137 void usbtmc_reset(struct scope *sc)
138 {
139 usb_reset(sc->usb.dev);
140 usbtmc_claim(sc);
141 }
142
143 static void usbtmc_clear(struct scope *sc)
144 {
145 int r;
146 unsigned char status[2];
147
148 printf("Initiating clear...\n");
149 r = usb_control_msg(sc->usb.dev, 0xA1,
150 USBTMC_CTL_INITIATE_CLEAR,
151 0, 0, (char*)status, 1,
152 USB_TIMEOUT);
153
154 if ((r != 1) || status[0] != USBTMC_STATUS_SUCCESS) {
155 printf("INITIATE_CLEAR failed (0x%x): %s\n", status[0], usb_strerror());
156 usbtmc_reset(sc);
157 return;
158 }
159
160 while(1) {
161 usleep(100000);
162 printf("Waiting for clear to complete...\n");
163
164 r = usb_control_msg(sc->usb.dev, 0xA1,
165 USBTMC_CTL_CHECK_CLEAR_STAT,
166 0, 0, (char*)status, 2,
167 USB_TIMEOUT);
168
169 if (r != 2) {
170 printf("CHECK_CLEAR failed: %s\n", usb_strerror());
171 return;
172 }
173
174 if (USBTMC_STATUS_FAIL(status[0])) {
175 printf("CHECK_CLEAR failed: 0x%x\n", status[0]);
176 return;
177 }
178
179 if ((status[0] == USBTMC_STATUS_SUCCESS) && (status[1] == 0)) {
180 printf("Success!\n");
181 break;
182 }
183 }
184 }
185
186 /*
187 * Send a scpi-command to the scope. The response goes into the buffer
188 * called resp, with a size of resplen. If resp==NULL, no response
189 * is requested.
190 */
191 int usbtmc_sendscpi(struct scope *sc, char* cmd,
192 unsigned char *resp, int resplen) {
193 int len,r;
194 int cmdlen = strlen(cmd);
195 struct usbtmc_header *req;
196
197 sc->usb.bTag++;
198
199 len = sizeof(struct usbtmc_header) + cmdlen;
200 if (len%4)
201 len += 4 - (len%4);
202
203 req = calloc(1, len);
204 if (req == NULL) {
205 perror("calloc");
206 exit(EXIT_FAILURE);
207 }
208
209 req->MsgID = USBTMC_DEV_DEP_MSG_OUT;
210 req->bTag = sc->usb.bTag;
211 req->bTagInverse = ~sc->usb.bTag;
212 req->TransferSize = LE32(cmdlen);
213 req->bmTransferAttributes = USBTMC_TRANSFERATTRIB_EOM;
214 memcpy(req->msg, cmd, cmdlen);
215
216 if (sc->usb.brokenRigol) {
217 r=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out,
218 (char*)req, sizeof(struct usbtmc_header),
219 USB_TIMEOUT);
220 USB_ERROR("USBTMC_DEV_DEP_MSG_OUT1", r);
221
222 r=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out,
223 (char*)&(req->msg), len - sizeof(struct usbtmc_header),
224 USB_TIMEOUT);
225 USB_ERROR("USBTMC_DEV_DEP_MSG_OUT2", r);
226 } else {
227 r=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out,
228 (char*)req, len, USB_TIMEOUT);
229 USB_ERROR("USBTMC_DEV_DEP_MSG_OUT", r);
230 }
231
232 free(req);
233
234 if (resp != NULL && resplen != 0) {
235 unsigned char *buff = NULL;
236 unsigned char rxbuff[USBTMC_IN_TRANSFERSIZE];
237 struct usbtmc_header *res;
238 int bytes_read;
239 unsigned int read_size = USBTMC_IN_TRANSFERSIZE;
240 unsigned int headerlen;
241
242 req = calloc(1, sizeof(struct usbtmc_header));
243 if (req == NULL) {
244 perror("calloc");
245 exit(EXIT_FAILURE);
246 }
247
248 if (sc->usb.brokenRigol == 1) {
249 read_size = sc->usb.wMaxPacketSize_in;
250 }
251
252 bytes_read = 0;
253 do {
254 headerlen = 0;
255
256 if ((sc->usb.brokenRigol == 0) || (bytes_read == 0)) {
257 sc->usb.bTag++;
258
259 req->MsgID = USBTMC_REQUEST_DEV_DEP_MSG_IN;
260 req->bTag = sc->usb.bTag;
261 req->bTagInverse = ~sc->usb.bTag;
262 req->TransferSize = LE32(USBTMC_IN_TRANSFERSIZE);
263 req->bmTransferAttributes = 0;
264 req->TermChar = 0;
265
266 /* send read command */
267 r=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out,
268 (char*)req, sizeof(struct usbtmc_header), USB_TIMEOUT);
269 USB_ERROR("USBTMC_REQUEST_DEV_DEP_MSG_IN", r);
270
271 headerlen = sizeof(struct usbtmc_header);
272 }
273
274 r=usb_bulk_read(sc->usb.dev, sc->usb.ep_bulk_in,
275 (char*)rxbuff, read_size, USB_TIMEOUT);
276 USB_ERROR("USBTMC_DEV_DEP_MSG_IN", r);
277
278 if (r < headerlen) {
279 fprintf(stderr, "Short read!\n");
280 return 0;
281 }
282
283 if (headerlen > 0) {
284 res = (struct usbtmc_header*)rxbuff;
285
286 if ((res->bTag != sc->usb.bTag) ||
287 (res->bTagInverse != (unsigned char)(~sc->usb.bTag))) {
288 fprintf(stderr, "Wrong TAG received! We: 0x%02x, Scope: 0x%02x\n", sc->usb.bTag, res->bTag);
289 if (sc->usb.brokenRigol == 1) {
290 fprintf(stderr, "Tying to restart transfer...\n");
291 bytes_read = 0;
292 continue;
293 }
294 return 0;
295 }
296
297 if (buff == NULL) {
298 len = LE32(res->TransferSize);
299 buff=malloc(len);
300 if (buff == NULL) {
301 perror("malloc");
302 exit(EXIT_FAILURE);
303 }
304 }
305 }
306
307 if ((r - headerlen) > 0) {
308 memcpy(buff + bytes_read, rxbuff + headerlen, r - headerlen);
309 bytes_read += r - headerlen;
310 }
311
312 read_size = USBTMC_IN_TRANSFERSIZE;
313 } while(bytes_read < len);
314
315 free(req);
316
317 /* TODO: FIXME */
318 if (bytes_read > resplen) {
319 fprintf(stderr, "Response buffer to small: %d instead of %d bytes!\n",
320 resplen, bytes_read);
321 bytes_read = resplen;
322 }
323
324 memcpy(resp, buff, bytes_read);
325 free(buff);
326
327 return bytes_read;
328 }
329 return 0;
330 }
331
332 void usbtmc_claim(struct scope *sc)
333 {
334 usb_claim_interface(sc->usb.dev, 0);
335 }
336
337 void usbtmc_release(struct scope *sc)
338 {
339 usb_release_interface(sc->usb.dev, 0);
340 }
341
342 /* Initialize the scope. */
343 struct scope* usbtmc_initscope(void) {
344 int r;
345 uint32_t vidpid;
346 struct scope *sc;
347
348 /* Init libusb */
349 usb_init();
350 /* Locate and open the scope */
351 sc = usbtmc_find_scope();
352 if (!sc) {
353 return NULL;
354 }
355
356 usbtmc_claim(sc);
357 sc->usb.cap = usbtmc_get_capabilities(sc);
358 printf("Device status: 0x%x\n", usb488_status(sc));
359 /* The following code isn't really necessary, the program works
360 OK without it too. */
361 r=usb_control_msg(sc->usb.dev, 0xC8, 9, 0, 0, (char*)&vidpid, 4, USB_TIMEOUT);
362 usbtmc_release(sc);
363 if (r < 0) {
364 fprintf (stderr, "Error %d sending init message: %s\n",
365 r, strerror (-r));
366 fprintf (stderr, "Do you have permission on the USB device?\n");
367 exit (1);
368 }
369 if (LE32(vidpid)!=0x40005dc) {
370 fprintf(stderr,"Init: buff[%i]=%x\n",r,LE32(vidpid));
371 }
372 return sc;
373 }
374
375 void usbtmc_close(struct scope *sc)
376 {
377 /* Free up and exit */
378 usb_close(sc->usb.dev);
379 }
Impressum, Datenschutz