int main(void)
{
double omega = (2.0*M_PI*SIN_FREQ*SAMP_TIME)/1.0E9;
RTIME until;
RT_TASK *task;
lsampl_t data[NCHAN*2];
long k, sinewave, retval = 0;
signal(SIGKILL, endme);
signal(SIGTERM, endme);
start_rt_timer(0);
task = rt_task_init_schmod(nam2num("MYTASK"), 1, 0, 0, SCHED_FIFO, 0xF);
printf("COMEDI CMD TEST BEGINS: SAMPLING FREQ: %d, RUN TIME: %d.\n", SAMP_FREQ, RUN_TIME);
if (init_board()) {;
printf("Board initialization failed.\n");
return 1;
}
do_cmd();
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
until = rt_get_cpu_time_ns() + (long long)RUN_TIME*1000000000;
for (k = 0; k < SAMP_FREQ*RUN_TIME && !end; k++) {
sinewave = (long)(maxdata/4*sin(k*omega));
data[0] = (lsampl_t)( sinewave + maxdata/2);
data[1] = (lsampl_t)(- sinewave + maxdata/2);
while (rt_comedi_command_data_write(dev, subdev, NCHAN, data) != NCHAN) {
rt_sleep(nano2count(SAMP_TIME/2));
}
if (k == TRIGSAMP) {
rt_comedi_trigger(dev, subdev);
}
}
while (until > rt_get_cpu_time_ns()) {
rt_sleep(nano2count(100000));
}
comedi_cancel(dev, subdev);
comedi_close(dev);
comedi_data_write(dev, subdev, 0, 0, AREF_GROUND, 2048);
comedi_data_write(dev, subdev, 1, 0, AREF_GROUND, 2048);
printf("COMEDI TEST ENDS.\n");
if (retval < 0) {
printf("rt_comedi_wait_timed overruns: %d\n", abs(retval));
}
stop_rt_timer();
rt_make_soft_real_time();
rt_task_delete(task);
return 0;
}
int bogio_close(bogio_spec *spec)
{
int r;
r = comedi_cancel(spec->m_dev, spec->subdevice);
r |= comedi_close(spec->m_dev);
free(spec->fsd);
free(spec->m_max_sample);
free(spec->m_cmd->chanlist);
free(spec->m_cmd);
return r;
}
int main() {
it=comedi_open("/dev/comedi0");
int ret;
if(cmd==NULL) {
cmd=malloc(sizeof(*cmd));
if(cmd==NULL) return -1;
} else {
if(cmd->chanlist) free(cmd->chanlist);
}
comedi_set_global_oor_behavior(COMEDI_OOR_NUMBER);
ret = prepare_cmd(COMEDI_SUBD_AI,cmd,freq);
printf("B");fflush(stdout);
//comedi_get_cmd_generic_timed(dev,subdevice,cmd,0,1e9/freq);
if(ret<0){
printf("comedi_get_cmd_generic_timed failed\n");
return ret;
}
/* Modify parts of the command */
cmd->scan_end_arg = 0;
cmd->stop_arg = 0;
setup_read_wave(COMEDI_SUBD_AI, 0, 0, 100);
ret = comedi_command(it,cmd);
if(ret)
printf("comedi_command (acq): %d\n", ret);
internal_trigger();
comedi_cancel(it, 0);
comedi_cancel(it, 1);
}
/**
* Start the the ADC sampling, unless the external trigger command
* is set it will begin sampling as soon as the usbdux device has been
* initialized.
* The final three arguments are very important to get right
* as the recorder thread will use them to determine where to write it's samples and
* when it's reached end of the buffer. It doesn't care about the c_buffer class
* at all.
* @param arg_device name of the comedi device e.g., 'comedi0'
* @param arg_sample_rate the rate the usb_dux should sample with in hertz (max=3[Mhz]})
* @param arg_start_address the start address of the circle buffer sample should be loading into
* @param arg_end_address the end address of the cicle buffer.
* @param arg_buffer_size byte size of the buffer.
*/
int start_Sampling(char* arg_device, uint32_t arg_sample_rate,
char* arg_start_address, char* arg_end_address, int arg_buffer_size){
_channel_amount = 16;
_sample_rate = arg_sample_rate;
unsigned int chanlist[_channel_amount];
unsigned int convert_arg = 1e9 / _sample_rate;
int ret;
comedi_cmd *cmd = (comedi_cmd *) calloc(1, sizeof(comedi_cmd));
_device = comedi_open(arg_device);
int buffer = 1048576*40;
buffer = (buffer * 4096)/4096;
if(comedi_set_max_buffer_size(_device, 0, buffer) < 0 ){
printf("Failed to set max buffer size to %i bytes\n", buffer);
return -1;
} else printf("Maximum buffer size set to %i bytes\n", comedi_get_max_buffer_size(_device,0));
if(comedi_set_buffer_size(_device, 0, buffer) < 0){
printf("Failed to set buffer size to %iBytes\n", buffer);
return -1;
} else printf("Buffer size set to %iBytes\n", comedi_get_buffer_size(_device,0));
if(!_device){
errx(1, "unable to open device");
comedi_perror("/dev/comedi0");
return -1;
}
for(int i = 0; i < _channel_amount; i++)
chanlist[i] = i;
comedi_set_global_oor_behavior(COMEDI_OOR_NUMBER);
if((ret = comedi_get_cmd_generic_timed(_device, 0, cmd, _channel_amount,0)) < 0){
printf("comedi_get_cmd_generic_timed failed\n");
return ret;
}
cmd->chanlist = chanlist;
cmd->stop_src = TRIG_NONE;
cmd->stop_arg = 0;
cmd->convert_arg = convert_arg;
//setup the sampling to start from the trigger.
//cmd->start_src = TRIG_EXT
//cmd->start_arg = 1;
/* call test twice because different things are tested?
* if tests are successful run sampling command */
if((ret = comedi_command_test(_device, cmd)) != 0
|| (ret = comedi_command_test(_device, cmd)) != 0
|| (ret = comedi_command(_device, cmd)) < 0){
fprintf(stderr, "err: %d\n", ret);
return -1;
}
FILE* dux_fp;
if((dux_fp = fdopen(comedi_fileno(_device), "r")) <= 0)
comedi_perror("fdopen");
char* write_address = arg_start_address;
Utility::SNAP_SAMPLE = 0;
Utility::LAST_SAMPLE = 0;
uint64_t active_sample = 0;
uint32_t tmp_block = 0;
int samples_pr_block = 4096/sizeof(Type);
while((ret = fread(write_address, 1, 4096,dux_fp)) >= 0){
write_address += 4096;
tmp_block += 1;
active_sample += samples_pr_block;
Utility::LAST_SAMPLE += samples_pr_block;
if(tmp_block >= Utility::SNAPSHOT_BLOCK_SIZE){
//printf("signalling serial snapshotter\n");
tmp_block = 0;
Utility::SNAP_SAMPLE = active_sample;
Utility::SNAP_READY = true;
Utility::CV.notify_one();
}
if(write_address == arg_end_address){
write_address -= arg_buffer_size;
//printf("resetting to beginning of buffer\n");
}
if(_stop == true)
break;
}
if(ret < 0)
perror("read");
comedi_cancel(_device, 0);
return 0;
}
int main(void)
{
RTIME until;
RT_TASK *task;
comedi_insn insn[NCHAN];
unsigned int read_chan[NICHAN] = { 0 };
unsigned int write_chan[NOCHAN] = { 0 };
#if !SINGLE_INSN
comedi_insnlist ilist = { NCHAN, insn };
#endif
#if SIN_FREQ
lsampl_t sinewave;
double omega = (2.0*M_PI*SIN_FREQ)/1.0E9;
double actualtime;
#endif
lsampl_t *hist;
lsampl_t data[NCHAN];
long i, k, n, retval;
int toggle;
FILE *fp;
double tms[2];
#if SINGLE_INSN
printf("single insn true\n");
#endif
#if SIN_FREQ
printf(" true\n");
#endif
signal(SIGKILL, endme);
signal(SIGTERM, endme);
hist = malloc(SAMP_FREQ*RUN_TIME*NCHAN*sizeof(lsampl_t) + 1000);
memset(hist, 0, SAMP_FREQ*RUN_TIME*NCHAN*sizeof(lsampl_t) + 1000);
start_rt_timer(0);
task = rt_task_init_schmod(nam2num("MYTASK"), 1, 0, 0, SCHED_FIFO, 0xF);
printf("COMEDI INSN%s TEST BEGINS: SAMPLING FREQ: %d, RUN TIME: %d.\n", SINGLE_INSN ? "" : "LIST", SAMP_FREQ, RUN_TIME);
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
if (init_board()) {;
printf("Board initialization failed.\n");
return 1;
}
for (i = 0; i < NICHAN; i++) {
BUILD_AREAD_INSN(insn[i], subdevai, data[i], 1, read_chan[i], AI_RANGE, AREF_GROUND);
}
for (i = 0; i < NOCHAN; i++) {
BUILD_AWRITE_INSN(insn[NICHAN + i], subdevao, data[NICHAN + i], 1, write_chan[i], AO_RANGE, AREF_GROUND);
}
printf("done building.\n"); fflush (stdout);
until = rt_get_time();
for (toggle = n = k = 0; k < SAMP_FREQ*RUN_TIME && !end; k++) {
#if SIN_FREQ
actualtime = count2nano(rt_get_time());
if(k<2) tms[k] = actualtime;
sinewave = (int) (maxdatao/8*sin(omega*actualtime));
data[NICHAN] = sinewave+maxdatao/2;
//data[NICHAN + 1] = -sinewave+maxdatao/2;
#else
data[NICHAN] = toggle*maxdatao/2;
data[NICHAN + 1] = (1 - toggle)*maxdatao/2;
toggle = 1 - toggle;
#endif
#if SINGLE_INSN
for (i = 0; i < NCHAN; i++) {
if ((retval = comedi_do_insn(dev, insn + i)) > 0) {
hist[n++] = data[i];
} else {
printf("Comedi insn failed # %ld out of %d instructions, retval %ld.\n", i, NCHAN, retval);
break;
}
}
#else
if ((retval = rt_comedi_do_insnlist(dev, &ilist)) == NCHAN) {
for (i = 0; i < NCHAN; i++) {
hist[n++] = data[i];
}
} else {
printf("Comedi insnlist processed only %lu out of %d instructions.\n", retval, NCHAN);
break;
}
#endif
rt_sleep_until(until += nano2count(SAMP_TIME));
}
comedi_cancel(dev, subdevai);
comedi_cancel(dev, subdevao);
comedi_data_write(dev, subdevao, 0, 0, AREF_GROUND, 2048);
comedi_data_write(dev, subdevao, 1, 0, AREF_GROUND, 2048);
comedi_close(dev);
printf("COMEDI INSN%s ENDS.\n", SINGLE_INSN ? "" : "LIST");
printf("t1: %g\n", tms[0]);
printf("t2: %g\n", tms[1]);
printf("tdiff: %g\n", tms[1]-tms[0]);
fp = fopen("rec.dat", "w");
for (n = k = 0; k < SAMP_FREQ*RUN_TIME; k++) {
fprintf(fp, "# %ld: ", k);
for (i = 0; i < NCHAN; i++) {
fprintf(fp, "%d\t", hist[n++]);
}
fprintf(fp, "\n");
}
fclose(fp);
free(hist);
stop_rt_timer();
rt_make_soft_real_time();
rt_task_delete(task);
return 0;
}
int main(void)
{
RT_TASK *task;
lsampl_t *hist;
lsampl_t data[NCHAN] = { 0 };
unsigned int val;
long i, k, n, cnt = 0, retval = 0;
FILE *fp;
signal(SIGKILL, endme);
signal(SIGTERM, endme);
hist = malloc(SAMP_FREQ*RUN_TIME*NCHAN*sizeof(lsampl_t) + 1000);
memset(hist, 0, SAMP_FREQ*RUN_TIME*NCHAN*sizeof(lsampl_t) + 1000);
start_rt_timer(0);
task = rt_task_init_schmod(nam2num("MYTASK"), 1, 0, 0, SCHED_FIFO, 0xF);
printf("COMEDI CMD TEST BEGINS: SAMPLING FREQ: %d, RUN TIME: %d.\n", SAMP_FREQ, RUN_TIME);
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
if (init_board()) {;
printf("Board initialization failed.\n");
return 1;
}
rt_comedi_register_callback(dev, subdev, COMEDI_CB_EOS, NULL, task);
do_cmd();
for (n = k = 0; k < SAMP_FREQ*RUN_TIME && !end; k++) {
#if ONECALL
val = COMEDI_CB_EOS;
#if TIMEDCALL
retval += rt_comedi_command_data_wread_timed(dev, subdev, NCHAN, data, nano2count(TIMEOUT), &val);
#else
retval += rt_comedi_command_data_wread(dev, subdev, NCHAN, data,&val);
#endif
#else
val = 0;
#if TIMEDCALL
retval += rt_comedi_wait_timed(nano2count(TIMEOUT), &val);
#else
retval += rt_comedi_wait(&val);
#endif
#endif
if (val & COMEDI_CB_EOS) {
#if !ONECALL
rt_comedi_command_data_read(dev, subdev, NCHAN, data);
#endif
// printf("Read %ld: %u.\n", k, data[0]);
for (i = 0; i < NCHAN; i++) {
hist[n++] = data[i];
}
} else {
printf("Callback mask does not match: %lu.\n", ++cnt);
}
}
comedi_cancel(dev, subdev);
comedi_close(dev);
printf("COMEDI TEST ENDS.\n");
if (retval < 0) {
printf("rt_comedi_wait_timed overruns: %d\n", abs(retval));
}
fp = fopen("rec.dat", "w");
for (n = k = 0; k < SAMP_FREQ*RUN_TIME; k++) {
fprintf(fp, "# %ld: ", k);
for (i = 0; i < NCHAN; i++) {
fprintf(fp, "%d\t", hist[n++]);
}
fprintf(fp, "\n");
}
fclose(fp);
free(hist);
stop_rt_timer();
rt_make_soft_real_time();
rt_task_delete(task);
return 0;
}
int main(int argc, char *argv[])
{
comedi_cmd cmd;
int err;
int n, m, k;
comedi_t *dev;
unsigned int chanlist[100];
unsigned int maxdata;
comedi_range *rng;
int ret;
struct parsed_options options;
int fn = 256*256;
sampl_t *data, *dp;
float v;
init_parsed_options(&options);
options.subdevice = -1;
options.n_chan = 100000;/* default number of samples */
parse_options(&options, argc, argv);
dev = comedi_open( options.filename );
if(dev == NULL){
fprintf(stderr, "error opening %s\n", options.filename);
return -1;
}
if(options.subdevice < 0)
options.subdevice = comedi_find_subdevice_by_type(dev, COMEDI_SUBD_AI, 0);
maxdata = comedi_get_maxdata(dev, options.subdevice, options.channel);
rng = comedi_get_range(dev, options.subdevice, options.channel, options.range);
memset(&cmd,0,sizeof(cmd));
/*
cmd.subdev = options.subdevice;
cmd.flags = 0;
cmd.start_src = TRIG_INT;
cmd.start_arg = 0;
cmd.scan_begin_src = TRIG_TIMER;
cmd.scan_begin_arg = 1e9 / options.freq;
cmd.convert_src = TRIG_TIMER;
cmd.convert_arg = 1e9 / options.freq / 50;
cmd.scan_end_src = TRIG_COUNT;
cmd.scan_end_arg = options.n_chan;
cmd.stop_src = TRIG_COUNT;
cmd.stop_arg = fn;
cmd.stop_src = TRIG_NONE;
cmd.stop_arg = 0;
*/
cmd.scan_begin_src = TRIG_TIMER;
cmd.flags = TRIG_ROUND_NEAREST;
err = comedi_get_cmd_generic_timed( dev, options.subdevice,
&cmd, options.n_chan,
1e9 / options.freq );
cmd.start_src = TRIG_INT;
cmd.start_arg = 0;
cmd.scan_end_arg = options.n_chan;
cmd.stop_src = TRIG_NONE;
cmd.stop_arg = 0;
cmd.chanlist = chanlist;
cmd.chanlist_len = options.n_chan;
for ( k=0; k<options.n_chan; k++ )
chanlist[k] = CR_PACK(k, options.range, options.aref);
dump_cmd(stderr,&cmd);
if ( cmd.scan_begin_arg > 1e9 / options.freq ) {
fprintf( stderr, "frequency too high! Maximum possible is %g Hz\n", 1.0e9/cmd.scan_begin_arg );
comedi_close( dev );
return 1;
}
err = comedi_command_test(dev, &cmd);
if (err > 0 && err != 4 ) {
fprintf( stderr, "comedi_command_test returned %d\n", err );
dump_cmd(stdout,&cmd);
exit(1);
}
err = comedi_command_test(dev, &cmd);
if (err > 0 && err != 4 ) {
fprintf( stderr, "comedi_command_test returned %d\n", err );
dump_cmd(stdout,&cmd);
exit(1);
}
dump_cmd(stderr,&cmd);
/* init data buffer: */
data = (sampl_t *)malloc( fn*sizeof( sampl_t ) );
if(data == NULL ){
perror("malloc\n");
exit(1);
}
fprintf( stderr, "execute command ...\n" );
if ((err = comedi_command(dev, &cmd)) < 0) {
comedi_perror("comedi_command");
exit(1);
}
fprintf( stderr, "start analog input ...\n" );
ret = comedi_internal_trigger(dev, options.subdevice, 0);
if(ret < 0){
perror("comedi_internal_trigger\n");
exit(1);
}
n = 0;
while( 1 ) {
m = read(comedi_fileno(dev),(void *)data,fn*sizeof( sampl_t));
if(m<0){
if ( errno != EAGAIN ) {
perror("read");
exit(0);
}
else {
fprintf( stderr, "... no more data can be read! Try later.\n" );
usleep( 100000 );
}
}
else {
m /= sizeof( sampl_t);
fprintf( stderr, "read %d samples\n",m);
n+=m;
}
}
comedi_cancel( dev, cmd.subdev );
fprintf( stderr, "finished\n" );
/* save data: */
dp = data;
for ( k=0; k<n; k++ ) {
v = comedi_to_phys(*dp, rng, maxdata);
printf( "%g\n", v );
/* printf( "%d\n", *dp );*/
++dp;
}
free( data );
comedi_close( dev );
return 0;
}
