minst.c

Atheros AP Test with Agilent N4010A source code

	// reset error byte
	nComErr = 0;
	if (!fConnected) return 0;
	// connection flag
	fConnected = 0;
	
	tcsetattr(fd,TCSANOW,&oldtio);
	
	close(fd);	
	
	return 0;
}

unsigned long com_write(const HANDLE fd, char *wrt) 
{
	unsigned long cnt;

	// reset error byte
	nComErr = 0;

	// write the com port
	cnt = write(fd,wrt,strlen(wrt));
	if (!cnt) {
		nComErr = nComErr | COM_ERROR_WRITE;
	}
	
	return cnt;
}

char *com_read(HANDLE fd) 
{
	static char   rd[50];
	unsigned long dwCommEvent;
	unsigned long dwRead, pos = 0;
	char          chRead;

	// reset error byte
	nComErr = 0;

	do {
			// read receive buffer
			if (read(fd, &chRead, 1)) {
				rd[pos] = chRead;
				pos++;
			} else {
				nComErr = nComErr | COM_ERROR_READ;
				return '\0';
			}
	} while (chRead != 0x06); // stop reading at termination character
    rd[pos] = '\0';
    return rd;
}		
#endif
char *temp_ctrl_checksum(char *buf) {

    unsigned long i, num = 0;
    static char cksm[3];

    for (i = 0; i < strlen(buf); i++) {
        num += buf[i];
    }

    sprintf(cksm, "%2X", 0xff & num);
    return cksm;

}

MANLIB_API unsigned long tempOpen(char *port, const int model) {
    return (unsigned long)com_open(port, model);
}

MANLIB_API int tempClose(const unsigned long ud) {
    return com_close((HANDLE)ud);
}

MANLIB_API double tempMeasTemp(const unsigned long ud) {
    char hdr[5];
    char seed[5];
    char *cksm;
    char pkt[10];
    char *rsp;
    unsigned long cnt, pos;
    double point;
    int sign;
    char value[5]={0,0,0,0,0};

    // determine the header to be transmitted
    sprintf( hdr, "%c%c%02d", STX,
                              TEMP_CTRL_PREAMBLE,
                              TEMP_CTRL_ADDRESS);

    // create seed for checksum string
    sprintf( seed, "%02d%02d", TEMP_CTRL_ADDRESS, TEMP_CTRL_MEAS_TEMP );

    // calculate checksum
    cksm = temp_ctrl_checksum(seed);

    // create final packet
    sprintf( pkt, "%4s%02d%2s%c", hdr, 
                                  TEMP_CTRL_MEAS_TEMP,
                                  cksm,
                                  ETX );

    // send final packet
    cnt = com_write((HANDLE)ud, pkt);

    // check for errors
    sleep(200);
    rsp = com_read((HANDLE)ud);

    pos = strlen(hdr);

	if ((rsp == NULL) || ( rsp[pos] == 'N' )) return 0;
    //if ( rsp[pos] == 'N' ) return 0;
    else {
        point = pow(10, -1 * (rsp[pos + 2] & 0x3) );
        sign  = ( rsp[pos + 3] & 0x1 ? -1 : 1 );
        strncpy( value, rsp + pos + 4, 4);

        return sign * atof(value) * point;
    }
}

MANLIB_API unsigned long tempSet(const unsigned long ud, const int setpoint) {
    
    char hdr[5];
    char data[7];
    char seed[13];
    char *cksm;
    char pkt[18];
    char *rsp;
    unsigned long cnt, pos;
    // determine the header to be transmitted
    sprintf( hdr, "%c%c%02d", STX,
                              TEMP_CTRL_PREAMBLE,
                              TEMP_CTRL_ADDRESS);
    // determine pieces of packet to be transmitted
    sprintf( data, "%04d%02d", abs(setpoint) * 10, ( setpoint < 0 ? 11 : 0 ) );

    // create seed for checksum string
    sprintf( seed, "%02d%04d%6s", TEMP_CTRL_ADDRESS, TEMP_CTRL_SET_TEMP, data );

    // calculate checksum
    cksm = temp_ctrl_checksum(seed);

    // create final packet
    sprintf( pkt, "%4s%04d%6s%2s%c", hdr, 
                                     TEMP_CTRL_SET_TEMP,
                                     data,
                                     cksm,
                                     ETX );

    // send final packet
    cnt = com_write((HANDLE)ud, pkt);

    // check for errors
    sleep(200);
    rsp = com_read((HANDLE)ud);
    pos = strlen(hdr);

    if ((rsp == NULL) || ( rsp[pos] == 'N' )) return 0;
    else return cnt;
    
}

char *ps_channel(const int channel) {

    // convert enum to string
    switch (channel) {
        case PS_P25V :
            return "P25V";
        case PS_N25V :
            return "N25V";
        case PS_P6V :
        default :
            return "P6V";
    }

}

MANLIB_API int psInit(const int adr, const int model) {

    ps = ibdev (0, adr, 0, T30s, 1, 0);
    ps_model = model;
    return ps;

}

MANLIB_API int psSetOutputState(const int ud, const int on_off) {

    gpibWrite( ud, qq( "OUTP %d", ( on_off == 0 ? 0 : 1 ) ) );
    return 1;

}

MANLIB_API int psSetVoltage(const int ud, 
                          const int channel, 
                          const double voltage,
                          const double current_limit) {

    gpibWrite( ud, qq("APPL %s,%.2f,%.3f", 
                     ps_channel(channel), voltage, current_limit) );
    return 1;

}

MANLIB_API double psMeasCurrent(const int ud, const int channel) { 

    return atof( gpibQuery( ud, qq("INST:NSEL %d;:MEAS:CURR?",channel), 20L ) );

}

char *att_code_110(const int value) {

    int i, yatten, xatten, extra;
    static char on[20]   = "A";        // on bits
    char        off[10]  = "B",        // off bits 
                digit[9] = "12345678"; // digits for strncat
    int         atten    = value;      // copy input

    // initialize string
    on[1] = '\0';

    // check for out of bounds
    if (atten <  0) atten = 0;
    if (atten > 121) atten = 121;

    // extract tens and ones place
    yatten = atten / 10;
    xatten = atten % 10;
    extra  = ( yatten >= 12 ? yatten - 11 : 0 );

    // carry y extra 
    yatten -= extra;
    xatten += extra * 10;

    // handle extra 40 dB with 110 dB switch
    if ( yatten > 7 ) { yatten -= 4 ; strncat(on, strchr(digit,'8'),1); }
    else                              strncat(off,strchr(digit,'8'),1);

    // build y string
    for (i = '7'; i >= '5'; i--) {

        ( yatten & 4 ? strncat(on, strchr(digit,i),1)
                     : strncat(off,strchr(digit,i),1) );
        yatten <<= 1;

    }

    // handle y extra carried over + 4th bit weighting
    if ( xatten > 7 ) { xatten -= 4 ; strncat(on, strchr(digit,'4'),1); }
    else                              strncat(off,strchr(digit,'4'),1);
    
    // build remaining x string
    for (i = '3'; i >= '1'; i--) {

        ( xatten & 4 ? strncat(on, strchr(digit,i),1)
                     : strncat(off,strchr(digit,i),1) );
        xatten <<= 1;

    }

    return strcat(on,off);

}

char *att_code(const int value) {

    int i, yatten, xatten, extra;
    static char on[20]   = "A";        // on bits
    char        off[10]  = "B",        // off bits 
                digit[9] = "12345678"; // digits for strncat
    int         atten    = value;      // copy input

    if (att_model == ATT_11713A_110) {
      return(att_code_110(value));
    }

    // initialize string
    on[1] = '\0';

    // check for out of bounds
    if (atten <  0) atten = 0;
    if (atten > 81) atten = 81;

    // extract tens and ones place
    yatten = atten / 10;
    xatten = atten % 10;
    extra  = ( yatten >= 8 ? yatten - 7 : 0 );

    // carry y extra 
    yatten -= extra;
    xatten += extra * 10;

    // build y string
    for (i = '8'; i >= '5'; i--) {

        ( yatten & 8 ? strncat(on, strchr(digit,i),1)
                     : strncat(off,strchr(digit,i),1) );
        yatten <<= 1;

    }

    // handle y extra carried over + 4th bit weighting
    if ( xatten > 7 ) { xatten -= 4 ; strncat(on, strchr(digit,'4'),1); }
    else                              strncat(off,strchr(digit,'4'),1);
    
    // build remaining x string
    for (i = '3'; i >= '1'; i--) {

        ( xatten & 4 ? strncat(on, strchr(digit,i),1)
                     : strncat(off,strchr(digit,i),1) );
        xatten <<= 1;

    }

    return strcat(on,off);

}

MANLIB_API int attInit(const int adr, const int model) {

    att = ibdev (0, adr, 0, T30s, 1, 0);
    att_model = model;
    return att;

}

MANLIB_API int attSet(const int ud, const int value) {

    gpibWrite(ud, att_code(value));
    return 1;

}

MANLIB_API int pmInit(const int ud, const int model) {

	if (model == NRP_Z11) {
		pm_model = model;
#ifndef LINUX
		reset_nrp();