SCPI on a Linux Board - Part 5a: LabVIEW Driver for LAB Switch: Open, Close and Switch functions

...add two more sections of code for making it a SCPI tree.

enum { /* list of table offsets (spells out the command) */
  __
 ,__C,__CL,__CLS
 ,__E,__ES,__ESE,__ESEs
                ,__ESEq
          ,__ESR,__ESRq
 ,__I,__ID,__IDN,__IDNq
 ,__O,__OP,__OPC,__OPCs
                ,__OPCq
 ,__R,__RS,__RST
 ,__S,__SR,__SRE,__SREs
                ,__SREq
     ,__ST,__STB,__STBq
 ,__T,__TS,__TST,__TSTq
 ,__W,__WA,__WAI
}
enum {   // list of function offsets (tasks to run)
  cb_CLS  ,cb_ESEs ,cb_ESEq ,cb_ESRq ,cb_IDNq
 ,cb_OPCs ,cb_OPCq ,cb_RST  ,cb_SREs ,cb_SREq
 ,cb_STBq ,cb_TSTq ,cb_WAI
}

and to fill in the two tables.

static struct parseNode pTbl[] = {  /* search tree */
  {'*', _C,__C,-1}
 ,{'C',__E,__CL,-1},{'L',  -1,__CLS,-1},{'S',   -1,    -1,cb_CLS}
 ,{'E',__I,__ES,-1},{'S',  -1,__ESE,-1},{'E',__ESR,__ESEs,    -1},{' ',__ESEq, -1,cb_ESEs}
                                                                 ,{'?',    -1, -1,cb_ESEq}
                                       ,{'R',   -1,__ESRq,    -1},{'?',    -1, -1,cb_ESRq}
 ,{'I',__O,__ID,-1},{'D',  -1,__IDN,-1},{'N',   -1,__IDNq,    -1},{'?',    -1, -1,cb_IDNq}
 ,{'O',__R,__OP,-1},{'P',  -1,__OPC,-1},{'C',   -1,__OPCs,    -1},{' ',__OPCq, -1,cb_OPCs}
                                                                 ,{'?',    -1, -1,cb_OPCq}
 ,{'R',__S,__RS,-1},{'S',  -1,__RST,-1},{'T',   -1,    -1,cb_RST}
 ,{'S',__T,__SR,-1},{'R',__ST,__SRE,-1},{'E',   -1,__SREs,    -1},{' ',__SREq, -1,cb_SREs}
                                                                 ,{'?',    -1, -1,cb_SREq}
                   ,{'T',  -1,__STB,-1},{'B',   -1,__STBq,    -1},{'?',    -1, -1,cb_STBq}
 ,{'T',__W,__TS,-1},{'S',  -1,__TST,-1},{'T',   -1,__TSTq,    -1},{'?',    -1, -1,cb_TSTq}
 ,{'W', -1,__WA,-1},{'A',  -1,__WAI,-1},{'I',   -1,    -1,cb_WAI}
};
static callBack cTbl[] = {  /* function links (vector table) */
  ieee_CLS  ,ieee_ESEs ,ieee_ESEq ,ieee_ESRq ,ieee_IDNq
 ,ieee_OPCs ,ieee_OPCq ,ieee_RST  ,ieee_SREs ,ieee_SREq
 ,ieee_STBq ,ieee_TSTq ,ieee_WAI
};

If you follow the logic, the function calls at each node end, will either set a flag, or return the data string.

Hi Jan,

Thanks for responding. The code I have is rather simple (small) in order to be portable and able to reside on small platforms. It starts with a simple parsing component:

struct parseNode {
 UByte c;
 SWord nx;
 SWord fn;
 SWord cb;
};

typedef UByte (*callBack)(UByte c);

static struct parseNode pTbl[] = {  /* search tree */
};
static callBack cTbl[] = {  /* function links (vector table) */
};
/**************************************************************************************************
* Serial Parser - a creation by Jack Chaney, created long ago when the earth was cooling.
*   Instead of waiting for the entire string to be entered, before parsing the instructions,
*   a state tree is used to parse the string on a per character basis as the string comes in
*   Optionally, at each node (recognized character) it is possible to route the incomming data
*   to a procedure. If the procedure returns 0 the search continues along the "found" stream.
*   If the procedure returns a 1 the search restarts at the head of the tree.
**************************************************************************************************/
void parse(UByte c) {
 UByte p;
 static SByte b = 0; 
 static SWord t = 0;
 if (isSysEchoOn()) { putCom(c); }                 /* Send the character back if echo is on */
 if (t == -1) { t = 0; b = 0; }                    /* Last pass was an end of branch, so reset to top of tree */
 p = ('a' <= c) && (c <= 'z') ? c & ~bit5 : c;     /* (optional) upper case instructions */
 if (b == 0) {                                     /* Clear flag = no more processing & last character found */
  while ((t != -1) && (pTbl[t].c != p)) { t = pTbl[t].nx; } /* Search the list for a match */
  if (t != -1) {                                  /* not end of branch, so we have found a match */
   if (pTbl[t].cb == -1) { t = pTbl[t].fn; }      /* if no process then point to next level search */
   else { b = 1; }                                /* if existing process, set flag so characters are sent there */
  }
 } else {                                         /* b is non zero, send incomming charater to linked process */
  b = cTbl[pTbl[t].cb](c);                        /* b returns: 0=complete, 1=reset, other=continue to process */
  t = b == 0 ? pTbl[t].fn : b == 1 ? -1 : t;      /* 0, point to next level search. 1, point to tree top */
 }
}

its all done in C (not C++) so it is very portable. I have source for status and measure components as well. I do not parse parameter strings and just use numeric values instead (again for size).  I can provide the pTbl tree and cTbl callout contents if you are interested.  The implementation was with a simple USB serial non blocking interface.

Jack, I've recently done a project with a SCPI parser on an Arduino UNO: Arduino in Test Instrumentation - Intro: SCPI Programmable Switch

It would be nice if you show your development here too. Heads-up: I don't do off-line exchanges.

Hokie smokes!!!  I might have some relevant information on this topic.  I have written a SCPI parser that actually runs on an Arduino Nano (reprogrammed).  I was using it for a small engine controller that I am playing with. I would love to get a chance to work with someone that is operating on the LabView side of things.  The system uses a serial parser, so there is no need for a message buffer (it parses the command a character at a time). If you are interested, let me know, and we can take the exchange off line.

Jack.

Hi Jan,

You can't beat a good bit of Labview automation and remote interfacing . I'm realling enjoying your series of blogs and am learning along the way also - thank you.

I used Labwindows CVI in the past (effectively a C version of Labview ) and managed to speed up many turgid and error prone measurement tasks plus, it never failed to impress the boss, when he visited the lab.

Rod