sercom.c

/*
 * @(#)sercom.c       07/07/28
 * 
 * Description  : Library to simplify the serial communication.
 *      Inspired by:
 *      http://tldp.org/HOWTO/Serial-Programming-HOWTO/x115.html
 *
 * License      : GNU GPL v.2
 * Contacts     : Tran Duy Khanh (www.tran.cz)
 */

#include <sys/signal.h>
#include <termios.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <string.h>
#include <stdlib.h>
#include <asm-x86_64/types.h>
#include "sercom.h"

unsigned char sercom_wait_flag = 1;

void sercom_sighandler(int status)
{
        /*printf("received SIGIO signal.\n");*/
        sercom_wait_flag = 0;
}

long sercom_get_baudrate(unsigned int baudrate)
{
        long br;
        switch (baudrate) {
                case 38400:
                        br  = B38400;
                        break;
                case 19200:
                        br  = B19200;
                        break;
                case 9600:
                        br  = B9600;
                        break;
                case 4800:
                        br  = B4800;
                        break;
                case 2400:
                        br  = B2400;
                        break;
                case 1800:
                        br  = B1800;
                        break;
                case 1200:
                        br  = B1200;
                        break;
                case 600:
                        br  = B600;
                        break;
                case 300:
                        br  = B300;
                        break;
                case 200:
                        br  = B200;
                        break;
                case 150:
                        br  = B150;
                        break;
                case 134:
                        br  = B134;
                        break;
                case 110:
                        br  = B110;
                        break;
                case 75:
                        br  = B75;
                        break;
                case 50:
                        br  = B50;
                        break;
                default:
                        br = B19200;
        }

        return br;
}

long sercom_get_databits(int databits)
{
        long db;
        switch (databits) {
                case 8:
                default:
                        db = CS8;
                        break;
                case 7:
                        db = CS7;
                        break;
                case 6:
                        db = CS6;
                        break;
                case 5:
                        db = CS5;
                        break;
        }
        return db;
}

long sercom_get_stopbits(int stopbits)
{
        long sb;
        switch (stopbits) {
                case 1:
                default:
                        sb = 0;
                        break;
                case 2:
                        sb = CSTOPB;
                        break;
        }
        return sb;
}

long sercom_get_parity(int parity)
{
        long par, paron;
        switch (parity) {
                /* none */
                case 0:
                default:
                        paron = 0;
                        par = 0;
                        break;
                /* odd */
                case 1:
                        paron = PARENB;
                        par = PARODD;
                        break;
                /* even */
                case 2:
                        paron = PARENB;
                        par = 0;
                        break;
        }
        return (par|paron);
}

void sercom_open(struct sercom_data *sercom)
{

        /* open the device(com port) to be non-blocking (read will return 
         * immediately) */
        if (sercom->devname[0] == 0)
                strcpy((char *)&sercom->devname, SERCOM_DEFAULT_DEV);
        sercom->fd = open(sercom->devname, O_RDWR | O_NOCTTY | O_NONBLOCK);
        if (sercom->fd < 0) {
                perror(sercom->devname);
                exit(-1);
        }

        /* install the serial handler before making the device asynchronous */
        sercom->saio.sa_handler = sercom_sighandler;
        sercom->saio.sa_flags = 0;
        sercom->saio.sa_restorer = NULL;
        sigemptyset(&sercom->saio.sa_mask);   
        sigaction(SIGIO, &sercom->saio, NULL);
        
        /* allow the process to receive SIGIO */
        fcntl(sercom->fd, F_SETOWN, getpid());
        /* Make the file descriptor asynchronous (the manual page says only
         * O_APPEND and O_NONBLOCK, will work with F_SETFL...) */
        fcntl(sercom->fd, F_SETFL, FASYNC);
        /* save current serial port settings */
        tcgetattr(sercom->fd, &sercom->oldtio);
        memset(&sercom->newtio, 0, sizeof(sercom->newtio));

        sercom->newtio.c_cflag = sercom_get_baudrate(sercom->baudrate) |
                        sercom_get_databits(sercom->databits) |
                        sercom_get_stopbits(sercom->stopbits) |
                        sercom_get_parity(sercom->parity) |
                        CRTSCTS | CLOCAL | CREAD;
        sercom->newtio.c_iflag = IGNPAR | ICRNL;
        sercom->newtio.c_oflag = 0;
        sercom->newtio.c_lflag = ICANON;
        /* blocking read until one character arrives */
        sercom->newtio.c_cc[VMIN] = 1;
        sercom->newtio.c_cc[VTIME] = 0; /* inter-character timer unused */
        /* clean the modem line and activate the settings for the port */
        tcflush(sercom->fd, TCIFLUSH);
        tcsetattr(sercom->fd, TCSANOW, &sercom->newtio);
}

ssize_t sercom_read(struct sercom_data *sercom, char *buf, ssize_t buflen)
{
        ssize_t len = -1;

        if (sercom_wait_flag == 0) {
                len = read(sercom->fd, buf, buflen);
                buf[len] = 0;
                sercom_wait_flag = 1;
        }

        return len;
}

void sercom_close(struct sercom_data *sercom)
{
        /* restore the old port settings */
        tcsetattr(sercom->fd, TCSANOW, &sercom->oldtio);
        close(sercom->fd);
}

---