ComArduino.c

#include <stdio.h>      // standard input / output functions
#include <stdlib.h>
#include <string.h>     // string function 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 <sys/ioctl.h>
#include <time.h>
#include <stdbool.h>
#include "ComArduino.h"

#define NANO_PER_SEC 1000000000.0

char comStr[MAX_COM_NAME+1] = "/dev/ttyUSB0";

static int USB;


/*****************************************************************************/
/**  Fecha a serial                                                          */
/*****************************************************************************/
void fechaSerial(void) {
    close(USB);
}

/*****************************************************************************/
/**  Configura a serial para trabalhar em modo RAW com o Arduino             */
/** Reterna  0 OK                                                            */
/**         -1 Não conseguiu obter parâmetros da serial                      */
/**         -2 Não conseguiu desabilitar DTR                                 */
/**         -3 Não conseguiu hab/desab DTS                                   */
/**         -4 Não conseguiu configurar os flags de comunicação              */
/*****************************************************************************/
int configuraSerial(void) {
    // Obtém a configuração da porta
    struct termios tty;
    memset (&tty, 0, sizeof tty);
    if ( tcgetattr ( USB, &tty ) != 0 ){
       printf("Error %d from tcgetattr %s\n", errno,strerror(errno));
       return -1;
    }

    // Desabilita o  DTR
    int dtr_flag = TIOCM_DTR;
    if (ioctl(USB, TIOCMBIC, &dtr_flag) != 0) {
        printf("Erro ao desabilitar DTR: %s\n", strerror(errno));
        return -2;
    }

    // Habilita e depois desabilita RTS para resetar o Arduino
    int rts_flag = TIOCM_RTS;
    ioctl(USB, TIOCMBIS, &dtr_flag); // Ativar DTR
    usleep(200000);                  // Atraso de 200 milissegundos
    if (ioctl(USB, TIOCMBIC, &rts_flag) != 0) {
        printf("Erro ao desabilitar RTS: %s\n", strerror(errno));
        return -3;
    }

    // Define Baud Rate
    cfsetospeed (&tty, B9600);
    cfsetispeed (&tty, B9600);

    //Define parâmetros de comunicação pela serial
    tty.c_cflag     &=  ~PARENB;    // Sem Paridade
    tty.c_cflag     &=  ~CSTOPB;    // 1 STOP BIT
    tty.c_cflag     &=  ~CSIZE;     // Limpa os bits de tamanho
    tty.c_cflag     |=  CS8;        // Define 8 bits por caractere
    tty.c_cflag     &=  ~CRTSCTS;   // Desativar controle de fluxo por hardware (RTS/CTS)
    tty.c_lflag     =   0;          // Sem sinais, sem echo, sem processamento canônico
    tty.c_oflag     =   0;          // Sem mapeamento, sem atrasos
    tty.c_cc[VMIN]  =   0;          // Leitura não bloqueia
    tty.c_cc[VTIME] =   10;         // Timout de 1.0 segundos
    //Ativar leitura e ignorar linhas de controle (DTR/DTS)
    tty.c_cflag     |=  CREAD | CLOCAL;                    // Habilitar leitura, ignorar controle de modem
    tty.c_iflag     &=  ~(IXON | IXOFF | IXANY);           // Desativar controle de fluxo por software
    tty.c_lflag     &=  ~(ICANON | ECHO | ECHOE | ISIG);   // Sem modo canônico, echo ou sinais (raw)
    tty.c_oflag     &=  ~OPOST;                            // Sem processamento de saída (raw)

    // Flush na porta, antes de aplicar os parâmetros
    tcflush( USB, TCIFLUSH );

    if ( tcsetattr ( USB, TCSANOW, &tty ) != 0) {
        printf("Error %d from tcgetattr %s\n", errno,strerror(errno));
        return -4;
    }
    return 0;
}

/*****************************************************************************/
/**                                                                          */
/** Tenta abrir serial /dev/ttyS0 a /dev/ttyS9                               */
/** Aplica configurações que levam o Arduino a resetar.                      */
/** Se conseguir abrir, realiza o ping para certificar que é o Arduino       */
/** Retorna 0, se sucesso                                                    */
/**        -1, se falha                                                      */
/*****************************************************************************/
int probeSerial(void){
    int size = strlen(comStr);
    int iniciarEm = comStr[size-1] - '0';
    int comAtual = iniciarEm;
    do {
        //Abre a serial
        USB = open( comStr, O_RDWR | O_NOCTTY |  O_NDELAY);
        if ( USB < 0 ) {
            printf("Error %d opening %s %s\n", errno, comStr, strerror(errno));
        }
        else {
            printf("Abriu COM %s\n", comStr);
            if (configuraSerial() == 0) {
                //Tempo para rebootar o Arduino Nano
                usleep(2800000);
                if (ping() == 0) {
                    return 0;
                }
                else
                    fechaSerial();
            }
        }
        comAtual = (comAtual + 1) % 10;
        comStr[size-1] = '0' + comAtual;

    } while (comAtual != iniciarEm);
    return -1;
}

/*****************************************************************************/
/** A troca de mensagem com o Arduino é sempre iniciada pela TV-Box          */
/** O protocolo envolve o reconhecimento do caractere de ínico de mensagem   */
/** '<' e do caractere finalizador de mensagem '>'.                          */
/** O Arduino tem apenas duas mensagens de retorno:                          */
/** <001,uptime em milissegundos>  --> Resposta ao ping                      */
/** <002,OK>                       --> Resposta aos demais comandos          */
/**                                                                          */
/** As mensagens de comando são apenas 6:                                    */
/** <100,0,0>           --> PING                                             */
/** <200,TEXTO,TIMEOUT> --> TIME (Linha 0, para sala, data e hora)           */
/** <300,TEXTO,TIMEOUT> --> LECTURE_NAME (Linha 1, para nome da palestra)    */
/** <400,TEXTO,TIMEOUT> --> SPEAKER (Linha 2, para nome do palestrante)      */
/** <500,TEXTO,TIEMOUT> --> ATTENDEE (Linha 3, aponta participante registrado*/
/** <600,0,0>           --> SUCCESS (Beep de sucesso no registro)            */
/** <601,0,0>           --> FAIL (Beep de falha no registro)                 */
/*****************************************************************************/
bool enviaRecebe(char* msg, char* recebido, int sizeRecebido) {
    int n_written = write( USB, msg, strlen(msg) );
    printf("Enviou %d chars\n", n_written);

    int n_read = 0;
    char buffer[1];
    int posAtual = 0;
    bool recvInProgress = false;
    double timeOut = 5.0; // Cinco segundos de timeout
    struct timespec now;
    double espereAte;
    double tempoAtual;
    clock_gettime(CLOCK_REALTIME, &now);
    espereAte  = now.tv_sec + now.tv_nsec / NANO_PER_SEC + timeOut;
    tempoAtual = now.tv_sec + now.tv_nsec / NANO_PER_SEC;
    //Este loop controla o timeout na leitura do retorno
    while (tempoAtual < espereAte){
        clock_gettime(CLOCK_REALTIME, &now);
        tempoAtual = now.tv_sec + now.tv_nsec / NANO_PER_SEC;
        n_read = read(USB, buffer, 1);
        if (n_read == 1) {
            if (recvInProgress == false) {
                //Precisa sincronizar com o início da mensagem
                if (buffer[0] == '<')
                    recvInProgress = true;
                continue;
            }
            else { //Recebendo a mensagem
                if (buffer[0] != '>' ) {
                    //Protege contra estouro de buffer
                    if (posAtual < sizeRecebido-1)
                        recebido[posAtual++] = buffer[0];
                }
                else {
                    recebido[posAtual] = '\0';
                    return true;
                }
            }
        }
    }
    recebido[posAtual] = '\0';
    return false;
}

/*****************************************************************************/
/**  Comando PING                                                            */
/*****************************************************************************/
int ping(void) {
    printf("Vai enviar dados\n");
    char msg[] = "<100,0,0>";
    char recebido[80] = "";
    bool ret = enviaRecebe(msg, recebido, 80);
    printf("Recebeu %s\n", recebido);
    if (!ret)
        return -2;
    char* strtokIndx = strtok(recebido,",");
    if (strcmp(strtokIndx, "001") == 0) {
        printf("Arduino encontrado em %s\n", comStr);
        return 0;
    }
    else
        return -1;
}

/*****************************************************************************/
/** Comando Time Linha 0 SALA DATA E HORA                                    */
/*****************************************************************************/
int setTime(char* sala, int timeout) {
    char msg[100];
    time_t t = time(NULL);
    struct tm tm = *localtime(&t);
    sprintf(msg, "<200,%s %02d/%02d %02d:%02d,%d>",sala, tm.tm_mday, tm.tm_mon + 1, tm.tm_hour, tm.tm_min, timeout);
    printf("Vai enviar dados\n");
    char recebido[80] = "";
    bool ret = enviaRecebe(msg, recebido, 80);
    printf("Recebeu %s\n", recebido);
    if (!ret)
        return -2;
    char* strtokIndx = strtok(recebido,",");
    if (strcmp(strtokIndx, "002") == 0) {
        printf("Mensagem Time enviada com sucesso %s\n", comStr);
        return 0;
    }
    else
        return -1;
}

/*****************************************************************************/
/** Comando Lecture Linha 1 NOME DA PALESTRA                                 */
/*****************************************************************************/
int setLecture(char* disciplina, int timeout) {
    char msg[100];
    sprintf(msg,"<300,%s,%d>",disciplina, timeout);
    printf("Vai enviar dados\n");
    char recebido[80] = "";
    bool ret = enviaRecebe(msg, recebido,80);
    printf("Recebeu %s\n", recebido);
    if (!ret)
        return -2;
    char* strtokIndx = strtok(recebido,",");
    if (strcmp(strtokIndx, "002") == 0) {
        printf("Mensagem Disciplina enviada com sucesso %s\n", comStr);
        return 0;
    }
    else
        return -1;
}

/*****************************************************************************/
/** Comando Speaker Linha 2 NOME DO PALESTRANTE                              */
/*****************************************************************************/
int setSpeaker(char* prof, int timeout) {
    char msg[100];
    sprintf(msg,"<400,%s,%d>",prof, timeout);
    printf("Vai enviar dados\n");
    char recebido[80] = "";
    bool ret = enviaRecebe(msg, recebido, 80);
    printf("Recebeu %s\n", recebido);
    if (!ret)
        return -2;
    char* strtokIndx = strtok(recebido,",");
    if (strcmp(strtokIndx, "002") == 0) {
        printf("Mensagem Prof enviada com sucesso %s\n", comStr);
        return 0;
    }
    else
        return -1;
}

/*****************************************************************************/
/** Comando Attendee Linha 3 NOME DE UM PARTICIPANTE QUE REGISTRA PRESENÇA   */
/** Também é usado no processo de uso de teclado para exibir user/pass       */
/*****************************************************************************/
int setAttendee(char* aluno, int timeout) {
    char msg[100];
    sprintf(msg,"<500,%s,%d>",aluno,timeout);
    //printf("Vai enviar dados\n");
    char recebido[80] = "";
    bool ret = enviaRecebe(msg, recebido, 80);
    //printf("Recebeu %s\n", recebido);
    if (!ret)
        return -2;
    char* strtokIndx = strtok(recebido,",");
    if (strcmp(strtokIndx, "002") == 0) {
        //printf("Mensagem Aluno enviada com sucesso %s\n", comStr);
        return 0;
    }
    else
        return -1;
}

/*****************************************************************************/
/**                                                                          */
/*****************************************************************************/
int setSuccess(void) {
    printf("Vai enviar dados\n");
    char msg[100] = "<600,0,0>";
    char recebido[80] = "";
    bool ret = enviaRecebe(msg, recebido, 80);
    printf("Recebeu %s\n", recebido);
    if (!ret)
        return -2;
    char* strtokIndx = strtok(recebido,",");
    if (strcmp(strtokIndx, "002") == 0) {
        printf("Mensagem BUZZER sucesso enviada com sucesso %s\n", comStr);
        return 0;
    }
    else
        return -1;
}

/*****************************************************************************/
/**                                                                          */
/*****************************************************************************/
int setFail(void) {
    printf("Vai enviar dados\n");
    char msg[100] = "<601,0,0>";
    char recebido[80] = "";
    bool ret = enviaRecebe(msg, recebido, 80);
    printf("Recebeu %s\n", recebido);
    if (!ret)
        return -2;
    char* strtokIndx = strtok(recebido,",");
    if (strcmp(strtokIndx, "002") == 0) {
        printf("Mensagem BUZZER falha enviada com sucesso %s\n", comStr);
        return 0;
    }
    else
        return -1;
}