Tarjeta de adquisicion

[fj87]

Hola a todos!
Soy nuevo en el foro y tambien practicamente nuevo en python jejeje

Actualmente estoy intentando realizar un programa en Python para el tratamiento de datos adquiridos desde una tarjeta de adquisicion. El problema principal es que la tarjeta no posee drivers para python y sólo para código C. He tratado de utilizar ctypes, pero tras varios días no he logrado ni un solo avance. No se realmente que hago mal o bien :S

Alguien tiene idea de como hacer algo similar?
Gracias :)

[razpeitia]

Puedes utilizar C y C++ para hacer tus modulos en python.

Link

Básicamente hacer un wrapper de tu modulo de C para python.

Bienvenido al foro.

[fj87]

Gracias razpeitia
para elaborar el wrapper, que programa utilizaría? La verdad que ando algo perdido en este asunto jejeje.

un saludo

[razpeitia]

Mira para elaborar un wrapper es relativamente sencillo.

Tienes las funciones en C o C++ entonces usas las librerías de python para C o C++ para, pasar tu librería deseada a python.

Básicamente necesitas, saber C o C++ su respectivo compilador y las librerías (la de python y la que deseas pasar a python).

Cabe aclarar que no es un trabajo sencillo, pero una vez que terminas te ahorraras mucho trabajo.

[AlvaroG]

Si la opción de ctypes te parece más atractiva, también podés preguntar por acá sobre el por qué no logras que funcione

[fj87]

siento dar tanto la lata, pero no me aclaro jejeje

yo hasta el momento, todo lo que he realizado con C han sido archivos ejecutables, entonces en este caso, a la hora de realizar la compilacion no se como actuar. Por ejemplo, podria hacer todo esto con el visual studio? por poner un ejemplo.

Con ctypes he visto algunos ejemplo de adquisicion de datos, pero no me aclaro mucho. Quiero decir que yo veo todas las estructuras que hay creadas en los .h que vienen con la tarjeta y demas, que no se muy bien si yo también tendria que crear esas estructuras en python a la hora de pasar parámetros a las funciones y demás. Mi único avance con ctypes ha sido cargar la libreria, cosa que haria hasta un niño jejejeje

Muchas gracias a los dos

[AlvaroG]

Iniciado por fj87

Alguien que pueda echarme una mano en esto?
Muchas gracias

es imposible ayudar sin más datos, ¿por qué no ponés el código y al menos algunas funciones de la biblioteca que estás accediendo con ctypes? No somos adivinos.

He borrado tu mensaje de acuerdo a las reglas del foro:

2.8 Los usuarios no pueden revivir o reactivar temas publicando información inútil o sin sentido, o llevando a cabo cualquier otra acción para deliberadamente mantener arriba en el índice del foro dicho tema o aumentar el contador de mensajes.

Saludos.

[fj87]

Es cierto, ha sido un error mio.

Supongamos que tengo un programa de este estilo (es el programa de ejemplo de la SDK de la tarjeta de adquisicion). Para hacer algo similar en python, de que manera deberia de actuar?

Que solución considerais más adecuada? uso de ctypes o por el contrario elaborar un wrapper? Podrías darme alguna noción de como actuar con ello?

Muchas gracias!
y nuevamente, perdón por saltarme las normas del foro.

un saludo

Código C:

/*
FUNCTIONS:
 
    WinMain()        gets handle to ADC subsystem, configures ADC for
                     continuous operation, opens a dialog box to receive
                     window messages, and performs continuous operation
                     on the ADC.
    GetDriver()      callback to get board name and open board, opens
                     the first available Open Layers board.
    OutputBox()      dialog box to handle information and error window
                     messages from the ADC subsystem.
 
*/
#include <windows.h>     
#include <stdlib.h>     
#include <stdio.h>     
#include <olmem.h>         
#include <olerrors.h>         
#include <oldaapi.h>
#include "contadc.h"
 
#define NUM_BUFFERS 4
#define STRLEN 80        /* string size for general text manipulation   */
char str[STRLEN];        /* global string for general text manipulation */
 
/* Error handling macros */
#define SHOW_ERROR(ecode) MessageBox(HWND_DESKTOP,olDaGetErrorString(ecode,\
                  str,STRLEN),"Error", MB_ICONEXCLAMATION | MB_OK);
 
#define CHECKERROR(ecode) if ((board.status = (ecode)) != OLNOERROR)\
                  {\
                  SHOW_ERROR(board.status);\
                  olDaReleaseDASS(board.hdass);\
                  olDaTerminate(board.hdrvr);\
                  return ((UINT)NULL);}
 
#define CLOSEONERROR(ecode) if ((board.status = (ecode)) != OLNOERROR)\
                  {\
                  SHOW_ERROR(board.status);\
                  olDaReleaseDASS(board.hdass);\
                  olDaTerminate(board.hdrvr);\
                  EndDialog(hDlg, TRUE);\
                  return (TRUE);}
 
/* simple structure used with board */
typedef struct tag_board {
   HDEV  hdrvr;        /* device handle            */
   HDASS hdass;        /* sub system handle        */
   ECODE status;       /* board error status       */
   char name[MAX_BOARD_NAME_LENGTH];  /* string for board name    */
   char entry[MAX_BOARD_NAME_LENGTH]; /* string for board name    */
} BOARD;
 
typedef BOARD* LPBOARD;
static BOARD board;
static ULNG count = 0;
 
BOOL CALLBACK
GetDriver( LPSTR lpszName, LPSTR lpszEntry, LPARAM lParam )   
/*
this is a callback function of olDaEnumBoards, it gets the 
strings of the Open Layers board and attempts to initialize
the board.  If successful, enumeration is halted.
*/
{
   LPBOARD lpboard = (LPBOARD)(LPVOID)lParam;
   
   /* fill in board strings */
 
   lstrcpyn(lpboard->name,lpszName,MAX_BOARD_NAME_LENGTH-1);
   lstrcpyn(lpboard->entry,lpszEntry,MAX_BOARD_NAME_LENGTH-1);
 
   /* try to open board */
 
   lpboard->status = olDaInitialize(lpszName,&lpboard->hdrvr);
   if   (lpboard->hdrvr != NULL)
      return FALSE;          /* false to stop enumerating */
   else                      
      return TRUE;           /* true to continue          */
}
BOOL CALLBACK
InputBox( HWND hDlg, 
          UINT message, 
          WPARAM wParam, 
          LPARAM lParam )
/*
This function processes messages for "Input" dialog box
*/
{
   DBL min=0,max=0;
   DBL volts;
   ULNG value;
   ULNG samples;
   UINT encoding=0,resolution=0;
   HBUF  hBuffer = NULL;
   PDWORD  pBuffer32 = NULL;
   PWORD  pBuffer = NULL;
   char WindowTitle[128];
   char temp[128];    
   DASSINFO ssinfo;
 
 
   switch (message) {
      case WM_INITDIALOG:   /* message: initialize dialog box  */
         
         /* set the title to the board name */ 
         
         olDaGetDASSInfo(board.hdass,&ssinfo);
         itoa(ssinfo.uiElement,temp,10);
         strncpy(WindowTitle,board.name,128);
         strncat(WindowTitle," Element # ",128);
         strncat(WindowTitle,temp,128);
 
         SetWindowText(hDlg,WindowTitle);
            
 
         /* set window handle and configure sub system */
         
         CLOSEONERROR (olDaSetWndHandle(board.hdass, hDlg,(UINT)NULL));
         CLOSEONERROR (olDaConfig(board.hdass));
 
         /* start sub system */
 
         CLOSEONERROR (olDaStart(board.hdass));
         return (TRUE);   /* Did process a message */
 
      case OLDA_WM_BUFFER_REUSED:   /* message: buffer reused  */
         break;
 
      case OLDA_WM_BUFFER_DONE:     /* message: buffer done  */
 
         /* get buffer off done list */
 
         CHECKERROR (olDaGetBuffer(board.hdass, &hBuffer));
 
         /* if there is a buffer */
 
         if( hBuffer )
         {
 
             /* get sub system information for code/volts conversion */
 
             CLOSEONERROR (olDaGetRange(board.hdass,&max,&min));
             CLOSEONERROR (olDaGetEncoding(board.hdass,&encoding));
             CLOSEONERROR (olDaGetResolution(board.hdass,&resolution));
 
            /* get max samples in input buffer */
 
            CLOSEONERROR (olDmGetValidSamples( hBuffer, &samples ) );
 
            /* get pointer to the buffer */
            if (resolution > 16)
            {
            CLOSEONERROR (olDmGetBufferPtr( hBuffer,(LPVOID*)&pBuffer32));
            /* get last sample in buffer */
            value = pBuffer32[samples-1];
            }
            else
            {
            CLOSEONERROR (olDmGetBufferPtr( hBuffer,(LPVOID*)&pBuffer));
            /* get last sample in buffer */
            value = pBuffer[samples-1];
            }
            /* put buffer back to ready list */
 
            CHECKERROR (olDaPutBuffer(board.hdass, hBuffer));
         
            /*  convert value to volts */
 
            if (encoding != OL_ENC_BINARY) 
            {
               /* convert to offset binary by inverting the sign bit */
      
               value ^= 1L << (resolution-1);
               value &= (1L << resolution) - 1;     /* zero upper bits */
            }
   
            volts = ((float)max-(float)min)/(1L<<resolution)*value + (float)min;
 
            /* display value */
   
            sprintf(str,"%.3f Volts",volts);
            SetDlgItemText (hDlg, IDD_VALUE, str);
         }
         return (TRUE);   /* Did process a message */
         
      case OLDA_WM_QUEUE_DONE:
      case OLDA_WM_QUEUE_STOPPED:
         /* using wrap multiple - if these message are received */
         /* acquisition has stopped.                            */
   
         EndDialog(hDlg, TRUE);
         return (TRUE);   /* Did process a message */
    
      case OLDA_WM_TRIGGER_ERROR:
         /* Process trigger error message */
 
         MessageBox(hDlg,"Trigger error: acquisition stopped",
                  "Error", MB_ICONEXCLAMATION | MB_OK);
         EndDialog(hDlg, TRUE);
         return (TRUE);   /* Did process a message */
        
      case OLDA_WM_OVERRUN_ERROR:
         /* Process underrun error message */
        
         MessageBox(hDlg,"Input overrun error: acquisition stopped",
                  "Error", MB_ICONEXCLAMATION | MB_OK);
         EndDialog(hDlg, TRUE);   /* Did process a message */
         return (TRUE);   /* Did process a message */
 
      case WM_COMMAND:      /* message: received a command */
 
         switch ( LOWORD(wParam) )  {
            case IDOK:
            case IDCANCEL:
               CLOSEONERROR (olDaAbort(board.hdass));
               EndDialog(hDlg, TRUE);
               return (TRUE);   /* Did process a message */
         }
         break;   
    }                               
    return (FALSE);               /* Didn't process a message */
}
 

[fj87]

Código C:

int WINAPI 
WinMain( HINSTANCE hInstance, 
         HINSTANCE hPrevInstance, 
         LPSTR lpCmdLine, 
         int nCmdShow )
/*++
This is our apps entry point.  It calls the open layers functions
to execute the required operation.
--*/
{
   DBL  freq;
   UINT size,dma,gainsup,samplesize;
   int i;
 
   UINT channel = 0;
   UINT numberADs = 0;
   UINT currentAD = 0;
   DBL gain = 1.0;
   HBUF  hBuffer = NULL;
   ECODE ec=OLNOERROR;
 
 
   board.hdrvr = NULL;
 
    // Get cmdline board
    if (lpCmdLine[0]!=0)
    {
     CHECKERROR( olDaInitialize(lpCmdLine,&board.hdrvr) );
     strcpy(board.name,lpCmdLine);
    }
    else
    {
   /* Get first available Open Layers board */
   CHECKERROR (olDaEnumBoards(GetDriver,(LPARAM)(LPBOARD)&board));
    }
   /* check for error within callback function */
 
   CHECKERROR (board.status);
 
   /* check for NULL driver handle - means no boards */
 
   if (board.hdrvr == NULL){
      MessageBox(HWND_DESKTOP, " No Open Layer boards!!!", "Error",
            MB_ICONEXCLAMATION | MB_OK);
      return ((UINT)NULL);
   }
 
   /* get handle to first available ADC sub system */
   CHECKERROR(olDaGetDevCaps(board.hdrvr,OLDC_ADELEMENTS,&numberADs));
 
    while(1)    // Enumerate through all the A/D subsystems and try and select the first available one...
   {
        ec=olDaGetDASS(board.hdrvr,OLSS_AD,currentAD,&board.hdass);
        if (ec!=OLNOERROR)
        {
        // busy subsys etc...
        currentAD++;
        if (currentAD>numberADs)
        {
            MessageBox(HWND_DESKTOP,"No Available A/D Subsystems!","Error",MB_ICONEXCLAMATION|MB_OK);
              return ((UINT)NULL);
        }
 
        }
        else
        break;
 
   }
 
   /*
      Set up the ADC - multiple wrap so we can get buffer reused
      window messages.
   */
 
   CHECKERROR (olDaGetSSCapsEx(board.hdass,OLSSCE_MAXTHROUGHPUT,&freq));
   CHECKERROR (olDaGetSSCaps(board.hdass,OLSSC_NUMDMACHANS,&dma));
   CHECKERROR (olDaGetSSCaps(board.hdass,OLSSC_SUP_PROGRAMGAIN,&gainsup));
   
   dma  = min (1, dma);            /* try for one dma channel   */ 
   freq = min (1000.0, freq);      /* try for 1000hz throughput */
 
   CHECKERROR (olDaSetDataFlow(board.hdass,OL_DF_CONTINUOUS));
   CHECKERROR (olDaSetWrapMode(board.hdass,OL_WRP_MULTIPLE));
   CHECKERROR (olDaSetClockFrequency(board.hdass,freq));
   CHECKERROR (olDaSetDmaUsage(board.hdass,dma));
   CHECKERROR (olDaSetChannelListEntry(board.hdass,0,channel));
 
   /* only set the gain if the board supports it!!! */
 
   if (gainsup)
      CHECKERROR (olDaSetGainListEntry(board.hdass,0,gain));
 
   CHECKERROR (olDaSetChannelListSize(board.hdass,1));
   CHECKERROR (olDaConfig(board.hdass));
 
   size = (UINT)freq/1;     /* 1 second buffer */
   
   /* allocate the input buffers */
   /* Put the buffer to the ADC  */
    
    CHECKERROR(olDaGetResolution(board.hdass,&samplesize));
    if (samplesize > 16)
        samplesize=4; //4 bytes...// e.g. 24 bits = 4 btyes
    else
        samplesize=2;             // e.g. 16 or 12 bits = 2 bytes
 
   for (i=0;i<NUM_BUFFERS;i++)
   {
      CHECKERROR (olDmCallocBuffer(0,0,(ULNG) size,samplesize,&hBuffer));
      CHECKERROR (olDaPutBuffer(board.hdass, hBuffer));
   }
 
   /*
      use a dialog box to collect information and error
      messages from the subsystem
   */
 
   DialogBox(hInstance, (LPCSTR)INPUTBOX, HWND_DESKTOP, InputBox);
 
   /*
      get the input buffers from the ADC subsystem and
      free the input buffers
   */
 
   CHECKERROR (olDaFlushBuffers(board.hdass));
   
   for (i=0;i<NUM_BUFFERS;i++)
   {
      CHECKERROR (olDaGetBuffer(board.hdass, &hBuffer));
      CHECKERROR (olDmFreeBuffer(hBuffer));
   }
   
   /* release the subsystem and the board */
 
   CHECKERROR (olDaReleaseDASS(board.hdass));
   CHECKERROR (olDaTerminate(board.hdrvr));
 
   /* all done - return */
 
   return ((UINT)NULL);
}
 

segunda parte.
Os agradecería enormemente algun consejo para afrontar una programación similar en python.

muchas gracias

[fj87]

Por si sirve como informacion, el modelo de la tarjeta es una data translation 304.

[AlvaroG]

Sin conocer el sistema, habría que analizar muy a fondo el archivo para poder elaborar una "traducción" a python.

Creo que los pasos que debes seguir van en este orden:
- saber qué funciones necesitás (conocer la API que brinda la biblioteca)
- cargar la biblioteca correspondiente con ctypes
- ver la lista de funciones exportadas (ctypes no puede darte esto, fijate por acá: http://stackoverflow.com/questions/2...ll-with-ctypes)
- ver cómo darle a cada función el dato que necesita

Si la opción es elaborar un wrapper, fijate por acá (fue lo primero que encontré, capaz que no es lo mejor) http://starship.python.net/crew/arce...ing/pyext.html


Saludos.

[fj87]

Hola a todos!

Tras tener un tiempo abandonado este tema debido a otros proyectos que tenia en marcha, me decidí a realizar el wrapper para la tarjeta de adquisición en codigo C.
En la elaboración del código C no he tenido problemas. A la hora de compilar la extensión, he seguido la documentacion que aparece en la pagina de python.org relativa a distutils.

Sin embargo, a la hora de ejecutar la instrucciín en linea de comandos para compilar, me aparece el siguiente error:

error: command 'dllwrap' failed with exit status 1

La instruccion para la compilación ha sido la siguiente:

python DTmodule.py build_ext --compiler=mingw32

siendo DTmodule.py un archivo generado siguiendo las instrucciones de distutils como he comentado.

He buscado información pero no he encontrado ninguna solución que pudiese servirme. ¿Alguien podría echarme una mano?

Un saludo.

[fj87]

Hola de nuevo!

Voy a autoresponderme a la duda anterior.
No he conseguido lograr la compilación empleando el módulo distutils, pero sí lo he conseguido realizando la compilación directe empleando MinGW. Para ello, la secuencia en la línea de comandos necesaria para obtener la librería .pyd es la siguiente:

gcc -shared -I"directorios de includes del archivo en c" codigo.c -L"directorios de las librerías empleadas" -l nombreslibrerias -o nombremodulo.pyd

con esto se puede conseguir sin ningun incoveniente el módulo que requeramos!

un saludo!

[fj87]

Sigo con este hilo, que ahora me ha surgido una nueva duda.

Los datos que adquiero desde la tarjeta, los almaceno en un array de C, ahora la pregunta es, ¿como puedo enviar del módulo escrito en C a mi aplicacion Python?
Necesitaria crear alguna clase?

Un saludo!