demo/cmd.c

   1 /*
   2    A little input demo for commands
   3
   4  */
   5
   6 #include <stdio.h>
   7 #include <comedilib.h>
   8 #include <fcntl.h>
   9 #include <unistd.h>
  10 #include <sys/ioctl.h>
  11 #include <errno.h>
  12 #include <getopt.h>
  13 #include <ctype.h>
  14
  15 #define N_SCANS         10
  16 #define N_CHANS         16
  17
  18 int subdevice = 0;
  19 int chan=0;
  20 int range = 0;
  21 int aref = AREF_GROUND;
  22 double freq = 1000;
  23
  24 #define BUFSZ 100
  25 char buf[BUFSZ];
  26
  27
  28 static void do_cmd(comedi_t *dev);
  29 void dump_cmd(comedi_cmd *cmd);
  30
  31 int main(int argc, char *argv[])
  32 {
  33         char *fn = NULL;
  34         comedi_t *dev;
  35
  36         fn = "/dev/comedi0";
  37
  38         dev = comedi_open(fn);
  39
  40         do_cmd(dev);
  41
  42         return 0;
  43 }
  44
  45 static void do_cmd(comedi_t *dev)
  46 {
  47         comedi_cmd cmd;
  48         unsigned int chanlist[4];
  49         int ret;
  50
  51         /* the subdevice that the command is sent to */
  52         cmd.subdev =    subdevice;
  53
  54         /* flags */
  55         cmd.flags =     0;
  56
  57         /* each event requires a trigger, which is specified
  58            by a source and an argument.  For example, to specify
  59            an external digital line 3 as a source, you would use
  60            src=TRIG_EXT and arg=3. */
  61
  62         cmd.start_src =         TRIG_NOW;
  63         cmd.start_arg =         0;
  64
  65         cmd.scan_begin_src =    TRIG_TIMER;
  66         cmd.scan_begin_arg =    1;      /* in ns */
  67
  68         cmd.convert_src =       TRIG_TIMER;
  69         cmd.convert_arg =       1;              /* in ns */
  70
  71         cmd.scan_end_src =      TRIG_COUNT;
  72         cmd.scan_end_arg =      4;              /* number of channels */
  73
  74         cmd.stop_src =          TRIG_COUNT;
  75         cmd.stop_arg =          1000;
  76
  77         /* the channel list determined which channels are sampled.
  78            In general, chanlist_len is the same as scan_end_arg.  Most
  79            boards require this.  */
  80         cmd.chanlist =          chanlist;
  81         cmd.chanlist_len =      4;
  82
  83         chanlist[0]=CR_PACK(0,range,aref);
  84         chanlist[1]=CR_PACK(1,range,aref);
  85         chanlist[2]=CR_PACK(2,range,aref);
  86         chanlist[3]=CR_PACK(3,range,aref);
  87
  88         /* data and data_len are not used for user-space
  89            programs */
  90         cmd.data = NULL;
  91         cmd.data_len = 0;
  92
  93         ret=ioctl(comedi_fileno(dev),COMEDI_CMDTEST,&cmd);
  94
  95         printf("test ret=%d\n",ret);
  96         if(ret<0){
  97                 printf("errno=%d\n",errno);
  98                 comedi_perror("ioctl");
  99                 return;
 100         }
 101
 102         dump_cmd(&cmd);
 103
 104         cmd.chanlist =          chanlist;
 105         cmd.chanlist_len =      4;
 106
 107         ret=ioctl(comedi_fileno(dev),COMEDI_CMDTEST,&cmd);
 108
 109         printf("test ret=%d\n",ret);
 110         if(ret<0){
 111                 printf("errno=%d\n",errno);
 112                 comedi_perror("ioctl");
 113                 return;
 114         }
 115
 116         dump_cmd(&cmd);
 117
 118         cmd.chanlist =          chanlist;
 119         cmd.chanlist_len =      4;
 120
 121         ret=ioctl(comedi_fileno(dev),COMEDI_CMD,&cmd);
 122
 123         printf("ret=%d\n",ret);
 124         if(ret<0){
 125                 printf("errno=%d\n",errno);
 126                 comedi_perror("ioctl");
 127                 return;
 128         }
 129
 130         do{
 131                 ret=read(comedi_fileno(dev),buf,BUFSZ);
 132                 printf("read %d\n",ret);
 133         }while(ret>0);
 134         printf("errno=%d\n",errno);
 135 }
 136
 137 char *cmd_src(int src)
 138 {
 139         switch(src){
 140         case TRIG_NONE:
 141                 return "none";
 142         case TRIG_NOW:
 143                 return "now";
 144         case TRIG_FOLLOW:
 145                 return "follow";
 146         case TRIG_TIME:
 147                 return "time";
 148         case TRIG_TIMER:
 149                 return "timer";
 150         case TRIG_COUNT:
 151                 return "count";
 152         case TRIG_EXT:
 153                 return "ext";
 154         case TRIG_INT:
 155                 return "int";
 156         default:
 157                 return "unknown";
 158         }
 159 }
 160
 161
 162 void dump_cmd(comedi_cmd *cmd)
 163 {
 164         printf("start: %s %d\n",
 165                 cmd_src(cmd->start_src),
 166                 cmd->start_arg);
 167
 168         printf("scan_begin: %s %d\n",
 169                 cmd_src(cmd->scan_begin_src),
 170                 cmd->scan_begin_arg);
 171
 172         printf("convert: %s %d\n",
 173                 cmd_src(cmd->convert_src),
 174                 cmd->convert_arg);
 175
 176         printf("scan_end: %s %d\n",
 177                 cmd_src(cmd->scan_end_src),
 178                 cmd->scan_end_arg);
 179
 180         printf("stop: %s %d\n",
 181                 cmd_src(cmd->stop_src),
 182                 cmd->stop_arg);
 183 }
 184