/** * @brief Find the must suitable range * * @param[in] dsc Device descriptor filled by a4l_open() and * a4l_fill_desc() * * @param[in] idx_subd Index of the concerned subdevice * @param[in] idx_chan Index of the concerned channel * @param[in] unit Unit type used in the range * @param[in] min Minimal limit value * @param[in] max Maximal limit value * @param[out] rng Found range * * @return The index of the most suitable range on success. Otherwise: * * - -ENOENT is returned if a suitable range is not found. * - -EINVAL is returned if some argument is missing or wrong; * idx_subd, idx_chan and the dsc pointer should be checked; check * also the kernel log ("dmesg"); WARNING: a4l_fill_desc() should * be called before using a4l_find_range() * */ int a4l_find_range(a4l_desc_t * dsc, unsigned int idx_subd, unsigned int idx_chan, unsigned long unit, double min, double max, a4l_rnginfo_t ** rng) { int i, ret; long lmin, lmax; a4l_chinfo_t *chinfo; a4l_rnginfo_t *rnginfo, *tmp = NULL; unsigned int idx_rng = -ENOENT; if (rng != NULL) *rng = NULL; /* Basic checkings */ if (dsc == NULL) return -EINVAL; /* a4l_fill_desc() must have been called on this descriptor */ if (dsc->magic != MAGIC_CPLX_DESC) return -EINVAL; /* Retrieves the ranges count */ ret = a4l_get_chinfo(dsc, idx_subd, idx_chan, &chinfo); if (ret < 0) return ret; /* Initializes variables */ lmin = (long)(min * A4L_RNG_FACTOR); lmax = (long)(max * A4L_RNG_FACTOR); /* Performs the research */ for (i = 0; i < chinfo->nb_rng; i++) { ret = a4l_get_rnginfo(dsc, idx_subd, idx_chan, i, &rnginfo); if (ret < 0) return ret; if (A4L_RNG_UNIT(rnginfo->flags) == unit && rnginfo->min <= lmin && rnginfo->max >= lmax) { if (tmp != NULL) { if (rnginfo->min >= tmp->min && rnginfo->max <= tmp->max) { idx_rng = i; tmp = rnginfo; } } else { idx_rng = i; tmp = rnginfo; } } } if (rng != NULL) *rng = tmp; return idx_rng; }
static int dump_text(a4l_desc_t *dsc, unsigned char *buf, int size) { int err = 0, width, tmp_size = 0; char *fmt; a4l_chinfo_t *chan; /* Retrieve the subdevice data size */ err = a4l_get_chinfo(dsc, idx_subd, idx_chan, &chan); 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; } width = a4l_sizeof_chan(chan); if (width < 0) { fprintf(stderr, "insn_read: incoherent info for channel %d\n", idx_chan); err = width; goto out; } switch(width) { case 1: fmt = "0x%02x\n"; break; case 2: fmt = "0x%04x\n"; break; case 4: default: fmt = "0x%08x\n"; break; } while (size - tmp_size > 0) { unsigned long values[64]; int i, tmp_cnt = ((size - tmp_size) / width > 64) ? 64 : ((size - tmp_size) / width); err = a4l_rawtoul(chan, values, buf + tmp_size, tmp_cnt); if (err < 0) goto out; for (i = 0; i < tmp_cnt; i++) fprintf(stdout, fmt, values[i]); tmp_size += tmp_cnt * width; } out: return err; }
static int dump_converted(a4l_desc_t *dsc, unsigned char *buf, int size) { int err = 0, width, tmp_size = 0; a4l_chinfo_t *chan; a4l_rnginfo_t *rng; /* Retrieve the channel info */ err = a4l_get_chinfo(dsc, idx_subd, idx_chan, &chan); 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; } /* Retrieve the range info */ err = a4l_get_rnginfo(dsc, idx_subd, idx_chan, idx_rng, &rng); if (err < 0) { fprintf(stderr, "insn_read: failed to recover range descriptor\n"); goto out; } width = a4l_sizeof_chan(chan); if (width < 0) { fprintf(stderr, "insn_read: incoherent info for channel %d\n", idx_chan); err = width; goto out; } fprintf(stdout, "Non Calibrated values: \n"); while (size - tmp_size > 0) { double values[64]; int i, tmp_cnt = ((size - tmp_size) / width > 64) ? 64 : ((size - tmp_size) / width); err = a4l_rawtod(chan, rng, values, buf + tmp_size, tmp_cnt); if (err < 0) goto out; for (i = 0; i < tmp_cnt; i++) { fprintf(stdout, "%F\n", values[i]); } tmp_size += tmp_cnt * width; } out: return err; }
int main(int argc, char *argv[]) { int ret = 0, len, ofs; unsigned int i, scan_size = 0, cnt = 0; unsigned long buf_size; void *map = NULL; a4l_desc_t dsc = { .sbdata = NULL }; int (*dump_function) (a4l_desc_t *, a4l_cmd_t*, unsigned char *, int) = dump_text; /* Compute arguments */ while ((ret = getopt_long(argc, argv, "vrd:s:S:c:mwk:h", cmd_read_opts, NULL)) >= 0) { switch (ret) { case 'v': verbose = 1; break; case 'r': real_time = 1; break; case 'd': filename = optarg; break; case 's': cmd.idx_subd = strtoul(optarg, NULL, 0); break; case 'S': cmd.stop_arg = strtoul(optarg, NULL, 0); break; case 'c': str_chans = optarg; break; case 'm': use_mmap = 1; break; case 'w': dump_function = dump_raw; break; case 'k': wake_count = strtoul(optarg, NULL, 0); break; case 'h': default: do_print_usage(); return 0; } } if (isatty(STDOUT_FILENO) && dump_function == dump_raw) { fprintf(stderr, "cmd_read: cannot dump raw data on a terminal\n\n"); return -EINVAL; } /* Recover the channels to compute */ do { cmd.nb_chan++; len = strlen(str_chans); ofs = strcspn(str_chans, ","); if (sscanf(str_chans, "%u", &chans[cmd.nb_chan - 1]) == 0) { fprintf(stderr, "cmd_read: bad channel argument\n"); return -EINVAL; } str_chans += ofs + 1; } while (len != ofs); /* Update the command structure */ cmd.scan_end_arg = cmd.nb_chan; cmd.stop_src = cmd.stop_arg != 0 ? TRIG_COUNT : TRIG_NONE; if (real_time != 0) { if (verbose != 0) printf("cmd_read: switching to real-time mode\n"); /* Prevent any memory-swapping for this program */ ret = mlockall(MCL_CURRENT | MCL_FUTURE); if (ret < 0) { ret = errno; fprintf(stderr, "cmd_read: mlockall failed (ret=%d)\n", ret); goto out_main; } /* Turn the current process into an RT task */ ret = rt_task_shadow(&rt_task_desc, NULL, 1, 0); if (ret < 0) { fprintf(stderr, "cmd_read: rt_task_shadow failed (ret=%d)\n", ret); goto out_main; } } /* Open the device */ ret = a4l_open(&dsc, filename); if (ret < 0) { fprintf(stderr, "cmd_read: a4l_open %s failed (ret=%d)\n", filename, ret); return ret; } if (verbose != 0) { printf("cmd_read: device %s opened (fd=%d)\n", filename, dsc.fd); printf("cmd_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) { fprintf(stderr, "cmd_read: malloc failed \n"); return -ENOMEM; } /* Get this data */ ret = a4l_fill_desc(&dsc); if (ret < 0) { fprintf(stderr, "cmd_read: a4l_fill_desc failed (ret=%d)\n", ret); goto out_main; } if (verbose != 0) printf("cmd_read: complex descriptor retrieved\n"); /* Get the size of a single acquisition */ for (i = 0; i < cmd.nb_chan; i++) { a4l_chinfo_t *info; ret = a4l_get_chinfo(&dsc, cmd.idx_subd, cmd.chan_descs[i], &info); if (ret < 0) { fprintf(stderr, "cmd_read: a4l_get_chinfo failed (ret=%d)\n", ret); goto out_main; } if (verbose != 0) { printf("cmd_read: channel %x\n", cmd.chan_descs[i]); printf("\t ranges count = %d\n", info->nb_rng); printf("\t bit width = %d (bits)\n", info->nb_bits); } scan_size += a4l_sizeof_chan(info); } if (verbose != 0) { printf("cmd_read: scan size = %u\n", scan_size); if (cmd.stop_arg != 0) printf("cmd_read: size to read = %u\n", scan_size * cmd.stop_arg); } /* Cancel any former command which might be in progress */ a4l_snd_cancel(&dsc, cmd.idx_subd); if (use_mmap != 0) { /* Get the buffer size to map */ ret = a4l_get_bufsize(&dsc, cmd.idx_subd, &buf_size); if (ret < 0) { fprintf(stderr, "cmd_read: a4l_get_bufsize() failed (ret=%d)\n", ret); goto out_main; } if (verbose != 0) printf("cmd_read: buffer size = %lu bytes\n", buf_size); /* Map the analog input subdevice buffer */ ret = a4l_mmap(&dsc, cmd.idx_subd, buf_size, &map); if (ret < 0) { fprintf(stderr, "cmd_read: a4l_mmap() failed (ret=%d)\n", ret); goto out_main; } if (verbose != 0) printf ("cmd_read: mmap performed successfully (map=0x%p)\n", map); } ret = a4l_set_wakesize(&dsc, wake_count); if (ret < 0) { fprintf(stderr, "cmd_read: a4l_set_wakesize failed (ret=%d)\n", ret); goto out_main; } if (verbose != 0) printf("cmd_read: wake size successfully set (%lu)\n", wake_count); /* Send the command to the input device */ ret = a4l_snd_command(&dsc, &cmd); if (ret < 0) { fprintf(stderr, "cmd_read: a4l_snd_command failed (ret=%d)\n", ret); goto out_main; } if (verbose != 0) printf("cmd_read: command successfully sent\n"); if (use_mmap == 0) { /* Fetch data */ do { /* Perform the read operation */ ret = a4l_async_read(&dsc, buf, BUF_SIZE, A4L_INFINITE); if (ret < 0) { fprintf(stderr, "cmd_read: a4l_read failed (ret=%d)\n", ret); goto out_main; } /* Display the results */ if (dump_function(&dsc, &cmd, buf, ret) < 0) { ret = -EIO; goto out_main; } /* Update the counter */ cnt += ret; } while (ret > 0); } else { unsigned long front = 0; /* Fetch data without any memcpy */ do { /* Retrieve and update the buffer's state (In input case, we recover how many bytes are available to read) */ ret = a4l_mark_bufrw(&dsc, cmd.idx_subd, front, &front); if (ret == -ENOENT) break; else if (ret < 0) { fprintf(stderr, "cmd_read: a4l_mark_bufrw() failed (ret=%d)\n", ret); goto out_main; } /* If there is nothing to read, wait for an event (Note that a4l_poll() also retrieves the data amount to read; in our case it is useless as we have to update the data read counter) */ if (front == 0) { ret = a4l_poll(&dsc, cmd.idx_subd, A4L_INFINITE); if (ret == 0) break; else if (ret < 0) { fprintf(stderr, "cmd_read: a4l_poll() failed (ret=%d)\n", ret); goto out_main; } } /* Display the results */ if (dump_function(&dsc, &cmd, &((unsigned char *)map)[cnt % buf_size], front) < 0) { ret = -EIO; goto out_main; } /* Update the counter */ cnt += front; } while (1); } if (verbose != 0) printf("cmd_read: %d bytes successfully received\n", cnt); ret = 0; out_main: if (use_mmap != 0) /* Clean the pages table */ munmap(map, buf_size); /* Free the buffer used as device descriptor */ if (dsc.sbdata != NULL) free(dsc.sbdata); /* Release the file descriptor */ a4l_close(&dsc); return ret; }
int dump_text(a4l_desc_t *dsc, a4l_cmd_t *cmd, unsigned char *buf, int size) { static int cur_chan; int i, err = 0, tmp_size = 0; char *fmts[MAX_NB_CHAN]; a4l_chinfo_t *chans[MAX_NB_CHAN]; for (i = 0; i < cmd->nb_chan; i++) { int width; err = a4l_get_chinfo(dsc, cmd->idx_subd, cmd->chan_descs[i], &chans[i]); if (err < 0) { fprintf(stderr, "cmd_read: a4l_get_chinfo failed (ret=%d)\n", err); goto out; } width = a4l_sizeof_chan(chans[i]); if (width < 0) { fprintf(stderr, "cmd_read: incoherent info for channel %d\n", cmd->chan_descs[i]); err = width; goto out; } switch(width) { case 1: fmts[i] = "0x%02x "; break; case 2: fmts[i] = "0x%04x "; break; case 4: default: fmts[i] = "0x%08x "; break; } } while (tmp_size < size) { unsigned long value; err = a4l_rawtoul(chans[cur_chan], &value, buf + tmp_size, 1); if (err < 0) goto out; fprintf(stdout, fmts[cur_chan], value); /* We assume a4l_sizeof_chan() cannot return because we already called it on the very same channel descriptor */ tmp_size += a4l_sizeof_chan(chans[cur_chan]); if(++cur_chan == cmd->nb_chan) { fprintf(stdout, "\n"); cur_chan = 0; } } fflush(stdout); out: return err; }
/*!***************************************************************************** ******************************************************************************** \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; }
static int dump_calibrated(a4l_desc_t *dsc, unsigned char *buf, int size) { struct a4l_calibration_data cal_info; struct a4l_polynomial converter; int err = 0, width, tmp_size = 0; a4l_chinfo_t *chan; a4l_rnginfo_t *rng; /* Retrieve the channel info */ err = a4l_get_chinfo(dsc, idx_subd, idx_chan, &chan); 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; } /* Retrieve the range info */ err = a4l_get_rnginfo(dsc, idx_subd, idx_chan, idx_rng, &rng); if (err < 0) { fprintf(stderr, "insn_read: failed to recover range descriptor\n"); goto out; } width = a4l_sizeof_chan(chan); if (width < 0) { fprintf(stderr, "insn_read: incoherent info for channel %d\n", idx_chan); err = width; goto out; } err = a4l_read_calibration_file(calibration_file, &cal_info); if (err < 0) { fprintf(stderr, "insn_read: error reading the calibration file \n"); goto out; } err = a4l_get_softcal_converter(&converter, idx_subd, idx_chan, idx_rng, &cal_info); if (err < 0) { fprintf(stderr, "insn_read: failed to get the softcal converter \n"); goto out; } fprintf(stdout, "Calibrated values: \n"); while (size - tmp_size > 0) { double values[64]; int i, tmp_cnt = ((size - tmp_size) / width > 64) ? 64 : ((size - tmp_size) / width); err = a4l_rawtodcal(chan, values, buf + tmp_size, tmp_cnt, &converter); if (err < 0) goto out; for (i = 0; i < tmp_cnt; i++) fprintf(stdout, "%F\n", values[i]); tmp_size += tmp_cnt * width; } out: return err; }