Ir para conteúdo

Arquivado

Este tópico foi arquivado e está fechado para novas respostas.

thyagoop

C para hardware

Recommended Posts

Vou tentar explicar o que esta acontecendo, eu tenho um aparelho com um LCD e 4 botões, estou criando um menu com eles. O quarto botão eu quero fazer o seguinte, uma contagem regressiva de 10 segundos, se caso o cliente soltar o botão o aparelho não é reiniciado. Somente se ele mantiver pressionado durante 10 segundos o botão é que ele é reiniciado.

Vou postar o código, pra ver se ajuda...

 

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

#include "plcm-util.h"

void escreve_linha_1(struct _plcm plcm, int devfd) {
    plcm.amg = 1;
    ioctl(devfd, PLCM_IOCTL_SET_LINE, &plcm);
}

void escreve_linha_2(struct _plcm plcm, int devfd) {
    plcm.amg = 2;
    ioctl(devfd, PLCM_IOCTL_SET_LINE, &plcm);
}

void stop(struct _plcm plcm, int devfd) {
    plcm.amg = 0;
    ioctl(devfd, PLCM_IOCTL_STOP_THREAD, &plcm);
}

void DispOff(struct _plcm plcm, int devfd) {
    plcm.amg = 0;
    ioctl(devfd, PLCM_IOCTL_DISPLAY_D, &plcm);
}

void DispOn(struct _plcm plcm, int devfd) {
    plcm.amg = 1;
    ioctl(devfd, PLCM_IOCTL_DISPLAY_D, &plcm);
}

/*FUNCOES PARA A LEITURA DO QUE ESTA ESCRITO NAS LINHAS DO LC*/

void read_1(int devfd, struct _plcm plcm, FILE *saida, unsigned char Ret_Message1) {
    plcm.amg = 2;
    ioctl(devfd, PLCM_IOCTL_SET_LINE, &plcm);
    read(devfd, Ret_Message1, sizeof (Ret_Message1));
    fprintf(saida, "A primeira linha do LCM1: %s\n", Ret_Message1);

}

void read_2(int devfd, struct _plcm plcm, FILE *saida, unsigned char Ret_Message2) {
    plcm.amg = 2;
    ioctl(devfd, PLCM_IOCTL_SET_LINE, &plcm);
    read(devfd, Ret_Message2, sizeof (Ret_Message2));
    fprintf(saida, "A segunda linha do LCM1: %s\n", Ret_Message2);
}

/*FUNCAO PARA LIMPAR O LCD*/

void clear(struct _plcm plcm, int devfd) {
    plcm.amg = 0;
    ioctl(devfd, PLCM_IOCTL_CLEARDISPLAY, &plcm);
    plcm.amg = 0;
    ioctl(devfd, PLCM_IOCTL_RETURNHOME, &plcm);
}
int main(int argc, char *argv[]) {

    struct _plcm plcm;
    int devfd,forking = 1;

    int botao1 = 1, botao2 = 1, botao3 = 1, botao4 = 1, inicio = 1;
    unsigned char Keypad_Value = 0, Pre_Value = 0, Counter = 0, count = 0;
    unsigned char Ret_Message1[40] = ""; //variavel que vai salvar o que esta escrito na primeira linha do lcd
    unsigned char Ret_Message2[40] = ""; //variavel que vai salvar o que esta escrito na segunda linha do lcd
    unsigned char Keypad_Message[40] = "";

    unsigned char detect_press;
    unsigned char detect_dir;

    FILE *saida_read = fopen("saida_read.txt", "w");

    pid_t pid, sid;

    pid = fork();
    if (pid < 0) {
        exit(EXIT_FAILURE);
    }

    if (pid > 0) {
        exit(EXIT_SUCCESS);
    }

    umask(0);

    openlog("gSafe", LOG_PID, LOG_DAEMON);

    sid = setsid();
    if (sid < 0) {

        exit(EXIT_FAILURE);
    }

    if ((chdir("/")) < 0) {

        exit(EXIT_FAILURE);
    }

    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);

    fds[0].FD = open("/dev/plcm_drv", O_RDWR);
    //devfd = open("/dev/plcm_drv", O_RDWR);
    if (devfd == -1) {
        printf("Cant open: /dev/plcm_drv\n");
        return -1;
    }

    Keypad_Message[40] = "";

    Keypad_Value = 0xaf;

    stop(plcm, devfd);
    DispOn(plcm, devfd);
    clear(plcm, devfd);

    goto principal;
    /*
        printf("O valor de detect_dir e: %x\n", detect_dir);
        printf("O valor de detect_press e: %x\n", detect_press);
        printf("O valor de Keypad_Value e: %x\n", Keypad_Value);
     */
    while (1) {
        plcm.amg = 0;
        ioctl(devfd, PLCM_IOCTL_GET_KEYPAD, &plcm); // Get keypad
        Keypad_Value = plcm.key_value; // Add the value to our local variable
        detect_press = (Keypad_Value & 0x40);
        detect_dir = (Keypad_Value & 0x28);

        switch (Keypad_Value) {
            case 0x87:
                if (Pre_Value != Keypad_Value) {
                    /*printf("\nO valor de detect_dir dento do case 0 e: %x\n", detect_dir);
                    printf("O valor de detect_press dento do case 0x0 e: %x\n", detect_press);*/
                    strcpy(Keypad_Message, "Status de Firewall   ");
                    read_1(devfd, plcm, &saida_read, Ret_Message1);
                    inicio = 0;
                    while (botao2 == 0) {

                        botao2 = 1;

                        escreve_linha_1(plcm, devfd);
                        //strcpy(Keypad_Message, "Status de Firewall   ");
                        write(devfd, " Status de Firewall     ", 40);

                        escreve_linha_2(plcm, devfd);
                        //strcpy(Keypad_info, "                       ");
                        write(devfd, "                        ", 40);
                        sleep(2);

                        escreve_linha_1(plcm, devfd);

                        //strcpy(Keypad_Message2, "Estados de Firewall    ");
                        write(devfd, " Estados de Firewall     ", 40);

                        escreve_linha_2(plcm, devfd);
                        //strcpy(Keypad_info2, " *Informacoes*      ");
                        write(devfd, " *Informacoes*       ", 40);

                        sleep(2);

                        escreve_linha_1(plcm, devfd);

                        //strcpy(Keypad_Message3, "Regras         ");
                        write(devfd, " Regras             ", 40);

                        escreve_linha_2(plcm, devfd);
                        //strcpy(Keypad_info3, " *Informacoes*       ");
                        write(devfd, "  *Informacoes*     ", 40);

                        sleep(2);
                        // inicio = 1;
                        goto principal;
                    }
                    // detect_dir = 0x01;
                }
                break;
            case 0xa7:
                if (Pre_Value != Keypad_Value) {
                    strcpy(Keypad_Message, "Status do Sistema   ");
                    inicio = 0;
                    while (botao1 == 0) {

                        botao1 = 1;

                        escreve_linha_1(plcm, devfd);
                        write(devfd, " Status do Sistema     ", 40);

                        escreve_linha_2(plcm, devfd);
                        write(devfd, "                        ", 40);
                        sleep(2);

                        escreve_linha_1(plcm, devfd);
                        write(devfd, " Status da Memoria        ", 40);

                        escreve_linha_2(plcm, devfd);
                        write(devfd, " *Informacoes*       ", 40);

                        sleep(2);

                        escreve_linha_1(plcm, devfd);
                        write(devfd, " Temperatura               ", 40);

                        escreve_linha_2(plcm, devfd);
                        write(devfd, "  *Informacoes*     ", 40);

                        sleep(2);

                        escreve_linha_1(plcm, devfd);
                        write(devfd, " Processos               ", 40);

                        escreve_linha_2(plcm, devfd);
                        write(devfd, "  *Informacoes*     ", 40);

                        sleep(2);

                        escreve_linha_1(plcm, devfd);
                        write(devfd, " Armazenamento               ", 40);

                        escreve_linha_2(plcm, devfd);
                        write(devfd, "  *Informacoes*     ", 40);

                        sleep(2);

                        escreve_linha_1(plcm, devfd);
                        write(devfd, " Swap               ", 40);

                        escreve_linha_2(plcm, devfd);
                        write(devfd, "  *Informacoes*     ", 40);

                        sleep(2);
                        //inicio = 1;
                        goto principal;
                    }
                }
                break;
            case 0x8f:
                if (Pre_Value != Keypad_Value) {
                    //  printf("\nO valor de detect_dir dento do case 0x08 e: %x\n", detect_dir);
                    //  printf("O valor de detect_press dento do case 0x08 e: %x\n", detect_press);
                    strcpy(Keypad_Message, "Status de Rede   ");
                    while (botao3 == 0) {

                        botao3 = 1;

                        escreve_linha_1(plcm, devfd);
                        write(devfd, " Status de Rede        ", 40);

                        escreve_linha_2(plcm, devfd);
                        write(devfd, "                        ", 40);
                        sleep(2);

                        escreve_linha_1(plcm, devfd);
                        write(devfd, " Colisoes             ", 40);

                        escreve_linha_2(plcm, devfd);
                        write(devfd, " *Informacoes*       ", 40);

                        sleep(2);

                        escreve_linha_1(plcm, devfd);
                        write(devfd, " Numero de FIBs                ", 40);

                        escreve_linha_2(plcm, devfd);
                        write(devfd, "  *Informacoes*     ", 40);

                        sleep(2);

                        escreve_linha_1(plcm, devfd);
                        write(devfd, " Numero de Rotas                 ", 40);

                        escreve_linha_2(plcm, devfd);
                        write(devfd, "  *Informacoes*     ", 40);

                        sleep(2);

                        escreve_linha_1(plcm, devfd);
                        write(devfd, " Sockets                   ", 40);

                        escreve_linha_2(plcm, devfd);
                        write(devfd, "  *Informacoes*     ", 40);

                        sleep(2);

                        escreve_linha_1(plcm, devfd);
                        write(devfd, " Conexoes                  ", 40);

                        escreve_linha_2(plcm, devfd);
                        write(devfd, "  *Informacoes*     ", 40);

                        goto principal;
                    }

                }
                //detect_dir = 0x01;
                break;
            case 0xaf:
                if (Pre_Value != Keypad_Value) { 

                    goto principal;
                }
                break;
        }
        switch (detect_press) {
            case 0x40:
                /* printf("O valor de detect_dir e: %x\n", detect_dir);
                 printf("O valor de detect_press e: %x\n", detect_press);
                 printf("O valor de Keypad_Value e: %x\n", Keypad_Value);*/
                switch (detect_dir) {
                    case 0x00:
                        botao2 = 0;
                        break;

                    case 0x20:
                        botao1 = 0;
                        break;

                    case 0x08:
                        botao3 = 0;
                        break;

                    case 0x28:
                        count = 0;
                        escreve_linha_1(plcm, devfd);
                        write(devfd, "O aparelho sera desligado             ", 40);
                        escreve_linha_2(plcm, devfd);
                        write(devfd, "em 5 segundos                      ", 40);
                        //while (/*detect_dir == 0x28 &&*/ detect_press == 0x40) {
                        //detect_press = (Keypad_Value & 0x40);
                        // printf("O valor de detect_press que passa pela %d vez e: %x\n", count, detect_press);

                        if (count == 0) {
                            write(devfd, "dentro de 1 segundo          ", 40);
                            count++;
                        }
                         //}
                        if (count == 1) {
                            write(devfd, "dentro de 2 segundos          ", 40);
                            count++;
                        }

                        if (count == 2) {
                            write(devfd, "dentro de 3 segundos          ", 40);
                            count++;
                        }

                        if (count == 3) {
                            write(devfd, "dentro de 4 segundos          ", 40);
                            count++;
                        }

                        if (count == 4) {
                            // system("./desliga.sh");
                            write(devfd, "DESLIGANDO            ", 40);
                            printf("*desliga\n\n");
                            close(saida_read);
                            return 0;
                        }
                        //}
                        break;
                }
                break;
            case 0x00:
                break;
        }

        if (Pre_Value != Keypad_Value) {
            //if (forking == 0) {
            if (inicio == 0) {
                syslog(LOG_NOTICE, "%x %s", plcm.key_value, Keypad_Message);
                write(devfd, Keypad_Message, 40);
                //inicio = 1;
            }
            //}
        }
        if (inicio == 1) {
principal:
        /*Aqui escreve algumas informações do LCD*/
        }

        Pre_Value = Keypad_Value;
        forking = 0;
        sleep(1);
    }
    
    closelog();
    exit(EXIT_SUCCESS);
}
OBS. Estou utilizando FreeBSD.

 

Valeu pessoal!

Compartilhar este post


Link para o post
Compartilhar em outros sites

Ok, bacana!

 

E qual é a tua dúvida?

Compartilhar este post


Link para o post
Compartilhar em outros sites

Tenho um aparelho com um LCD e 4 botões, estou criando um menu com eles. O quarto botão eu quero fazer o seguinte, uma contagem regressiva de 10 segundos, se caso o cliente soltar o botão o aparelho não é reiniciado. Somente se ele mantiver pressionado durante 10 segundos o botão é que ele é reiniciado.

Minha duvida, é como fazer isso....

Compartilhar este post


Link para o post
Compartilhar em outros sites

×

Informação importante

Ao usar o fórum, você concorda com nossos Termos e condições.