void do_cmd(comedi_t *dev,comedi_cmd *cmd)
{
int total=0;
int ret;
int go;
ret=comedi_command_test(dev,cmd);
printf("test ret=%d\n",ret);
if(ret<0){
printf("errno=%d\n",errno);
comedi_perror("comedi_command_test");
return;
}
dump_cmd(stdout,cmd);
ret=comedi_command_test(dev,cmd);
printf("test ret=%d\n",ret);
if(ret<0){
printf("errno=%d\n",errno);
comedi_perror("comedi_command_test");
return;
}
dump_cmd(stdout,cmd);
ret=comedi_command(dev,cmd);
printf("ret=%d\n",ret);
if(ret<0){
printf("errno=%d\n",errno);
comedi_perror("comedi_command");
return;
}
go=1;
while(go){
ret=read(comedi_fileno(dev),buf,BUFSZ);
if(ret<0){
if(errno==EAGAIN){
printf("EAGAIN\n");
usleep(10000);
}else{
go = 0;
perror("read");
}
}else if(ret==0){
go = 0;
}else{
//int i;
total+=ret;
//printf("read %d %d\n",ret,total);
//printf("count = %d\n",count);
//print_time();
}
}
}
TEST(ComediTest,AnalogReadings ) {
lsampl_t data;
int ret;
int subdev = 0;
int chan = 0;
int range = 0;
int aref = AREF_GROUND;
int num_scans = options.n_scan;
int num_channels = options.n_chan;
int readscans;
std::string prop("/sys/class/comedi/comedi0/read_buffer_pos");
dev = comedi_open(options.filename);
ASSERT_TRUE( dev );
subdev_flags = comedi_get_subdevice_flags(dev, options.subdevice);
RecordProperty("NumScans", num_scans);
#if 0
fprintf(stderr, "command before testing:\n");
dump_cmd(stderr, cmd);
#endif
prepare_cmd_lib(dev, options.subdevice, num_scans, num_channels, 1e9 / options.freq, cmd);
#if 0
fprintf(stderr, "command before testing:\n");
dump_cmd(stderr, cmd);
#endif
/**
* Setup the Command structure
*/
cmd->chanlist_len = 2;
cmd->stop_arg = num_scans;
/* verify no problems */
ret = comedi_command_test(dev, cmd);
ASSERT_GE( ret, 0 ) << "Comedi Testing of command for device was ok";
/* make sure our scan number hasn't changed */
ASSERT_EQ( cmd->stop_arg , num_scans );
ASSERT_EQ( cmd->chanlist_len , 2 );
ret = comedi_command(dev, cmd);
sleep(1);
ASSERT_GE( ret, 0 ) << "Able to Submit comedi command\n";
/* Verify that the buffer position has in fact moved
to say num_scans scans remain in it */
FILE *fp = fopen(prop.c_str(),"r");
ASSERT_TRUE( fp ) << "Able to open sysfs property file";
fscanf(fp,"%d",&readscans );
ASSERT_EQ( readscans, 4*num_scans ) << "Able to read the fifo position 4*" << num_scans << "\n";
fclose(fp);
comedi_close( dev );
}
void ComediScope::startDAQ() {
for(int devNo=0;devNo<nComediDevices;devNo++) {
/* start the command */
int ret=comedi_command(dev[devNo],cmd[devNo]);
if(ret<0){
comedi_perror("comedi_command");
exit(1);
}
}
startTimer( 50 ); // run continuous timer
counter->start( 500 );
}
int myBoard_start( int board ) {
MY_BOARD_HARDWARE *pBoardHard = myBoard_getHardwareBoard( board );
MY_BOARD_SOFTWARE *pBoardSoft = myBoard_getSoftwareBoard( board );
if (pBoardHard == NULL || pBoardSoft == NULL) return 1;
int status = comedi_command(
pBoardHard->p_comediFileHandle,
pBoardHard->p_comediCommand
);
if (status < 0) {
return -1;
}
return 0;
}
int do_cmd(void)
{
int ret, i;
comedi_cmd cmd;
unsigned int chanlist[NCHAN];
unsigned int buf_read[NCHAN] = { 2, 3, 4, 5, 6 };
memset(&cmd, 0, sizeof(cmd));
for (i = 0; i < NCHAN; i++) {
chanlist[i] = CR_PACK(buf_read[i], AI_RANGE, AREF_GROUND);
}
cmd.subdev = subdev;
cmd.flags = TRIG_RT | TRIG_WAKE_EOS;
cmd.start_src = TRIG_NOW;
cmd.start_arg = 0;
cmd.scan_begin_src = TRIG_TIMER;
cmd.scan_begin_arg = SAMP_TIME;
cmd.convert_src = TRIG_TIMER;
cmd.convert_arg = 2000;
cmd.scan_end_src = TRIG_COUNT;
cmd.scan_end_arg = NCHAN;
cmd.stop_src = TRIG_NONE;
cmd.stop_arg = 0;
cmd.chanlist = chanlist;
cmd.chanlist_len = NCHAN;
ret = comedi_command_test(dev, &cmd);
printf("1st comedi_command_test returned: %d.\n", ret);
ret = comedi_command_test(dev, &cmd);
printf("2nd comedi_command_test returned: %d.\n", ret);
printf("CONVERT ARG: %d\n", cmd.convert_arg);
if (ret) {
return ret;
}
ret = comedi_command(dev, &cmd);
printf("Comedi_command returned: %d.\n", ret);
return ret;
}
int do_cmd(void)
{
int ret, i;
unsigned int chanlist[NCHAN];
unsigned int buf_write[NCHAN] = { 0, 1 };
memset(&cmd, 0, sizeof(cmd));
for (i = 0; i < NCHAN; i++) {
chanlist[i] = CR_PACK(buf_write[i], AO_RANGE, AREF_GROUND);
}
cmd.subdev = subdev;
cmd.flags = TRIG_RT | TRIG_WRITE;
cmd.start_src = TRIG_INT;
cmd.start_arg = 0;
cmd.scan_begin_src = TRIG_TIMER;
cmd.scan_begin_arg = SAMP_TIME;
cmd.convert_src = TRIG_NOW;
cmd.convert_arg = 0;
cmd.scan_end_src = TRIG_COUNT;
cmd.scan_end_arg = NCHAN;
cmd.stop_src = TRIG_NONE;
cmd.stop_arg = 0;
cmd.chanlist = chanlist;
cmd.chanlist_len = NCHAN;
ret = comedi_command_test(dev, &cmd);
ret = comedi_command_test(dev, &cmd);
if (ret) {
return ret;
}
ret = comedi_command(dev, &cmd);
return ret;
}
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);
}
int test_mmap(void)
{
comedi_cmd cmd;
unsigned char *buf;
unsigned int chanlist[1];
int go;
int fails;
int total=0;
int ret;
void *b;
unsigned char *adr;
unsigned char *map;
unsigned int flags;
int i;
unsigned sample_size;
unsigned map_len;
flags = comedi_get_subdevice_flags(device,subdevice);
/* attempt to make subdevice the current 'read' subdevice */
if(flags&SDF_CMD_READ) comedi_set_read_subdevice(device,subdevice);
if(!(flags&SDF_CMD) || (comedi_get_read_subdevice(device)!=subdevice)){
printf("not applicable\n");
return 0;
}
if(flags & SDF_LSAMPL) sample_size = sizeof(lsampl_t);
else sample_size = sizeof(sampl_t);
map_len = sample_size * N_SAMPLES;
if(comedi_get_cmd_generic_timed(device, subdevice, &cmd, 1, 1)<0){
printf("E: comedi_get_cmd_generic_timed failed\n");
return 0;
}
buf=malloc(sample_size * N_SAMPLES);
map = mmap(NULL, map_len,PROT_READ, MAP_SHARED, comedi_fileno(device),0);
if(!map){
printf("E: mmap() failed\n");
return 0;
}
/* test readability */
for(adr = map; adr < map + map_len; adr += PAGE_SIZE){
ret=test_segfault(adr);
if(ret){
printf("E: %p failed\n",adr);
}else{
printf("%p ok\n",adr);
}
}
if(realtime)cmd.flags |= TRIG_RT;
cmd.chanlist = chanlist;
cmd.scan_end_arg = 1;
cmd.stop_arg = N_SAMPLES;
cmd.chanlist_len = 1;
chanlist[0] = CR_PACK(0,0,0);
comedi_command(device,&cmd);
go=1;
b=buf;
while(go){
ret = read(comedi_fileno(device), b,
(N_SAMPLES * sample_size) - total);
if(ret<0){
if(errno==EAGAIN){
usleep(10000);
}else{
go = 0;
perror("read");
}
}else if(ret==0){
go = 0;
}else{
total += ret;
b += ret;
if(verbose) printf("read %d %d\n",ret,total);
if(total >= (N_SAMPLES * sample_size)){
go = 0;
}
}
}
fails = 0;
for(i=0;i<total;i++){
if(buf[i]!=map[i]){
if(fails==0)printf("E: mmap compare failed\n");
printf("offset %d (read=%02x mmap=%02x)\n",i,
buf[i], map[i]);
fails++;
if(fails>10)break;
}
}
if(fails==0) printf("compare ok\n");
munmap(map, map_len);
/* test if area is really unmapped */
for(adr = map; adr < map + map_len; adr += PAGE_SIZE){
ret=test_segfault(adr);
if(ret){
printf("%p segfaulted (ok)\n",adr);
}else{
printf("E: %p still mapped\n",adr);
}
}
free(buf);
return 0;
}
static PyObject*
comediModule(PyObject* self, PyObject* args)
{
char *device;
int subdevice;
int channel;
int range;
int aref;
int n_chan;
int n_scan;
float freq;
if (!PyArg_ParseTuple(args, "siiiiiif", &device, &subdevice, &channel, &range, &aref, &n_chan, &n_scan, &freq))
return NULL;
comedi_t *dev;
comedi_cmd c,*cmd=&c;
int ret;
int total=0;
int i;
struct timeval start,end;
int subdev_flags;
lsampl_t raw;
struct parsed_options options;
init_parsed_options(&options);
options.filename = device;
options.subdevice = subdevice;
options.channel = channel;
options.range = range;
options.aref = aref;
options.n_chan = n_chan;
options.n_scan = n_scan;
options.freq = freq;
/* open the device */
dev = comedi_open(options.filename);
if(!dev){
comedi_perror(options.filename);
exit(1);
}
// Print numbers for clipped inputs
comedi_set_global_oor_behavior(COMEDI_OOR_NUMBER);
/* Set up channel list */
for(i = 0; i < options.n_chan; i++){
chanlist[i] = CR_PACK(options.channel + i, options.range, options.aref);
range_info[i] = comedi_get_range(dev, options.subdevice, options.channel, options.range);
maxdata[i] = comedi_get_maxdata(dev, options.subdevice, options.channel);
}
prepare_cmd_lib(dev, options.subdevice, options.n_scan, options.n_chan, 1e9 / options.freq, cmd);
fprintf(stderr, "command before testing:\n");
dump_cmd(stderr, cmd);
ret = comedi_command_test(dev, cmd);
if(ret < 0){
comedi_perror("comedi_command_test");
if(errno == EIO){
fprintf(stderr,"Ummm... this subdevice doesn't support commands\n");
}
exit(1);
}
fprintf(stderr,"first test returned %d (%s)\n", ret,
cmdtest_messages[ret]);
dump_cmd(stderr, cmd);
ret = comedi_command_test(dev, cmd);
if(ret < 0){
comedi_perror("comedi_command_test");
exit(1);
}
fprintf(stderr,"second test returned %d (%s)\n", ret,
cmdtest_messages[ret]);
if(ret!=0){
dump_cmd(stderr, cmd);
fprintf(stderr, "Error preparing command\n");
exit(1);
}
/* this is only for informational purposes */
gettimeofday(&start, NULL);
fprintf(stderr,"start time: %ld.%06ld\n", start.tv_sec, start.tv_usec);
/* start the command */
ret = comedi_command(dev, cmd);
if(ret < 0){
comedi_perror("comedi_command");
exit(1);
}
subdev_flags = comedi_get_subdevice_flags(dev, options.subdevice);
const int ndim = 2;
npy_intp nd[2] = {n_scan, n_chan};
PyObject *myarray;
double *array_buffer;
myarray = PyArray_SimpleNew(ndim, nd, NPY_DOUBLE);
Py_INCREF(myarray);
array_buffer = (double *)PyArray_DATA(myarray);
while(1){
ret = read(comedi_fileno(dev),buf,BUFSZ);
if(ret < 0){
/* some error occurred */
perror("read");
break;
}else if(ret == 0){
/* reached stop condition */
break;
}else{
static int col = 0;
double j = 0.0;
int bytes_per_sample;
total += ret;
if(options.verbose)fprintf(stderr, "read %d %d\n", ret, total);
if(subdev_flags & SDF_LSAMPL)
bytes_per_sample = sizeof(lsampl_t);
else
bytes_per_sample = sizeof(sampl_t);
for(i = 0; i < ret / bytes_per_sample; i++){
if(subdev_flags & SDF_LSAMPL) {
raw = ((lsampl_t *)buf)[i];
} else {
raw = ((sampl_t *)buf)[i];
}
*array_buffer++ = print_datum(raw, col, 1);
col++;
if(col == options.n_chan){
col=0;
j++;
printf("\n");
}
}
}
}
/* this is only for informational purposes */
gettimeofday(&end,NULL);
fprintf(stderr,"end time: %ld.%06ld\n", end.tv_sec, end.tv_usec);
end.tv_sec -= start.tv_sec;
if(end.tv_usec < start.tv_usec){
end.tv_sec--;
end.tv_usec += 1000000;
}
end.tv_usec -= start.tv_usec;
fprintf(stderr,"time: %ld.%06ld\n", end.tv_sec, end.tv_usec);
return myarray;
}
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;
}
int main(int argc, char *argv[])
{
comedi_t *dev;
comedi_cmd c,*cmd=&c;
int ret;
int total=0;
int i;
struct timeval start,end;
int subdev_flags;
lsampl_t raw;
struct parsed_options options;
init_parsed_options(&options);
parse_options(&options, argc, argv);
/* The following variables used in this demo
* can be modified by command line
* options. When modifying this demo, you may want to
* change them here. */
options.filename = "/dev/comedi0";
options.subdevice = 0;
options.channel = 0;
options.range = 6;
options.aref = AREF_DIFF;
options.n_chan = 8;
options.n_scan = 100000;
options.freq = 1000.0;
options.physical = 1;
/* open the device */
dev = comedi_open(options.filename);
if(!dev){
comedi_perror(options.filename);
exit(1);
}
// Print numbers for clipped inputs
comedi_set_global_oor_behavior(COMEDI_OOR_NUMBER);
/* Set up channel list */
//for(i = 0; i < options.n_chan/2; i++){
for(i = 0; i < options.n_chan; i++){
chanlist[i] = CR_PACK(options.channel + i, options.range, options.aref);
range_info[i] = comedi_get_range(dev, options.subdevice, options.channel, options.range);
maxdata[i] = comedi_get_maxdata(dev, options.subdevice, options.channel);
}
/*
for(i = options.n_chan/2; i < options.n_chan; i++){
fprintf(stderr,"%d: %d\n", i, options.channel + i + 8);
chanlist[i] = CR_PACK(options.channel + i + 8, options.range, options.aref);
range_info[i] = comedi_get_range(dev, options.subdevice, options.channel, options.range);
maxdata[i] = comedi_get_maxdata(dev, options.subdevice, options.channel);
}
*/
/* prepare_cmd_lib() uses a Comedilib routine to find a
* good command for the device. prepare_cmd() explicitly
* creates a command, which may not work for your device. */
prepare_cmd_lib(dev, options.subdevice, options.n_scan, options.n_chan, 1e9 / options.freq, cmd);
//prepare_cmd(dev, options.subdevice, options.n_scan, options.n_chan, 1e9 / options.freq, cmd);
fprintf(stderr, "command:\n");
dump_cmd(stderr, cmd);
/* this is only for informational purposes */
gettimeofday(&start, NULL);
fprintf(stderr,"start time: %ld.%06ld\n", start.tv_sec, start.tv_usec);
/* start the command */
ret = comedi_command(dev, cmd);
if(ret < 0){
comedi_perror("comedi_command");
exit(1);
}
subdev_flags = comedi_get_subdevice_flags(dev, options.subdevice);
while(1){
ret = read(comedi_fileno(dev),buf,BUFSZ);
if(ret < 0){
/* some error occurred */
perror("read");
continue;
}else if(ret == 0){
/* reached stop condition */
break;
}else{
static int col = 0;
int bytes_per_sample;
total += ret;
if(options.verbose)fprintf(stderr, "read %d %d\n", ret, total);
if(subdev_flags & SDF_LSAMPL)
bytes_per_sample = sizeof(lsampl_t);
else
bytes_per_sample = sizeof(sampl_t);
for(i = 0; i < ret / bytes_per_sample; i++){
if(subdev_flags & SDF_LSAMPL) {
raw = ((lsampl_t *)buf)[i];
} else {
raw = ((sampl_t *)buf)[i];
}
print_datum(raw, col, options.physical);
col++;
if(col == options.n_chan){
printf("\n");
col=0;
}
}
}
}
/* this is only for informational purposes */
gettimeofday(&end,NULL);
fprintf(stderr,"end time: %ld.%06ld\n", end.tv_sec, end.tv_usec);
end.tv_sec -= start.tv_sec;
if(end.tv_usec < start.tv_usec){
end.tv_sec--;
end.tv_usec += 1000000;
}
end.tv_usec -= start.tv_usec;
fprintf(stderr,"time: %ld.%06ld\n", end.tv_sec, end.tv_usec);
return 0;
}
void do_cmd(comedi_t *dev,comedi_cmd *cmd)
{
int total=0;
int ret;
int go;
fd_set rdset;
struct timeval timeout;
ret=comedi_command_test(dev,cmd);
printf("test ret=%d\n",ret);
if(ret<0){
printf("errno=%d\n",errno);
comedi_perror("comedi_command_test");
return;
}
dump_cmd(stdout,cmd);
ret=comedi_command_test(dev,cmd);
printf("test ret=%d\n",ret);
if(ret<0){
printf("errno=%d\n",errno);
comedi_perror("comedi_command_test");
return;
}
dump_cmd(stdout,cmd);
ret=comedi_command(dev,cmd);
printf("ret=%d\n",ret);
if(ret<0){
printf("errno=%d\n",errno);
comedi_perror("comedi_command");
return;
}
go=1;
while(go){
FD_ZERO(&rdset);
FD_SET(comedi_fileno(dev),&rdset);
timeout.tv_sec = 0;
timeout.tv_usec = 50000;
ret = select(comedi_fileno(dev)+1,&rdset,NULL,NULL,&timeout);
if(ret<0){
perror("select");
}else if(ret==0){
/* timeout */
}else if(FD_ISSET(comedi_fileno(dev),&rdset)){
ret=read(comedi_fileno(dev),buf,BUFSZ);
if(ret<0){
if(errno==EAGAIN){
go = 0;
perror("read");
}
}else if(ret==0){
go = 0;
}else{
//int i;
total+=ret;
//printf("read %d %d\n",ret,total);
//printf("count = %d\n",count);
do_toggle();
#if 0
for(i=0;i<ret;i+=sizeof(sampl_t)){
do_toggle();
}
#endif
}
}
}
}
bogio_spec *bogio_open(bogio_spec *spec)
{
unsigned int *chanlist; /* For Comedi channel flags */
unsigned int osr; /* Oversampling rate */
int i;
/* Maybe the caller didn't have a bogio_spec */
if (spec == NULL) {
spec = calloc(1U, sizeof(bogio_spec));
/* We have to set these here because 0 is a valid argument */
spec->subdevice = 0U;
spec->range = 0U; /* +/- 4V */
spec->aref = AREF_GROUND;
}
/* Set defaults if the caller didn't supply parameters */
if (spec->comedi_device == NULL)
spec->comedi_device = "/dev/comedi0";
if (spec->sample_rate == 0)
spec->sample_rate = 1000; /* 1kHz default sample rate */
if (spec->channels == 0)
spec->channels = 8; /* 8 input channels by default */
/* implied: oversampling = 0 (no oversampling) */
/* Reserve memory for the Comedi command */
spec->m_cmd = calloc(1, sizeof(comedi_cmd));
/* Try to open the device */
spec->m_dev = comedi_open(spec->comedi_device);
if (spec->m_dev == NULL){
comedi_perror(spec->comedi_device);
return NULL;
}
/* Calculate the oversampled rate for the target sample rate */
spec->oversampling = 0; /* To do! */
osr = spec->oversampling ? spec->oversampling : 1;
osr *= (1000000000U/spec->sample_rate); /* That's 1e9 */
/* Set up channel list */
chanlist = (unsigned int *)calloc(spec->channels, sizeof(unsigned int));
for(i=0 ; i < spec->channels ; i++)
chanlist[i]=CR_PACK(i, spec->range, spec->aref);
i = comedi_get_cmd_generic_timed(spec->m_dev,
spec->subdevice,
spec->m_cmd,
spec->channels,
osr
);
if (i < 0) {
fprintf(stderr, "comedi_get_cmd_generic_timed failed\n");
return NULL;
}
/* Modify parts of the command */
spec->m_cmd->chanlist = chanlist;
spec->m_cmd->chanlist_len = spec->channels;
spec->m_cmd->scan_end_arg = spec->channels;
spec->m_cmd->stop_src = TRIG_NONE;
spec->m_cmd->stop_arg = 0;
/* comedi_command_test() tests a command to see if the
trigger sources and arguments are valid for the subdevice.
If a trigger source is invalid, it will be logically ANDed
with valid values (trigger sources are actually bitmasks),
which may or may not result in a valid trigger source.
If an argument is invalid, it will be adjusted to the
nearest valid value. In this way, for many commands, you
can test it multiple times until it passes. Typically,
if you can't get a valid command in two tests, the original
command wasn't specified very well. */
i = comedi_command_test(spec->m_dev, spec->m_cmd);
if (i < 0) {
comedi_perror("comedi_command_test -- first attempt");
exit(-1);
}
/* fprintf(stderr,"first test returned %d\n",i); */
i = comedi_command_test(spec->m_dev, spec->m_cmd);
if (i < 0){
comedi_perror("comedi_command_test -- second attempt");
return NULL;
}
/* fprintf(stderr,"second test returned %d\n",i); */
if (i != 0){
fprintf(stderr,"Error preparing command\n");
return NULL;
}
/* Make sure the sample rate wasn't modified */
if (spec->m_cmd->convert_src==TRIG_TIMER && spec->m_cmd->convert_arg)
spec->sample_rate = 1E9/spec->m_cmd->convert_arg;
if (spec->m_cmd->scan_begin_src==TRIG_TIMER && spec->m_cmd->scan_begin_arg)
spec->sample_rate = 1E9/spec->m_cmd->scan_begin_arg;
/* start the command */
i = comedi_command(spec->m_dev, spec->m_cmd);
if (i < 0) {
comedi_perror("comedi_command");
return NULL;
}
/* That worked: report the current settings */
/* Read the maxdata value and range for each channel;
it will be used later for normalisation */
spec->m_max_sample = calloc(spec->channels, sizeof(lsampl_t));
spec->fsd = calloc(spec->channels, sizeof(comedi_range *));
for (i = 0 ; i < spec->channels ; i++) {
spec->m_max_sample[i] = comedi_get_maxdata(spec->m_dev,
spec->subdevice,
i);
spec->fsd[i] = comedi_get_range(spec->m_dev,
spec->subdevice,
i,
spec->range);
}
return spec;
}
MainWindow::MainWindow( QWidget *parent ) :
QWidget(parent),
adChannel(0),
psthLength(1000),
psthBinw(20),
spikeThres(1),
psthOn(0),
spikeDetected(false),
time(0),
linearAverage(0)
{
// initialize comedi
const char *filename = "/dev/comedi0";
/* open the device */
if( (dev = comedi_open(filename)) == 0 )
{
comedi_perror(filename);
exit(1);
}
// do not produce NAN for out of range behaviour
comedi_set_global_oor_behavior(COMEDI_OOR_NUMBER);
maxdata = comedi_get_maxdata(dev, COMEDI_SUB_DEVICE, 0);
crange = comedi_get_range(dev,COMEDI_SUB_DEVICE,0,0);
numChannels = comedi_get_n_channels(dev, COMEDI_SUB_DEVICE);
chanlist = new unsigned[numChannels];
/* Set up channel list */
for( int i=0; i<numChannels; i++ )
chanlist[i] = CR_PACK(i, COMEDI_RANGE_ID, AREF_GROUND);
int ret = comedi_get_cmd_generic_timed( dev,
COMEDI_SUB_DEVICE,
&comediCommand,
numChannels,
(int)(1e9/(SAMPLING_RATE)) );
if(ret < 0)
{
printf("comedi_get_cmd_generic_timed failed\n");
exit(-1);
}
/* Modify parts of the command */
comediCommand.chanlist = chanlist;
comediCommand.stop_src = TRIG_NONE;
comediCommand.stop_arg = 0;
/* comedi_command_test() tests a command to see if the
* trigger sources and arguments are valid for the subdevice.
* If a trigger source is invalid, it will be logically ANDed
* with valid values (trigger sources are actually bitmasks),
* which may or may not result in a valid trigger source.
* If an argument is invalid, it will be adjusted to the
* nearest valid value. In this way, for many commands, you
* can test it multiple times until it passes. Typically,
* if you can't get a valid command in two tests, the original
* command wasn't specified very well. */
ret = comedi_command_test(dev, &comediCommand);
if(ret < 0)
{
comedi_perror("comedi_command_test");
exit(-1);
}
fprintf(stderr, "first test returned %d\n", ret);
ret = comedi_command_test(dev, &comediCommand);
if(ret < 0)
{
comedi_perror("comedi_command_test");
exit(-1);
}
fprintf(stderr, "second test returned %d\n", ret);
if(ret != 0)
{
fprintf(stderr,"Error preparing command\n");
exit(-1);
}
// the timing is done channel by channel
// this means that the actual sampling rate is divided by
// number of channels
if ((comediCommand.convert_src == TRIG_TIMER)&&(comediCommand.convert_arg)) {
sampling_rate=(((double)1E9 / comediCommand.convert_arg)/numChannels);
}
// the timing is done scan by scan (all channels at once)
// the sampling rate is equivalent of the scan_begin_arg
if ((comediCommand.scan_begin_src == TRIG_TIMER)&&(comediCommand.scan_begin_arg)) {
sampling_rate=(double)1E9 / comediCommand.scan_begin_arg;
}
// 50Hz or 60Hz mains notch filter
iirnotch = new Iir::Butterworth::BandStop<IIRORDER>;
assert( iirnotch != NULL );
iirnotch->setup (IIRORDER, sampling_rate, NOTCH_F, NOTCH_F/10.0);
/* start the command */
ret = comedi_command(dev, &comediCommand);
if(ret < 0)
{
comedi_perror("comedi_command");
exit(1);
}
int subdev_flags = comedi_get_subdevice_flags(dev, COMEDI_SUB_DEVICE);
if( (sigmaBoard = subdev_flags & SDF_LSAMPL) )
readSize = sizeof(lsampl_t) * numChannels;
else
readSize = sizeof(sampl_t) * numChannels;
// Initialize data for plots
for(int i=0; i<MAX_PSTH_LENGTH; i++)
{
xData[i] = i; // time axis
yData[i] = 0;
timeData[i] = double(i)*psthBinw; // psth time axis
spikeCountData[i] = 0;
psthData[i] = 0;
}
// the gui, straight forward QT/Qwt
resize(640,420);
QHBoxLayout *mainLayout = new QHBoxLayout( this );
QVBoxLayout *controlLayout = new QVBoxLayout;
mainLayout->addLayout(controlLayout);
QVBoxLayout *plotLayout = new QVBoxLayout;
plotLayout->addStrut(400);
mainLayout->addLayout(plotLayout);
// two plots
RawDataPlot = new DataPlot(xData, yData, psthLength,
crange->max, crange->min, this);
plotLayout->addWidget(RawDataPlot);
RawDataPlot->show();
plotLayout->addSpacing(20);
MyPsthPlot = new PsthPlot(timeData, psthData, psthLength/psthBinw, this);
plotLayout->addWidget(MyPsthPlot);
MyPsthPlot->show();
/*---- Buttons ----*/
// AD group
QGroupBox *ADcounterGroup = new QGroupBox( "A/D Channel", this );
QVBoxLayout *ADcounterLayout = new QVBoxLayout;
ADcounterGroup->setLayout(ADcounterLayout);
ADcounterGroup->setAlignment(Qt::AlignJustify);
ADcounterGroup->setSizePolicy( QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed) );
controlLayout->addWidget( ADcounterGroup );
QwtCounter *cntChannel = new QwtCounter(ADcounterGroup);
cntChannel->setRange(0, numChannels-1, 1);
cntChannel->setValue(adChannel);
ADcounterLayout->addWidget(cntChannel);
connect(cntChannel, SIGNAL(valueChanged(double)), SLOT(slotSetChannel(double)));
filter50HzCheckBox = new QCheckBox( "50Hz filter" );
filter50HzCheckBox->setEnabled( true );
ADcounterLayout->addWidget(filter50HzCheckBox);
// psth functions
QGroupBox *PSTHfunGroup = new QGroupBox( "Actions", this );
QVBoxLayout *PSTHfunLayout = new QVBoxLayout;
PSTHfunGroup->setLayout(PSTHfunLayout);
PSTHfunGroup->setAlignment(Qt::AlignJustify);
PSTHfunGroup->setSizePolicy( QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed) );
controlLayout->addWidget( PSTHfunGroup );
averagePsth = new QComboBox(PSTHfunGroup);
averagePsth->addItem(tr("PSTH"));
averagePsth->addItem(tr("VEP"));
PSTHfunLayout->addWidget(averagePsth);
connect( averagePsth, SIGNAL(currentIndexChanged(int)), SLOT(slotAveragePsth(int)) );
triggerPsth = new QPushButton(PSTHfunGroup);
triggerPsth->setText("PSTH on");
triggerPsth->setCheckable(true);
PSTHfunLayout->addWidget(triggerPsth);
connect(triggerPsth, SIGNAL(clicked()), SLOT(slotTriggerPsth()));
QPushButton *clearPsth = new QPushButton(PSTHfunGroup);
clearPsth->setText("clear data");
PSTHfunLayout->addWidget(clearPsth);
connect(clearPsth, SIGNAL(clicked()), SLOT(slotClearPsth()));
QPushButton *savePsth = new QPushButton(PSTHfunGroup);
savePsth->setText("save data");
PSTHfunLayout->addWidget(savePsth);
connect(savePsth, SIGNAL(clicked()), SLOT(slotSavePsth()));
// psth params
QGroupBox *PSTHcounterGroup = new QGroupBox( "Parameters", this );
QVBoxLayout *PSTHcounterLayout = new QVBoxLayout;
PSTHcounterGroup->setLayout(PSTHcounterLayout);
PSTHcounterGroup->setAlignment(Qt::AlignJustify);
PSTHcounterGroup->setSizePolicy( QSizePolicy(QSizePolicy::Fixed,
QSizePolicy::Fixed) );
controlLayout->addWidget( PSTHcounterGroup );
QLabel *psthLengthLabel = new QLabel("Sweep length", PSTHcounterGroup);
PSTHcounterLayout->addWidget(psthLengthLabel);
QwtCounter *cntSLength = new QwtCounter(PSTHcounterGroup);
cntSLength->setNumButtons(2);
cntSLength->setIncSteps(QwtCounter::Button1, 10);
cntSLength->setIncSteps(QwtCounter::Button2, 100);
cntSLength->setRange(1, MAX_PSTH_LENGTH, 1);
cntSLength->setValue(psthLength);
PSTHcounterLayout->addWidget(cntSLength);
connect(cntSLength,
SIGNAL(valueChanged(double)),
SLOT(slotSetPsthLength(double)));
QLabel *binwidthLabel = new QLabel("Binwidth", PSTHcounterGroup);
PSTHcounterLayout->addWidget(binwidthLabel);
cntBinw = new QwtCounter(PSTHcounterGroup);
cntBinw->setNumButtons(2);
cntBinw->setIncSteps(QwtCounter::Button1, 1);
cntBinw->setIncSteps(QwtCounter::Button2, 10);
cntBinw->setRange(1, 100, 1);
cntBinw->setValue(psthBinw);
PSTHcounterLayout->addWidget(cntBinw);
connect(cntBinw, SIGNAL(valueChanged(double)), SLOT(slotSetPsthBinw(double)));
QLabel *thresholdLabel = new QLabel("Spike Threshold", PSTHcounterGroup);
PSTHcounterLayout->addWidget(thresholdLabel);
editSpikeT = new QTextEdit("0");
QFont editFont("Courier",14);
QFontMetrics editMetrics(editFont);
editSpikeT->setMaximumHeight ( editMetrics.height()*1.2 );
editSpikeT->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
editSpikeT->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
editSpikeT->setFont(editFont);
PSTHcounterLayout->addWidget(editSpikeT);
connect(editSpikeT, SIGNAL(textChanged()), SLOT(slotSetSpikeThres()));
thresholdMarker = new QwtPlotMarker();
thresholdMarker->setValue(0,0);
thresholdMarker->attach(RawDataPlot);
thresholdMarker->setLineStyle(QwtPlotMarker::HLine);
// Generate timer event every 50ms
(void)startTimer(50);
}
int main(int argc, char *argv[])
{
comedi_cmd c,*cmd=&c;
struct header_info header;
long int t_samples, t_bytes, t_sleep;
long int ret;
int dt_usec, usec_elapsed;
// struct timeval start,end;
struct parsed_options options;
unsigned short *samples; //, *junk;
struct timeval now,then;
long long unsigned int exec = 0;
time_t t;
umask(000);
signal(SIGINT,do_depart);
if (geteuid() != 0) {
fprintf(stderr,"Must be setuid root to renice self.\n");
exit(0);
}
cmd_init_parsed_options(&options);
cmd_parse_options(&options, argc, argv);
t_samples = options.n_chan * options.samples;
t_bytes = t_samples * 2;
t_sleep = (long int) DMA_OVERSCAN_MULT*(1e6/options.freq)*options.samples;
printf("freq = %f, tsamp = %li, tby = %li, tsleep = %li.\n",options.freq,t_samples,t_bytes,t_sleep);
/* Test for failful options */
if (options.freq <= 1/(options.cadence + 0.00005)) {
fprintf(stderr,"Acquisition frequency is faster than sampling frequency! FAIL!\n");
exit(ACQERR_BADINPUT);
}
if (options.samples > 16777216) {
fprintf(stderr,"acq_d can't take more than 2^24 samples per set! Try acq_c.\n");
exit(ACQERR_BADINPUT);
}
ret = nice(-20);
fprintf(stderr,"I've been niced to %li.\n",ret);
if (ret != -20) printf(" WARNING!! Data collection could not set nice=-20. Data loss is probable at high speed.");
dt_usec = options.cadence * 1e6;
gettimeofday(&then, NULL);
/* open the device */
dev = comedi_open(options.devfile);
if (!dev) {
comedi_perror(options.devfile);
exit(ACQERR_BADDEV);
}
// printf("%li samples in %i-byte buffer.\n\n",t_samples,comedi_get_buffer_size(dev,options.subdevice));
prepare_cmd_lib(dev,options,cmd);
printf("Testing command...");
ret = comedi_command_test(dev, cmd);
if (ret < 0) {
comedi_perror("comedi_command_test");
if(errno == EIO){
fprintf(stderr,"Ummm... this subdevice doesn't support commands\n");
}
exit(ACQERR_BADCMD);
}
printf("%s...",cmdtest_messages[ret]);
ret = comedi_command_test(dev, cmd);
printf("%s...",cmdtest_messages[ret]);
ret = comedi_command_test(dev, cmd);
printf("%s...\n",cmdtest_messages[ret]);
if (ret < 0) {
fprintf(stderr,"Bad command, and unable to fix.\n");
dump_cmd(stderr, cmd);
exit(ACQERR_BADCMD);
}
dump_cmd(stdout,cmd);
comedi_close(dev);
//fprintf(stderr,"%i scan -- %i chan -- %li samples -- %li bytes\n",options.samples,options.n_chan,t_samples,t_bytes);
/* Print data file header */
// sprintf(dataheader, "[system]\n"
// "whoami = \"%s\"")
samples = (unsigned short*) malloc(t_bytes);
// junk = (unsigned short*) malloc(t_bytes);
if ((samples == NULL)) { // | (junk == NULL)) {
fprintf(stderr,"Error allocating sample memory!\n");
exit(ACQERR_BADMEM);
}
printf("Starting acquisition...\n");
/*Open the serial port*/
/*serial = (FILE*)fopen("/dev/ttyS0","w");*/
/* Do what we're here to do */
while (running) {
if (exec == options.sets) {
break;
}
exec++;
serial_toggle();
/* open the device */
dev = comedi_open(options.devfile);
if (!dev) {
comedi_perror(options.devfile);
exit(ACQERR_BADDEV);
}
gettimeofday(&now, NULL);
usec_elapsed = (now.tv_sec - then.tv_sec) * 1e6 + (now.tv_usec - then.tv_usec);
while (usec_elapsed < dt_usec) {
usleep(USLEEP_GRAN);
gettimeofday(&now, NULL);
usec_elapsed = (now.tv_sec - then.tv_sec) * 1e6 + (now.tv_usec - then.tv_usec);
}
/* start the command */
ret = comedi_command(dev, cmd);
if (ret < 0) {
comedi_perror("comedi_command");
exit(ACQERR_BADCMD);
}
then = now;
/*
* Insert enough waiting to get through most of the sampling
*/
/*serial_toggle();*/
usleep(t_sleep);
/*
* Wait until the buffer has our data.
*/
int exsleeps = 0;
do {
usleep(USLEEP_GRAN);
comedi_poll(dev,options.subdevice);
ret = comedi_get_buffer_contents(dev,options.subdevice);
exsleeps++;
} while(ret < t_bytes);
// printf("Waited %ius for additional data.\n",exsleeps);
/*
* Get teh dataz.
*/
ret = read(comedi_fileno(dev), samples, t_bytes);
if (ret < t_bytes) {
fprintf(stderr,"Read mismatch! Got %li of %li bytes (%li/%li samples).\n",ret,t_bytes,ret/2,t_samples);
}
header.num_read = ret/2;
// collect & discard overscan
/* ret = comedi_get_buffer_contents(dev,options.subdevice);
if (realloc(junk,ret) == NULL) {
fprintf(stderr,"Error in oversample realloc?\n");
exit(ACQERR_BADMEM);
}
if (ret > 0) {
ret = read(comedi_fileno(dev),junk,ret);
}*/
comedi_close(dev);
// Prepare header
t = time(NULL);
sprintf(header.site_id,"%s",site_str);
header.start_time = t;
header.start_timeval = now;
header.num_channels=options.n_chan;
header.channel_flags=0x0F;
header.num_samples=options.samples;
header.sample_frequency=options.freq;
header.time_between_acquisitions=options.cadence;
header.byte_packing=0;
header.code_version=current_code_version;
// Save latest to monitor file
if (strcmp(options.monfile,"") != 0) {
out = open(options.monfile,O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
ret = errno;
if (out > 0) {
ret = write(out,&header,sizeof(header));
ret = write(out,samples,2*header.num_read);
close(out);
}
else {
fprintf(stderr,"Unable to open monitor file %s: %s.\n",options.monfile,strerror(ret));
exit(ACQERR_BADOUT);
}
}
if (options.cadence >= 1.0 && options.verbose) printf("\tSaved latest to: %s\n",options.monfile);
// Append to output file
if (strcmp(options.outfile,"") != 0) {
out = open(options.outfile,O_WRONLY|O_APPEND|O_CREAT,S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
ret = errno;
if (out > 0) {
ret = write(out,samples,2*header.num_read);
close(out);
if (options.cadence >= 1.0 && options.verbose) printf("\tAppended to: %s\n",options.outfile);
}
else {
fprintf(stderr,"Unable to open output file %s: %s.\n",options.outfile,strerror(ret));
exit(ACQERR_BADOUT);
}
}
}
if (dev != NULL)
comedi_close(dev);
if (out != 0)
close(out);
printf("\nEnd.\n");
exit(0);
}
int PLLReferenceGeneration()
{
//Initial test function to try out Real time stuff.
int m, i=0, err, n;
lsampl_t data_to_card;
static comedi_t * dev;
static int OutputFIFOBufferSize;
static int PLLGenerationBufferSize;
unsigned int maxdata;
unsigned int chanlist[16];
int ret;
static lsampl_t data[PLLGenerationBufferNPoints]; //this is the buffer used to send data points out
comedi_cmd cmd;
dev = comedi_open(device_names[PLLReferenceGenerationChannel.board_number]);
//Check the size of the output buffer
OutputFIFOBufferSize = comedi_get_buffer_size(dev, PLLReferenceGenerationChannel.subdevice);
rt_printk("OutputFIFO Buffer size is %i\n", OutputFIFOBufferSize);
//Set the actual buffer size that we will be using to half this and the number of data points to one fourth
//Now configure the output channel using a Comedi instruction
//BufferSize is initially set to be double the number of PLLGenerationBufferNPoints
PLLGenerationBufferSize = 2*PLLGenerationBufferNPoints;
maxdata = comedi_get_maxdata(dev, PLLReferenceGenerationChannel.subdevice, PLLReferenceGenerationChannel.channel);
rt_printk("PLL Reference channel max data is %i\n", maxdata);
offset = maxdata / 2;
amplitude = maxdata - offset;
memset(&cmd,0,sizeof(cmd));
cmd.subdev = PLLReferenceGenerationChannel.subdevice;
cmd.flags = CMDF_WRITE;
cmd.start_src = TRIG_INT;
cmd.start_arg = 0;
cmd.scan_begin_src = TRIG_TIMER;
cmd.scan_begin_arg = PLLGenMinPulseTime; //minimum update time for the
cmd.convert_src = TRIG_NOW;
cmd.convert_arg = 0;
cmd.scan_end_src = TRIG_COUNT;
cmd.scan_end_arg = NCHAN; //only one channel
cmd.stop_src = TRIG_NONE;
cmd.stop_arg = 0;
cmd.chanlist = chanlist;
cmd.chanlist_len = NCHAN;
chanlist[0] = CR_PACK(PLLReferenceGenerationChannel.channel, AO_RANGE, AREF_GROUND);
dds_init(PLLWaveformFrequency, PLLUpdateFrequency);
err = comedi_command_test(dev, &cmd);
if (err < 0) {
comedi_perror("comedi_command_test");
exit(1);
}
err = comedi_command_test(dev, &cmd);
if (err < 0) {
comedi_perror("comedi_command_test");
exit(1);
}
if ((err = comedi_command(dev, &cmd)) < 0) {
comedi_perror("comedi_command");
exit(1);
}
dds_output(data,PLLGenerationBufferNPoints);
n = PLLGenerationBufferNPoints * sizeof(sampl_t);
m = write(comedi_fileno(dev), (void *)data, n);
if(m < 0){
perror("write");
exit(1);
}else if(m < n)
{
fprintf(stderr, "failed to preload output buffer with %i bytes, is it too small?\n"
"See the --write-buffer option of comedi_config\n", n);
exit(1);
}
if(!(PLLRefGen_Task = rt_task_init_schmod(nam2num( "PLLReferenceGeneration" ), // Name
2, // Priority
0, // Stack Size
0, //, // max_msg_size
SCHED_FIFO, // Policy
CPUMAP ))) // cpus_allowed
{
printf("ERROR: Cannot initialize pll reference generation task\n");
exit(1);
}
//specify that this is to run on one CPU
rt_set_runnable_on_cpuid(PLLRefGen_Task, 1);
//Convert samp_time, which is in nanoseconds, to tick time
//sampling_interval = nano2count(SAMP_TIME); //Converts a value from
//nanoseconds to internal count units.
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_make_hard_real_time();
PLLUpdateTime = nano2count(PLLGenerationLoopTime);
rt_printk("PLL generation update time is %f12 \n",count2nano((float) PLLUpdateTime));
// Let's make this task periodic..
expected = rt_get_time() + 100*PLLUpdateTime;
rt_task_make_periodic(PLLRefGen_Task, expected, PLLUpdateTime); //period in counts
//rt_task_resume(Sinewaveloop_Task);
PLLGenerationOn = TRUE;
// Concurrent function Loop
//rt_printk("SineWaveAmplitude is is %f \n",SineWaveAmplitude);
//rt_printk("SineWaveFrequency is %f \n",SineWaveFrequency);
//rt_printk("sine_loop_running is %d \n",sine_loop_running);
//rt_printk("SAMP_TIME is %d \n",SAMP_TIME);
start_time = (float)rt_get_time_ns()/1E9; //in seconds
old_time = start_time;
rt_printk("PLLReferenceGenerationChannel board_it is %p \n",PLLReferenceGenerationChannel.board_id);
rt_printk("PLLReferenceGenerationChannel devicename is %p \n",*(PLLReferenceGenerationChannel.devicename));
rt_printk("PLLReferenceGenerationChannel boardname is %p \n",*(PLLReferenceGenerationChannel.boardname));
rt_printk("PLLReferenceGenerationChannel subdevice is %d \n",PLLReferenceGenerationChannel.subdevice);
rt_printk("PLLReferenceGenerationChannel channel is %d \n",PLLReferenceGenerationChannel.channel);
OutputValue = 1;
PLLGenerationBufferSize = comedi_get_buffer_size(dev, PLLReferenceGenerationChannel.subdevice);
//sine_loop_running = 0; //set this to 0 for testing
while(PLLGenerationOn)
{
i++; // Count Loops.
current_time = (float)rt_get_time_ns()/1E9;
//rt_printk("LOOP %d,-- Period time: %f12 %f12\n",i, current_time - old_time,count2nano((float)sampling_interval)/1E9);
OutputValue = SineWaveAmplitude*sin(2*PI*SineWaveFrequency*(current_time-start_time));
//OutputValue = -1*OutputValue;
//rt_printk("OutputValue is %f12 \n",OutputValue);
data_to_card = (lsampl_t) nearbyint(((OutputValue - MinOutputVoltage)/OutputRange)*MaxOutputBits);
//m=rt_comedi_command_data_write(AnalogOutputChannel.board_id, AnalogOutputChannel.subdevice, NCHAN, data_to_card);
comedi_lock(dev, AnalogOutputChannel.subdevice);
m=comedi_data_write(dev, AnalogOutputChannel.subdevice, AnalogOutputChannel.channel, AO_RANGE, AREF_DIFF, data_to_card);
comedi_unlock(dev, AnalogOutputChannel.subdevice);
// m=comedi_data_write(AnalogOutputChannel.board_id, AnalogOutputChannel.subdevice,
// AnalogOutputChannel.channel, AO_RANGE, AREF_GROUND, data_to_card);
//rt_printk("Data_to_card is %d; result from rt_comedi_command_data_write is %d \n",data_to_card, m);
//rt_printk("LOOP %d,-- AO Out time: %f12 \n",i, (float)rt_get_time_ns()/1E9 - current_time);
//rt_printk("Data_to_card is %d \n",data_to_card);
//old_time = current_time;
/* if (i== 100000)
{
sine_loop_running = 0;
//printf("LOOP -- run: %d %d\n ",keep_on_running,&keep_on_running);
//printf("RTAI LOOP -- run: %d \n ",i);
break;
}
*/
rt_task_wait_period(); // And waits until the end of the period.
}
rt_make_soft_real_time();
comedi_close(dev);
rt_task_delete(Sinewaveloop_Task); //Self termination at end.
pthread_exit(NULL);
return 0;
}
/**
* 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;
}
void do_cmd(comedi_t *dev,comedi_cmd *cmd)
{
int total=0;
int ret;
int go;
fd_set rdset;
struct timeval timeout;
ret=comedi_command_test(dev,cmd);
printf("test ret=%d\n",ret);
if(ret<0){
printf("errno=%d\n",errno);
comedi_perror("comedi_command_test");
return;
}
dump_cmd(stdout,cmd);
ret=comedi_command_test(dev,cmd);
printf("test ret=%d\n",ret);
if(ret<0){
printf("errno=%d\n",errno);
comedi_perror("comedi_command_test");
return;
}
dump_cmd(stdout,cmd);
comedi_set_read_subdevice(dev, cmd->subdev);
ret = comedi_get_read_subdevice(dev);
if (ret < 0 || ret != cmd->subdev) {
fprintf(stderr,
"failed to change 'read' subdevice from %d to %d\n",
ret, cmd->subdev);
return;
}
ret=comedi_command(dev,cmd);
printf("ret=%d\n",ret);
if(ret<0){
printf("errno=%d\n",errno);
comedi_perror("comedi_command");
return;
}
go=1;
while(go){
FD_ZERO(&rdset);
FD_SET(comedi_fileno(device),&rdset);
timeout.tv_sec = 0;
timeout.tv_usec = 50000;
ret = select(comedi_fileno(dev)+1,&rdset,NULL,NULL,&timeout);
//printf("select returned %d\n",ret);
if(ret<0){
perror("select");
}else if(ret==0){
/* hit timeout */
printf("timeout, polling...\n");
ret = comedi_poll(device,cmd->subdev);
printf("poll returned %d\n",ret);
}else if(FD_ISSET(comedi_fileno(device),&rdset)){
/* comedi file descriptor became ready */
//printf("comedi file descriptor ready\n");
ret=read(comedi_fileno(dev),buf,sizeof(buf));
printf("read returned %d\n",ret);
if(ret<0){
if(errno==EAGAIN){
go = 0;
perror("read");
}
}else if(ret==0){
go = 0;
}else{
int i;
total+=ret;
//printf("read %d %d\n",ret,total);
for(i=0;i<ret/sizeof(sampl_t);i++){
printf("%d\n",buf[i]);
}
}
}else{
/* unknown file descriptor became ready */
printf("unknown file descriptor ready\n");
}
}
}