serialConnector.c

/*===================================================================== 
// arduino-serial-lib -- 
// simple library for reading/writing serial ports
//
// 2006-2013, Tod E. Kurt, http://todbot.com/blog/
//
* The MIT License (MIT)

* Copyright (c) 2014 Tod E. Kurt
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files 
* (the "Software"), to deal in the Software without restriction, 
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, 
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be 
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER  LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#include <stdio.h>    // Standard input/output definitions 
#include <unistd.h>   // UNIX standard function definitions 
#include <fcntl.h>    // File control definitions 
#include <errno.h>    // Error number definitions 
#include <termios.h>  // POSIX terminal control definitions 
#include <string.h>   // String function definitions 
#include <sys/ioctl.h>

int serialport_init(const char* serialport, int baud)
{
    struct termios toptions;
    int fd;
    
    //fd = open(serialport, O_RDWR | O_NOCTTY | O_NDELAY);
    fd = open(serialport, O_RDWR | O_NONBLOCK );
    
    if (fd == -1)  {
        perror("serialport_init: Unable to open port ");
        return -1;
    }
    
    //int iflags = TIOCM_DTR;
    //ioctl(fd, TIOCMBIS, &iflags);     // turn on DTR
    //ioctl(fd, TIOCMBIC, &iflags);    // turn off DTR

    if (tcgetattr(fd, &toptions) < 0) {
        perror("serialport_init: Couldn't get term attributes");
        return -1;
    }
    speed_t brate = baud; // let you override switch below if needed
    switch(baud) {
    case 4800:   brate=B4800;   break;
    case 9600:   brate=B9600;   break;
#ifdef B14400
    case 14400:  brate=B14400;  break;
#endif
    case 19200:  brate=B19200;  break;
#ifdef B28800
    case 28800:  brate=B28800;  break;
#endif
    case 38400:  brate=B38400;  break;
    case 57600:  brate=B57600;  break;
    case 115200: brate=B115200; break;
    }
    cfsetispeed(&toptions, brate);
    cfsetospeed(&toptions, brate);

    // 8N1
    toptions.c_cflag &= ~PARENB;
    toptions.c_cflag &= ~CSTOPB;
    toptions.c_cflag &= ~CSIZE;
    toptions.c_cflag |= CS8;
    // no flow control
    toptions.c_cflag &= ~CRTSCTS;

    //toptions.c_cflag &= ~HUPCL; // disable hang-up-on-close to avoid reset

    toptions.c_cflag |= CREAD | CLOCAL;  // turn on READ & ignore ctrl lines
    toptions.c_iflag &= ~(IXON | IXOFF | IXANY); // turn off s/w flow ctrl

    toptions.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); // make raw
    toptions.c_oflag &= ~OPOST; // make raw

    // see: http://unixwiz.net/techtips/termios-vmin-vtime.html
    toptions.c_cc[VMIN]  = 0;
    toptions.c_cc[VTIME] = 0;
    //toptions.c_cc[VTIME] = 20;
    
    tcsetattr(fd, TCSANOW, &toptions);
    if( tcsetattr(fd, TCSAFLUSH, &toptions) < 0) {
        perror("init_serialport: Couldn't set term attributes");
        return -1;
    }

    return fd;
}

/* ================================================================== */

#include "connector.h"

// global variables
int fd_serial_device;

void concatArray(unsigned char *first, int firstLen, unsigned char *second, int secondLen)
{
    int i=0;
    for (i=0;i<secondLen;i++)
    {
    first[i + firstLen] = second[i];
    }
}

void serial_blocking_read(int fd, void *buf, size_t nbytes)
{
    unsigned char tmp_buf[255];
    int counter=0;
    int curr_bytes=0;
    
    while(counter < nbytes)
    {
    curr_bytes = read(fd,tmp_buf,nbytes);
    if(curr_bytes < 1 )
        continue;
    concatArray(buf,counter,tmp_buf,curr_bytes);
    counter += curr_bytes;
    }
}

union {
    unsigned int integer;
    unsigned char byte[256];
} converter;

void copyArraySerialConn(unsigned char* src,unsigned char *dest,unsigned int len)
{
    int i=0;
    for(i=0;i<len;i++)
        dest[i]=src[i];
}

unsigned int discoverySerialImpl (discoveredDevice_t *devs)
{
    printf("Start Discovery\n");

    unsigned char message[256];
    
    message[0]= DISCOVERY;
    write(fd_serial_device,message,1);


    /*
     * 1 byte    sizeAddr   1 byte       
     * sizeAddr  |  addr  | sizeIOMsg | ...  
     *   (A)         (B)       (C)  
     *
     *    1 byte     sizeIDSen sizeIDSen   2 byte    1 byte     1 byte 
     * | sizeIDSen | num Sens | ID Sen | type Sen | size Out | type Out|
     *     (D)         (E)        (F)      (G)         (H)       (I)
     *
     *    1 byte     sizeIDAct sizeIDAct    2 byte    1 byte   1 byte
     * | sizeIDAct | num Acts | ID Act  | type Act | size In | type In |
     *    (J)         (K)         (L)        (M)        (N)       (O)  
     */

    serial_blocking_read(fd_serial_device,message,1); // (A)
    unsigned int sizeAddress = message[0];
    printf("Size Address %u\n",sizeAddress);

    serial_blocking_read(fd_serial_device,message,sizeAddress); // (B)
    //using file descriptor for address
    devs[0].address.integer=fd_serial_device;
    printf("(Address (used fd): %u)\n",message[0]);
    
    serial_blocking_read(fd_serial_device,message,1); // (C)
    devs[0].sizeIODevice=message[0];
    //printf(" %u\n",);

    serial_blocking_read(fd_serial_device,message,1); // (D)
    devs[0].sizeIDSensor=message[0];
    printf("SizeIDSensor: %u\n",devs[0].sizeIDSensor);

    serial_blocking_read(fd_serial_device,message,devs[0].sizeIDSensor); // (E)
    converter.integer=0;
    copyArraySerialConn(message,converter.byte,devs[0].sizeIDSensor);
    devs[0].numSensors=converter.integer;
    printf("Num Sensors: %u\n",devs[0].numSensors);

    unsigned int s=0;
    for(s=0;s<devs[0].numSensors;s++)
    {
        serial_blocking_read(fd_serial_device,message,devs[0].sizeIDSensor); // (F)
        converter.integer=0;
        copyArraySerialConn(message,converter.byte,devs[0].sizeIDSensor);
        devs[0].sensors[s].ID.integer=converter.integer;
        printf("Sensor ID: %u\n",devs[0].sensors[s].ID.integer);

        serial_blocking_read(fd_serial_device,message,SIZE_TYPE_SENSOR); // (G)
        converter.integer=0;
        copyArraySerialConn(message,converter.byte,SIZE_TYPE_SENSOR);
        devs[0].sensors[s].typeSensor.integer=converter.integer;
        printf("Sensor Type: %u\n",devs[0].sensors[s].typeSensor.integer);

        serial_blocking_read(fd_serial_device,message,1); // (H)
        devs[0].sensors[s].sizeOutput=message[0];
        printf("Sensor sizeOutput: %u\n",devs[0].sensors[s].sizeOutput);

        serial_blocking_read(fd_serial_device,message,1); //(I)
        devs[0].sensors[s].typeOutput=message[0];
        printf("Sensor typeOutput: %u\n",devs[0].sensors[s].typeOutput);
    }

    serial_blocking_read(fd_serial_device,message,1); // (J)
    devs[0].sizeIDActuator=message[0];
    printf("Size ID Actuator %u\n",devs[0].sizeIDActuator);

    serial_blocking_read(fd_serial_device,message,devs[0].sizeIDActuator); // (K)
    converter.integer=0;
    copyArraySerialConn(message,converter.byte,devs[0].sizeIDActuator);
    devs[0].numActuators=converter.integer;
    printf("Num Actuators %u\n",devs[0].numActuators);

    unsigned int a=0;
    for(a=0;a<devs[0].numActuators;a++)
    {
        serial_blocking_read(fd_serial_device,message,devs[0].sizeIDActuator); // (L)
        converter.integer=0;
        copyArraySerialConn(message,converter.byte,devs[0].sizeIDActuator);
        devs[0].actuators[a].ID.integer=converter.integer;

        serial_blocking_read(fd_serial_device,message,SIZE_TYPE_ACTUATOR); // (M)
        converter.integer=0;
        copyArraySerialConn(message,converter.byte,SIZE_TYPE_ACTUATOR);
        devs[0].actuators[a].typeActuator.integer=converter.integer;

        serial_blocking_read(fd_serial_device,message,1); // (N)
        devs[0].actuators[a].sizeInput=message[0];
        //printf("Act sizeInput %u\n", mesage[0]);

        serial_blocking_read(fd_serial_device,message,1); //(O)
        devs[0].actuators[a].typeInput=message[0];
        //printf("Act typeInput %u\n", message[0]);
    }
    
    return 1;

}

int checkDeviceSerialImpl ( unsigned char* addr)
{
    unsigned int ad = (addr[0] << 8) + addr[1];
    int check=0;
    if(ad == 35 || ad == 5 || ad == 500)
        check=1;
    return check;
}

void msgToDeviceSerialImpl (unsigned char* addr, unsigned char sizeData, unsigned char* data)
{
        unsigned char msg[255];
    
    msg[0] = MSG_TO_DEVICE;
    write(fd_serial_device,msg,SIZE_OPERATION);
    write(fd_serial_device,data,sizeData);
}

void msgAndAnswerToDeviceSerialImpl (unsigned char* addr, unsigned char sizeReqAns, unsigned char* request, unsigned char* answer)
{
        unsigned char msg[255];
    msg[0] = MSG_AND_ANSWER_TO_DEVICE;
    write(fd_serial_device,msg,SIZE_OPERATION);
    write(fd_serial_device,request,sizeReqAns);
    
    serial_blocking_read(fd_serial_device,answer,sizeReqAns);
}

void getSensorValueSerialImpl (unsigned char* addr, unsigned char sizeIDSen, unsigned char* IDSen, unsigned char sizeValue, unsigned char* value)
{
        unsigned char msg[255];
    msg[0] = GET_SENSOR_VALUE;
    write(fd_serial_device,msg,SIZE_OPERATION);
    write(fd_serial_device,IDSen,sizeIDSen);
    
    serial_blocking_read(fd_serial_device,value,sizeValue);
}

void setActuatorValueSerialImpl (unsigned char* addr, unsigned char sizeIDAct,unsigned char* IDAct, unsigned char sizeValue ,unsigned char* value)
{
        unsigned char msg[255];
    msg[0] = SET_ACTUATOR_VALUE;
    write(fd_serial_device,msg,SIZE_OPERATION);
    write(fd_serial_device,IDAct,sizeIDAct);
    write(fd_serial_device,value,sizeValue);
}


connectorInterface_t createSerialConnector(const char* serialport, int baud)
{
        fd_serial_device = serialport_init(serialport,baud);
    sleep(3);

    connectorInterface_t conn;

    conn.name = "SerialConnector";
    conn.sizeAddress = sizeof(int); // file descriptor
    conn.discovery = discoverySerialImpl;
    conn.checkDevice = checkDeviceSerialImpl;
    conn.msgToDevice = msgToDeviceSerialImpl;
    conn.msgAndAnswerToDevice = msgAndAnswerToDeviceSerialImpl;
    conn.getSensorValue = getSensorValueSerialImpl;
    conn.setActuatorValue = setActuatorValueSerialImpl;

    return conn;
}