Hello Kent,
thank you for viewing my question. I am only concerned about the error messages in this part of the program because the rest works...using solution I still get the same error messages...that the operators is not defined for the LARGE_INTEGER_TYPE:


C:\datos\judith\proyecto_judith\pci 1784\pci 1784 configuration5.cpp(110) : warning C4305: 'argument' : truncation from 'const double' to 'float'
C:\datos\judith\proyecto_judith\pci 1784\pci 1784 configuration5.cpp(55) : warning C4101: 'num_contador' : unreferenced local variable
C:\datos\judith\proyecto_judith\pci 1784\pci 1784 configuration5.cpp(387) : warning C4244: 'argument' : conversion from 'unsigned long' to 'unsigned short', possible loss of data
C:\datos\judith\proyecto_judith\pci 1784\pci 1784 configuration5.cpp(426) : warning C4244: 'argument' : conversion from 'const double' to 'unsigned char', possible loss of data
C:\datos\judith\proyecto_judith\pci 1784\pci 1784 configuration5.cpp(752) : warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning)
C:\datos\judith\proyecto_judith\pci 1784\pci 1784 configuration5.cpp(754) : warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning)
C:\datos\judith\proyecto_judith\pci 1784\pci 1784 configuration5.cpp(756) : error C2677: binary '*' : no global operator defined which takes type 'union _LARGE_INTEGER' (or there is no acceptable conversion)
C:\datos\judith\proyecto_judith\pci 1784\pci 1784 configuration5.cpp(758) : error C2678: binary '>' : no operator defined which takes a left-hand operand of type 'union _LARGE_INTEGER' (or there is no acceptable conversion)
C:\datos\judith\proyecto_judith\pci 1784\pci 1784 configuration5.cpp(758) : fatal error C1903: unable to recover from previous error(s); stopping compilation
Error executing cl.exe.

pci 1784 configuration5.obj - 3 error(s), 6 warning(s)

Qour question: I only copied an existing code...I am afraid my programming knowledge is so poor that I cannot even see a real difference.

Judith

Hello Jose,
I tried to use the signed _int64 instead of unsigned int_64 but it gives me the same errors...
cannot convert parameter 1 from '__int64 *' to 'union _LARGE_INTEGER *'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
??
Judith

Hi Kent,
thank you very much...now I don´t get errors anymore...
1 more question...when I want to compile the whole program now the compiler tells me the following:

pci 1784 configuration5.obj : error LNK2001: unresolved external symbol _mexPrintf
Debug/pci 1784 configuration5.exe : fatal error LNK1120: 1 unresolved externals
Error executing link.exe.

pci 1784 configuration5.exe - 2 error(s), 0 warning(s)

although I put #include "mex.h"....I think I didn´t include a library maybe??
Judith

#include <Afxwin.h>
#include <stdio.h>
#include <conio.h>
#include <iostream.h>
#include <time.h>
#include <winsock2.h>
#include <mmsystem.h>
#include <math.h>
#include "driver.h"
#include "os.h"
#include "dask.h"
#include "jr3ft.h"
#include "stdafx.h"

#include <windows.h>
#include "mex.h"
#include <windows.h>
#include <windef.h>
#include <stdio.h>
#include <conio.h>
#include "ADS1784.h"

void ConfiguraTargetes(void);
void TancaTarjetes(void);
void EscriuTau(int quin, float valor);
long Devicehandler1720;
static double esperaH(double temp);


void main(void)
{      
    BYTE byBoard_ID;
UCHAR byCounter,num_contador;
      DWORD status;
      DWORD lpCntValue;
      CHAR  *texto;

      
    byBoard_ID = 0;
    byCounter = CNT_0;
      
      
    printf(" The card selected is %d   ", byBoard_ID);
      if (byCounter==CNT_0)
      {
         texto="Contador 0";
      }
      printf(" \n\n %s   ", texto);
    ConfiguraTargetes();
      
      printf("empiezo el bucle");
      
      int i;      
      i=0;
      lpCntValue=0;
      while (i<1000) //&& (lpCntValue < 0xfffee920))
      {

            status = P1784CounterRead(byBoard_ID,byCounter,&lpCntValue);
      
      if (status != ERROR_SUCCESS) //ERROR_SUCCESS = function success
    {
            printf("\n\n La lectura es NO OK");
            if (status = CounterNumErr)
            {
                  printf("\n\n Counter number Error");
                  printf("\n Press any key to exit....");
                  getch();//espera que se pulse una tecla e inmediamente después devuelve un valor
                  exit(1); //se puede salir anticipadamente de un programa usando la función exit()
            }
                  else
                  {
                        printf("\n\n Input parameter error!");
                        getch();//espera que se pulse una tecla e inmediamente después devuelve un valor
                        exit(1); //se puede salir anticipadamente de un programa usando la función exit()
                  }
      }
      
      printf("\n\n Counter value read: %x  ", lpCntValue);
      
      EscriuTau(1,0.2);

      //if (lpCntValue >= 0xfec3d74b) //counter too high; girar clockwise in order to disminuir contador
      //      EscriuTau(1,-0.2); //para girar en otro dirección
      //if (lpCntValue<= 0xfec2b441) //counter too little; girar anticlockwise in order to aumentar contador
      //      EscriuTau(1,0.2); //para girar en otro dirección
      
      
            i++;
      

      esperaH(10.0);

      }
      //printf("\n\n Counter value read: %x  ", lpCntValue);
      /*
      printf("\n Press any key to exit....");
      
      getch();
      TancaTarjetes();
      exit(1);
      */

      TancaTarjetes();
      
      
}




void ConfiguraTargetes()
{
      //CONFIGURAR TARJETA PCI 1784:

      BYTE byBoard_ID;

      byBoard_ID = 0;
      //Check how many PCI-1784 card in this system:
      //P1784DevAvailable(DWORD *lpReturnBoardStatus) //evy. in EscriuTau!!!


      //PCI1784 available status.  Bit value : 0 for non avaliable, 1 for available        
      //*lpReturnBoardStatus:  

      //Value   Meaning  
      //Bit 0        For board ID 0
      //Bit 1        For board ID 1
      //Bit 2   For board ID 2
      //.....
 
      //Bit 15  For board ID15



   
   
   
      


      //Device Open:
      //Initial the PCI-1784 and system resource for operation.
      //Before using any P1784 DLL function except P1784DevAvailable,
      //user must use this function first.
      //BYTE byBoard_ID;
      DWORD dwReturnCode;
      dwReturnCode = P1784DevOpen(byBoard_ID);
      //status1784 = P1784DevOpen(BYTE 0); // (BYTE byBoard_ID) O-15

      if (dwReturnCode != ERROR_SUCCESS) //ERROR_SUCCESS = function success
    {
        printf("\n\n Program Fail %4x",dwReturnCode);
        printf("\n Board 0 doesn't exsit !");
        printf("\n Press any key to exit....");
        getch();//espera que se pulse una tecla e inmediamente después devuelve un valor
        exit(1); //se puede salir anticipadamente de un programa usando la función exit()
    }


      //Configure counters:


      //counter mode:
//Select counter mode, PCI1784 counter have 5 modes. X1,X2,X4 is quadrature input mode.
//Quadrature input consists of two square wave inputs(A and B) which are 90 degree out of phase.
      //The PCI1784 counts the square wave transitions and determines the direction by comparing channel A
      //is leading channel B or vice versa.
      
      

      UCHAR byCounter;
      //      Counter 0
      byCounter=CNT_0;

      P1784SelectCntMode(byBoard_ID,byCounter,X4);  //(BYTE byBoard_ID, BYTE byCounter, WORD wMode)
      //P1784SelectCntMode(0,CNT_1,X4);
      //P1784SelectCntMode(0,CNT_2,X4);
      //P1784SelectCntMode(0,CNT_3,X4);
      
      
      //BYTE CNT_0, CNT_1, CNT_2, CNT_3;
      //WORD X4;

      //wMode:
      //DISABLE:PCI1784 will not accept input, but you can still access all its registers.
      //X1:The counter will increment (or decrement) the counter whenever a rising edge occurs on input channel A
       //X2:The counter will increment (or decrement) the counter whenever a rising edge occurs or falling edge
      //   occurs on input channel A
       //X4:The counter will increment (or decrement) the counter whenever a rising or falling edge occurs on input channel A or B
       //_2_PULSE:In 2 pulse mode the PCI1784 uses two input pulses as counting sources: one for clockwise(CW)
      //               and one for counterclockwise(CCW)counting. The counter will decrement whenever a rising edge
      //               occurs on channel A. It will increment whenever a rising edge occurs on channel B
       //_1_PULSE:In pulse/direction mode the PCI1784 uses one input line(A) for pulse input and one line (B) for direction.
      //               If channel B is high (1), the counter will decrement whenever a rising edge occurs on channel A.
      //               If channel B is low (0), the counter will increment whenever a rising edge occurs on channel A.
 

      //CNT_0: Select counter 0
      //CNT_1: Select counter 1
      //CNT_2: Select counter 2
      //CNT_3: Select counter 3




      //counter latch:
      //When you read a counter, you are actually reading a value latched into a buffer.
      //The PCI1784 provides five different latching modes, only one of which is active
      //at any given time. Make sure that you know which latching mode is current one
      //whenever you read the counter. Otherwise, you may read an old value or one that
      //was latched at a different time that you except.
      
      
      P1784SetLatchSource(0,CNT_0,SOFTWARE);//(BYTE byBoard_ID, BYTE byCounter, WORD wLatchSource)  
      //P1784SetLatchSource(0,CNT_1,SOFTWARE);
      //P1784SetLatchSource(0,CNT_2,SOFTWARE);
      //P1784SetLatchSource(0,CNT_3,SOFTWARE);

      //wLatchSource:
      //SOFTWARE:Whenever you read a channels data registers, the counter values will be latched in buffer.
      //               The S/W latch will  only take effect when you read the the counter.
       //INDEX:A rising edge on the channels index input line will latch the channels counter value
       //TIMER:The Card latches the counter value on a rising edge of pulses from the cards on-board timer.
       //DI_0:A rising edge on the boards DI0 line will latch the counter value for the channel.
      //DI_1:A rising edge on the boards DI1 line will latch the counter value for the channel.
      //DI_2:A rising edge on the boards DI2 line will latch the counter value for the channel.
      //DI_3:A rising edge on the boards DI3 line will latch the counter value for the channel.
 


      //counter lock overflow:
      //Set counter locked when counter overflows.
      
      P1784EnableOverFlowLock(0,CNT_0,FALSE);//(BYTE byBoard_ID, BYTE byCounter, BOOL bValue)
      //P1784EnableOverFlowLock(0,CNT_1,FALSE);
      //P1784EnableOverFlowLock(0,CNT_2,FALSE);
      //P1784EnableOverFlowLock(0,CNT_3,FALSE);
      //bValue:
      //Specifies counter locked when counter overflows.
      //If TRUE, counter locked when counter overflows.
      //If FALSE, Counter continues counting (wraps over) when counter overflow.


      //counter lock underflow:
      //Set counter locked when counter underflows.

      P1784EnableUnderFlowLock(0,CNT_0,FALSE);//(BYTE byBoard_ID, BYTE byCounter, BOOL bValue)  
      //P1784EnableUnderFlowLock(0,CNT_1,FALSE);
      //P1784EnableUnderFlowLock(0,CNT_2,FALSE);
      //P1784EnableUnderFlowLock(0,CNT_3,FALSE);

      //bValue:
      //Specifies counter locked when counter underflows.
      //If TRUE, counter locked when counter underflows. If FALSE,
      //Counter continues counting (wraps over) when counter underflows.
      //reset value:

      //Set the reset value when counter reset.
      P1784EnableResetValue(0,CNT_0,FALSE);//(BYTE byBoard_ID, BYTE byCounter, BOOL bValue)
      //P1784EnableResetValue(0,CNT_1,FALSE);
      //P1784EnableResetValue(0,CNT_1,FALSE);
      //P1784EnableResetValue(0,CNT_3,FALSE);

            
      //bValue:
      //The reset value when counter reset.
      //If TRUE, the reset value is 80000000h. If FALSE, it is  00000000h



      //digital filter:

      //digital filter clock:
      //Set digital filter clock frequency.
      DWORD wMode;
      wMode = _8MHZ;
      P1784SelectFilterClock(byBoard_ID,wMode);//(BYTE byBoard_ID, DWORD wMode);  

      //wMode: sampling clock mode; _8MHZ/_4MHZ/_2MHZ/_1MHZ


      //enable digital filter:
      //Set quadrature input (channel A, B) with digital filter.
      
      P1784EnableDigitalFilter(0,CNT_0,TRUE);//(BYTE byBoard_ID, BYTE byCounter, BOOL bValue)  
      //P1784EnableDigitalFilter(0,CNT_1,TRUE);
      //P1784EnableDigitalFilter(0,CNT_2,TRUE);
      //P1784EnableDigitalFilter(0,CNT_3,TRUE);

      //bValue:
      //Specifies quadrature input frequency with digital filter.
      //If TRUE, Quadrature input frequency with digital filter.
      //If FALSE, quadrature input frequency without digital filter



      
      
      
      

      
      
      //Configure Timer:
      


      //Set divide value and timer base of Timer.
      //When you use Timer Latch on a rising edge of pulses from the cards on board timer,
      //You can set timer cycle periods from 0.02 ms to 51 seconds.
      //The cycle time is the product of the timer base period and a multiplier.
      //Timer base periods are 0.02, 0.2, 2, 20 or 200 ms. The multiplier ranges from 1 to 255.
      //The divider can range from 1 to 255.


      P1784SetTimerPeriod(0,0.5,_5KHZ);//(BYTE byBoard_ID, BYTE byDivideValue, BYTE byTimerBase)  
      

      //byDivideValue:The divider value 1-255; to create different timer periods!!
      //byTimerBase:
      //_50KHZ:Timer base periods is 0.02ms
      //_5KHZ :Timer base periods is 0.2ms
      //_500HZ:Timer base periods is 2ms
      //_50HZ :Timer base periods is 20ms
      //_5HZ  :Timer base periods is 200ms
      //example:
      //For example, to set a timer period of 20 ms, you would set the timer base to 1ms and the divider to 20.
      //That is :
      //Timer period = Base Time * divider
      //20 ms = 1 ms * 20




      



      //Configure Comparator:
      
            
      //Read current comparator.
      //DWORD *dwCntValue;


      //P1784ComparatorRead(byBoard_ID,CNT_0,dwCntValue); //(BYTE byBoard_ID, BYTE byCounter, DWORD *dwCntValue)
      //P1784ComparatorRead(byBoard_ID,CNT_1,dwCntValue);
      //P1784ComparatorRead(byBoard_ID,CNT_2,dwCntValue);
      //P1784ComparatorRead(byBoard_ID,CNT_3,dwCntValue);

      //*dwCntValue:The value of the data in current comparator


      
      //Set the comparing condition. Comparing condition consists of 2 parts,
      //P1784SetTriggerComp(0,CNT_0,0,1000);//(BYTE byBoard_ID, BYTE byCounter, BYTE byMode, ULONG dwData)
      //P1784SetTriggerComp(0,CNT_0,0,1000);
      //P1784SetTriggerComp(0,CNT_0,0,1000);
      //P1784SetTriggerComp(0,CNT_0,0,1000);

      //byCounter:CNT_0 or CNT_1 or CNT_2 or CNT_3
      //comparing mode:0 for ">", 1 for "<"      
      //dwData:the value to be compared


      

      

      //Event monitor/interrupt:

      //Enable or Disable the event for 4 counters; starts or stops counter operation
      //P1784EnableEvent(byBoard_ID,CNT_0,1);//(BYTE byBoard_ID, BYTE byCounter, WORD wIntSource)


      //wIntSource:The interrupt event source
      //CNT_OVERFLOW:counter overflow
      //CNT_UNDERFLOW:counter underflow
      //CNT_INDEX:counter index in
      //DI0_TRI:DI0 input, When set this value, the byCounter parameter will be ignore.
      //DI1_TRI:DI1 input, When set this value, the byCounter parameter will be ignore.
      //DI2_TRI:DI2 input, When set this value, the byCounter parameter will be ignore.
      //DI3_TRI:DI3 input, When set this value, the byCounter parameter will be ignore.
      //CNT_OVERCOMP:counter over-compare
      //CNT_UNDERCOMP:counter under-compare
      //INT_TIMER:The card's on-board timer's pulse come
      //INT_ALL:All of the events enabled
 





        

      //You can use the CheckEvent function to monitor the event status.
      //The CheckEvent function is a synchronous method to check the event.
      //You have to specify a period for the time out.
      //When an event occurs, it returns the event status(dwRetEventStatus) immediately.
      //If no event occurs in this period, it returns a time out error.  
      //It uses an efficient polling method to check the event.
      //Your CPU can then simultaneously perform other functions.

      //checks status; when it reaches a count it will return a hardware event

      //DWORD *dwRetEventStatus;
      //DWORD dwMillisecond;
      //P1784CheckEvent(byBoard_ID,dwRetEventStatus,dwMillisecond);
      
      //dwMillisecond: Time-out interval in milliseconds
      //*dwRetEventStatus: Current Event status; The status of interrupt. When some interrupt comes into existence,
      //                               the relative bit of Interrupt status register will become 1, otherwise 0.  
      //The status of interrupt. When some interrupt comes into existence, the relative bit of Interrupt status register
      //will become 1, otherwise 0.  

      //D15  D14  D13  D12  D11  D10  D9  D8  D7  D6  D5  D4  D3  D2  D1  D0  
      //DI3  DI2  DI1  DI0  IX3  IX2  IX1 IX0 UN3 UN2 UN1 UN0 OV3 OV2 OV1 OV0

      //D31  D30  D29  D28  D27  D26  D25 D24  D23  D22  D21  D20  D19  D18  D17  D16  
      //IF                   TM                                   UC3  UC2  UC1  UC0  OC3  OC2  OC1  OC0
 
      //1. OVn = Counter overflow flag
      //2. UNn = counter underflow flag
      //3. IXn = Index input flag
      //4. DIn = Digital input flag
      //5. OCn = Counter over compare register flag
      //6. UCn = Counter under compare register flag
      //7. TM  = Timer pulse flag
      //8. IF = Interrupt flag
      //   (n = 0 to 3)


      


      //Digital Input/Output functions:

      //Digital Input:
      //BYTE *lpReturnValue;
      //P1784DI(0,lpReturnValue);//(BYTE byBoard_ID, BYTE *lpReturnValue)  

      //*lpReturnValue: Data received (0/1) from each 4 input channel

      

      //Set Digital Output Mode:
      //The function is to change the digital output mode into Indicated or normal output, and control the pulse width.
      //BYTE byDOMode;
      //byDOMode = 0; // set DO mode to normal
      //dwReturnCode = P1784SetDOMode(byBoard_ID,byDOMode);
      //P1784SetDOMode(0,0);//(BYTE byBoard_ID, BYTE byDOMode);  

       //byDOMode:
      //D7      D6      D5  D4  D3  D2  D1  D0
      //DM3 DM2 DM1 DM0 LE3 LE2 LE1 LE0
 
      
      //1. LEn = Digital output level control
      //      0        Pulse with counter clock
      //      1        Level with clear interrupt
      //2. DMn = Digital output mode control
      //      0        Normal
      //      1           Indicated
      //      (n = 0 to 3)

      //if(dwReturnCode != ERROR_SUCCESS)
    //{
      //  printf("\n Set DO mode fail %4x",dwReturnCode);
        //printf("\n Press any key to exit....");
        //getch();
        //exit(1);
    //}







      //Get Digital Output Status:
      //P1784GetDOStatus(byBoard_ID,lpReturnValue);

      //*lpReturnValue: Output;The output data status of each channel

      
      //digital output/output data:
      //BYTE byWriteValue;
      //byWriteValue = 1; //in bits: 00000001
      //P1784DO(byBoard_ID,byWriteValue);//(BYTE byBoard_ID, BYTE byWriteValue)
      //byWriteValue:input; output data
 
      // Output data
   
    //while(byWriteValue<=8)
    //{
      //  printf("\nDigital Output Data : 0x%1x",byWriteValue);

        // Write Digital Output Data
        //dwReturnCode = P1784DO(byBoard_ID,byWriteValue);
        //if (dwReturnCode != ERROR_SUCCESS)
        //{
          //  printf("\n\n Program Fail %4x",dwReturnCode);
            //printf("\n Press any to exit....");
            //getch();
            //exit(1);
        //}
        //printf("\n Output data is %d",byDOValue);
        //byWriteValue=byWriteValue<<1; //1 shifts one position to the left: 00000010-->00000100-->00001000 usw.
    //}

    //printf("\n\n Press any key to quit\n");
    //getch();





      


      //CONFIGURAR TARJETA PCI 1720:

      int status1720;
      status1720 = DRV_DeviceOpen(0,&Devicehandler1720); //tarjeta 0 advantechautomation-->device manager --> Advantech device manager




}
 



      





void TancaTarjetes(void)
{      
      
      //PARA