Subversion Repositories f9daq

#include <formatio.h>

#include <utility.h>

#include <python.h>

#include <ansi_c.h>

#include <cvirte.h>             

#include <userint.h>

#include "TestGui.h"

#include "ExportCVIFunctions.h" 

// http://www.linuxjournal.com/node/8497/print

static int pTSQData[2];

static int tfID;

CmtThreadPoolHandle threadHandle = 0;

CmtTSQHandle  queueHandle;

int panelHandle;

int ProcessUserEvent(int pID, int rID,int mode);

char strbuf[0xFF];

int mprintf(const char *format, ...) {

  va_list aptr;

  int ret,log;

  FILE *flog;

  va_start(aptr, format);

  ret = vsprintf(strbuf, format, aptr);

  va_end(aptr);

  SetCtrlVal(panelHandle,PANEL_STDIO,strbuf);

  return(ret);

}

// map uir controls ....

#define MAX_UIRCTRLMAP_SIZE 1000

typedef struct {

  char name[32];

  int id;

  int handle;

} UirCtrlMap;

UirCtrlMap gUirCtrlMap[MAX_UIRCTRLMAP_SIZE];

int gNUirCtrlMap=0;

int GetControlID(const char *ctrl) {

  for (int i=0; i<gNUirCtrlMap; i++) {

    if (strcmp(ctrl,gUirCtrlMap[i].name)==0) return ctrl,gUirCtrlMap[i].id;

  }

  return -1;

}

int GetPanelHandle(const char *ctrl) {

  if ( strstr(ctrl, "PANEL_")!= NULL ) return panelHandle;

  return 0;

}

DLLEXPORT int pySetPanelHandle(int handle) {

  panelHandle = handle;

  return 0;

}

DLLEXPORT int pySetQueueHandle(int handle) {

  queueHandle = handle;

  return 0;

}

DLLEXPORT int pySetThreadHandle(int handle) {

  threadHandle = handle;

  return 0;

}

DLLEXPORT int pyLoadUirHeader(const char *fname) {

  int ndim=MAX_PATHNAME_LEN;

  char line[MAX_PATHNAME_LEN];

  char cmd[MAX_PATHNAME_LEN];

  FILE *fp = NULL;

  ssize_t size;

  int n0= gNUirCtrlMap;

  if ( GetFileInfo(fname,&size) ) fp = fopen(fname,"r");

  if (!fp) {

    mprintf("Error! Cannot open header file %s\n",fname);

    return -1;

  }

  while (fgets(line,ndim,fp)!=NULL ) {

    char ctrl[32];

    int ctrlid;

    int nb = sscanf(line,"%s%s%d",cmd, ctrl, &ctrlid);

    if (strstr(cmd,"#define")!=NULL && nb==3) {

      strcpy(gUirCtrlMap[gNUirCtrlMap].name, ctrl );

      if (gNUirCtrlMap<MAX_UIRCTRLMAP_SIZE) {

        gUirCtrlMap[gNUirCtrlMap].id     = ctrlid;

        gUirCtrlMap[gNUirCtrlMap].handle = GetPanelHandle(ctrl);

        mprintf("%s= Ctrl '%d' Panel'%d'\n", ctrl,ctrlid, gUirCtrlMap[gNUirCtrlMap].handle);  

        gNUirCtrlMap++;

      } else {

        mprintf("ERROR: Increase gNUirCtrlMap\n");

      }

    }

  }

  fclose(fp);

  mprintf("Number of Controls loaded from File %s = %d \n", fname,gNUirCtrlMap-n0);

  return 0;

}

DLLEXPORT int pyGetCtrlVal(char *param, char *paramValue){

  int pID= GetPanelHandle(param);

  int rID= GetControlID(param);

  int datatype;

  int retval=-1;

  if (rID>0 && pID>0) {

    GetCtrlAttribute (pID, rID, ATTR_DATA_TYPE, &datatype);

    retval =  GetCtrlVal(pID, rID, paramValue);

     switch (datatype) {

      case VAL_INTEGER:

        mprintf("[GetCtrlVal]  %s value=%d panel=%d control=%d\n",param, *(int *) paramValue,pID,rID);

        break;

      case VAL_UNSIGNED_INTEGER:

        mprintf("[GetCtrlVal]  %s value=%u panel=%d control=%d\n",param, *(unsigned int *) paramValue,pID,rID);

        break;

      case VAL_SHORT_INTEGER:

        mprintf("[GetCtrlVal]  %s value=%d panel=%d control=%d\n",param, *(short *) paramValue,pID,rID);    

        break;

      case VAL_UNSIGNED_SHORT_INTEGER:

        mprintf("[GetCtrlVal]  %s value=%d panel=%d control=%d\n",param, *(unsigned short *) paramValue,pID,rID);    

        break;

      case VAL_DOUBLE :

        mprintf("[GetCtrlVal]  %s value=%f panel=%d control=%d\n",param, *(double *) paramValue,pID,rID);

        break;

      case VAL_STRING :

      default:  

        mprintf("[GetCtrlVal]  %s value=%s panel=%d control=%d\n",param, paramValue,pID,rID);

        break;

     }  

  }  

  return retval;

}  

DLLEXPORT int pyQueueUserEvent(char *param){  

  int pID= GetPanelHandle(param);

  int rID= GetControlID(param);

  int retval=-1;

  mprintf("QueueUserEvent %s panelHandle %d controlID %d\n",param, pID, rID );

  if (rID>0 && pID>0) {

    int data[2] = {pID,rID};

    mprintf("queueHandle %d\n", queueHandle );

    retval = CmtWriteTSQData (queueHandle, data, 1, TSQ_INFINITE_TIMEOUT, NULL);

  }

  return retval;

}

DLLEXPORT int pyProcessUserEvent(char *param){  

  int pID= GetPanelHandle(param);

  int rID= GetControlID(param);

  int retval=-1;

  mprintf("ProcessUserEvent %s panelHandle %d controlID %d\n",param, pID, rID );

  if (rID>0 && pID>0) retval = ProcessUserEvent(pID, rID,0);

  return retval;

}

DLLEXPORT int pySetCtrlVal(char *param, char *paramValue)

{

  int pID= GetPanelHandle(param);

  int rID= GetControlID(param);

  int datatype;

  int ret=0;

  if (rID>0 && pID>0) {

    GetCtrlAttribute (pID, rID, ATTR_DATA_TYPE, &datatype);

    switch (datatype) {

      case VAL_INTEGER:

        ret=SetCtrlVal (pID, rID, atoi(paramValue));

        break;

      case VAL_UNSIGNED_INTEGER:

        ret=SetCtrlVal (pID, rID, strtoul(paramValue,NULL,0));

        break;

      case VAL_SHORT_INTEGER:

        ret=SetCtrlVal (pID, rID, atoi(paramValue));

        break;

      case VAL_UNSIGNED_SHORT_INTEGER:

        ret=SetCtrlVal (pID, rID, strtoul(paramValue,NULL,0));

        break;

      case VAL_DOUBLE :

        ret=SetCtrlVal (pID, rID, atof(paramValue));

        break;

      case VAL_STRING :

        ret=SetCtrlVal (pID, rID, paramValue      );

        break;

      default:

        mprintf("[SetCtrlVal] ATTR_DATA_TYPE of the %s not supported datatype %d\n", param, datatype);

    }

    mprintf("[SetCtrlVal]  %s %s panel=%d control=%d\n",param, paramValue,pID,rID);

  } else {

    mprintf("[SetCtrlVal] Invalid Ctrl %s %s panel=%d control=%d  nctrls=%d\n",param, paramValue,pID,rID,gNUirCtrlMap);

  }

  return  ret;

}

DLLEXPORT int pyPrint(int panel)

{

  mprintf("Hi! %d\n", panel);

  //return  SetCtrlVal(panel, ctrl,text );  

  return 0;

}

void CVICALLBACK QueueUserEventCallback (CmtTSQHandle queueHandle, unsigned int event, int value, void *callbackData) {

  int *data= (int *)  callbackData;

  int mdata[2];

  CmtReadTSQData (queueHandle, mdata, 1, 0, 0);

  mprintf("QueueUserEvent --->Thread Safe Queue  %d %d\n", mdata[0],mdata[1]);

  QueueUserEvent (1001, mdata[0], mdata[1]);

}

int CVICALLBACK Test(void *functionData)

{

  mprintf("Test\n");

  return 0;

}

int CVICALLBACK ExecPython(void *functionData)

{

  char *argv="testgui.py";

  int argc=1;

  Py_Initialize();

  mprintf("Py_Main() %d\n", Py_Main(argc, &argv));

  Py_Finalize();

  return 0;

}

int cRunPython = 0;

int CVICALLBACK RunPython(void *functionData)

{

  char *fname="testgui.py";

  char handles[0xFF];

  int argc=0, merr=0;

  char *argv = "TestGui.exe";

  while ( cRunPython ) {

    mprintf("RunPython not finished yet... Waiting ....\n");

    Delay(0.5);// To Ensure only one python interpreter is running    

  }

  cRunPython = 1;

  Py_Initialize();

  mprintf("Py_IsInitialized(); %d\n", Py_IsInitialized());

  mprintf("Py_GetVersion() %s\n",   Py_GetVersion() );

  PyRun_SimpleString("import sys\n");

  PyRun_SimpleString("sys.stdout = sys.stderr = open(\"log_file.txt\", \"w\")\n" );

  sprintf(handles, "panel=%d\nqueue=%d\n", panelHandle, (int) queueHandle);

  mprintf(handles);

  PyRun_SimpleString(handles);

  PyRun_SimpleString(

    "print('Example , how to use python from NI LWCVI')\n"

    "from time import time,ctime\n"

    "print( 'Today is',ctime(time()))\n"

  );

  PyObject *obj = Py_BuildValue("s", fname);

  FILE *fp = _Py_fopen_obj(obj, "r+");

  //fp = fopen(fname,"r");  // tole ne dela

  if(fp != NULL) merr = PyRun_SimpleFile(fp, fname);

  mprintf("PyRun_SimpleFile(%s) %d ---->output\n",fname, merr);

  Py_Finalize();

  char line[MAX_PATHNAME_LEN];

  FILE *fpout= fopen("log_file.txt","r");

  if (fpout) {

    while (fgets(line,MAX_PATHNAME_LEN,fpout)!=NULL) mprintf(line);

    fclose(fpout);

  }

  cRunPython = 0;

        return 0;

}

void SetDimming(int state) {

  mprintf("SetDimming %d\n", state);  

  SetCtrlAttribute (panelHandle, PANEL_START, ATTR_DIMMED, state);

  SetCtrlAttribute (panelHandle, PANEL_INTERPRETER, ATTR_DIMMED, state);  

  SetCtrlAttribute (panelHandle, PANEL_TEST, ATTR_DIMMED, state);  

}

int nthreads=0;

void CVICALLBACK EndOfThread ( CmtThreadPoolHandle poolhandle,

                               CmtThreadFunctionID functionID, unsigned int event,

                               int value, void *callbackData  ) {

  mprintf("%d End of Thread handle=%d functionID=%d\n", nthreads, (int)poolhandle, functionID);

  nthreads--;

  if (!nthreads) SetDimming(0);

  return ;

}

int ProcessUserEvent(int pID, int rID,int mode){

  ThreadFunctionPtr thread = NULL;

  int retval=0;

  switch (rID) {

    case PANEL_START:

      thread=RunPython;

      break;

    case PANEL_INTERPRETER:

      thread=ExecPython;

      break;

    case PANEL_TEST:

      thread=Test;

      break;

    case PANEL_EXIT :

      return 1;

    default:

      mprintf("Unknown Event panel %d control %d\n",pID,rID);

  }

  if (thread!=NULL) {

    if (mode) {

      SetDimming(1);  

      mprintf("%d ProcessUserEvent in new Thread panel=%d button=%d mode=%d\n",nthreads, pID, rID, mode);

      retval = CmtScheduleThreadPoolFunctionAdv (threadHandle, thread, &rID,

               DEFAULT_THREAD_PRIORITY,

               EndOfThread,

               EVENT_TP_THREAD_FUNCTION_END,

               NULL, RUN_IN_SCHEDULED_THREAD,

               &tfID);

      if (retval<0) {

        char txt[MAX_PATHNAME_LEN];

        CmtGetErrorMessage(retval, txt);

        MessagePopup("CmtScheduleThreadPoolFunctionAdv", txt);

      } else nthreads++;

    } else {

      mprintf("ProcessUserEvent panel=%d button=%d mode=%d\n", pID, rID, mode);

      thread(NULL);

    }

  }

  ProcessSystemEvents();

  return retval;

}  

int main (int argc, char *argv[])

{

        if (InitCVIRTE (0, argv, 0) == 0)

                return -1;      /* out of memory */

        if ((panelHandle = LoadPanel (0, "TestGui.uir", PANEL)) < 0)

                return -1;

  //pyLoadUirHeader("TestGui.h"); 

  int status=0;

  CmtNewThreadPool (10,  &threadHandle);  

  if ( status = CmtNewTSQ (1, 2*sizeof(int), OPT_TSQ_AUTO_FLUSH_ALL, &queueHandle) <0)

    mprintf("CmtNewTSQ cannot be installed\n");

  else {

    mprintf("CmtNewTSQ handle %d\n", (int) queueHandle );

  }

  if ( status = CmtInstallTSQCallback (queueHandle, EVENT_TSQ_ITEMS_IN_QUEUE, EVENT_TSQ_QUEUE_SIZE,

                                       QueueUserEventCallback, pTSQData, CmtGetCurrentThreadID(), NULL)  <0)

    mprintf("CmtInstallTSQCallback cannot be installed\n");  ;

        DisplayPanel (panelHandle);

  int pID, rID, retval;

  do {

    GetUserEvent (1, &pID, &rID);  

    retval = ProcessUserEvent(pID,rID,1);

  } while (!retval);

  CmtDiscardThreadPool (threadHandle);

        DiscardPanel (panelHandle);

        return 0;

}

/*

static PyObject * SetCtrlVal_wrapper(PyObject * self, PyObject * args)

{

  char * input;

  char result[0xFF];

  PyObject * ret;

  // parse arguments

  if (!PyArg_ParseTuple(args, "s", &input)) {

    return NULL;

  }

  // run the actual function

  int retval = SetCtrlVal(panelHandle, PANEL_TXT,input );

  sprintf(result,"%d", retval);

  // build the resulting string into a Python object.

  ret = PyBytes_FromString(result);

  free(result);

  return ret;

}

static PyMethodDef module_methods[] = {

    {"fib",(PyCFunction) SetCtrlVal_wrapper, METH_VARARGS,"Outputs the text to the PANEL_TXT"},

    {NULL,NULL,0,NULL}

};

static struct PyModuleDef cModPyDem =

{

    PyModuleDef_HEAD_INIT,

    "SetCtrlVal", // name of module

    "",          // module documentation, may be NULL

    -1,          // size of per-interpreter state of the module, or -1 if the module keeps state in global variables.

    module_methods

};

PyMODINIT_FUNC PyInit_cModPyDem(void)

{

    return PyModule_Create(&cModPyDem);

}

*/