Máquina de votação eletrônica usando EEPROM interna do AVR

2024年6月9日 Roberto Magalhães

O microcontrolador máquinas de votação baseadas tornou o processo de votação e contagem do lote votado mais fácil do que antes. Anteriormente os votos eram marcados em papel que depois eram guardados em segurança numa caixa e dentro de uma sala bem protegida durante dias. O processo de separação dos votos e contagem manual pode demorar muitos dias. Mas depois de encontrar a urna eletrônica os votos podem ser marcados sem o uso de papéis, o que torna o processo de votação ecologicamente correto. Além disso, torna o processo de contagem mais rápido e os resultados podem ser anunciados num período de tempo comparativamente mais curto.

Deve haver um controlador dentro do Máquina de votação eletrônica (EVM) que controla o processo e deve existir um meio de armazenamento onde sejam armazenados os dados do voto. Deveria haver uma unidade de balé que fosse utilizada de tal forma que quem veio votar pudesse votar apenas um. Deve haver também um teclado que possa ser usado por aqueles que desejam votar. Neste projeto o microcontrolador AVR é utilizado para demonstrar o funcionamento de uma urna de votação mais simples que pode se comunicar serialmente com um PC e que pode armazenar a contagem dos votos em sua memória interna.

Este projeto é sobre como podemos fazer uso de recursos internos EEPROM do AVR para armazenamento de dados para fins futuros. Neste projeto estamos fazendo uma Urna Eletrônica (EVM) utilizando a EEPROM do AVR. Tal como acontece com o EVM normal, existe uma unidade de controle e uma unidade de balé. A unidade de balé pode ser usada para votar somente após ser habilitada pressionando uma tecla na unidade de controle. Depois de dar um único voto, a unidade de balé será desativada novamente. Cada vez que um usuário pressiona uma tecla, o Telas LCD em qual candidato ele votou.

O interessante é que cada vez que um voto for emitido, a contagem será atualizada automaticamente na EEPROM interna. Assim, uma vez realizada a votação, podemos desconectar a unidade da fonte de alimentação e mantê-la segura até o dia da contagem. Podemos ligar o conselho e mesmo depois de um longo período de tempo podemos ler o número de votos emitidos para cada candidato conectando o EVM ao através HyperTerminal via comunicação serial com AVR.

Código-fonte do projeto

###

#define F_CPU 8000000

#include #include #include #include #incluir "lcd.h" #include "usart.h" void switch_init(void); vazio led_init ( vazio ); vazio evm_init ( vazio ); vazio evm_raedy_wait ( vazio ); void evm_vote (void); char read_key_wait(void); void update_count (int candidato_address); void send_count_out (void); void reset_count (void); int principal (void) { char poll_result_mode = 1; evm_init ; CARDÁPIO: //-----------------------------------------// stdout = &lcd_out; lcd_clear ; printf("A-POLL B-COUNT"); printf("nRESET CONTAGEM-C"); //-----------------------------------------// poll_result_mode=read_key_wait ; //espera até que qualquer tecla seja pressionada // e lê o valor atual do teclado mudar ( poll_result_mode ) { caso 0: enquanto (1) { evm_raedy_wait ; evm_vote ; } vá para MENU; caso 1: enviar_contagem_out ; vá para MENU; caso 2: reset_count ; vá para MENU; } enquanto (1); } vazio switch_init ( vazio ) { cli ; DDRC &= 0xE0; PORTC = 0xFF; DDRD = 0x80; PORTD = 0x80; sei ; } vazio led_init ( vazio ) { cli ; DDRD = 0x80; PORTD = 0x80; sei ; } vazio evm_init { led_init ; switch_init ; usart_init ; lcd_init ; } vazio evm_raedy_wait ( vazio ) { lcd_clear ; printf("_______EVM______"); //============ espere até que a unidade evm seja habilitada pelo switch externo ===============// enquanto (( PINC & 0x10 ) ); _atraso_ms(50); enquanto ( !( PINC & 0x10 ) ); PORTD &= 0x7F; //============ espere até que a unidade evm seja habilitada pelo switch externo ===============// lcd_clear ; printf("VOCÊ PODE VOTAR AGORA"); } char read_key_wait (void) { botão char; enquanto (0x0F == (botão = (PINC & 0x0F))); //espera até que qualquer tecla seja pressionada // e lê o valor atual do teclado _atraso_ms(50); interruptor (botão) { caso 0x0B: retornar 0; caso 0x07: retornar 1; caso 0x0D: retorno 2; caso 0x0E: retorno 3; }; retornar 0; } vazio evm_vote ( vazio ) { botão char; botão=read_key_wait ; //espera até que qualquer tecla seja pressionada // e lê o valor atual do teclado interruptor (botão) { caso 0: contagem_atualização(0); lcd_clear ; printf("Você votou em A"); quebrar; caso 1: contagem_atualização(1); lcd_clear ; printf("Você votou em B"); quebrar; caso 2: contagem_atualização(2); lcd_clear ; printf("Você votou em C"); quebrar; caso 3: contagem_atualização(3); lcd_clear ; printf("Você votou em D"); quebrar; }; PORTD = 0x80; _atraso_ms(3000); } void update_count (int candidato_address) { int endereço_base = 100; contagem interna = 0; contagem = eeprom_read_byte ((unsigned char *) (base_address + candidate_address)); contar++; eeprom_write_byte ((unsigned char *) (base_address + candidate_address), contagem); } void send_count_out (void) { int endereço_base = 100; int eu = 0; stdout = &uart_out; printf("n______________________EVM______________________"); para (eu = 0; eu < 4; eu++) printf("nCANDIDATE: %c, NO. VOTOS: %d", ('A' + i), eeprom_read_byte ((unsigned char *) (base_address + i))); } void reset_count (void) { int endereço_base = 100; int eu = 0; para (eu = 0; eu < 4; eu++) eeprom_write_byte ((unsigned char *) (base_address + i), 0); lcd_clear ; printf("RESET(OK)"); _atraso_ms (2000); } ########## LCD ##########

#ifndef _LCD_H #define _LCD_H #ifndef F_CPU #define F_CPU 8000000 #fim se #include #include #include #include #include #define rs PA0 #define rw PA1 #define em PA2 vazio lcd_init ; void dis_cmd(char); void dis_data(char); void lcdcmd(char); void lcddata(char); vazio lcd_clear(vazio); vazio lcd_2nd_line(vazio); vazio lcd_1st_line(vazio); void lcd_string(const char *dados); int lcd_print(char c, ARQUIVO *fluxo); int lcd_scroll(const char *dados); ARQUIVO lcd_out = FDEV_SETUP_STREAM(lcd_print, NULL, _FDEV_SETUP_WRITE); char disp_beg = " "; int lcd_print(char c, ARQUIVO *fluxo) { se('n' ==c) lcd_2nd_line ; outro dis_dados(c); retornar 0; } int lcd_scroll(const char *dados) { int eu; int j = 0; strcat(disp_beg, dados); para(eu = 0; eu < 14; eu ++) strcat(disp_beg, " "); enquanto(1) { para(eu = 0;eu < 16;eu ++) { if(!disp_beg(i + j)) retornar 0; outro; dis_data(disp_beg(i + j)); } j++; _atraso_ms(500); lcd_clear ; } retornar 0; } void lcd_string(const char *dados) { para(;*dados;dados++) dis_dados (*dados); } vazio lcd_clear(vazio) { dis_cmd(0x01); _atraso_ms(10); } vazio lcd_2nd_line(vazio) { dis_cmd(0xC0); _atraso_ms(1); } vazio lcd_1st_line(vazio) { dis_cmd(0x80); _atraso_ms(1); } void lcd_init // função para inicializar { DDRA=0xFF; dis_cmd(0x02); // para inicializar o LCD no modo de 4 bits. dis_cmd(0x28); //para inicializar o LCD em 2 linhas, 5X7 pontos e modo 4 bits. dis_cmd(0x0C); dis_cmd(0x06); dis_cmd(0x80); dis_cmd(0x01); _atraso_ms(500); stdout = &lcd_out; } void dis_cmd(char cmd_value) { char cmd_valor1; cmd_valor1 = cmd_valor & 0xF0; //mascara a mordidela inferior porque os pinos PA4-PA7 são usados. lcdcmd(cmd_valor1); //envia para LCD cmd_valor1 = ((cmd_valor<<4) & 0xF0); //desloca 4 bits e mascara lcdcmd(cmd_valor1); //envia para LCD } void dis_data(char data_value) { char valor_dados1; valor_dados1=valor_dados&0xF0; lcddata(dados_valor1); valor_dados1=((valor_dados<<4)&0xF0); lcddata(dados_valor1); } void lcdcmd(char cmdout) { PORTA=cmdout; PORTA&=~(1< PORTA&=~(1< PORTA =(1< _atraso_ms(1); PORTA&=~(1< } void lcddata(char dataout) { PORTA=saída de dados; PORTA =(1< PORTA&=~(1< PORTA =(1< _atraso_ms(1); PORTA&=~(1< } #fim se

###

Código-fonte do projeto

###

#ifndef _USART_H

#define _USART_H #ifndef F_CPU #define F_CPU 8000000 #fim se #define USART_BAUDRATE 9600 #define BAUD_PRESCALE (((F_CPU / (USART_BAUDRATE * 16UL))) - 1) #include #include #include void usart_init ; void usart_putch(envio de caractere não assinado); unsigned int usart_getch ; void usart_send_string(const char* dados); int uart_print(char c, ARQUIVO *fluxo); ARQUIVO uart_out = FDEV_SETUP_STREAM(uart_print, NULL, _FDEV_SETUP_WRITE); int uart_print(char c, ARQUIVO *fluxo) { se (c == 'n') uart_print('r', fluxo); loop_until_bit_is_set(UCSRA, UDRE); UDR = c; retornar 0; } void usart_init { UCSRB = (1 << RXEN) (1 << TXEN); //Ativa o circuito de transmissão e recepção UCSRC = (1 << URSEL) (1< //Use tamanhos de caracteres de 8 bits UBRRL = BAUD_PRESCALE; // Carrega os 8 bits inferiores do valor da taxa de transmissão. //no byte baixo do registrador UBRR UBRRH = (BAUD_PRESCALE >> 8); // Carrega os 8 bits superiores do valor da taxa de transmissão. //no byte alto do registrador UBRR stdout = &uart_out; } void usart_putch(envio de caractere não assinado) { enquanto ((UCSRA & (1 << UDRE)) == 0); // Não faça nada até que o UDR esteja pronto.. // para que mais dados sejam gravados nele UDR = enviar; // Envia o byte } int não assinado usart_getch { enquanto ((UCSRA & (1 << RXC)) == 0); // Não faça nada até que os dados tenham sido recebidos e estejam prontos para serem lidos no UDR retorno(UDR); //retorna o byte } void usart_send_string(const char* dados) { para(; *dados; dados++) usart_putch(*dados); } #fim se

###