---

pcomm.cpp

/*
   Copyright (C) 1999 PolyWog and Javaman for Ghetto.Org
   This file is part of the PCR-1000 API Library.

   The PCR-1000 API Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   The PCR-1000 API Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the PCR-1000 API Library; see the file LICENSE.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.
 */

#if defined (SunOS) || defined (Irix)
#include <strings.h>
#else if defined (BSD) || defined (Linux)
#include <string.h>     /* bzero(), strcpy(), strcpy() etc... */
#endif
#include <assert.h> /* assert() */
#include "pcomm.h"

PComm :: PComm (char *pcrDev, tcflag_t baudRate, const char *name)
{
    if (name==NULL) {
        strcpy(int_name, "PComm_Obj");
    } else {
        strcpy(int_name, name);
    }

    callCount=0;
    bzero(pcrDevice, sizeof(pcrDevice));
    strncpy(pcrDevice, pcrDev, sizeof(pcrDevice)-1);
    pcrSpeed = baudRate;

    if (!PCOpen(pcrDev, baudRate))
        { exit(-1); }

}
PComm :: ~PComm ()
{
        PCClose();

#ifdef DEBUG_VER_
    fprintf(stderr, "%s: Destroyed\n", int_name);
#endif // DEBUG_VER_ //
}
bool PComm :: PCOpen(const char *pcrDev, tcflag_t baudRate)
{

    /* Open modem device for reading and writing and not as controlling tty
       because we don't want to get killed if linenoise sends CTRL-C.  */
    fd = open(pcrDev, O_RDWR | O_NOCTTY );
    if (fd <0) {
                perror(pcrDev); 
                return false; 
#ifdef DEBUG_VER_
        } else {
                fprintf(stderr, "PCOMM: PCOpen(%s, %ld): Success at %d\n", 
                        pcrDev, baudRate, fd);
#endif // DEBUG_VER_
        }       
        

    oldtio      = new termios;
    newtio      = new termios;


        // functions necessary to initialise socket sets for
        // use with the select() function(s).
        timeOut = new timeval;
        FDSet   = new fd_set;
        // clear out that memory.
        bzero(timeOut, sizeof(struct timeval));
        bzero(FDSet, sizeof(fd_set));
        // remove any socket descriptors if necessary
        // and add socket 'fd' to the FDSet
        FD_ZERO(FDSet);
        FD_SET(fd, FDSet);
        // set default timeout values to five seconds
        timeOut->tv_sec  = 5;
        timeOut->tv_usec = 0;
        // now we should be ready to use the select() statement.
        // just make sure that if the socket `fd' is closed
        // to repopulate the fd_set and to call select with
        // fd+1 as the first arg

    tcgetattr(fd,oldtio); /* save current serial port settings */
    bzero(newtio, sizeof(struct termios));

    /*
       BAUDRATE: Set bps rate. use cfsetispeed and cfsetospeed.
       CLOCAL  : local connection, no modem contol
       CREAD   : enable receiving characters
       ~HUPCL  : dont reset DTR to low when program finishes
       ~PARENB : dont enable parity bits
       ~CSTOPB : no stop bits
       ~CSIZE  :
       CS8     : 8n1 (8bit,no parity,1 stopbit)
     */
    cfsetispeed( newtio, baudRate );
    cfsetospeed( newtio, baudRate );
    newtio->c_cflag |=  (CLOCAL | CREAD);
    newtio->c_cflag &= ~HUPCL ;
    newtio->c_cflag &= ~PARENB ;
    newtio->c_cflag &= ~CSTOPB ;
    newtio->c_cflag &= ~CSIZE;
    newtio->c_cflag |= CS8;

    /* ICANON  : enable canonical input disable all echo functionality,
                 and don't send signals to calling program */
    newtio->c_lflag |= ICANON;
    newtio->c_lflag &= ~(ECHO | ECHOCTL);

    /* Raw output.  */
    newtio->c_oflag &= ~OPOST;

    /* now clean the modem line and activate the settings for the port */
    /* tcflush(fd, TCIFLUSH); */
    tcsetattr(fd,TCSANOW,newtio);

    return true;
}
void PComm :: PCClose()
{
    close(fd);

    /* restore the old port settings */
    tcsetattr(fd,TCSANOW,oldtio);
    delete oldtio;
    delete newtio;

    FD_ZERO(FDSet);
    delete FDSet;
    delete timeOut;   

}
size_pc PComm :: PCTell(char *mesg)
{
    #ifdef DEBUG_VER_
    fprintf(stderr, "Tell: %s\n", mesg);
    #endif /* DEBUG_VER_ */

    return (Write(mesg));
}
size_pc PComm :: PCAsk(char *mesg)
{
    #ifdef DEBUG_VER_2
    fprintf(stderr, "Ask: %s\n", mesg);
    assert(mesg!=0);
    assert(strlen(mesg)==2);
    #endif /* DEBUG_VER_ */

    bzero(askBuf, sizeof(askBuf));
    strcpy(askBuf, mesg);
    strcat(askBuf, PCRQST);

    return (Write(askBuf)-1);
}
size_pc PComm :: PCHear(char *mesg)
{
    char *cut;

    #ifdef DEBUG_VER_2
    assert(mesg != 0);
    fprintf(stderr, "PComm: PCHEAR \n");
    #endif /* DEBUG_VER_ */

    hearCtr=0;
    bzero(hearBuf, sizeof(hearBuf));
    bzero(mesg, sizeof(mesg));

    hearCtr = Read(hearBuf);
    cut=strpbrk(hearBuf, PCRECMD);
    if (cut!=NULL) { 
        *cut=0; 
        hearCtr -= 2;
    }
        
    strcpy(mesg, hearBuf); 
    
    #ifdef DEBUG_VER_2
    fprintf(stderr, "Hear: %s\n", mesg);
    #endif /* DEBUG_VER_ */

        if (errRead) {
                return (-1);
        } else { 
                return (hearCtr);
        }

}
size_pc PComm :: PCRawWrite(char *mesg)
{

    bzero(writeBuf, sizeof(writeBuf));
    strcpy(writeBuf, mesg);

    if (select(fd+1, NULL, FDSet, NULL, timeOut)) {
        writeCtr = write(fd, writeBuf, strlen(writeBuf));
    } else {
#ifdef DEBUG_VER_
            fprintf(stderr, "PCRawWrite Time Out on socket %d\n", fd);
#endif // DEBUG_VER_ 
        writeCtr = 0;
    }

    if ((unsigned)writeCtr!=strlen(writeBuf)) {
        return (-1);
    }

    return writeCtr;
   
}
size_pc PComm :: PCRawRead(char *mesg)
{
    readCtr = 1;

    bzero(readBuf, sizeof(readBuf));
    bzero(readBuf, sizeof(mesg));

    while(readCtr==1) {
        if (select(fd+1, FDSet, NULL, NULL, timeOut)) {
                readCtr= read(fd, readBuf, sizeof(readBuf));
                strcpy(mesg, readBuf);
        } else {
                readCtr=(-1);
#ifdef DEBUG_VER_
            fprintf(stderr, "PCRawRead Time Out on socket %d\n", fd);
#endif // DEBUG_VER_ 

        }
    }

    return readCtr;
}
size_pc PComm :: Write(char *submesg)
{
    int __writeCtr;

    bzero(writeBuf, sizeof(writeBuf));
    strcpy(writeBuf, submesg);
    strcat(writeBuf, PCRECMD);

    #ifdef DEBUG_VER_2
    fprintf(stderr, "Write Attempt: %s\n", writeBuf);
    #endif /* DEBUG_VER_ */

    if (select(fd+1, NULL, FDSet, NULL, timeOut)) {
                __writeCtr=write(fd, writeBuf, strlen(writeBuf));
    } else {
#ifdef DEBUG_VER_
            fprintf(stderr, "Write() Time Out on socket %d\n", fd);
#endif // DEBUG_VER_ 
            __writeCtr=0;
    }

    return (__writeCtr-2);
}
size_pc PComm :: Read(char *submesg)
{
    readCtr=1;
    int loopBreaker=0;

#ifdef DEBUG_VER_2
    assert(submesg!=0);
    fprintf(stderr, "PComm: READ");
#endif /* DEBUG_VER_ */

    bzero(readBuf, sizeof(readBuf));
    bzero(submesg, sizeof(submesg));

    while((readCtr==1) && (loopBreaker<10)) {
        if (select(fd+1, FDSet, NULL, NULL, timeOut)) {
                readCtr=read(fd, readBuf, sizeof(readBuf));
                // call Count keeps track of the number of
                // read()/writes() to the serial object
                    countCall();
                loopBreaker++;
        } else {
#ifdef DEBUG_VER_
                fprintf(stderr, "Read() Time Out on socket %d\n", fd);
#endif // DEBUG_VER_ //
                    readCtr=1;
                errRead=true;
                loopBreaker++;
        }
    }

    /* 
       Was there an error reading? ie: after five
       loops, did we still read in new lines (in other
       words, did the radio have nothing to tell us?)
       Then we should have never been called, and set
       errRead appropriately.
     */
    (readCtr==1)?(errRead=true):(errRead=false);

    strcpy(submesg, readBuf);

    #ifdef DEBUG_VER_2
    fprintf(stderr, "\nRead: %i -  %s\n", readCtr, submesg);
    #endif /* DEBUG_VER_ */

    return readCtr;

}
void PComm :: resetCall()
{
#ifdef DEBUG_VER_2
        fprintf(stderr, "PCOMM: resetCall() @ %d \n", callCount);
#endif DEBUG_VER_2
        callCount=0;
        int __readCounter=0;
        int __loopbreaker=0;
        
        PCClose();
        PCOpen(pcrDevice, pcrSpeed);
        bzero(callBuf, sizeof(callBuf));
        strncpy(callBuf, PCRPWRON, sizeof(callBuf)-1);
        strncat(callBuf, PCRECMD,  ((sizeof(callBuf))-(strlen(callBuf))-1));
        if (select(fd+1, NULL, FDSet, NULL, timeOut)) {
        write(fd, callBuf, strlen(callBuf));
            if (select(fd+1, NULL, FDSet, NULL, timeOut)) {
                bzero(callBuf, sizeof(callBuf));
                while ((__readCounter==1) && (__loopbreaker<10)) {
                    __readCounter = read(fd, callBuf, sizeof(callBuf));
                    __loopbreaker++;
                }
#ifdef DEBUG_VER_
            } else {
               // we should never have gotten here, if so, we are fubar'd
               // and should abort the program
                fprintf(stderr, "Read failed in PCOMM: resetCall()");
                fprintf(stderr, "***UNRECOVERABLE ERROR***");
                abort();
#endif // DEBUG_VER_
            }
#ifdef DEBUG_VER_
        } else {
            // we should never have gotten here, if so, we are fubar'd
            // and should abort the program
                fprintf(stderr, "Write failed in PCOMM: resetCall()");
        fprintf(stderr, "***UNRECOVERABLE ERROR***");
        abort();
#endif // DEBUG_VER_
        }
}
void PComm :: countCall()
{
        if (callCount<200) {
                callCount++;
        } else {
                resetCall();
        }

#ifdef DEBUG_VER_2
        fprintf(stderr, "PCOMM: countCall() %d\n", callCount);
#endif // DEBUG_VER_
}       

---