[go: nahoru, domu]
1/* Industrialio buffer test code.
2 *
3 * Copyright (c) 2008 Jonathan Cameron
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
8 *
9 * This program is primarily intended as an example application.
10 * Reads the current buffer setup from sysfs and starts a short capture
11 * from the specified device, pretty printing the result after appropriate
12 * conversion.
13 *
14 * Command line parameters
15 * generic_buffer -n <device_name> -t <trigger_name>
16 * If trigger name is not specified the program assumes you want a dataready
17 * trigger associated with the device and goes looking for it.
18 *
19 */
20
21#define _GNU_SOURCE
22
23#include <unistd.h>
24#include <dirent.h>
25#include <fcntl.h>
26#include <stdio.h>
27#include <errno.h>
28#include <sys/stat.h>
29#include <sys/dir.h>
30#include <linux/types.h>
31#include <string.h>
32#include <poll.h>
33#include <endian.h>
34#include <getopt.h>
35#include <inttypes.h>
36#include "iio_utils.h"
37
38/**
39 * size_from_channelarray() - calculate the storage size of a scan
40 * @channels:		the channel info array
41 * @num_channels:	number of channels
42 *
43 * Has the side effect of filling the channels[i].location values used
44 * in processing the buffer output.
45 **/
46int size_from_channelarray(struct iio_channel_info *channels, int num_channels)
47{
48	int bytes = 0;
49	int i = 0;
50	while (i < num_channels) {
51		if (bytes % channels[i].bytes == 0)
52			channels[i].location = bytes;
53		else
54			channels[i].location = bytes - bytes%channels[i].bytes
55				+ channels[i].bytes;
56		bytes = channels[i].location + channels[i].bytes;
57		i++;
58	}
59	return bytes;
60}
61
62void print2byte(int input, struct iio_channel_info *info)
63{
64	/* First swap if incorrect endian */
65	if (info->be)
66		input = be16toh((uint16_t)input);
67	else
68		input = le16toh((uint16_t)input);
69
70	/*
71	 * Shift before conversion to avoid sign extension
72	 * of left aligned data
73	 */
74	input = input >> info->shift;
75	if (info->is_signed) {
76		int16_t val = input;
77		val &= (1 << info->bits_used) - 1;
78		val = (int16_t)(val << (16 - info->bits_used)) >>
79			(16 - info->bits_used);
80		printf("%05f ", ((float)val + info->offset)*info->scale);
81	} else {
82		uint16_t val = input;
83		val &= (1 << info->bits_used) - 1;
84		printf("%05f ", ((float)val + info->offset)*info->scale);
85	}
86}
87/**
88 * process_scan() - print out the values in SI units
89 * @data:		pointer to the start of the scan
90 * @channels:		information about the channels. Note
91 *  size_from_channelarray must have been called first to fill the
92 *  location offsets.
93 * @num_channels:	number of channels
94 **/
95void process_scan(char *data,
96		  struct iio_channel_info *channels,
97		  int num_channels)
98{
99	int k;
100	for (k = 0; k < num_channels; k++)
101		switch (channels[k].bytes) {
102			/* only a few cases implemented so far */
103		case 2:
104			print2byte(*(uint16_t *)(data + channels[k].location),
105				   &channels[k]);
106			break;
107		case 4:
108			if (!channels[k].is_signed) {
109				uint32_t val = *(uint32_t *)
110					(data + channels[k].location);
111				printf("%05f ", ((float)val +
112						 channels[k].offset)*
113				       channels[k].scale);
114
115			}
116			break;
117		case 8:
118			if (channels[k].is_signed) {
119				int64_t val = *(int64_t *)
120					(data +
121					 channels[k].location);
122				if ((val >> channels[k].bits_used) & 1)
123					val = (val & channels[k].mask) |
124						~channels[k].mask;
125				/* special case for timestamp */
126				if (channels[k].scale == 1.0f &&
127				    channels[k].offset == 0.0f)
128					printf("%" PRId64 " ", val);
129				else
130					printf("%05f ", ((float)val +
131							 channels[k].offset)*
132					       channels[k].scale);
133			}
134			break;
135		default:
136			break;
137		}
138	printf("\n");
139}
140
141int main(int argc, char **argv)
142{
143	unsigned long num_loops = 2;
144	unsigned long timedelay = 1000000;
145	unsigned long buf_len = 128;
146
147	int ret, c, i, j, toread;
148	int fp;
149
150	int num_channels;
151	char *trigger_name = NULL, *device_name = NULL;
152	char *dev_dir_name, *buf_dir_name;
153
154	int datardytrigger = 1;
155	char *data;
156	ssize_t read_size;
157	int dev_num, trig_num;
158	char *buffer_access;
159	int scan_size;
160	int noevents = 0;
161	char *dummy;
162
163	struct iio_channel_info *channels;
164
165	while ((c = getopt(argc, argv, "l:w:c:et:n:")) != -1) {
166		switch (c) {
167		case 'n':
168			device_name = optarg;
169			break;
170		case 't':
171			trigger_name = optarg;
172			datardytrigger = 0;
173			break;
174		case 'e':
175			noevents = 1;
176			break;
177		case 'c':
178			num_loops = strtoul(optarg, &dummy, 10);
179			break;
180		case 'w':
181			timedelay = strtoul(optarg, &dummy, 10);
182			break;
183		case 'l':
184			buf_len = strtoul(optarg, &dummy, 10);
185			break;
186		case '?':
187			return -1;
188		}
189	}
190
191	if (device_name == NULL)
192		return -1;
193
194	/* Find the device requested */
195	dev_num = find_type_by_name(device_name, "iio:device");
196	if (dev_num < 0) {
197		printf("Failed to find the %s\n", device_name);
198		ret = -ENODEV;
199		goto error_ret;
200	}
201	printf("iio device number being used is %d\n", dev_num);
202
203	asprintf(&dev_dir_name, "%siio:device%d", iio_dir, dev_num);
204	if (trigger_name == NULL) {
205		/*
206		 * Build the trigger name. If it is device associated its
207		 * name is <device_name>_dev[n] where n matches the device
208		 * number found above
209		 */
210		ret = asprintf(&trigger_name,
211			       "%s-dev%d", device_name, dev_num);
212		if (ret < 0) {
213			ret = -ENOMEM;
214			goto error_ret;
215		}
216	}
217
218	/* Verify the trigger exists */
219	trig_num = find_type_by_name(trigger_name, "trigger");
220	if (trig_num < 0) {
221		printf("Failed to find the trigger %s\n", trigger_name);
222		ret = -ENODEV;
223		goto error_free_triggername;
224	}
225	printf("iio trigger number being used is %d\n", trig_num);
226
227	/*
228	 * Parse the files in scan_elements to identify what channels are
229	 * present
230	 */
231	ret = build_channel_array(dev_dir_name, &channels, &num_channels);
232	if (ret) {
233		printf("Problem reading scan element information\n");
234		printf("diag %s\n", dev_dir_name);
235		goto error_free_triggername;
236	}
237
238	/*
239	 * Construct the directory name for the associated buffer.
240	 * As we know that the lis3l02dq has only one buffer this may
241	 * be built rather than found.
242	 */
243	ret = asprintf(&buf_dir_name,
244		       "%siio:device%d/buffer", iio_dir, dev_num);
245	if (ret < 0) {
246		ret = -ENOMEM;
247		goto error_free_triggername;
248	}
249	printf("%s %s\n", dev_dir_name, trigger_name);
250	/* Set the device trigger to be the data ready trigger found above */
251	ret = write_sysfs_string_and_verify("trigger/current_trigger",
252					dev_dir_name,
253					trigger_name);
254	if (ret < 0) {
255		printf("Failed to write current_trigger file\n");
256		goto error_free_buf_dir_name;
257	}
258
259	/* Setup ring buffer parameters */
260	ret = write_sysfs_int("length", buf_dir_name, buf_len);
261	if (ret < 0)
262		goto error_free_buf_dir_name;
263
264	/* Enable the buffer */
265	ret = write_sysfs_int("enable", buf_dir_name, 1);
266	if (ret < 0)
267		goto error_free_buf_dir_name;
268	scan_size = size_from_channelarray(channels, num_channels);
269	data = malloc(scan_size*buf_len);
270	if (!data) {
271		ret = -ENOMEM;
272		goto error_free_buf_dir_name;
273	}
274
275	ret = asprintf(&buffer_access, "/dev/iio:device%d", dev_num);
276	if (ret < 0) {
277		ret = -ENOMEM;
278		goto error_free_data;
279	}
280
281	/* Attempt to open non blocking the access dev */
282	fp = open(buffer_access, O_RDONLY | O_NONBLOCK);
283	if (fp == -1) { /* If it isn't there make the node */
284		printf("Failed to open %s\n", buffer_access);
285		ret = -errno;
286		goto error_free_buffer_access;
287	}
288
289	/* Wait for events 10 times */
290	for (j = 0; j < num_loops; j++) {
291		if (!noevents) {
292			struct pollfd pfd = {
293				.fd = fp,
294				.events = POLLIN,
295			};
296
297			poll(&pfd, 1, -1);
298			toread = buf_len;
299
300		} else {
301			usleep(timedelay);
302			toread = 64;
303		}
304
305		read_size = read(fp,
306				 data,
307				 toread*scan_size);
308		if (read_size < 0) {
309			if (errno == -EAGAIN) {
310				printf("nothing available\n");
311				continue;
312			} else
313				break;
314		}
315		for (i = 0; i < read_size/scan_size; i++)
316			process_scan(data + scan_size*i,
317				     channels,
318				     num_channels);
319	}
320
321	/* Stop the buffer */
322	ret = write_sysfs_int("enable", buf_dir_name, 0);
323	if (ret < 0)
324		goto error_close_buffer_access;
325
326	/* Disconnect the trigger - just write a dummy name. */
327	write_sysfs_string("trigger/current_trigger",
328			dev_dir_name, "NULL");
329
330error_close_buffer_access:
331	close(fp);
332error_free_data:
333	free(data);
334error_free_buffer_access:
335	free(buffer_access);
336error_free_buf_dir_name:
337	free(buf_dir_name);
338error_free_triggername:
339	if (datardytrigger)
340		free(trigger_name);
341error_ret:
342	return ret;
343}
344