Duvida em C para hardware

1. Duvida em C para hardware

thyagoop
(usa Fedora)

Enviado em 22/01/2015 - 09:30h

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, se eu apertar ele por mais de 10 segundos eu reinicio o aparelho.

Tentei utilizar o seguinte código:

#include<stdio.h>

#include<curses.h>

int main()

{

char tecla;

initscr();



clear();



keypad(stdscr, TRUE);



noecho();

timeout(2000); //a função já garante a execução do bloco com ou sem entrada de teclado; // Espera 2 segundos

tecla=getch(); 

endwin();

}

compilei o codigo acima da seguinte maneira:

cc meuprograma.c -o meuprograma -lncurses

Compilou sem problemas, porem não obtive sucesso em o que eu preciso fazer.
Não posso passar o código que eu já fiz pois é para a empresa que eu trabalho, então se alguém já tiver passado por uma experiência parecida com essa e puder me dar uma ajuda.
Valeu pessoal!

0 0

Quote

2. Re: Duvida em C para hardware

Thihup
(usa Manjaro Linux)

Enviado em 22/01/2015 - 09:37h

Oi novamente =D

Esse aparelho retorna algum valor apertando o botão ?

Se sim , essa não é a opção correta

Espero ter ajudado

[]'s

T+

1 0

Quote

3. Re: Duvida em C para hardware

thyagoop
(usa Fedora)

Enviado em 22/01/2015 - 09:47h

Opa de novo :D
Retorna sim, um valor em hexa.
Você saberia de alguma forma cara?
_______________________________________________________________________
“I have promises to keep, and miles to go before I sleep.” - Robert Frost

0 0

Quote

4. Re: Duvida em C para hardware

mulatinho
(usa Slackware)

Enviado em 22/01/2015 - 10:26h

Talvez seja possível fazer com NCURSES, mas... a forma mais simples de fazer isso é usando um multiplexador,

Funções para fazer isso:
- select()
- poll()
- epoll()

1 0

Quote

5. Re: Duvida em C para hardware

thyagoop
(usa Fedora)

Enviado em 22/01/2015 - 10:29h

mulatinho escreveu:

Talvez seja possível fazer com NCURSES, mas... a forma mais simples de fazer isso é usando um multiplexador,

Funções para fazer isso:
- select()
- poll()
- epoll()

Muito obrigado amigo, vou dar uma pesquisada nessas funções e ver se resolve meu problema.
Qualquer coisa eu aviso aqui..
Mas se souberem de algo mais que pode me ajudar, pode ir postando aqui.
vlw!
_______________________________________________________________________
“I have promises to keep, and miles to go before I sleep.” - Robert Frost

0 0

Quote

6. Re: Duvida em C para hardware

thyagoop
(usa Fedora)

Enviado em 22/01/2015 - 13:39h

Eu preciso que faça o seguinte, quando eu apertar e segurar o quarto botão preciso que faça 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);

}

Ta ai a forma que eu fiz primeiramente...
_______________________________________________________________________
“I have promises to keep, and miles to go before I sleep.” - Robert Frost

0 0

Quote

7. Re: Duvida em C para hardware

mulatinho
(usa Slackware)

Enviado em 22/01/2015 - 14:27h

// mulato <alex@mulatinho.net>

#include <stdio.h>

#include <stdlib.h>

#include <sys/select.h>

#include <sys/times.h>

#include <sys/types.h>

#include <unistd.h>

#include <string.h>



int main(void)

{

	int ret, bytes;

	fd_set rfds;

	struct timeval t;

	char buffer[256];

	

	while (1) {

		FD_ZERO(&rfds);

		FD_SET(STDIN_FILENO, &rfds);



		t.tv_sec = 10;

		t.tv_usec = 0;



		memset(buffer, 0, sizeof(buffer));

		ret = select(1, &rfds, NULL, NULL, &t);

		fprintf(stdout, "select: %d\n", ret);



		if (ret == -1) {

			fprintf(stdout, "yeahhh\n");

		} else {

			if (FD_ISSET(0, &rfds)) {

				bytes = read(STDIN_FILENO, buffer, sizeof(buffer));

				fprintf(stdout, "saida do usuario: %s\n", buffer);

			}

		}



		fprintf(stdout, "10 segundos se passaram e nada...\n");

		sleep(1);

	}



	return 0;

}

mlt@slack:~/codez/c$ ./test-select 

select: 0

10 segundos se passaram e nada...

select: 0

10 segundos se passaram e nada...

buffer

select: 1

saida do usuario: buffer

1 0

Quote

8. Re: Duvida em C para hardware

thyagoop
(usa Fedora)

Enviado em 23/01/2015 - 08:45h

mulatinho escreveu:

// mulato <alex@mulatinho.net>

#include <stdio.h>

#include <stdlib.h>

#include <sys/select.h>

#include <sys/times.h>

#include <sys/types.h>

#include <unistd.h>

#include <string.h>



int main(void)

{

	int ret, bytes;

	fd_set rfds;

	struct timeval t;

	char buffer[256];

	

	while (1) {

		FD_ZERO(&rfds);

		FD_SET(STDIN_FILENO, &rfds);



		t.tv_sec = 10;

		t.tv_usec = 0;



		memset(buffer, 0, sizeof(buffer));

		ret = select(1, &rfds, NULL, NULL, &t);

		fprintf(stdout, "select: %d\n", ret);



		if (ret == -1) {

			fprintf(stdout, "yeahhh\n");

		} else {

			if (FD_ISSET(0, &rfds)) {

				bytes = read(STDIN_FILENO, buffer, sizeof(buffer));

				fprintf(stdout, "saida do usuario: %s\n", buffer);

			}

		}



		fprintf(stdout, "10 segundos se passaram e nada...\n");

		sleep(1);

	}



	return 0;

}

mlt@slack:~/codez/c$ ./test-select 

select: 0

10 segundos se passaram e nada...

select: 0

10 segundos se passaram e nada...

buffer

select: 1

saida do usuario: buffer

Muito obrigado pela resposta, mas não estou conseguindo entender muito bem como funciona esta função select...
Você poderia me dar uma breve explicação?

_______________________________________________________________________
“I have promises to keep, and miles to go before I sleep.” - Robert Frost

0 0

Quote

9. Re: Duvida em C para hardware

mulatinho
(usa Slackware)

Enviado em 23/01/2015 - 10:30h

Opa, a função select multiplexa síncronamente descritores de arquivo.

Os descritores de arquivo como sabemos podem ser: sockets, arquivos, e dispositivos de entrada e saída.

Nesse caso como você colocou no seu código, usei o descritor 'STDIN_FILENO' e como você pode vêr utilizou-se também a struct timeval que define os segundos em que a função 'select()' irá esperar para que algum evento aconteça utilizando o descritor, o primeiro argumento da função select corresponde a quantidade de descritores que serão tratados, eu aconselho a você a lêr um pouco mais sobre a manpage [1] da função e também exemplos do beej [2];

[1] http://linux.die.net/man/2/select
[2] http://www.beej.us/guide/bgnet/output/html/multipage/selectman.html

Com isso você pode facilmente adaptar esse pedaço de código, espero ter ajudado.

1 0

Quote

10. Re: Duvida em C para hardware

thyagoop
(usa Fedora)

Enviado em 23/01/2015 - 10:40h

Muitíssimo obrigado cara!
Vou estudar mais aqui e qualquer coisa eu posto aqui de novo!
_______________________________________________________________________
“I have promises to keep, and miles to go before I sleep.” - Robert Frost

0 0

Quote