Forum

Sociedade de Educação e Cultura de São José doRio Preto LTDA
Fórum
Curso: Engenharia Elétrica

Disciplina: Controle e Automação Digital Turma: 54391
Docente: 20013690-Tacio Luiz de Souza Barbeiro
Assunto do fórum
Considere o sistema de controle lógico apresentado no esquema abaixo. O processo despeja uma quantidade exata de tinta dentro
de galões que são transportados através de uma esteira. Ao iniciar o sistema, a válvula V2 deve estar fechada para que o
reservatório seja preenchido com a quantidade exata de tinta, através do acionamento da válvula V1. Este volume exato é verificado
através do sensor de nível S1. Após esta etapa, o sistema verifica a presença de um galão na posição correta da esteira através do
sensor D e despeja o líquido dentro do galão, liberando a válvula V2. Na etapa de transporte, o motor M da esteira só deve ser
acionado se o galão estiver com a quantidade exata de tinta, sendo que o reservatório demora 10 segundos para esvaziar
completamente. O sistema deve informar em um display LCD o estado do galão (Posicionado, Enchendo, Pronto). Desenvolva um
programa em linguagem C para microcontroladores PIC capaz de realizar o processo descrito acima.
Abertura: 27/04/2011 15:12 Encerramento: 01/06/2011 17:27

Participação dos alunos:
20013690-Tacio Luiz de Souza Barbeiro 01/06/2011 17:27
Caros alunos,
A resposta do exercício do Fórum se encontra nos documentos compartilhados (Arquivos Exercício1).

20052516-Elton Daví Lourenço 01/06/2011 02:18
ainda não consegui fazer o programa, pois tive muita dificuldades no laboratório, peguei 3 pics com defeito e 3 lcd com defeito.
Agora comprei Pic e o Lcd, vou ver se consigo fazer agora programa.
Forum.rdl 06/06/2011 11:37:57 Página 1 de 28

20064424-Vitor Aparecido dos Reis 31/05/2011 13:24

#include <16f877A.h>
#use delay(clock=4000000)
#fuses HS,NOWDT,PUT,NOLVP
#include <mod_lcd.c>
int tcl = 0;
int tecla_pres;
//Aqui inicia a sub rotina de verificação de tecla pressionada
int varre_teclas (void)
{
if (!input(pin_b6)) return(1); // S1 NIVEL CHEIO(sensor)
if (!input(pin_b3)) return(2); // D POSICIONADO (sensor)
// se nenhuma tecla está pressionada, o flag desligará
// tecla_pres e retorna o valor 0
tecla_pres = 0;
return (0);
}
// Rotina principal de verificação do teclado

// Verifica se é uma nova tecla e filtra ruídos
int teclas (void)
{
int t;
t = varre_teclas(); // verifica se há tecla
if ((t) && (!tecla_pres)) // se há tecla e o flag está apagado
{
tecla_pres = 1; // Ativa o flag
if (t != tcl) // se a tecla atual é diferente da tecla anterior
{
// filtra os ruídos de contato
delay_ms (50); // aguarda 50ms
// lê novamente as tecla e verifica
// se a mesma tecla ainda está pressionada
// caso positivo, retorna a tecla
if (varre_teclas() == t) return (t);
}
}
return (0); // se não há tecla, retorna 0
}
void main(void) // Aqui inicia o programa...

{
lcd_ini();
lcd_escreve ('\f'); // apaga o display
lcd_pos_xy(1,1);
printf(lcd_escreve,"Forum 2.VitorReis \n\r");
lcd_pos_xy(1,2);
printf(lcd_escreve,"Aguarde, inicializando");
delay_ms(2000);
lcd_escreve ('\f');
while(true)
{
tcl = teclas();
if(tcl == 2)
{
output_low(PIN_B7);
lcd_pos_xy(1,2);
printf(lcd_escreve,"Posicionado");
//delay_ms(1000);
output_high(PIN_B5);
lcd_escreve('\f');
lcd_pos_xy(1,2);
printf(lcd_escreve,"Enchendo o galão...");
do
{
tcl=teclas();
}while(tcl != 1);
output_low(PIN_B5);
delay_ms(1000);
output_low(PIN_B4);
lcd_escreve('\f');
printf(lcd_escreve,"Galão cheio.");
delay_ms(1000);
}
else
{
lcd_escreve('\f');
printf(lcd_escreve,"Posicionando");
delay_ms(1000);
}
}
}
20064424-Vitor Aparecido dos Reis 31/05/2011 13:03
Boa tarde.
Estou postando essa explicação para quem assim como eu usou a sub-rotina no programa. No contexto da programação, uma sub-
rotina (função, procedimento ou mesmo subprograma) consiste em uma porção de código que resolve um problema muito
específico, parte de um problema maior (a aplicação final). O conceito de função difere da noção de procedimento, já que devolve
um valor, se bem que, em algumas linguagens, esta distinção não é sequer existente, por exemplo, em C, a implementação de um
procedimento é uma função do tipo void. No contexto da programação orientada a objetos, estas sub-rotinas são encapsuladas nos
próprios objetos, passando a designar-se métodos.
Algumas das vantagens na utilização de sub-rotinas durante a programação são:
. a redução de código duplicado num programa;
. a possibilidade de reutilizar o mesmo código sem grandes alterações em outros programas;
. a decomposição de problemas grandes em pequenas partes;
. melhorar a interpretação visual de um programa;
. esconder ou regular uma parte de um programa, mantendo o restante código alheio às questões internas resolvidas dentro dessa
função;
As componentes de uma sub-rotina são:
. O seu protótipo, que inclui os parâmetros que são passados à sub-rotina na altura da invocação;
. O corpo, que contém o bloco de código que resolve o problema proposto;
. Um possível valor de retorno, que poderá ser utilizado imediatamente a seguir à invocação da sub-rotina.
Como exemplo de compilações de sub-rotinas, a biblioteca STL da linguagem C++, que fornece ao utilizador uma série de funções e
procedimentos que realizam tarefas triviais, poupando o programador da sua reimplementação.

20071672-Tiago Henrique Michelmani 31/05/2011 12:44

#fuses HS,NOWDT,PUT,NOBROWNOUT,NOLVP
#include <mod_lcd.c> // Biblioteca de Funções do LCD
// Progama Principal
void main()
{
lcd_ini(); // inicializa o lcd
output_low(PIN_B3);
output_low(PIN_B4);
output_low(PIN_B5);
// Verificação inicial do estado atual do processo
if (input(PIN_B1))
{
do
{
output_high(PIN_B4); //Tirando o galão
while (input(PIN_B1));
}
}
if (input(PIN_B2))
{
do
{
output_high(PIN_B4); // Posicionando o galão
lcd_pos_xy(1,1);
printf (lcd_escreve,"Posicionando!");
while (!input(PIN_B1));
}
output_high(PIN_B3); //Abindo a valvula V2
output_low(PIN_B5); // Mantendo a valvula V1 fechada
lcd_pos_xy(1,1);
printf (lcd_escreve,"Enchendo");
delay_ms(10000); // Tempo de enchimento do galão
output_low(PIN_B3); // Fechando a valvula V2
lcd_pos_xy(1,1);
printf (lcd_escreve,"Pronto!");
do
{
}
}
if (input(PIN_B1)) && (input(PIN_B2))
{
do
{
}
do
{
lcd_pos_xy(1,1);
}
lcd_pos_xy(1,1);
lcd_pos_xy(1,1);
do
{
}
}
while (true)
{
do
{
output_high(PIN_B5); // Aciona a valvula V1
do
{
lcd_pos_xy(1,1);
}
}
lcd_pos_xy(1,1);
lcd_pos_xy(1,1);
do
{
}
}
}
20071046-Douglas de Marqui Zapata da Silva 30/05/2011 11:20
Bom dia pessoal, lendo as postagens no forum notei que alguns amigos optaram por criar uma subrotina de varre teclas para
analisar os sensores, tentei criar uma programação que não utiliza essa subrotina, peço que analisem minha programação afim de
comparar se ela executa a mesma função da varre teclas, obrigado.

20071046-Douglas de Marqui Zapata da Silva 30/05/2011 11:12
#include <16F877A.h> // definindo microcontrolador a ser usado
#use delay(clock=4000000) // definindo clock de 4MHZ
#include <mod_lcd.c> // incluindo biblioteca de funcionamento do LCD
#fuses HS, NOWDT, NOBROWOUT, PUT, NOLVP // definindo os parâmetros de configuração do microcontrolador para o tipo de
cristal, desativando o watch dog timer, desativando a proteção para a tensão de entrada no micro, tempo de incialização para o
LCD, e desativando a gravação do micro em baixa tensão.
//definindo nomes para os pinos a serem usados:
#define V1 PIN_B0
#define V2 PIN_B1
#define S1 PIN_B2
#define D PIN_B3
#define M PIN_B4
void main () // programa principal
{
lcd_ini(); // inicializando LCD
lcd_escreve('\f'); // limpa o LCD
lcd_pos_xy(1,1); //posicionando cursor do LCD
printf(lcd_escreve, "Automação Digital");
delay_ms(1000);
//setando os pinos:
output_low V1, V2, M;
while(true) // definindo um loop infinito no programa

{

printf(lcd_escreve, "Posicionando");
delay_ms(1000);
do
{
output_high M; //ativando esteira
}while (input M);
if (!input M)
{
output_low M; // desativando esteira
}
do
{
output_high V1; // enchendo reservatório
}while (input S1);
if (!input S1)
{
output_low V1; //fechando valvula V1

}

printf(lcd_escreve, "Enchendo");
delay_ms(1000);
output_high V2; // enchendo o galão

delay_ms(10000); // aguardando 10 segundos
output_low v2; // fechando valvula V2

printf(lcd_escreve, "Pronto");

20064362-Julierme Felipe Sisto 29/05/2011 17:44

#include <mod_lcd.c> // Biblioteca de funções do LCD
//Iniciando Programa
#define V1 (PIN_BO)
#define V2 (PIN_B1)
#define S (PIN_B2)
#define D (PIN_B3)
#define M (PIN_B4)
void main ()

output_high (V1); //saída em nível lógico alto
output_low (V2);
output_high (S); //saída em nível lógico alto
output_low (D); //saída em nível lógico baixo
output_low (M);
lcd_escreve ('\f'); // apaga o lcd
lcd_pos_xy(1,1);
printf(lcd_escreve,"Tintas");
lcd_pos_xy(1,2);
printf(lcd_escreve,"Rio Preto!");
//enchimento do tanque até o nível do sensor
while (true)
{
if(!input(S));
{
do
{
output_high (V1);
}
}
while (true0
{
if(input(S));
{
do
{
output_low (V1);
}
}
}
//Verifica se há galão no sensor
while (true)
{
if(input(D)); //verifica se já há algum galão de tinta na esteira
{
do
{
output_high (D); //ativando sensor para verificação de presença de galão
output_high (M);//ativando esteira para posicionamento de galão
lcd_escreve('\f'); //apaga o lcd
lcd_escreve_xy(1,1);
printf(lcd_escreve,"Posicionando..");
}
}
//Quando houver galão no sensor
while (true)
if(input(D));
do
{
output_low (M); //desativa motor da esteira
lcd_escreve('\f'); //limpa lcd
printf(lcd_escreve,"Posicionado!");
output_high (V2); //ativa a valvula V1 para enchimento do reservatório
delay_ms(5000);
lcd_escreve ('\f');
lcd_escreve_xy(1,1)
printf(lcd_escreve,"Enchendo..");
delay_ms(5000); //ativa o sensor para verificação do enchimento máximo do tanque
output_low (V2);
lcd_escreve ('\f'); // limpa lcd
printf(lcd_escreve,"Enchimento");
printf(lcd_escreve,"Completo");
lcd_escreve ('\f'); //apaga o lcd
}
}
//ativa o motor para retirada do galão e posicionamento de novo galão
output_high (M); //ativa motor da esteira

}

20064342-Rodrigo Carlos de Lima 28/05/2011 15:36

void main()
{
output_low(PIN_B3);
output_low(PIN_B4);
output_low(PIN_B5);
lcd_pos_xy(4,1);
printf (lcd_escreve,"Forum 2");
delay_ms(1000);
while (true)
{
if (input(PIN_B1)) //Confere se já existe algum galão posicionado
{
do
{
}while (input(PIN_B1));
output_low(PIN_B4);
delay_ms(1);
}
if (input(PIN_B2))
{
do
{
lcd_pos_xy(1,1);
}while (!input(PIN_B1));
output_low(PIN_B4);
delay_ms(1);
lcd_pos_xy(1,1);
lcd_pos_xy(1,1);
do
{
output_low(PIN_B4);
}
do
{
lcd_pos_xy(4,1);
printf (lcd_escreve,"AGUARDE!");
output_low(PIN_B5);
delay_ms(1);
do
{
lcd_pos_xy(1,1);
output_low(PIN_B4);
delay_ms(1);
lcd_pos_xy(1,1);
lcd_pos_xy(1,1);
do
{
output_low(PIN_B4);
delay_ms(1);
}
}

20071328-Douglas Rafael de Paula 23/05/2011 16:32

Segue abaixo meu programa para realizar a Função.
#define V1 PIN_B0
#define V2 PIN_B1
#define S1 input(PIN_B2)
#define D input(PIN_B3)
#define Motor PIN_B4
// Definição de Variáveis
int tcl;
boolean tecla_pres;
// Subrotina de verificação de tecla pressionada

{
if (!S1) return(1);
if (!D) return(2);
// se nenhuma tecla está pressionada, desliga o flag
tecla_pres = 0;
return (0);
}

// Verifica se é uma nova tecla e filtra ruído
int teclas (void)
{
int t;
{
tecla_pres = 1; // ativa o flag
{
// filtra o ruido de contato
}
}
}
void main()
{
tcl = 0; // limpa a tecla atual
tecla_pres = 0; // desliga o flag de tecla pressionada
output_low(V1); //Fecha valvula de enchimento reservatorio
output_low(V2); //Fecha valvula de enchimento do galão
output_low(Motor); //Desliga motor da esteira
while (true)
{
lcd_pos_xy(1,1);
printf (lcd_escreve,"Reservatorio");
lcd_pos_xy(1,2);
printf (lcd_escreve,"Enchendo... ");
output_high(V1); //Abre valvula de encher reservatorio
do{ tcl = teclas(); }while(tcl != 1); //Espera encher
output_low(V1); //Desliga valvula V1

output_high(Motor); //Liga motor
lcd_pos_xy(1,1);
printf (lcd_escreve," Galao ");
lcd_pos_xy(1,2);
printf (lcd_escreve," Posicionando ");
do{ tcl = teclas(); }while(tcl != 2); //Espera Chegar galão
output_low(Motor); //Desliga motor

output_high(V2); //Enche galão
lcd_pos_xy(1,2);
printf (lcd_escreve," Enchendo... ");
Delay_ms(10000); //Espera 10s

output_low(V2); //Desliga valvula V2
lcd_pos_xy(1,2);
printf (lcd_escreve," Pronto! ");
Delay_ms(1000);
}
}

20070361-Fabio Henrique dos Reis 22/05/2011 01:17

Segue versão revisada e compilada:
void main()
{
output_low(PIN_B3);
output_low(PIN_B4);
output_low(PIN_B5);
lcd_pos_xy(4,1);
printf (lcd_escreve,"PHENIX");
lcd_pos_xy(3,2);
printf (lcd_escreve,"AUTOMATION");
delay_ms(1000);
while (true)
{
{
do
{
output_low(PIN_B4);
delay_ms(1);
}
if (input(PIN_B2))
{
do
{
lcd_pos_xy(1,1);
output_low(PIN_B4);
delay_ms(1);
lcd_pos_xy(1,1);
lcd_pos_xy(1,1);
do
{
output_low(PIN_B4);
}
do
{
lcd_pos_xy(4,1);
printf (lcd_escreve,"AGUARDE!");
output_low(PIN_B5);
delay_ms(1);
do
{
lcd_pos_xy(1,1);
output_low(PIN_B4);
delay_ms(1);
lcd_pos_xy(1,1);
lcd_pos_xy(1,1);
do
{
output_low(PIN_B4);
delay_ms(1);
}
}

Segue uma versão revisada do programa:
void main()
{
output_low(PIN_B3);
output_low(PIN_B4);
output_low(PIN_B5);

{
do
{
}
if (input(PIN_B2))
{
do
{
lcd_pos_xy(1,1);
lcd_pos_xy(1,1);
lcd_pos_xy(1,1);
do
{
}
while (true)
{
do
{
do
{
lcd_pos_xy(1,1);
lcd_pos_xy(1,1);
lcd_pos_xy(1,1);
do
{
}
}


void main()
{
output_low(PIN_B3);
output_low(PIN_B4);
output_low(PIN_B5);
if (input(PIN_B1))
{
do
{
}
}
if (input(PIN_B2))
{
do
{
lcd_pos_xy(1,1);
}
lcd_pos_xy(1,1);
lcd_pos_xy(1,1);
do
{
}
}
if (input(PIN_B1)) && (input(PIN_B2))
{
do
{
}
do
{
lcd_pos_xy(1,1);
}
lcd_pos_xy(1,1);
lcd_pos_xy(1,1);
do
{
}
}
while (true)
{
do
{
do
{
lcd_pos_xy(1,1);
}
}
lcd_pos_xy(1,1);
lcd_pos_xy(1,1);
do
{
}
}
}
Colegas, estou tentando criar uma rotina de verificação do sistema (como ele se encontra no momento de inicialização), mas não sei
qual comando devo usar para comparar duas entradas. Alguem pode ajudar.
Colegas, estou tentando criar uma rotina de verificação do sistema (como ele se encontra no momento de inicialização), mas não sei
qual comando devo usar para comparar duas entradas. Alguem pode ajudar.
20045189-Thiago da Silva Velani 21/05/2011 09:04
Estou com um pouco de dificuldade no microcomtrolador (pic),mas estou tentando.
20064123-Lucas Fernandes Borin 18/05/2011 08:55
Fábio / Denivon,
Estou na mesma situação, com um pouco de dificuldades com o microcontrolador por ser algo novo para nós, e além de ter que
revisar toda a disciplina de programação para relembrar os conceitos.
Sugiro marcarmos uma reunião para discutir o projeto em questão e assim podermos alinhar os pensamentos. Vale ressaltar que a
dica postada pelo Laerte é muito interassante não só para esse projeto, como para o próprio TCC de cada um.
20064324-Laerte Ribeiro Silveira 17/05/2011 15:43
Caros,
aqui vai uma dica: Depois de compilado o programa, na hora de carregar o arquivo para o PIC no Proteus, ao invés de abrir o .HEX
abra o .COFF, e comece a simulação apertando o botão "pause". Se as funções estiverem habilitadas, isto permitirá que você
vizualize seu programa sendo executado linha a linha apertando a tecla F10 para dar andamento passo a passo.
OBS: Para a vizualização é preciso que seu programa esteja na mesma pasta que o seu circuito do Proteus está salvo.
Dessa forma conseguirá detectar possíveis erros em sua programação, pois ficará em seu comando cada linha de sua programação e
poderá vizualizar o circuito em funcionamento.
Porém não confunda, na hora de gravar o microcontrolador fisicamente, só deve ser carregado no programa de gravação o
arquivo .HEX
Quaisquer dúvidas podemos conversar por aqui ou em sala de aula.

20054526-Edson Antonio Barroso 17/05/2011 11:14
CAROS COLEGAS POSTEM SUAS DÚVIDAS PRA QUE POSSAMOS DISCUTIR AS LINHAS DE PROGRAMAÇÃO.
DICA: OBSERVEM O PROGRAMA DA GARAGEM QUE DA PRA UTILIZAR VARIAS ESTRUTURAS DA PROGRAMAÇÃO.
20050891-Denivon José dos Santos 16/05/2011 16:28
Fábio,
Como também é primeira vez que estou conhecendo a ferramenta microcontrolador (PIC) e o simulador (Proteus), também estou
tendo dificuldades, mas continuarei tentando, qualque novidade nos falamos.
Estou tentando criar o programa, mas estou com muitas dificuldades, principamente no que se refere aos comandos. Vou continuar
tentando e assim que tver algo pronto colocarei no forum.

20064324-Laerte Ribeiro Silveira 05/05/2011 23:02
#fuses HS,NOWDT,PUT
#include <lcd.c>
void main(){
char automato;
automato = 'A';
lcd_init();
lcd_putc('\f');
while(true){
switch (automato){
case 'A':{
output_low(pin_b2); //desliga válvula V2
output_high(pin_b1); //liga válvula V1
automato = 'B';
}
break;
case 'B':{
if (!input(pin_a0)){ //verifica o nivel do reservatório (sensor S1)
delay_ms(50); //filtra ruído no sensor S1
}
if (!input(pin_a0)){ //verifica denovo o nível do reservatório (sensor S1)
output_high(pin_b0); //liga motor da esteira
automato = 'C';
lcd_putc('\f');
}
}
break;
case 'C':{
if (!input(pin_a1)){ //verifica presença de galão (sensor D)
delay_ms(50); //filtra ruído no sensor D
}
if (!input(pin_a1)) { //verifica denovo presença de galão (sensor D)
lcd_gotoxy(1,1);
printf(lcd_putc,"Posicionado");
output_low(pin_b0); //desliga o motor da esteira
delay_ms(3000);
output_high(pin_b2); //liga válvula V2
lcd_putc('\f');
lcd_gotoxy(1,1);
printf(lcd_putc,"Enchendo");
delay_ms(10000); //10 segundos para encher o galão
lcd_putc('\f');
lcd_gotoxy(1,1);
printf(lcd_putc,"Pronto");
automato = 'A';
}
}
break;
}
}
}

20054526-Edson Antonio Barroso 02/05/2011 15:23

#fuses HS,NOWDT,PUT,NOLVP
#include <mod_lcd.c>
int tcl = 0;
int tecla_pres;
// Subrotina de verificação de tecla pressionada
{
if (!input(pin_b6)) return(1); // S1 NIVEL CHEIO(sensor)
if (!input(pin_b3)) return(2); // D POSICIONADO (sensor)
// se nenhuma tecla está pressionada, desliga o flag
tecla_pres = 0;
return (0);
}

// Verifica se é uma nova tecla e filtra ruído
int teclas (void)
{
int t;
{
tecla_pres = 1; // ativa o flag
{
// filtra o ruido de contato
}
}
}
void main(void) // Programa inicia aqui...

{
lcd_ini();
lcd_pos_xy(1,1);
printf(lcd_escreve,"Forum 2.EdsonAB \n\r");
lcd_pos_xy(1,2);
printf(lcd_escreve,"Inicializando");
delay_ms(2000);
lcd_escreve ('\f');
while(true)
{
tcl = teclas();
if(tcl == 2)
{
output_low(PIN_B7);
lcd_pos_xy(1,2);
printf(lcd_escreve,"Posicionado");
//delay_ms(1000);
lcd_escreve('\f');
lcd_pos_xy(1,2);
printf(lcd_escreve,"Enchendo");
do
{
tcl=teclas();
}while(tcl != 1);
output_low(PIN_B5);
delay_ms(1000);
output_low(PIN_B4);
lcd_escreve('\f');
printf(lcd_escreve,"Cheio");
delay_ms(1000);
}
else
{
lcd_escreve('\f');
printf(lcd_escreve,"Posicionando");
delay_ms(1000);
}
}
}

Forum

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Forum

Enviado por

Direitos autorais:

Formatos disponíveis

Sociedade de Educação e Cultura de São José doRio Preto LTDA

Curso: Engenharia Elétrica

Abertura: 27/04/2011 15:12 Encerramento: 01/06/2011 17:27

A resposta do exercício do Fórum se encontra nos documentos compartilhados (Arquivos Exercício1).

Forum.rdl 06/06/2011 11:37:57 Página 1 de 28

Forum.rdl 06/06/2011 11:37:57 Página 2 de 28

// Rotina principal de verificação do teclado

void main(void) // Aqui inicia o programa...

Forum.rdl 06/06/2011 11:37:57 Página 4 de 28

Forum.rdl 06/06/2011 11:37:57 Página 5 de 28

#include <mod_lcd.c> // Biblioteca de Funções do LCD

// Verificação inicial do estado atual do processo

Forum.rdl 06/06/2011 11:37:57 Página 7 de 28

//definindo nomes para os pinos a serem usados:

void main () // programa principal

while(true) // definindo um loop infinito no programa

lcd_escreve('\f'); // limpa o LCD

}while (input M);

}while (input S1);

output_low V1; //fechando valvula V1

lcd_escreve('\f'); // limpa o LCD

output_high V2; // enchendo o galão

lcd_escreve('\f'); // limpa o LCD

Forum.rdl 06/06/2011 11:37:57 Página 8 de 28

Forum.rdl 06/06/2011 11:37:57 Página 9 de 28

#include <mod_lcd.c> // Biblioteca de funções do LCD

lcd_ini(); // inicializa o lcd

//enchimento do tanque até o nível do sensor

//Verifica se há galão no sensor

//Quando houver galão no sensor

//ativa o motor para retirada do galão e posicionamento de novo galão

output_high (M); //ativa motor da esteira

Forum.rdl 06/06/2011 11:37:57 Página 11 de 28

Forum.rdl 06/06/2011 11:37:57 Página 12 de 28

#include <mod_lcd.c> // Biblioteca de Funções do LCD

Forum.rdl 06/06/2011 11:37:57 Página 14 de 28

Forum.rdl 06/06/2011 11:37:57 Página 15 de 28

#include <mod_lcd.c> // Biblioteca de Funções do LCD

// Subrotina de verificação de tecla pressionada

// Rotina principal de verificação do teclado

printf (lcd_escreve,"Enchendo... ");

output_high(V1); //Abre valvula de encher reservatorio

do{ tcl = teclas(); }while(tcl != 1); //Espera encher

output_low(V1); //Desliga valvula V1

do{ tcl = teclas(); }while(tcl != 2); //Espera Chegar galão

output_low(Motor); //Desliga motor

Delay_ms(10000); //Espera 10s

Forum.rdl 06/06/2011 11:37:57 Página 17 de 28

Forum.rdl 06/06/2011 11:37:57 Página 18 de 28

#include <mod_lcd.c> // Biblioteca de Funções do LCD

Forum.rdl 06/06/2011 11:37:57 Página 20 de 28

#include <mod_lcd.c> // Biblioteca de Funções do LCD

// Verificação inicial do estado atual do processo

if (input(PIN_B1)) //Confere se já existe algum galão posicionado

Forum.rdl 06/06/2011 11:37:57 Página 21 de 28

Forum.rdl 06/06/2011 11:37:57 Página 22 de 28

#include <mod_lcd.c> // Biblioteca de Funções do LCD

// Verificação inicial do estado atual do processo

Quaisquer dúvidas podemos conversar por aqui ou em sala de aula.

Forum.rdl 06/06/2011 11:37:57 Página 24 de 28

Forum.rdl 06/06/2011 11:37:57 Página 25 de 28

Forum.rdl 06/06/2011 11:37:57 Página 26 de 28

// Rotina principal de verificação do teclado

void main(void) // Programa inicia aqui...