common.c

Go to the documentation of this file.

/************************************************************************************************/
/*! \file common.c
*  \brief Communicate with serial device.
*  \author $Author: jayhawk_hokie $
*  \version $Revision: 1.6 $
*  \date    $Date: 2007/08/02 23:18:28 $
************************************************************************************************/
/*!
*
************************************************************************************************/


#include "satctl.h"
#include "common.h"

/*! \brief Initialize serial port \n
 *      The presumption was that we'd always be talking
 *      exclusively to devices in 8N1.  Now, to use 2 stop bits, we had to use
 *      a define to avoid rewriting all the code that uses init_serial as it is
 *      already written.  Any major version change should incorporate an option
 *      for doing this properly in the code.
 *      @param *portfn pointer to port file name
 *      @param brate
 *      @param *portfd pointer to port file descripter 
 *      @return int 0 if successful 
*/
int init_serial(char *portfn, speed_t brate, int *portfd) {
        struct termios tty;             /* tty termios attrib structure */
        int mcs;                        /* Modem-control settings flags */

        portfd[0] = open( portfn, O_RDWR | O_NOCTTY );  /* Open the port - a more common call to open port */
        /* portfd[0] = open( portfn, O_RDWR ); */                       /* Open the port - orginally set */
        if (portfd[0] == -1) return(-1);

        tcgetattr(portfd[0], &tty);             /* Get the port attributes */
        cfsetospeed(&tty, brate);               /* Put outrate in tty struct */
        cfsetispeed(&tty, brate);               /* Put inrate in tty struct */
/* This was an oversight.  The presumption was that we'd always be talking
 * exclusively to devices in 8N1.  Now, to use 2 stop bits, we had to use
 * a define to avoid rewriting all the code that uses init_serial as it is
 * already written.  Any major version change should incorporate an option
 * for doing this properly in the code.
 */
#ifndef TSB
  tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS8;   /* Set 8 data bits */
#else
  tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS8 | CSTOPB;
                                        /* Set 8 data bits & 2 stop bits */
#endif

        /* Set raw, no echo mode */
        tty.c_iflag = (IGNBRK | IXON | IXOFF | IXANY); /* Set ingore-breaks - added for software flow control 
                (MIGHT CAUSE PROBLEMS FOR OTHER DEVICES) */
        /* tty.c_iflag = IGNBRK; */                     /* Set ingore-breaks */
        tty.c_lflag = 0;                        /* Clear local modes flag */
        tty.c_oflag = 0;                        /* Clear output modes flag */
        tty.c_cflag |= CLOCAL | CREAD;  /* Ignore modem ctrl/ enable rcvr */
        tcsetattr(portfd[0], TCSANOW, &tty);    /* Effect flags, active now */

        /* Set RTS line */
        ioctl(portfd[0], TIOCMGET, &mcs);       /* Get modem-control flags */
        mcs |= TIOCM_RTS | TIOCM_DTR;           /* Modify modem-control flags */
        ioctl(portfd[0], TIOCMSET, &mcs);       /* Put modem-control flags */

        /* Port is ready for use */
        return(0);
}

/*! \brief Send data string to serial port
 *      @param fd file descriptor for port
 *      @param *str pointer to return string
*       @return int 0 if successful 
*/
int say(int fd, char *str) {
        static int wrote;                       /* Number of bytes written */
        static int slen;                        /* Length of submitted string */

        slen = strlen(str);                     /* Get # bytes to write */
        /* Debug */  
                /*if (debug>4)
                fprintf(stderr, "writing \"%s\" (len: %d) to %d\n", str, slen+2, fd);*/
  
                /*tmp = (char *)malloc(slen+3);         * Allocate buffer accordingly */
                /*strcpy(tmp, str);                     * Copy and add 2 EOL's & a NULL */
                /*tmp[slen++] = eol[0];
                tmp[slen++] = eol[0];
                tmp[slen] = 0;
                */
 
        wrote = write(fd, str, slen);           /* Hocus Pocus !!! */
        /* TODO: Here's the first thing that could stand fixing.  This writing
        * is all but blind.  Granted, we return what we wrote, but we don't
        * loop to write the rest.  At this point, writing commands on the order
        * of 10 bytes max, this should suffice.  Later on, this routine will
        * probably need to be made more robust.
        */
        if (!wrote) perror("say():write() failed");
        /* if (debug>4)
                fprintf(stderr, "wrote %d bytes\n", wrote);
        free(tmp);*/
        return(0);
}

/*! \brief hear function reads data from serial port \n
 *      @param fd file descriptor for port
 *      @param *str pointer to return string
 *      @param maxlen maximum length of return string
 *      @param minlen minimum length of return string ( 0 = end string at character return, 
 *              !0 = minimum length)
 *      @param maxbtime maximum blocking time for select function 
 *              (select function looks for ports to read)
 *      @param term termination character to search for if minlen = 0
 *      @return int 0 if successful 
*/
int hear(int fd, char *str, int maxlen, int minlen, int maxbtime, char term) {
        int tbr = 0;                    /* Total bytes read (cumulative) */
        int i;                          /* A loop variable */
        struct timeval rtmr;            /* Time to block in select() call */
        fd_set rfds;                    /* fd set containing our port fd */
        char *ptr; 
        static char *left = NULL;
        static int useleft = 0;
        char *buffer;
        buffer = (char *) malloc(100);

        if (!left)
                left = (char *)malloc(maxlen+1);
        bzero(str, maxlen);             /* Zero out the target string (& illicit
                                         * any segfaults now in case someone didn't
                                         * properly initialize this.  Sneaky, eh?) */
        FD_ZERO(&rfds);                 /* Setup the fd set */ 
        FD_SET(fd, &rfds);

        rtmr.tv_sec = maxbtime/1000000;  /* Setup the block timer */
        rtmr.tv_usec = maxbtime - (rtmr.tv_sec * 1000000);
        /* First, check for leftovers from last time... */
        if (useleft) 
        {
                strcpy(str, left);
                tbr = strlen(left);
                left[0] = 0;
        }
  /* This is not too straightforward, but should be sufficiently sophisticated.
   * Regardless, it's complicated enough to warrant explanation.
   * This loop will run the shortest of:
   * 1) 2 un-reset loops (2 loops of maxbtime usec w/o read data)
   * 2) IF minlen, then until tbr >= minlen (i.e. minlen bytes get read)
   * 3) IF NOT minlen, then until tbr[last]=term (i.e. the term char gets read)
   * 4) maxlen characters already read
   */
  for ( i = 0;
        /* Run while i < 3 (until i reaches 3) and.... */       
        (i < 3) &&      
        /*(i < 3) && */
        /* If minlen, then while tbr < minlen, else until we get a term char */
        /*(minlen ? (tbr<minlen) : (str[tbr?(tbr-1):0]!=term) ) &&*/
        /* if minlen is false (i.e. minlen = 0) then if no terminate found then 
                do maxlen > tbr . */
        (minlen ? (tbr<minlen) : !strchr(str, term)) &&
        (maxlen > tbr) ;
        i++) 
        {
                if (select(fd+1, &rfds, NULL, NULL, &rtmr)) 
                {    /* Data to read? */
                        tbr += read(fd, str+tbr, maxlen-tbr);          /* Read returned data */
                        i = 0;
                } 
                else 
                {
                }
        }       
  if (!minlen)
          if ((ptr=strchr(str, term))) {        /* Assignment intentional */
                  if (ptr != str+tbr-1) {       /* The term character is being used, but is NOT the last character read */
                          /* strcpy(left, ptr+1); */    /* So copy the rest into the leftover buffer */
                          /* useleft = 1; */            /* Mark the marker. */
                          /* tbr -= (int)((str+tbr)-ptr);*/     /* and reduce tbr to the right value */
                          /* ptr[1] = 0; */             /* Finally, terminate the return string at the right place */
                  }
          }
  if (tbr == 0) {
    return(1);
  }
  return(0);
}

/* Do not change the comments below - they will be added automatically by CVS*/
/*****************************************************************************
*       $Log: common.c,v $
*       Revision 1.6  2007/08/02 23:18:28  jayhawk_hokie
*       Fixed Warnings.
*       
*       Revision 1.5  2006/08/11 20:07:47  bwilliam
*       Updated init_serial and hear functions. Modified so magnetometer can function.
*       
*       
*
******************************************************************************/

---