leitura analógica com saida PWM! estação meteorológica.

[verd]

olá companheiros estou com a seguinte buxa para resolver e preciso de alguns palpites!!

estou montando uma estação meteorológica, mas vou liga-la ao clp por 4 a 20ma, a questão da direção do vento eu já resolvi, coloquei 8 relés reed ligados ao pic com saida PWM para o XTR 116, que já pega este sinal PWM e converte de 4 a 20ma,

agora preciso implementar a velocidade do vento e sair 4 a 20ma, o problema é q o xtr 116 só entende pwm

a idéia é a seguinte ja tenho a extrutura da estação, vou apenas implementar a eletrônica,

as pas do ventilador da estação contém um imã, e com uma pequena bobina vou ligar um amplificador para pegar o sinal em milivolts e coloca-lo na entrada analógica do pic e apartir desta entrada preciso sair em pwm!

alguém tem algum palpite do que pretendo fazer? estou no caminho? lembrando que não posso alterar a extrutura da estação!!

palpites serão bem vindos!! obrigado!!

[MOR_AL]

... as pas do ventilador da estação contém um imã, e com uma pequena bobina vou ligar um amplificador para pegar o sinal em milivolts e coloca-lo na entrada analógica do pic e apartir desta entrada preciso sair em pwm! ...

Acho que sua bobina conterá pulsos (positivos e negativos - CA). Cada conjunto destes pulsos representará uma passagem do ímã na bobina.
Talvez cada pulso corresponda a uma volta.
Estes pulsos não correspondem a uma tensão analógica PROPORCIONAL à rotação.
Acho que, após o seu amplificador, você terá que "Contar" o número desses pulsos, para determinar a velocidade.
MOR_AL

[verd]

Valeu MOR_ALL!! humm entendido, ja deu uma clareada nas idéias!!

[verd]

então parto pra idéia de um contador? para contar estes pulsos em relação ao tempo?

[MOR_AL]

então parto pra idéia de um contador? para contar estes pulsos em relação ao tempo?

Isso!
O número de pulsos por segundo (ou minuto) tem uma relação biunívoca (...aí outra vez, Fabim) com a velocidade do vento. Cada número de pulsos corresponde a uma, e somente uma velocidade. E vice-versa.
Para conhecer esta relação você terá que partir de um aparelho calibrado. Para cada valor de velocidade do vento do aparelho, você terá um número de pulsos (por segundo ou por minuto) do seu sensor de velocidade do vento.
Faça uma tabelinha, e com ela faça um gráfico dos pontos. Tente colocar uma reta que passe o mais próximo possível destes pontos. A equação desta reta permitirá que você relacione qualquer número de pulsos (por segundo ou por minuto) dentro dos pontos limites medidos.
O correto seria "interpolar uma reta" baseado nos pontos obtidos. Há um processo matemático que fornece a melhor reta.
Ou então, verifique se o fabricante fornece alguma relação já medida por ele. Isso facilitará seu problema.
MOR_AL

[fabim]

Biunívoco

Código: Selecionar todos

é um termo consagrado no jargão dos matemáticos, e distingue-se de unívoco. Refere-se a funções ou correspondências entre dois conjuntos, mas estes não são mutuamente exclusivos, pelo contrário: uma correspondência biunívoca é em particular unívoca, mas é mais do que meramente unívoca.

Uma correspondência de um conjunto noutro diz-se unívoca, se a dois elementos distintos do primeiro conjunto se fizerem corresponder elementos também distintos do segundo. Por exemplo, se fizermos corresponder a cada pessoa o seu nome próprio, esta não é uma correspondência unívoca, já que a diferentes pessoas se faz corresponder o mesmo nome (e.g. Maria). No entanto, se fizermos corresponder a cada pessoa o número do seu B.I., esta já é uma correspondência unívoca: não há (não deve haver) duas pessoas com o mesmo número de B.I.

Uma correspondência diz-se biunívoca se for unívoca e a cada elemento do segundo conjunto se fizer corresponder algum elemento do primeiro. No exemplo dos B.I., a correspondência não é biunívoca, uma vez que existem números aos quais não está atribuído nenhum B.I. Um exemplo de uma correspondência biunívoca é aquela que faz corresponder a cada número o seu simétrico em símbolos, e, se chamarmos f à correspondência em causa, temos: f(1)=-1, f(2)=-2, f(3)=-3, etc., e também f(-1)=1, f(-2)=2, f(-3)=3, etc.

É claro que nas correspondências acima estão subentendidos os "primeiro" e "segundo" conjuntos, aos quais se dá o nome de domínio e contradomínio (ou conjunto de chegada), respectivamente. No primeiro exemplo, o domínio é o conjunto de todas as pessoas e o contradomínio é o conjunto de todos os nomes próprios. Para o segundo exemplo, temos como domínio o conjunto de todas as pessoas que têm B.I. e como contradomínio o conjunto dos números naturais. Finalmente, no terceiro exemplo, o domínio e o contradomínio coincidem, e são neste caso o conjunto dos números inteiros.

A escolha do contradomínio pode determinar a qualidade de uma correspondência ser biunívoca ou não. Se no último exemplo tivéssemos escolhido para conjunto de chegada o conjunto de todos os números reais (incluindo as fracções e os irracionais), a correspondência deixaria de ser biunívoca, continuando contudo a ser unívoca.

Embora desajeitadas quando explicadas por palavras, estas definições são fáceis de compreender com esquemas de "setinhas", os chamados diagramas de Venn. Desenhe-se um círculo com pontinhos lá dentro para representar o domínio, os pontinhos representando os elementos do conjunto. Desenhe-se ao lado um segundo círculo com os respectivos pontinhos representando o contradomínio. Partindo de cada elemento do domínio, desenhe-se uma seta a apontar para o elemento do contradomínio ao qual se faz corresponder o primeiro elemento. Uma correspondência é unívoca se duas setas nunca apontarem para o mesmo elemento do conjunto de chegada. Se além disso todos os elementos do contradomínio tiverem uma seta para si dirigida, então a aplicação (outro nome para correspondência) diz-se biunívoca.

Não me parece que haja contradição na palavra «biunívoco». Bi- porque é unívoca nos dois sentidos: a elementos distintos do domínio correspondem elementos distintos do contradomínio, e a cada elemento do contradomínio corresponde pelo menos um elemento do domínio.

É um termo enraizado e reconhecido. Não me parece que os matemáticos estejam dispostos a abdicar por completo dele. Há, no entanto, sinónimos: Biunívoco = bijectivo (um-a-um). Este termo é pouco comum em Português, mas há quem o use.

[verd]

Salve companheiros!!

a direção do vento está resolvida, fiz uma placa com 8 reed´s e cada reed entra numa entrada digital e sai um valor de pwm que entra do xtr e sai 4 a 20ma.

agora estou implementando um pluviômetro, ele também é digital com reed, funciona no sistema de gangorra, cada tombo da gangorra equivale a 2mm de chuva e um pulso na entrada do pic e um incremento na saida pwm pro 4 a 20ma

sou iniciante em C preciso de uma função que quando o sistema do pluviômetro parar de contar por um certo tempo ele iria zerar e colocar o pwm em 0.

alguma idéia? estouro de timer? se alguem tiver alguma função modelo para me giuar ficarei grato!! estou perdido em c!!

[Djalma Toledo Rodrigues]

Delay e sua respectiva biblioteca

DJ

[verd]

Valeu Djalma!! estava procurando por timer e não encontrava! hehe

[verd]

alguem pode me dar alguma dica: to começando a programar em C segue meu código:


//***********************Variaveis*********************************************/

unsigned short current_duty;
unsigned short old_duty;
unsigned short current_duty1;
unsigned short old_duty1, i, contador;

//**********************configurações******************************************/
void config() {
ADCON1 = 0x06; //Todos os pinos digital
PORTA = 255;
TRISA = 255; // PORTA entrada
PORTB = 255; // set PORTB to 0
TRISB = 255; // designate PORTB pins as output
PORTC = 0; // set PORTC to 0
TRISC = 0; // designate PORTC pins as output
PWM1_Init(5000); // Initialize PWM1 module at 5KHz
PWM2_Init(5000); // Initialize PWM2 module at 5KHz

}


//*********************Principal***********************************************/
void main() {

config();

current_duty = 0; // initial value for current_duty
current_duty1 = 0; // initial value for current_duty1

PWM1_Start(); // start PWM1
PWM2_Start(); // start PWM2
PWM1_Set_Duty(current_duty); // Set current duty for PWM1
PWM2_Set_Duty(current_duty1); // Set current duty for PWM2

while (1) { // endless loop
if (PORTB.F0) { // button on RA0 pressed
// Delay_ms(1);
PWM1_Set_Duty(31.875);
}

if (PORTB.F1) { // button on RA1 pressed
//Delay_ms(1);
PWM1_Set_Duty(63.75);
}
if (PORTB.F2) { // button on RA0 pressed
//Delay_ms(1);
PWM1_Set_Duty(95.625);
}

if (PORTB.F3) { // button on RA1 pressed
//Delay_ms(1);
PWM1_Set_Duty(127.5);
}

if (PORTB.F4) { // button on RA0 pressed
//Delay_ms(1);
PWM1_Set_Duty(159.375);
}

if (PORTB.F5) { // button on RA1 pressed
//Delay_ms(1);
PWM1_Set_Duty(191.25);
}
if (PORTB.F6 ) { // button on RA0 pressed
//Delay_ms(1);
PWM1_Set_Duty(223.125);
}

if (PORTB.F7 ) { // button on RA1 pressed
//Delay_ms(1);
PWM1_Set_Duty(255);
}


if (PORTA.F0) { // button on RA2 pressed
Delay_ms(5);
current_duty1++; // increment current_duty1
PWM2_Set_Duty(current_duty1);
Delay_ms(10), contador ++;

}


if ( contador > 100 ) { // button on RA3 pressed
Delay_ms(10);
PWM2_Set_Duty(0);

}
}
}

tenho 8 entradas digitais cada uma irá sair com um valor de pwm, no caso seria os reed´s indicando a direção do vendo pra sair pwm e sair 4 a 20ma.

ente ultimo if seria pro medidor de chuva cada contagem no medidor iria incrementar um pulso de pwm pra sair de 4 a 20ma.

o que estou tentando fazer, fazeR um contador de tempo que depois que o PORTA.F0 parace de receber pulso por um determinado tempo ele zerasse o pwm para que fosse possivel inicial um novo incremento.

alguem com pratica em c pode dar alguma dica!! obrigado!!

[verd]

disculpe os comentaris do programa, peguei da biblioteca do mikroC e esqueci de altera-los!!

[verd]

fiz uma boa gambiarra mas deu certo!!! já podem criticar!! hehe


//***********************Variaveis*********************************************/

unsigned short current_duty;
unsigned short old_duty;
unsigned short current_duty1;
unsigned short old_duty1, i, contador;

//**********************configurações******************************************/
void config() {
ADCON1 = 0x06; //Todos os pinos digital
PORTA = 255;
TRISA = 255; // PORTA entrada
PORTB = 255; // saidas PORTB
TRISB = 255; // PORTB saida
PORTC = 0; // set PORTC to 0
TRISC = 0; // PORTC saida
PWM1_Init(5000); // inicializa PWM1 em 5KHz
PWM2_Init(5000); // inicializa PWM2 em 5KHz

}


//*********************Principal***********************************************/
void main() {

config();

current_duty = 0; // valor inicial current_duty
current_duty1 = 0; // valor inicial para current_duty1

PWM1_Start(); // start PWM1
PWM2_Start(); // start PWM2
PWM1_Set_Duty(current_duty); // ciclo PWM1
PWM2_Set_Duty(current_duty1); // ciclo PWM2

for (;;) {

inicio:

if (PORTB.F0) { // port b0 pressionado
// Delay_ms(1);
PWM1_Set_Duty(31.875); // valor do pwm
}

if (PORTB.F1) { // port b1 pressionado
//Delay_ms(1);
PWM1_Set_Duty(63.75); // valor do pwm
}
if (PORTB.F2) { // port b2 pressionado
//Delay_ms(1);
PWM1_Set_Duty(95.625); // valor do pwm
}

if (PORTB.F3) { // port b3 pressionado
//Delay_ms(1);
PWM1_Set_Duty(127.5); // valor do pwm
}

if (PORTB.F4) { // port b4 pressionado
//Delay_ms(1);
PWM1_Set_Duty(159.375); // valor do pwm
}

if (PORTB.F5) { // port b5 pressionado
//Delay_ms(1);
PWM1_Set_Duty(191.25); // valor do pwm
}
if (PORTB.F6 ) { // port b6 pressionado
//Delay_ms(1);
PWM1_Set_Duty(223.125); // valor do pwm
}

if (PORTB.F7 ) { // port b7 pressionado
//Delay_ms(1);
PWM1_Set_Duty(255); // valor do pwm
}


if (PORTA.F0) { // port a0 pressionado
Delay_ms(5);
current_duty1++; // incrementa current_duty1
PWM2_Set_Duty(current_duty1); // valor do pwm


}
Delay_ms(10);
if (PORTA.F0 == 0) Delay_ms(10), contador ++;

// if (PORTA.F1) { // port a0 pressionado
// Delay_ms(1);
// PWM2_Set_Duty(0); // incrementa current_duty1
// current_duty1 = 0;
// }



if ( contador > 100 ) { // rotina de contagem
Delay_ms(10);
goto saida;


}


}

saida:

Delay_ms(10);
PWM2_Set_Duty(0); // incrementa current_duty1
current_duty1 = 0;
contador = 0 ;
goto inicio;

}