Interfacing RFID reader with ZKit-ARM-1769

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <stdio.h>

/* UART(P2) device path by default - RFID reader is connected to this port */
#define PORT "/dev/ttyS1"

#define RFID_START_CHAR '\n'
#define RFID_STOP_CHAR  '\r'
#define RFID_SIZE       10
/**
 * rfid_init - initialize RFID reader
 *
 * Initializes the RFID reader serial interface and returns the
 * serial port file descriptor.
 *
 * Returns:
 *   serial port fd on success.
 *   -1 on failure, errno is set accordingly.
 */
static int rfid_init(void)
{
        struct termios options;
        speed_t speed;
        int fd;
        int ret;
        fd = open(PORT, O_RDWR | O_NOCTTY);
        if (fd == -1)
                return -1;
         /* get serial port attributes*/
        ret = tcgetattr(fd, &options);
         /* clear the attributes*/
        bzero(&options, sizeof(options));
         /* setting baud rate as required by the RFID reader */
        speed = B9600;
        cfsetospeed(&options, speed);
        cfsetispeed(&options, speed);
         /*
          * c_flag, control mode flag costants => ignore modem control lines,
          * enable receiver, character size mask respectively
          */
        options.c_cflag |= (CLOCAL | CREAD |  CS8);
         /*
          * c-iflag, input mode flag constants => ignore framming errors and
          * parity errors, ignore break condition on input respectively
          */
        options.c_iflag |= (IGNPAR | IGNBRK );
        options.c_cc[VTIME] = 10;
        options.c_cc[VMIN] = 0;
         /* TCSANOW => set sttributes now*/
        tcsetattr(fd, TCSANOW, &options);
        return fd;
}

/*
 * Wait for a character on the serial port.
 */
static void wait_for(int fd, char ch)
{
        char read_ch;
        int ret;

        while (1) {
                ret = read(fd, &read_ch, 1);
                if (ret == 1 && read_ch == ch)
                        break;
        }
}

/**
 * read_rfid - read an RFID
 * @fd: the RFID serial port file descriptor
 * @string: buffer to store the RFID, should be atleast 11 characters
 *
 * Returns:
 *    0 - on success
 *   -1 - if read fails, errno is set accordingly.
 *   -2 - if stop byte is not seen, or if short RFID is read
 */
static int rfid_read(int fd, char *string)
{
        int nbytes;
        int ret;

        wait_for(fd, '\n');
        nbytes = 0;
        while (nbytes < (RFID_SIZE + 1)) {
                ret = read(fd, &string[nbytes], 1);
                if (ret < 0)
                        return ret;

                if (ret == 1) {
                        if (string[nbytes] == RFID_STOP_CHAR) {
                                if (nbytes != RFID_SIZE)
                                        return -2;

                                string[nbytes] = 0;
                                return 0;
                        }
                        nbytes++;
                }
        }
        return -2;
}

/*
 * List of permitted RFIDs.
 */
static char *permit_list[] = {
        "660093E2BA",
        "660093DD86",
        "2345678901"
};

/*
 * Check if the specified ID is in the permitted list.
 */
static int authenticate_id(char *buf)
{
        int index;
        int count = sizeof(permit_list) / sizeof(char *);

        for (index = 0; index < count; index++) {
                if (strcmp(buf, permit_list[index]) == 0)
                        return 0;
        }
        return 1;
}

int app_main(int argc, char *argv[])
{
        int fd, ret, flag;
        char buf[RFID_SIZE + 1];  /* RFID size, plus 1 byte for '\0' */

        fd = rfid_init();
        if (fd == -1) {
                perror("error initializing RFID reader\n");
                return -1;
        }

        printf("RFID ready\n");

        while (1) {
                ret = rfid_read(fd, buf);
                if (ret == -2)
                        continue;

                if (ret == -1) {
                        perror("error reading data\n");
                        return -1;
                }

                printf("Read ID: %s\n", buf);

                flag = authenticate_id(buf);
                if (!flag)
                        printf("Authentication success\n");
                else
                        printf("Authentication failure\n");
        }

        return 0;
}