/*!*****************************************************************************
********************************************************************************
\note printDeviceInfo
\date Nov. 2009
\remarks
A function that provide more detailed information about all subdivices and
channels of a device
*******************************************************************************
Function Parameters: [in]=input,[out]=output
******************************************************************************/
void
printDeviceInfo(a4l_desc_t *dsc)
{
int i,j;
int rc;
a4l_sbinfo_t *info;
// print out information about this device
printf(" Board Name : %s\n",dsc->board_name);
printf(" #Subdevices : %d\n",dsc->nb_subd);
printf(" Input Subdevice Index : %d\n",dsc->idx_read_subd);
printf(" Output Subdevice Index : %d\n",dsc->idx_write_subd);
printf(" Data Buffer Size : %d\n",dsc->sbsize);
// get info about each of the subdevices
for (i=1; i<=dsc->nb_subd; ++i) {
rc = a4l_get_subdinfo(&desc,i-1,&info);
if (rc < 0) {
printf("ni_test: a4l_get_subdinfo (ID=%d on %s) failed (rc=%d)\n",i-1,DEVICE, rc);
return;
}
printf(" Subdevice ID = %d\n",i-1);
// what can this sub device do?
if ((info->flags&A4L_SUBD_TYPES) == A4L_SUBD_UNUSED) {
printf(" Subdevice is unused\n");
printf("\n");
continue;
}
if ((info->flags&A4L_SUBD_TYPES) == A4L_SUBD_AI)
printf(" Subdevice is analog input\n");
if ((info->flags&A4L_SUBD_TYPES) == A4L_SUBD_AO)
printf(" Subdevice is analog output\n");
if ((info->flags&A4L_SUBD_TYPES) == A4L_SUBD_DI)
printf(" Subdevice is digital input\n");
if ((info->flags&A4L_SUBD_TYPES) == A4L_SUBD_DO)
printf(" Subdevice is digital output\n");
if ((info->flags&A4L_SUBD_TYPES) == A4L_SUBD_DIO)
printf(" Subdevice is digital input/output\n");
if ((info->flags&A4L_SUBD_TYPES) == A4L_SUBD_COUNTER)
printf(" Subdevice is counter\n");
if ((info->flags&A4L_SUBD_TYPES) == A4L_SUBD_TIMER)
printf(" Subdevice is timer\n");
if ((info->flags&A4L_SUBD_TYPES) == A4L_SUBD_MEMORY)
printf(" Subdevice is memory, EEPROM, or DPRAM\n");
if ((info->flags&A4L_SUBD_TYPES) == A4L_SUBD_CALIB)
printf(" Subdevice is calibration DAC\n");
if ((info->flags&A4L_SUBD_TYPES) == A4L_SUBD_PROC)
printf(" Subdevice is processor or DSP\n");
if ((info->flags&A4L_SUBD_TYPES) == A4L_SUBD_SERIAL)
printf(" Subdevice is serial I/O\n");
if (info->flags & A4L_SUBD_CMD)
printf(" Subdevice can handle command (asynchronous acquisition)\n");
if (info->flags & A4L_SUBD_MMAP)
printf(" Subdevice can do mmap operations\n");
printf(" Status %ld\n",info->status);
printf(" Number of Channels %d\n",info->nb_chan);
// get channel info
for (j=1; j<=info->nb_chan; ++j) {
a4l_chinfo_t *chan_info;
rc = a4l_get_chinfo(&desc,i-1,j-1,&chan_info);
printf(" %2d.Channel: #Bits = %d #Ranges = %d Flags = 0x%lx\n",
j-1,chan_info->nb_bits,
chan_info->nb_rng,chan_info->chan_flags);
}
printf("\n");
}
}
int main(int argc, char *argv[])
{
int err = 0;
unsigned int cnt = 0;
a4l_desc_t dsc = { .sbdata = NULL };
a4l_sbinfo_t *sbinfo;
a4l_chinfo_t *chinfo;
a4l_rnginfo_t *rnginfo;
int (*dump_function) (a4l_desc_t *, unsigned char *, int) = dump_text;
/* Compute arguments */
while ((err = getopt_long(argc,
argv,
"vrd:s:S:c:R:y:wh", insn_read_opts,
NULL)) >= 0) {
switch (err) {
case 'v':
verbose = 1;
break;
case 'd':
filename = optarg;
break;
case 's':
idx_subd = strtoul(optarg, NULL, 0);
break;
case 'S':
scan_size = strtoul(optarg, NULL, 0);
break;
case 'c':
idx_chan = strtoul(optarg, NULL, 0);
break;
case 'R':
idx_rng = strtoul(optarg, NULL, 0);
dump_function = dump_converted;
break;
case 'w':
dump_function = dump_raw;
break;
case 'y':
dump_function = dump_calibrated;
calibration_file = optarg;
break;
case 'h':
default:
do_print_usage();
return 0;
}
}
if (isatty(STDOUT_FILENO) && dump_function == dump_raw) {
fprintf(stderr,
"insn_read: cannot dump raw data on a terminal\n\n");
return -EINVAL;
}
/* Open the device */
err = a4l_open(&dsc, filename);
if (err < 0) {
fprintf(stderr,
"insn_read: a4l_open %s failed (err=%d)\n",
filename, err);
return err;
}
if (verbose != 0) {
printf("insn_read: device %s opened (fd=%d)\n", filename,
dsc.fd);
printf("insn_read: basic descriptor retrieved\n");
printf("\t subdevices count = %d\n", dsc.nb_subd);
printf("\t read subdevice index = %d\n", dsc.idx_read_subd);
printf("\t write subdevice index = %d\n", dsc.idx_write_subd);
}
/* Allocate a buffer so as to get more info (subd, chan, rng) */
dsc.sbdata = malloc(dsc.sbsize);
if (dsc.sbdata == NULL) {
err = -ENOMEM;
fprintf(stderr, "insn_read: info buffer allocation failed\n");
goto out_insn_read;
}
/* Get this data */
err = a4l_fill_desc(&dsc);
if (err < 0) {
fprintf(stderr, "insn_read: a4l_fill_desc failed (err=%d)\n",
err);
goto out_insn_read;
}
if (verbose != 0)
printf("insn_read: complex descriptor retrieved\n");
/* If no subdevice index was set, look for an analog input
subdevice */
if (idx_subd == -1)
idx_subd = dsc.idx_read_subd;
if (idx_subd == -1) {
fprintf(stderr,
"insn_read: no analog input subdevice available\n");
err = -EINVAL;
goto out_insn_read;
}
if (verbose != 0)
printf("insn_read: selected subdevice index = %d\n", idx_subd);
/* We must check that the subdevice is really an AI one
(in case, the subdevice index was set with the option -s) */
err = a4l_get_subdinfo(&dsc, idx_subd, &sbinfo);
if (err < 0) {
fprintf(stderr,
"insn_read: get_sbinfo(%d) failed (err = %d)\n",
idx_subd, err);
err = -EINVAL;
goto out_insn_read;
}
if ((sbinfo->flags & A4L_SUBD_TYPES) != A4L_SUBD_AI) {
fprintf(stderr,
"insn_read: wrong subdevice selected "
"(not an analog input)\n");
err = -EINVAL;
goto out_insn_read;
}
if (idx_rng >= 0) {
err = a4l_get_rnginfo(&dsc,
idx_subd, idx_chan, idx_rng, &rnginfo);
if (err < 0) {
fprintf(stderr,
"insn_read: failed to recover range descriptor\n");
goto out_insn_read;
}
if (verbose != 0) {
printf("insn_read: range descriptor retrieved\n");
printf("\t min = %ld\n", rnginfo->min);
printf("\t max = %ld\n", rnginfo->max);
}
}
/* Retrieve the subdevice data size */
err = a4l_get_chinfo(&dsc, idx_subd, idx_chan, &chinfo);
if (err < 0) {
fprintf(stderr,
"insn_read: info for channel %d on subdevice %d not available (err=%d)\n",
idx_chan, idx_subd, err);
goto out_insn_read;
}
/* Set the data size to read */
scan_size *= a4l_sizeof_chan(chinfo);
if (verbose != 0) {
printf("insn_read: channel width is %u bits\n",
chinfo->nb_bits);
printf("insn_read: global scan size is %u\n", scan_size);
}
while (cnt < scan_size) {
int tmp = (scan_size - cnt) < BUF_SIZE ?
(scan_size - cnt) : BUF_SIZE;
/* Perform the synchronous read */
err = a4l_sync_read(&dsc,
idx_subd, CHAN(idx_chan), 0, buf, tmp);
if (err < 0) {
fprintf(stderr,
"insn_read: a4l_sync_read failed (err=%d)\n",
err);
goto out_insn_read;
}
/* Dump the read data */
tmp = dump_function(&dsc, buf, err);
if (tmp < 0) {
err = tmp;
goto out_insn_read;
}
/* Update the count */
cnt += err;
}
if (verbose != 0)
printf("insn_read: %u bytes successfully received\n", cnt);
err = 0;
out_insn_read:
/* Free the information buffer */
if (dsc.sbdata != NULL)
free(dsc.sbdata);
/* Release the file descriptor */
a4l_close(&dsc);
return err;
}
