ASM51

Fala galera,
Tudo certo?

Então.. estou com dificuldades em um projeto aqui.
Preciso fazer o controle de velocidade de um motor DC com um PIC 16F628A.
O motor que eu utilizarei será de 5Vcc e 500mA.
Utilizarei a saída analógica que é de 5Vcc e um amplificador operacional pra alimentar os 500mA do motor.

Na entrada do pic serão utilizadas 2 chaves lógicas para determinar as velocidades.
Por exemplo:
00 - motor parado
01 - 40% da velocidade
10 - 70% da velocidade
11 - 100% da velocidade

Porém, não tenho muita noção de como fazer a programação em C.
Estou utilizando o mplab com compilador CCS.

Por um acaso alguém tem algum exemplo próximo ao meu projeto para me dar uma base?
A parte física eu faço e qualquer coisa meu professor ajuda.
O problema seria a parte da programação mesmo.

Agradeço desde já.

Se voce tá baseado no CCS, isso ajuda muito no aseu caso, pois pode usar o PIC WIZARD, que é uma ferramenta do compilador que te prepara um template de programa, pre-carregando os registradores do uC com valores iniciais.

Sugiro gerar uma saida DC pelo PWM saindo para um filtro RC.

Quanto á alimentação de 5V pro motor, sugiro usar em separado do uC, pois quando der partida poderá ressetar o uC.

Amplificador Operacional com capacidade de 500mA? Onde vc achou isso?


.

Veja esta parte física
A princípio basta

Código: Selecionar todos

                        [VCC]
                          |   
                       (motor)
                          |c
                          |/
saída pwm---------[470R]--|  b
                          |\
                          |e
                        [gnd]


TIP29 p.ex. Nem precisa dissipador. Se for usar o tal ampop 500mA (?) aí sim.
Quanto a parte 'espiritual' ccs não é minha religião
boa sorte

proex escreveu:Amplificador Operacional com capacidade de 500mA? Onde vc achou isso?


.

Meu professor falou que é possível. Até porque farei só a simulação no proteus, e o amplificador seria usado pra não drenar corrente do pic (já que a corrente de saída é de somente 25mA).

ze escreveu:Veja esta parte física
A princípio basta

Código: Selecionar todos

                        [VCC]
                          |   
                       (motor)
                          |c
                          |/
saída pwm---------[470R]--|  b
                          |\
                          |e
                        [gnd]


TIP29 p.ex. Nem precisa dissipador. Se for usar o tal ampop 500mA (?) aí sim.
Quanto a parte 'espiritual' ccs não é minha religião
boa sorte

É .. essa era a minha idéia. Já me ajuda, obrigado.

Olá gvigano seja bem vindo !

Só pra saber, você já vez o PIC funcionar o pisca led ?

Andre_Cruz escreveu:Olá gvigano seja bem vindo !

Só pra saber, você já vez o PIC funcionar o pisca led ?

Já. Pois nesse semestre é a primeira vez que estou trabalhando com pic

Pessoal. Estou quase lá.

Porém estou com mais uma pedrinha no caminho.
Preciso fazer um filtro virtual de ruídos.

Para saber como está o andamento do projeto, é assim:
Estou usando 2 botões em 2 entradas digitais para fazer o incremento e decremento de velocidade.
Quando aperto o botão para incremento, o pic incrementa em 100 a variável duty (do tipo int16, inicialmente com 0) e manda para função de controle do pwm: set_pwm1_duty(duty);.
Até aí tudo bem, porém quando for implementar, certamente terei problemas com ruído.

Minha ideia é a seguinte: preciso criar um temporizador virtual e uma variável contadora. Se eu pressionar o botão por 100 ms então a variável duty = duty + 100. Caso o tempo seja menor que 100 ms (no caso de um ruído) ele não cai na condição de incremento do duty.

Aqui está o programa:


cpp code

#include <16F628A.h>
#device adc = 10
#FUSES NOWDT                                      //Watch Dog Timer desabilitado
#FUSES XT //oscilador cristal <= 4mhz
#FUSES PUT //Power Up Timer
#FUSES NOPROTECT                             //sem proteção para leitura da eprom
#FUSES BROWNOUT                              //Resetar quando detectar brownout
#FUSES MCLR                                        //Reset habilitado
#FUSES NOLVP                                     // prog.
#use delay(clock=4000000)                //Definição do Clock = 4 MHz


//******************************************************************************************//
//Configuração I/O                                                                                    //
//*****************************************************************************************//

#BYTE PORTA = 0X05            //DEFINE PORTA
#BYTE PORTB = 0X06            //DEFINE PORTB

//******************************************************************************************//
// VARIÁVEIS                                                                                              //
//*****************************************************************************************//

int16 duty;       //Variável para definição da largura do pulso PWM


//******************************************************************************************//
// PROGRAMA PRINCIPAL                                                                            //
//******************************************************************************************//

void main () 
{
setup_timer_2(T2_DIV_BY_4,255,1);       //Configuração Timer2 para uso do PWM 
                                                                  //Frequência do PWM = 5KHz
setup_ccp1(CCP_PWM);                           //Configura canal CCP1 como PWM

set_tris_a(0b11111111);                        //Define entradas e saídas
set_tris_b(0b00000000);

duty=0;
set_pwm1_duty(0);

   while (TRUE)                        //Laço de leitura das entrada digitais e ajuste do Duty
   {
 
    if (input (pin_A0 == 1 && duty < 1000)   //se botao RA0 pressionado
     {
        delay_ms(40);
        duty = duty + 100;           //incrementa  duty em 100
        set_pwm1_duty(duty);   //altera o duty cycle
     }
 
     if (input (pin_A1)== 1 && duty >0)   //se botao RA1 pressionado
     {
       delay_ms(40);
       duty = duty - 100;  //decrementa duty em 100
       set_pwm1_duty(duty);
     }
    Delay_ms(10);      // Altera a velocidade lentamente

  }                    //Término laço principal
}                      //Término Programa principal

gvigano escreveu:Minha ideia é a seguinte: preciso criar um temporizador virtual e uma variável contadora. Se eu pressionar o botão por 100 ms então a variável duty = duty + 100. Caso o tempo seja menor que 100 ms (no caso de um ruído) ele não cai na condição de incremento do duty.

Você tem razão a chave mecânica não é perfeita e ao pressiona-la seus contatos alternam entre fechado e aberto por um tempo, para resolver isso existe várias maneiras pesquise por button debounce ou switch debounce. Como você disse que vai fazer apenas a simulação no Proteus você não precisa se preocupar com a alternância dos contatos da chave mecânica no Proteus ela é ideal.

Vou te falar que por pura preguiça de implementar debounce de botão por firmware, eu costumava o fazer por circuito R-C mesmo.
No seu caso, se não houver mais funcionalidades agregadas no programa ( LCD, RS232, etc... ) o Delay_ms(40) que voce usou pode ser suficiente.

Porém, se desejar fazer algo um pouco melhor prevendo mais funcionalidades, para evitar o programa ficar preso em laços fechados de delay, teria de primeiramente ativar uma interrupção de Timer para que a contagem dessa temporização fosse externa o main(). Tenho exemplos de debounce bem bolados, mas pra encaixar no seu programa, voce teria de primeiro o alterar para incluir uma interrupção, como por exemplo do TIMER0.