src/hudaqlib/generic.c

   1 /****************************************************************/\r
   2 /**@file generic.c:\r
   3  * Description: Empty implementation of API layer.              *\r
   4  * Dependency: ---                                              *\r
   5  *              Copyright 2006-2007 Humusoft s.r.o.             *\r
   6  ****************************************************************/\r
   7 #if defined(_WIN32) || defined(_WIN64)\r
   8 #include <windows.h>\r
   9 #endif\r
  10 #include <malloc.h>\r
  11 #include <math.h>\r
  12 \r
  13 #include "hudaqlib.h"\r
  14 #include "hudaq_internal.h"\r
  15 \r
  16 \r
  17 \r
  18 /////////////EMPTY/DUMMY IMPLEMENTATION STUBS///////////////////\r
  19 \r
  20 /** Prototype for any Get Parameter function */\r
  21 \r
  22 int DummyInit(DeviceRecord *DevRecord, int IniOptions)\r
  23 {\r
  24         return -1;\r
  25 }\r
  26 \r
  27 \r
  28 void DummyDone(DeviceRecord *DevRecord)\r
  29 {\r
  30         return;\r
  31 }\r
  32 \r
  33 \r
  34 //////////////////GENERIC PROCEDURES//////////////////////////////\r
  35 \r
  36 \r
  37 /** Device independent implementation for all devices. */\r
  38 int GenericDIReadBit(const DeviceRecord *DevRecord, unsigned channel, unsigned bit)\r
  39 {\r
  40         if((DevRecord->pCT->HudaqDIRead(DevRecord,channel) & (1<<bit)) == 0)\r
  41                 return 0;\r
  42         return 1;\r
  43 }\r
  44 \r
  45 \r
  46 /** Get data from multiple digital input channels from devices that supports only one channel. */\r
  47 HUDAQSTATUS GenericOneDIReadMultiple(const DeviceRecord *DevRecord, unsigned number, const unsigned* channels, unsigned* values)\r
  48 {\r
  49         unsigned InWord;\r
  50         char Flag = 0;\r
  51 \r
  52         if (number==0 || channels==NULL || values==NULL) return HUDAQBADARG;\r
  53         if(DevRecord->pCT->HudaqDIRead==NULL) return HUDAQFAILURE;\r
  54 \r
  55         InWord = DevRecord->pCT->HudaqDIRead(DevRecord,0);\r
  56         while(number-->0)\r
  57         {\r
  58                 if (*channels==0)\r
  59                 {\r
  60                         *values=InWord;\r
  61                         Flag |= 1;\r
  62                 }\r
  63                 else\r
  64                 {\r
  65                         *values=0;\r
  66                         Flag |= 2;\r
  67                 }\r
  68                 values++;\r
  69                 channels++;\r
  70         }\r
  71 \r
  72         if(Flag==3) return HUDAQPARTIAL;        //several values are valid and several are not\r
  73         if(Flag==2) return HUDAQFAILURE;        //no valid value returned\r
  74         return HUDAQSUCCESS;                    //all values are valid (or no channel asked)\r
  75 }\r
  76 \r
  77 \r
  78 /** Device independent implementation for all devices.\r
  79   If at least one call succeeds, HUDAQPARTIAL is returned. */\r
  80 HUDAQSTATUS GenericDOWriteMultiple(const DeviceRecord *DevRecord, unsigned number, const unsigned* channels, const unsigned* values)\r
  81 {\r
  82 \r
  83         HUDAQSTATUS r2, ret=HUDAQSUCCESS;\r
  84         int success=0;\r
  85 \r
  86         if(DevRecord==NULL) return HUDAQBADARG;\r
  87         if(DevRecord->pCT->HudaqDOWrite==NULL) return HUDAQFAILURE;\r
  88 \r
  89         if(number==0 || channels==NULL || values==NULL) return HUDAQBADARG;\r
  90 \r
  91         while(number-->0)\r
  92         {\r
  93                 r2 = DevRecord->pCT->HudaqDOWrite(DevRecord,*channels,*values);\r
  94                 if (r2==HUDAQSUCCESS)\r
  95                         success++;\r
  96                 else\r
  97                         ret=r2;         // store last failure in ret\r
  98 \r
  99                 channels++; values++;\r
 100         }\r
 101 \r
 102         if (ret==HUDAQSUCCESS || success==0) return ret;\r
 103         return HUDAQPARTIAL;\r
 104 }\r
 105 \r
 106 \r
 107 /** Multiple AI reads for devices that do not support this feature. */\r
 108 HUDAQSTATUS GenericAIReadMultiple(const DeviceRecord *DevRecord, unsigned number, const unsigned *channels, double *values)\r
 109 {\r
 110         unsigned MaxChannels;\r
 111         char Flag = 0;\r
 112 \r
 113         if (channels==NULL || values==NULL || number==0) return HUDAQBADARG;\r
 114         if (DevRecord->pCT->HudaqAIRead==NULL) return HUDAQFAILURE; //Wrong internal table, should not occur.\r
 115 \r
 116         MaxChannels = (unsigned)DevRecord->pCT->HudaqGetParameter(DevRecord,0,HudaqAINUMCHANNELS);\r
 117         while(number-->0)\r
 118         {\r
 119                 if(MaxChannels>*channels)\r
 120                 {\r
 121                         Flag |= 1;\r
 122                         *values = DevRecord->pCT->HudaqAIRead(DevRecord,*channels);\r
 123                 }\r
 124                 else\r
 125                 {\r
 126                         *values = UNDEFINED_VALUE;\r
 127                         Flag |= 2;\r
 128                 }\r
 129                 values++;\r
 130                 channels++;\r
 131         }\r
 132 \r
 133         if(Flag==3) return HUDAQPARTIAL;        //several values are valid and several are not\r
 134         if(Flag==2) return HUDAQFAILURE;        //no valid value returned\r
 135         return HUDAQSUCCESS;                    //all values are valid (or no channel asked)\r
 136 }\r
 137 \r
 138 \r
 139 /** Encoder reset generic caller. */\r
 140 void HUDAQAPI HudaqEncReset(HUDAQHANDLE handle, unsigned channel)\r
 141 {\r
 142         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 143         if(DevRecord==NULL) return;\r
 144         if(DevRecord->pCT->HudaqEncReset==NULL) return;\r
 145         DevRecord->pCT->HudaqEncReset(DevRecord,channel);\r
 146 }\r
 147 \r
 148 \r
 149 /** Counter reset generic caller. */\r
 150 void HUDAQAPI HudaqCtrReset(HUDAQHANDLE handle, unsigned channel)\r
 151 {\r
 152         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 153         if(DevRecord==NULL) return;\r
 154         if(DevRecord->pCT->HudaqCtrReset==NULL) return;\r
 155         DevRecord->pCT->HudaqCtrReset(DevRecord,channel);\r
 156 }\r
 157 \r
 158 \r
 159 //////////////////////////////////////////////////////////////////////////\r
 160 /** Generic function callers for all supported devices. */\r
 161 \r
 162 double HUDAQAPI HudaqGetParameter(HUDAQHANDLE handle, unsigned channel, HudaqParameter param)\r
 163 {\r
 164         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 165         if(DevRecord==NULL) return 0;\r
 166         if(DevRecord->pCT->HudaqGetParameter==NULL) return 0;\r
 167         return DevRecord->pCT->HudaqGetParameter(DevRecord,channel,param);\r
 168 }\r
 169 \r
 170 HUDAQSTATUS HUDAQAPI HudaqSetParameter(HUDAQHANDLE handle, unsigned channel, HudaqParameter param, double value)\r
 171 {\r
 172         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 173         if(DevRecord==NULL) return HUDAQBADARG;\r
 174         if(DevRecord->pCT->HudaqSetParameter==NULL) return HUDAQFAILURE;\r
 175         return DevRecord->pCT->HudaqSetParameter(DevRecord,channel,param,value);\r
 176 }\r
 177 \r
 178 const HudaqRange* HUDAQAPI HudaqQueryRange(HUDAQHANDLE handle, HudaqSubsystem S, unsigned item)\r
 179 {\r
 180         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 181         if(DevRecord==NULL) return NULL;\r
 182         if(DevRecord->pCT->HudaqQueryRange==NULL) return NULL;\r
 183         return DevRecord->pCT->HudaqQueryRange(DevRecord,S,item);\r
 184 }\r
 185 \r
 186 //////////////////////////////////////////////\r
 187 \r
 188 int HUDAQAPI HudaqDIRead(HUDAQHANDLE handle, unsigned channel)\r
 189 {\r
 190         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 191         if(DevRecord==NULL) return HUDAQBADARG;\r
 192         if(DevRecord->pCT->HudaqDIRead==NULL) return 0;\r
 193         return DevRecord->pCT->HudaqDIRead(DevRecord,channel);\r
 194 }\r
 195 \r
 196 int HUDAQAPI HudaqDIReadBit(HUDAQHANDLE handle, unsigned channel, unsigned bit)\r
 197 {\r
 198         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 199         if(DevRecord==NULL) return 0;\r
 200         if(DevRecord->pCT->HudaqDIReadBit==NULL) return 0;\r
 201         return DevRecord->pCT->HudaqDIReadBit(DevRecord,channel,bit);\r
 202 }\r
 203 \r
 204 HUDAQSTATUS HUDAQAPI HudaqDIReadMultiple(HUDAQHANDLE handle, unsigned number, const unsigned* channels, unsigned* values)\r
 205 {\r
 206         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 207         if(DevRecord==NULL) return HUDAQBADARG;\r
 208         if(DevRecord->pCT->HudaqDIReadMultiple==NULL) return HUDAQNOTSUPPORTED;\r
 209         return DevRecord->pCT->HudaqDIReadMultiple(DevRecord,number,channels,values);\r
 210 }\r
 211 \r
 212 \r
 213 HUDAQSTATUS HUDAQAPI HudaqDOWriteMultiple(HUDAQHANDLE handle, unsigned number, const unsigned* channels, const unsigned* values)\r
 214 {\r
 215         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 216         if(DevRecord==NULL) return HUDAQBADARG;\r
 217         if(DevRecord->pCT->HudaqDOWrite==NULL) return HUDAQNOTSUPPORTED;\r
 218         return DevRecord->pCT->HudaqDOWriteMultiple(DevRecord,number,channels,values);\r
 219 }\r
 220 \r
 221 HUDAQSTATUS HUDAQAPI HudaqDOWrite(HUDAQHANDLE handle, unsigned channel, unsigned value)\r
 222 {\r
 223         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 224         if(DevRecord==NULL) return HUDAQBADARG;\r
 225         if(DevRecord->pCT->HudaqDOWrite==NULL) return HUDAQFAILURE;\r
 226         return DevRecord->pCT->HudaqDOWrite(DevRecord,channel,value);\r
 227 }\r
 228 \r
 229 void HUDAQAPI HudaqDOWriteBit(HUDAQHANDLE handle, unsigned channel, unsigned bit, int value)\r
 230 {\r
 231         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 232         if(DevRecord==NULL) return;\r
 233         if(DevRecord->pCT->HudaqDOWriteBit==NULL) return;\r
 234         DevRecord->pCT->HudaqDOWriteBit(DevRecord,channel,bit,value);\r
 235 }\r
 236 \r
 237 void HUDAQAPI HudaqDOWriteMultipleBits(HUDAQHANDLE handle, unsigned channel, unsigned mask, unsigned value)\r
 238 {\r
 239         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 240         if(DevRecord==NULL) return;\r
 241         if(DevRecord->pCT->HudaqDOWriteMultipleBits==NULL) return; // HUDAQNOTSUPPORTED;\r
 242         DevRecord->pCT->HudaqDOWriteMultipleBits(DevRecord,channel,mask,value);\r
 243 }\r
 244 \r
 245 \r
 246 double HUDAQAPI HudaqAIRead(HUDAQHANDLE handle, unsigned channel)\r
 247 {\r
 248         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 249         if(DevRecord==NULL) return UNDEFINED_VALUE;\r
 250         if(DevRecord->pCT->HudaqAIRead==NULL) return UNDEFINED_VALUE;\r
 251         return DevRecord->pCT->HudaqAIRead(DevRecord,channel);\r
 252 }\r
 253 \r
 254 HUDAQSTATUS HUDAQAPI HudaqAIReadMultiple(HUDAQHANDLE handle, unsigned number, const unsigned *channels, double *values)\r
 255 {\r
 256         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 257         if(DevRecord==NULL) return HUDAQBADARG;\r
 258         if(DevRecord->pCT->HudaqAIReadMultiple==NULL) return HUDAQNOTSUPPORTED;\r
 259         return DevRecord->pCT->HudaqAIReadMultiple(DevRecord,number,channels,values);\r
 260 }\r
 261 \r
 262 \r
 263 void HUDAQAPI HudaqAOWrite(HUDAQHANDLE handle, unsigned channel, double value)\r
 264 {\r
 265         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 266         if(DevRecord==NULL) return;\r
 267         if(DevRecord->pCT->HudaqAOWrite==NULL) return;\r
 268         DevRecord->pCT->HudaqAOWrite(DevRecord,channel,value);\r
 269 }\r
 270 \r
 271 HUDAQSTATUS HUDAQAPI HudaqAOWriteMultiple(HUDAQHANDLE handle, unsigned number, const unsigned* channels, const double* values)\r
 272 {\r
 273         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 274         if(DevRecord==NULL) return HUDAQBADARG;\r
 275         if(DevRecord->pCT->HudaqAOWriteMultiple==NULL) return HUDAQNOTSUPPORTED;\r
 276         return DevRecord->pCT->HudaqAOWriteMultiple(DevRecord,number,channels,values);\r
 277 }\r
 278 \r
 279 \r
 280 int HUDAQAPI HudaqEncRead(HUDAQHANDLE handle, unsigned channel)\r
 281 {\r
 282         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 283         if(DevRecord==NULL) return 0;\r
 284         if(DevRecord->pCT->HudaqEncRead==NULL) return 0;\r
 285         return DevRecord->pCT->HudaqEncRead(DevRecord,channel);\r
 286 }\r
 287 \r
 288 \r
 289 int HUDAQAPI HudaqCtrRead(HUDAQHANDLE handle, unsigned channel)\r
 290 {\r
 291         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 292         if(DevRecord==NULL) return 0;\r
 293         if(DevRecord->pCT->HudaqCtrRead==NULL) return 0;\r
 294         return DevRecord->pCT->HudaqCtrRead(DevRecord,channel);\r
 295 }\r
 296 \r
 297 \r
 298 HUDAQSTATUS HUDAQAPI HudaqPWMWrite(HUDAQHANDLE handle, unsigned channel, double frequency, double dutycycle)\r
 299 {\r
 300         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 301         if(DevRecord==NULL) return HUDAQBADARG;\r
 302         if(DevRecord->pCT->HudaqPWMWrite==NULL) return HUDAQNOTSUPPORTED;\r
 303         return DevRecord->pCT->HudaqPWMWrite(DevRecord,channel,frequency,dutycycle);\r
 304 }\r
 305 \r
 306 \r
 307 HUDAQSTATUS HUDAQAPI HudaqPWM3Write(HUDAQHANDLE handle, unsigned channel, double frequency, double duty1, double duty2, double duty3)\r
 308 {\r
 309         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 310         if(DevRecord==NULL) return HUDAQBADARG;\r
 311         if(DevRecord->pCT->HudaqPWM3Write==NULL) return HUDAQNOTSUPPORTED;\r
 312         return DevRecord->pCT->HudaqPWM3Write(DevRecord,channel,frequency,duty1,duty2,duty3);\r
 313 }\r
 314 \r
 315 \r
 316 HUDAQSTATUS HudaqPWMWriteMultiphase(HUDAQHANDLE handle, unsigned channel, unsigned phasenum, const unsigned *phases, double frequency, const double *duties)\r
 317 {\r
 318         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 319         if(DevRecord==NULL) return HUDAQBADARG;\r
 320         if(DevRecord->pCT->HudaqPWMWriteMultiphase==NULL) return HUDAQNOTSUPPORTED;\r
 321         return DevRecord->pCT->HudaqPWMWriteMultiphase(DevRecord,channel,phasenum,phases,frequency,duties);\r
 322 }\r
 323 \r
 324 \r
 325 HUDAQSTATUS HUDAQAPI HudaqStepWrite(HUDAQHANDLE handle, unsigned channel, int position)\r
 326 {\r
 327         const DeviceRecord *DevRecord = HudaqGetDeviceRecord(handle);\r
 328         if(DevRecord==NULL) return HUDAQBADARG;\r
 329         if(DevRecord->pCT->HudaqStepWrite==NULL) return  HUDAQNOTSUPPORTED;\r
 330         return DevRecord->pCT->HudaqStepWrite(DevRecord,channel,position);\r
 331 }\r
 332 \r
 333 \r
 334 static double GenericGetParameter(const DeviceRecord *DevRecord, unsigned channel, HudaqParameter param)\r
 335 {\r
 336         switch(param & HudaqSubsystemMASK)\r
 337         {\r
 338                 //case HudaqDI:\r
 339                 //case HudaqDO:\r
 340                 //case HudaqAI:  \r
 341                 //case HudaqAO:  \r
 342                 //case HudaqEnc:\r
 343                 //case HudaqPWM:\r
 344                 //case HudaqCtr:\r
 345                 //case HudaqStep:\r
 346                 case HudaqIRQ:\r
 347                         switch((int)param)\r
 348                         {\r
 349                                 case HudaqIRQ+0: \r
 350                                         return ((UserDataHeader *)DevRecord->DrvRes.DriverData)->IRQcounter;\r
 351                         }\r
 352                         break;\r
 353         }\r
 354         return WRONG_VALUE;\r
 355 }\r
 356 \r
 357 \r
 358 \r
 359 /** Empty call table. */\r
 360 const CallTable CtDummy =\r
 361 {\r
 362         "", 0, 0,\r
 363         DummyInit,\r
 364         DummyDone,\r
 365 \r
 366         NULL,                       // Not available\r
 367         GenericGetParameter,\r
 368         NULL,                       // Not available\r
 369 \r
 370         // INITIALIZE DI callers\r
 371         NULL,\r
 372         NULL,\r
 373         NULL,\r
 374         // INITIALIZE DO callers\r
 375         NULL,\r
 376         NULL,\r
 377         NULL,\r
 378         NULL,\r
 379         // INITIALIZE AI callers\r
 380         NULL,\r
 381         NULL,\r
 382         // INITIALIZE AO callers\r
 383         NULL,\r
 384         NULL,\r
 385         // INITIALIZE Enc callers\r
 386         NULL,                       // Not available\r
 387         NULL,\r
 388         // INITIALIZE Ctr callers\r
 389         NULL,                       // Not available\r
 390         NULL,\r
 391         // INITIALIZE PWM callers\r
 392         NULL,                       // Not available\r
 393         NULL,\r
 394         NULL,\r
 395         // INITIALIZE Step callers\r
 396         NULL,                       // Not available\r
 397 };\r
 398 \r
 399 \r
 400 \r