Como trabalhar com timer dos pic na linguagem c ccs

[ze2]

não era pra dar ctrl-c ctrl-v. era pra analisar e/ou entender pow. uso o hitech-c.
aguardar a água é fácil
#define nivel_agua RA2
while(!nivel_agua); //trava o processamento até encher hein
no seu compilador algo como
output_high(encher_tanquinho);
while(!input(nivel_agua);//trava o processamento até encher hein
//break; // <-pra direcionar pro case 2 tire o break
case 2:
...
sei lá... 2old4this....

[andre_luis]

...não estou sabendo uma forma de quando chegar no final da primeira case, mandar a saida de encher o tanquinho ficar acionada, aguardando o nivel de agua ( no caso quando a agua encostar no sensor e o mesmo mandar p/ o pic o 1(5v)), e direcionar para o case 2 que se faz referencia ao enxague:

Basta que você insira mais uma etapa entre o case 1 e o case 2.

Na verdade, para manter uma intelegibilidade no programa e tornar menos penosa a depuração, recomendo fortemente você não usar numeros nas constantes, mas sim um texto descritiva para cada, etapa conforme o exemplo que postei mais acima, que aplicado no seu caso ficaria algo assim:

cpp code

#define         ETAPA_QUE_FAZ_ISSO             1
#define         ETAPA_QUE_FAZ_AQUILO         2 
#define         ETAPA_QUE_FAZ_OUTRA COISA     3

No seu programa ficaria assim para a primeira etapa:
cpp code

switch (a){
 case ETAPA_QUE_FAZ_ISSO :
       temp1=0;{
       output_high(rodar_motor);
       while(temp1>=0 && temp1<=30);

Para a etapa intermediária, poderia ser algo assim, em pseudo-código :
cpp code

case ETAPA_QUE_FAZ_AQUILO :
       while ( sensor não esta acionado ) { } ; // ou seja, não faz nada enquanto não encher

Notar que cada estado de funcionamento da máquina pode ser colocada dentro de um case.

[carlucio]

Meu problema agora esta nesta parte, quando tento ativar a saida encher tanquinho se não colocar a temporização não ativa a saida e tambem da forma que coloquei o aguarda nivel e da maneira utilizando o while não esta funcionado conforme abaixo:


output_high(encher_tanquinho);{ --------------------->> Ativa saida
while(!input(nivel_agua) == 1){ ---------------------------->>>>> AGUARDA ATINGIR O NIVEL PARA DIRECIONAR PARA A CASE 2 que testei e não funcionou
a=2;
// }

while(temp1>=116 && temp1<=130); ---------------->>> Se não colocar uma temporização não funciona e tambem quando a saida estiver liberada atraves da
} temporização não aceita o comando do nivel acima citado.
break;

Alguem temm ideia do que esta errado.

[andre_luis]

Não olhei seu programa com mais calma, mas provavelmente não esteja funcionando porque você realiza atribuição de valores da variável a não somente dentro do case, mas também no programa principal, e isso é uma pratica não muito recomendada em programação, como mostrado nos trechos abaixo extraidos do seu programa.

cpp code

while(true)
    {
    output_low(rodar_motor);
    output_low(esvaziar_tanquinho);
    output_low(encher_tanquinho);

    if(input(programa_1)==0)
        {
        processo_normal();
        a=1;
        }

cpp code

void função 1(void)
    {
    a=1
    switch (normal)
        {

Experimenta fazer como implementei no artigo postado na seção Blog, onde no final de cada case, é apontado o valor do próximo switch, e somente nesses locais é que devem ser atribuidos os valores para a sua variável a.

Ou seja, aplicado no seu caso, seria algo assim:
cpp code

switch ( a )
    {
    case 1:   { Rotinas diversas; a=2 ; break ; }
    case 2:   { Rotinas diversas; a=3 ; break ; }
    case 3:   { Rotinas diversas; a=4 ; break ; }
    ...
    default:  { a=1 ; break ; } // Aqui será carregado o valor inicial dessa variável
    }

+++

[carlucio]

Andre,

Fiz conforme voce me orientou, mas quando retirei a atribuição de a do while(true) o programa não faz nada. Mesmo assim fiz umas modificações no programa conforme orientação sua e mesmo assim não esta funcionando segue o codigo abaixo:

Código: Selecionar todos

#include "C:\Documents and Settings\CARLUCIO\Desktop\switch teste\tanquinho aut.h"

#define nivel_agua pin_a2
#define programa_1    pin_a3
#define programa_2    pin_a0
#define encher_tanquinho pin_b3
#define esvaziar_tanquinho pin_b0
#define alarme     pin_b5
#define rodar_motor pin_b4

int a=0;
int16 temp1=0, temp2=0, temp3=0;


int contagem_t0=0;
int processo_normal, processo_enxague;
static boolean led;


#int_RTCC
void  RTCC_isr(void)
{
set_timer0 (131-get_timer0());
contagem_t0++;
if(contagem_t0==125)
{
contagem_t0=0;
led=!led;
output_bit(pin_a6,led);
if(temp1==2000)
{
temp1=0;
}
else{
temp1++;
}

if(temp2==3000)
{
temp2=0;
}
else{
temp2++;
}
if(temp3==1000)
{
temp3=0;
}
else{
temp3++;
}

}
}



void processo_normal(void){

switch (a){

case 1:
       temp1=0;//{
       output_high(rodar_motor);
       while(temp1>=0 && temp1<=30);
       //}
       output_low(rodar_motor);//{
       
       while(temp1>=31 && temp1<=60);
      // }
       output_high(rodar_motor);//{
       
       while(temp1>=61 && temp1<=80);
       //}
       output_low(rodar_motor);//{
       
       while(temp1>=81 && temp1<=90);
       //}
              output_high(esvaziar_tanquinho);//{
       
       while(temp1>=91 && temp1<=110);
             // }
       output_low(esvaziar_tanquinho);//{ ---------------------->>>>> Meu problema esta daqui em diante, não consigo fazer o programa ativar a saia encher tanquinho sem                                              determinar a ela uma temporização e quando determino a mesma não aceita logo apos ser direcionado  para outra case.
       a=3;
       
       
     while(temp1>=111 && temp1<=115);
           

       //output_high(encher_tanquinho);//{
      // while(!input(nivel_agua))//{
       //a=3;
       
      // }
       
       
       while(temp1>=116 && temp1<=130);
       //}
       break;
       


case 2:
       
       output_low(encher_tanquinho);
       delay_ms(1000);
       output_high(rodar_motor);

       temp1=0;
       while(temp1>=0 && temp1<=30);
       {
       output_low(rodar_motor);
       }
       while(temp1>=31 && temp1<=60);
       {
       output_high(rodar_motor);
       }
       while(temp1>=61 && temp1<=80);
       {
       output_low(rodar_motor);
       }
       while(temp1>=81 && temp1<=85);
       {
       //output_low(rodar_motor);
       //delay_ms(2000);
       output_high(esvaziar_tanquinho);
       }
       while(temp1>=86 && temp1<=100);
       {
       output_low(esvaziar_tanquinho);
       delay_ms(2000);
       output_high(encher_tanquinho);
       }
   
       

       

 break;


case 3:
      output_high(encher_tanquinho);
      while(input(nivel_agua)==0)
      output_low(encher_tanquinho);
      a=2;
      break;
     
     
     
      default: a=1;
      break;



}
}











void main()
{

   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_64);
  set_timer0(131);
  setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
   enable_interrupts(INT_RTCC);
   enable_interrupts(GLOBAL);
//Setup_Oscillator parameter not selected from Intr Oscillator Config tab

   // TODO: USER CODE!!

while(true)
{

output_low(rodar_motor);
output_low(esvaziar_tanquinho);
output_low(encher_tanquinho);


if(input(programa_1)==0){
processo_normal();
a=1;  ----------------------------------------->>>>>Não faz nada se não fizer esta referencia
}

//if(input(nivel_agua)==0){
//processo_normal();
//a=2;
//}
//
}

}

Queria saber porque a saida encher tanquinh não esta sendo ativa sem determinar uma temporização e porque o programa no final da case 1 não esta direcionando para outra case ?!

[cfreund]

Abaixo, um programa que faz a mesma coisa que o seu. Coloque para funcionar e corrija os problemas sem mexer com a estrutura.

cpp code

#use delay(clock=20000000) // << Frequência do crystal é de 20MHz?

#define PIN_NIVEL_AGUA			pin_a2
#define PIN_BOT_PROG1			pin_a3
#define PIN_BOT_PROG2			pin_a0
#define PIN_ENCHER				pin_b3
#define PIN_ESVAZIAR			pin_b0
#define PIN_MOTOR				pin_b4
#define PIN_ALARME				pin_b5

#define FUNC_LIGA_MOTOR()		{ output_high(PIN_MOTOR); }
#define FUNC_DESLIGA_MOTOR()	{ output_low (PIN_MOTOR); }

#define FUNC_ESVAZIAR()			{	output_high(PIN_ESVAZIAR);			\
									delay_ms(30000);					\
									output_low(PIN_ESVAZIAR); 			\
								}
								  
#define FUNC_ENCHER()			{	output_high(PIN_ENCHER);			\
									while (input(PIN_NIVEL_AGUA) == 0);	\	// Aguarda enquanto o pino A2 estiver em "0 Volts"
									output_low(PIN_ENCHER);				\
								}
								
#define FUNC_ALARME()			{	output_high(PIN_ALARME);			\
									delay_ms(5000);						\
									output_low(PIN_ALARME);				\
								}

enum {
	FIM,			// = 0
	ESPERA_1MIN,	// = 1
	ESPERA_2MIN,
	ESPERA_3MIN,
	ESPERA_4MIN,
	ESPERA_5MIN,
	INICIO,
	COMPLETAR_AGUA,
	LAVAR,
	DESCARTAR_AGUA,
} STEPS;

const unsigned char funcao1[] = {
	INICIO,
	
	DESCARTAR_AGUA,
	COMPLETAR_AGUA,

	LAVAR,			// Motor ligado por 30 segundos e desligado por mais 30.
	LAVAR,			// Cada operação LAVAR, tem a duração de 60 segundos.
	LAVAR,			// ...
	LAVAR,			// 4x LAVAR = 4 minutos

	DESCARTAR_AGUA,
	
	FIM
};

const unsigned char funcao2[] = {
	INICIO,
	
	DESCARTAR_AGUA,
	COMPLETAR_AGUA,

	LAVAR,
	ESPERA_5MIN,	// 5 minutos sem fazer nada.
	LAVAR,

	DESCARTAR_AGUA,
	
	FIM
};

void executar (const unsigned char *passos);

int main () {
	setup_timer_0 (T0_DISABLED);
	setup_timer_1 (T1_DISABLED);
	setup_timer_2 (T2_DISABLED,0,1);
	setup_comparator (NC_NC_NC_NC);
	setup_vref (FALSE);

	output_low(PIN_MOTOR);
	output_low(PIN_ESVAZIAR);
	output_low(PIN_ENCHER);
	output_low(PIN_ALARME);
	
	while (1) {
		if (input(PIN_BOT_PROG1)) {
			executar(funcao1);
		else if (input(PIN_BOT_PROG2)) {
			executar(funcao2);
		}
	}
}

void executar (const unsigned char *passos) {
	unsigned int  i;

	for (; *passos; ++passos) {
		switch (*passos) {
		case ESPERA_1MIN:
		case ESPERA_2MIN:
		case ESPERA_3MIN:
		case ESPERA_4MIN:
		case ESPERA_5MIN:
			i = *passos * 60;			// Ex. Se passos = ESPERA_4MIN, i = 60 * 4
			while(i--) delay_ms(1000);	// OBS: delay_ms(x); x não deve ser maior que 65535.
			break;
			
		case INICIO:
			FUNC_LIGA_MOTOR();
			delay_ms(30000);			// Aguarda 30 segundos
			FUNC_DESLIGA_MOTOR();
			delay_ms(30000);
			FUNC_LIGA_MOTOR();
			delay_ms(30000);
			FUNC_DESLIGA_MOTOR();
			break;
			
		case LAVAR:
			FUNC_LIGA_MOTOR();
			delay_ms(30000);
			FUNC_DESLIGA_MOTOR();
			delay_ms(30000);
			break;
			
		case COMPLETAR_AGUA:
			FUNC_ENCHER();
			break;
			
		case DESCARTAR_AGUA:
			FUNC_ESVAZIAR();
			break;
			
		default: // FIM
			FUNC_ALARME();
			delay_ms(5000);
			FUNC_ALARME();
			delay_ms(5000);
			FUNC_ALARME();
			return;
		}
	}
}

[carlucio]

Cfreund,

Ate peço desculpas para outras pessoas, mas a temporização que estou fazendo para testes uso poucos segundos, mas os tempos vao giram em torno de 5 , 4 e 3 minutos.
Mesmo assim agradeço pela dica e vou tentar fazer adaptações para minha necesssidade.

[cfreund]

Fiz alguns comentários no código. Espia lá.

[carlucio]

Cfreund,

Fiz conforme o programa que voce postou e fiz algumas alterações mas, não sei porque esta aparecendo 38 erros. Veja:

Código: Selecionar todos

#include "C:\Documents and Settings\CARLUCIO\Desktop\enumeração\aut tank.h"
//#int_RTCC
///void  RTCC_isr(void)
//{

//}

//#use delay(clock=20000000) // << Frequência do crystal é 20MHz? ------------->>>>> Utilizei  o clock interno de 4mhz
 
#define PIN_NIVEL_AGUA  pin_a2
#define PIN_BOT_PROG1   pin_a3
#define PIN_BOT_PROG2   pin_a0
#define PIN_ENCHER      pin_b3
#define PIN_ESVAZIAR    pin_b0
#define PIN_MOTOR       pin_b4
#define PIN_ALARME      pin_b5
 
#define FUNC_LIGA_MOTOR()       { output_high(PIN_MOTOR); }
#define FUNC_DESLIGA_MOTOR()    { output_low (PIN_MOTOR); }
 
#define FUNC_ESVAZIAR()        { output_high(PIN_ESVAZIAR); \ ------------->>>>> esta barra aqui esta certa? Precisa ?
                                  delay_ms(30000);           \     // Aguarda 30 segundos
                                  output_low(PIN_ESVAZIAR); \
                                }
                                   
#define FUNC_ENCHER()           { output_high(PIN_ENCHER);
                                  while (input(PIN_NIVEL_AGUA) == 0);  // Aguarda enquanto o pino A2 estiver em "0 Volts"
                                  output_low(PIN_ENCHER);   -------------->>>>> No define pode ser fazer mensão a funções do programa com abertura e fechamento das chaves, neste local (no define ? ) :?:
                                }
                                 
#define FUNC_ALARME()           { output_high(PIN_ALARME); \
                                  delay_ms(5000); \             // Aguarda 10 segundos
                                  output_low(PIN_ALARME); \
                                }
 
enum {
    FIM,            // = 0
    ESPERA_1MIN,    // = 1
    ESPERA_2MIN,
    ESPERA_3MIN,
    ESPERA_4MIN,
    ESPERA_5MIN,
    ESPERA_6MIN,    // = 6
    INICIO,
    COMPLETAR_AGUA,
    LAVAR,
    DESCARTAR_AGUA,
} STEPS;
 
 
const unsigned char funcao1[] = {
    INICIO,
     
    DESCARTAR_AGUA,
    COMPLETAR_AGUA,
 
    LAVAR,
 
    DESCARTAR_AGUA,
     
    FIM
};
 
const unsigned char funcao2[] = {
    INICIO,
     
    DESCARTAR_AGUA,
    COMPLETAR_AGUA,
 
    LAVAR,
    ESPERA_5MIN,
    LAVAR,
 
    DESCARTAR_AGUA,
     
    FIM
};
 
void executar (const unsigned char *passos){
 
void main () {
    setup_timer_0 (T0_DISABLED);
    setup_timer_1 (T1_DISABLED);
    setup_timer_2 (T2_DISABLED,0,1);
    setup_comparator (NC_NC_NC_NC);
    setup_vref (FALSE);
 
    output_low(PIN_MOTOR);
    output_low(PIN_ESVAZIAR);
    output_low(PIN_ENCHER);
    output_low(PIN_ALARME);
     
    while (1) {
        if (input(PIN_BOT_PROG1)) {
            executar(funcao1);
        else if (input(PIN_BOT_PROG2)) {
            executar(funcao2);
        }
    }
}
 
void executar (const unsigned char *passos) {
    unsigned int  i;
 
    for (; *passos; ++passos) {
        switch(*passos){
        case ESPERA_2MIN:
        case ESPERA_3MIN:
        case ESPERA_4MIN:
        case ESPERA_5MIN:
        case ESPERA_6MIN:
            i = 60 * (*passos);         // Ex. Se passos = ESPERA_4MIN, i = 60 * 4
            while(i--) delay_ms(1000);  // OBS: delay_ms(x); x não deve ser maior que 65535.
            break;
             
        case INICIO:
            FUNC_LIGA_MOTOR();
            delay_ms(30000);    // Aguarda 30 segundos
            FUNC_DESLIGA_MOTOR();
            delay_ms(30000);
            FUNC_LIGA_MOTOR();
            delay_ms(30000);
            FUNC_DESLIGA_MOTOR();
            break;
             
        case LAVAR:
            FUNC_LIGA_MOTOR();
            delay_ms(30000);
            FUNC_DESLIGA_MOTOR();
            delay_ms(30000);
            FUNC_LIGA_MOTOR();
            delay_ms(30000);
            FUNC_DESLIGA_MOTOR();
            delay_ms(30000);
            break;
             
        case COMPLETAR_AGUA:
            FUNC_ENCHER();
            break;
             
        case DESCARTAR_AGUA:
            FUNC_ESVAZIAR();
            break;
             
        default:  //FIM
            FUNC_ALARME();
            delay_ms(5000);
            FUNC_ALARME();
            delay_ms(5000);
            FUNC_ALARME();
            return;
        }
    }
}

}
}
//void main()
//{

//   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_64);
  // setup_timer_1(T1_DISABLED);
  // setup_timer_2(T2_DISABLED,0,1);
  // setup_comparator(NC_NC_NC_NC);
  // setup_vref(FALSE);
  // enable_interrupts(INT_RTCC);
   //enable_interrupts(GLOBAL);
//Setup_Oscillator parameter not selected from Intr Oscillator Config tab

   // TODO: USER CODE!!

//}

Os erros mais comuns e repetidos são estes:

1- expecting a identifier;
2- expecting a declaration;
3-expecting a( ------------------>>>> o lugar onde aparece este problema ja esta com os parenteses
4- undefinied identifier t0 disabled
5- expecitng close a paren ------------->>>> lugar que tambem ja tem os parenteses
6- a numeric expression must apper here
7- undefinied identifier passos
8- expect } --------->>>>> em lugares que ja tem as chaves normalmente


Como ainda não trabalhei com enumerações, estou amarado neste ponto sem saber o que fazer, e tentei de todo o jeito sanar os problemas que apareceram mas sem sucesso.

[cfreund]

O problema estava nas constantes. A arquitetura utilizada pelo PIC, não permite manipular do jeito que eu estava fazendo. Falha minha.

Arquivo "lavadora.h":
cpp code

#include <16F628A.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O

#use delay(internal=4000000)

Arquivo "lavadora.c":
cpp code

#include <lavadora.h>

#define PIN_NIVEL_AGUA          pin_a2
#define PIN_BOT_PROG1           pin_a3
#define PIN_BOT_PROG2           pin_a0
#define PIN_ENCHER              pin_b3
#define PIN_ESVAZIAR            pin_b0
#define PIN_MOTOR               pin_b4
#define PIN_ALARME              pin_b5
 
#define FUNC_LIGA_MOTOR()       { output_high(PIN_MOTOR); }
#define FUNC_DESLIGA_MOTOR()    { output_low (PIN_MOTOR); }
 
#define FUNC_ESVAZIAR()         { output_high(PIN_ESVAZIAR);            \
                                  delay_ms(30000);                      \
                                  output_low(PIN_ESVAZIAR);             \
                                }
                                   
#define FUNC_ENCHER()           { output_high(PIN_ENCHER);              \
                                  while (input(PIN_NIVEL_AGUA) == 0);   \
                                  output_low(PIN_ENCHER);               \
                                }
                                 
#define FUNC_ALARME()           { output_high(PIN_ALARME);              \
                                  delay_ms(5000);                       \
                                  output_low(PIN_ALARME);               \
                                }
 
enum STEPS {
    FIM,            // = 0
    ESPERA_1MIN,    // = 1
    ESPERA_2MIN,
    ESPERA_3MIN,
    ESPERA_4MIN,
    ESPERA_5MIN,
    INICIO,
    COMPLETAR_AGUA,
    LAVAR,
    DESCARTAR_AGUA,
};
 
unsigned char funcao1[] = {
    INICIO,
     
    DESCARTAR_AGUA,
    COMPLETAR_AGUA,
 
    LAVAR,          // Motor ligado por 30 segundos e desligado por mais 30.
    LAVAR,          // Cada operação LAVAR, tem a duração de 60 segundos.
    LAVAR,          // ...
    LAVAR,          // 4x LAVAR = 4 minutos
 
    DESCARTAR_AGUA,
     
    FIM
};
 
unsigned char funcao2[] = {
    INICIO,
     
    DESCARTAR_AGUA,
    COMPLETAR_AGUA,
 
    LAVAR,
    ESPERA_5MIN,    // 5 minutos sem fazer nada.
    LAVAR,
 
    DESCARTAR_AGUA,
     
    FIM
};
 
void executar (unsigned char *passos);
 
void main () {
    setup_comparator (NC_NC_NC_NC);
    setup_vref (FALSE);
 
    output_low(PIN_MOTOR);
    output_low(PIN_ESVAZIAR);
    output_low(PIN_ENCHER);
    output_low(PIN_ALARME);
     
    while (true) {
        if (input(PIN_BOT_PROG1)) {
            executar (funcao1);
        } else if (input(PIN_BOT_PROG2)) {
            executar (funcao2);
        }
    }
}
 
void executar (unsigned char *passos) {
    unsigned int  i;
 
    for (; *passos; ++passos) {
        switch (*passos) {
        case ESPERA_1MIN:
        case ESPERA_2MIN:
        case ESPERA_3MIN:
        case ESPERA_4MIN:
        case ESPERA_5MIN:
            i = (*passos) * 60;         // Ex. Se passos = ESPERA_4MIN, i = 60 * 4
            while(i--) delay_ms(1000);  // OBS: delay_ms(x); x não deve ser maior que 65535.
            break;
             
        case INICIO:
            FUNC_LIGA_MOTOR();
            delay_ms(30000);            // Aguarda 30 segundos
            FUNC_DESLIGA_MOTOR();
            delay_ms(30000);
            FUNC_LIGA_MOTOR();
            delay_ms(30000);
            FUNC_DESLIGA_MOTOR();
            break;
             
        case LAVAR:
            FUNC_LIGA_MOTOR();
            delay_ms(30000);
            FUNC_DESLIGA_MOTOR();
            delay_ms(30000);
            break;
             
        case COMPLETAR_AGUA:
            FUNC_ENCHER();
            break;
             
        case DESCARTAR_AGUA:
            FUNC_ESVAZIAR();
            break;
             
        default: // FIM
            FUNC_ALARME();
            delay_ms(5000);
            FUNC_ALARME();
            delay_ms(5000);
            FUNC_ALARME();
            return;
        }
    }
}

[carlucio]

cfreund,


Ok, agora compilou.
Como trabalhei na madrugada vou deixar para testar mais tarde.
A unica coisa que vi e que vou ter que alterar a sequencia logica do funcionamento.


Quando ponho o programa para rodar ele ja vai direta para a função 1, ou seja, não esta funcionando quando aperto o botão referente a função 1 ou 2.
A sequencia do processo deve ser essa:

Seleciona o botão referente ao processo escolhido;
enche o tanquinho ate chegar ao sensor de nivel;
roda o motor e para na seguinte ordem: 5min opera/3min para/ 4min opera / 2 min para / 3 min roda / descarta agua / aciona sirene para função 1
5min opera/3min para/ 4min opera / 2 min para / 3 min roda / descarta agua / enche novamente ate o sensor / 5min opera/3min para/ 4min opera / descarta agua aciona sirene para função 2;

Mas o processo acima tentarei modificar. Desde ja muito obrigado.


Agora minha duvida, e saber se so incluir no programa um if(input (PIN_BOT_PROG1)==0) dentro do switch case mencionado acima, resolve o problema para selecionar o programa desejado?

[cfreund]

Para resolver o problema no botão, altere:

cpp code

while (true) {
        if (input(PIN_BOT_PROG1) == 0) {
            executar (funcao1);
        } else if (input(PIN_BOT_PROG2) == 0) {
            executar (funcao2);
        }
    }

Processos:
cpp code

unsigned char funcao1[] = {    // 5min opera/3min para/ 4min opera / 2 min para / 3 min roda / descarta agua / aciona sirene para função 1
    INICIO,          // Para acomodar a roupa?
      
    DESCARTAR_AGUA,          // Trocar água no caso de um RESET?
    COMPLETAR_AGUA,          // 
  
    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 5 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.
  
    ESPERA_3MIN,                   // Não faz nada durante três minutos

    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 4 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.

    ESPERA_2MIN,                   // Não faz nada durante dois minutos

    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 3 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.

    DESCARTAR_AGUA,
      
    FIM                                    // Aciona Sierene e encerra função executar()
};

unsigned char funcao2[] = {    // 5min opera/3min para/ 4min opera / 2 min para / 3 min roda / descarta agua / 
                                            //enche novamente ate o sensor / 5min opera/3min para/ 4min opera / descarta agua aciona sirene
    INICIO,          // Para acomodar a roupa?
      
    DESCARTAR_AGUA,          // Trocar água no caso de um RESET?
    COMPLETAR_AGUA,          // 
  
    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 5 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.
  
    ESPERA_3MIN,                   // Não faz nada durante três minutos

    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 4 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.

    ESPERA_2MIN,                   // Não faz nada durante dois minutos

    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 3 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.

    DESCARTAR_AGUA,
    COMPLETAR_AGUA,
  
    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 5 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.
  
    ESPERA_3MIN,                   // Não faz nada durante três minutos

    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 4 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.

    DESCARTAR_AGUA,

    FIM                                    // Aciona Sierene e encerra função executar()
};

Você não precisa mudar nada dentro da função executar() para fazer funcionar.

Talvez seja necessário alterar os valores de delay_ms() para aumentar/diminuir o tempo de trabalho.

Ou, adicionar uma função. Por exemplo, CENTRIFUGAR. Ficaria assim:

cpp code

enum STEPS {
    FIM,            // = 0
    ESPERA_1MIN,    // = 1
    ESPERA_2MIN,
    ESPERA_3MIN,
    ESPERA_4MIN,
    ESPERA_5MIN,
    INICIO,
    COMPLETAR_AGUA,
    LAVAR,
    DESCARTAR_AGUA,
    CENTRIFUGAR                    // ******
};
  
unsigned char funcao1[] = {
    INICIO,
      
    DESCARTAR_AGUA,
    COMPLETAR_AGUA,
  
    LAVAR,          // Motor ligado por 30 segundos e desligado por mais 30.
    LAVAR,          // Cada operação LAVAR, tem a duração de 60 segundos.
    LAVAR,          // ...
    LAVAR,          // 4x LAVAR = 4 minutos
  
    DESCARTAR_AGUA,
      
    CENTRIFUGAR,                // ***************

    FIM
};

// Incluir no switch-case:
case CENTRIFUGAR:
            FUNC_LIGA_MOTOR();
            delay_ms(60000);
            delay_ms(60000);
            delay_ms(60000);            // 3 minutos
            FUNC_DESLIGA_MOTOR();
            break;

[carlucio]

Cfreund,

No programa, quando aciono o botão 1 o mesmo conforme alterações que eu fiz retirando inicio e descartar agua que não eram necessarios, agora o programa fica travado direto no motor rodando, não entendi porque. (creio que é a mesma coisa para o botão 2)

Código: Selecionar todos

#define PIN_NIVEL_AGUA          pin_a2
#define PIN_BOT_PROG1           pin_a3
#define PIN_BOT_PROG2           pin_a0
#define PIN_ENCHER              pin_b3
#define PIN_ESVAZIAR            pin_b0
#define PIN_MOTOR               pin_b4
#define PIN_ALARME              pin_b5
 
#define FUNC_LIGA_MOTOR()       { output_high(PIN_MOTOR); }
#define FUNC_DESLIGA_MOTOR()    { output_low (PIN_MOTOR); }
 
#define FUNC_ESVAZIAR()         { output_high(PIN_ESVAZIAR);            \
                                  delay_ms(60000);        \
                                  delay_ms(60000);        \                  ---------------------->>>>> Tive que alterar pois um tanquinho não esvaziasse em menos 3 minutos
                                  delay_ms(60000);        \
                                  output_low(PIN_ESVAZIAR);             \
                                }
                                   
#define FUNC_ENCHER()           { output_high(PIN_ENCHER);              \
                                  while (input(PIN_NIVEL_AGUA) == 0);   \
                                  output_low(PIN_ENCHER);               \
                                }
                                 
#define FUNC_ALARME()           { output_high(PIN_ALARME);              \
                                  delay_ms(5000);                       \
                                  output_low(PIN_ALARME);               \
                                }
 
enum STEPS {
    FIM,            // = 0
    ESPERA_1MIN,    // = 1
    ESPERA_2MIN,
    ESPERA_3MIN,
    ESPERA_4MIN,
    ESPERA_5MIN,
    INICIO,
    COMPLETAR_AGUA,
    LAVAR,
    DESCARTAR_AGUA,
    CENTRIFUGAR
};
 
unsigned char funcao1[] = {
  //  INICIO,          // Para acomodar a roupa?                      ------------------- >>>>>Não se faz necessario, pois o motor sem agua internamente pode travar com peso da         roupa
       
 //   DESCARTAR_AGUA,          // Trocar água no caso de um RESET?  -------->>>>>> O primeiro processo deve ser encher tanquinho
    COMPLETAR_AGUA,  //   ------>>>> Quando acionar o botão 1 deve-se encher o tanquinho para depois liberar o processo lavar, não se esta fazendo isso!
 
   // CENTRIFUGAR
 
    LAVAR,  ----------------------------->>>>>>>>>>> Para iniciar aqui, depende-se de se ter agua no tanquinho.
    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 5 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.
   
    ESPERA_3MIN,                   // Não faz nada durante três minutos
 
    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 4 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.
 
    ESPERA_2MIN,                   // Não faz nada durante dois minutos
 
    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 3 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.
 
    DESCARTAR_AGUA,
       
    FIM                                    // Aciona Sierene e encerra função executar()
};
 
unsigned char funcao2[] = {
 //   INICIO,          // Para acomodar a roupa?     --------->>>>> Idem ao anterior
       
   // DESCARTAR_AGUA,          // Trocar água no caso de um RESET?  ------->>>>>Idem ao anterior
    COMPLETAR_AGUA,      ---------------->>>>> Idem ao processo anterior.
   
    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 5 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.
   
    ESPERA_3MIN,                   // Não faz nada durante três minutos
 
    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 4 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.
 
    ESPERA_2MIN,                   // Não faz nada durante dois minutos
 
    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 3 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.
 
    DESCARTAR_AGUA,  -------------->>>>> para se passar de um processo de descarga para completar, neste local pode-se colocar um tempo de 1 segundo (delay) para dar tempo de uma solenoide sair  para a outra entrar?


    COMPLETAR_AGUA,
   
    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 5 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.
   
    ESPERA_3MIN,                   // Não faz nada durante três minutos
 
    LAVAR,
    LAVAR,
    LAVAR,
    LAVAR,                              // Motor irá trabalhar por 4 minutos. Com ciclo de 30 segundos ligado e 30 segundos desligado.
   
    ESPERA_1MIN,
   
    CENTRIFUGAR,
 
    DESCARTAR_AGUA,
 
    FIM                                    // Aciona Sierene e encerra função executar()
};
 
void executar (unsigned char *passos);
 
void main () {
    setup_comparator (NC_NC_NC_NC);
    setup_vref (FALSE);
 
    output_low(PIN_MOTOR);
    output_low(PIN_ESVAZIAR);
    output_low(PIN_ENCHER);
    output_low(PIN_ALARME);
     
    while (true) {
        if (input(PIN_BOT_PROG1)==0) {
            executar (funcao1);
        } else if (input(PIN_BOT_PROG2)==0) {
            executar (funcao2);
        }
    }
}
 
void executar (unsigned char *passos) {
    unsigned int  i;
 
    for (; *passos; ++passos) {
        switch (*passos) {
        case ESPERA_1MIN:
        case ESPERA_2MIN:
        case ESPERA_3MIN:
        case ESPERA_4MIN:
        case ESPERA_5MIN:
            i = (*passos) * 60;         // Ex. Se passos = ESPERA_4MIN, i = 60 * 4
            while(i--) delay_ms(1000);  // OBS: delay_ms(x); x não deve ser maior que 65535.
            break;
             
        case INICIO:
            FUNC_LIGA_MOTOR();
            delay_ms(30000);            // Aguarda 30 segundos
            FUNC_DESLIGA_MOTOR();
            delay_ms(30000);
            FUNC_LIGA_MOTOR();
            delay_ms(30000);
            FUNC_DESLIGA_MOTOR();
            break;
             
        case LAVAR:
            FUNC_LIGA_MOTOR();
            delay_ms(30000);
            delay_ms(30000);
            //FUNC_DESLIGA_MOTOR();  -------->>>> Não se faz necessario
            break;
             
        case COMPLETAR_AGUA:
            FUNC_ENCHER();
            break;
             
        case DESCARTAR_AGUA:
            FUNC_ESVAZIAR();
            break;
           
        case CENTRIFUGAR:
            FUNC_LIGA_MOTOR();
            delay_ms(60000);
            delay_ms(60000);
            delay_ms(60000);            // 3 minutos
            //FUNC_DESLIGA_MOTOR();   ------->>>>> Não se faz necessario
            break;   
             
        default: // FIM
            FUNC_ALARME();
            delay_ms(5000);
            FUNC_ALARME();
            delay_ms(5000);
            FUNC_ALARME();
            return;
        }
    }
}



Destaquei minhas duvidas acima. Aguardo um orientação

[cfreund]

Coloquei as funções INICIO e DESCARTAR, pois estavam no seu programa.

Como o motor irá desligar? Você comentou "FUNC_DESLIGA_MOTOR()".

[cfreund]

DESCARTAR_AGUA, -------------->>>>> para se passar de um processo de descarga para completar, neste local pode-se colocar um tempo de 1 segundo (delay) para dar tempo de uma solenoide sair para a outra entrar?

Código: Selecionar todos

#define FUNC_ESVAZIAR()         { output_high(PIN_ESVAZIAR);            \
                                  delay_ms(60000);        \
                                  delay_ms(60000);        \                  ---------------------->>>>> Tive que alterar pois um tanquinho não esvaziasse em menos 3 minutos
                                  delay_ms(60000);        \
                                  output_low(PIN_ESVAZIAR);             \
                                  delay_ms(1000);        \                               //  1 segundo para fechar a válvula
                                }