Controlando um Servomotor com um PIC

Prosseguindo na minha exploração do "servo de parabólica", apresento aqui o hardware e software de um pequeno teste de controle, usando um processador PIC.

Neste teste utilizo dois botões, um para mover o motor para "esquerda" e outro para "direita" (é claro que estas direções dependem da posição de montagem do motor).

O Hardware

Dada a simplicidade da aplicação, usei um PIC12F629 I/P (o modelo PIC12F675 também pode ser usado sem alterações). Este microcontrolador é encapsulado em um CI DIP de 8 pinos e possui memória de programa para 1K instruções e 64 bytes de Ram. Pode trabalhar com um clock interno de 4MHz e tem funções típicas de um microcontrolador como watchdog e timer.

Tirando os dois pinos de alimentação, os outros seis podem ser usados como entrada e saída digital. No meu projeto, 3 destes pinos são utilizados para programação in-circuit, dois são usados como entradas (para conexão das teclas) e o último é usado como saída para controlar o motor (clique para ampliar):

As teclas são ligadas diretamente entre os pinos de entrada e o terra; o microcontrolador será configurado pelo software para ativar os resistores de pull-up internos.

O Software

Apesar dos recursos limitados, é possível programar o PIC12F629 em C. Um arquivo de include (Servo.h) contém as opções de configuração (fuses) do PIC e as definições de nomes mais "amigáveis" para os pinos de entrada e saída:

#include <12F629.h>#device adc=8
#FUSES NOWDT                    //No Watch Dog Timer
#FUSES INTRC_IO                 //Internal RC Osc, no CLKOUT
#FUSES NOCPD                    //No EE protection
#FUSES NOPROTECT                //Code not protected from reading
#FUSES MCLR                     //Master Clear pin enabled
#FUSES NOPUT                    //No Power Up Timer
#FUSES BROWNOUT                 //Reset when brownout detected
#use delay(clock=4000000)
 
#define MOTOR     PIN_A2
#define BOTAO_RG  PIN_A4
#define BOTAO_LF  PIN_A5

O programa principal (Servo.c) começa com as definições de algumas constantes e variáveis:

#include "C:\Pic\Servo\Servo.h"

#define  TMP_OVF     64       // tempo uSeg entre interrupções do timer
#define  TMP_PERIODO 20000    // periodo do PWM em uSeg
#define  TMP_BOTAO   500000l  // tempo uSeg entre testes dos botões
#define  DUTY_0      400      // tempo para 0 graus
#define  DUTY_90     1000     // tempo para 90 graus
#define  DUTY_180    1600     // tempo para 180 graus

unsigned int16 cnt_duty, cnt_periodo;   // contadores para PWM
int16 cnt_botao;               // contador p/ teste do botão
int16 duty;                    // duty atual

O programa principal consiste na programação do timer e das entradas e saídas. Em seguida o programa fica em um loop infinito, apenas tratando interrupções:

void main()
{
    // configura os periféricos
    #use fast_io(A)
    set_tris_A(0xFB);
    port_a_pullups(0x30);
    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
    SET_TIMER0 (192);    // conta de 192 a 255
    setup_timer_1(T1_DISABLED);
    setup_comparator(NC_NC);setup_vref(FALSE);

    // inicia as variaveis
    cnt_periodo = TMP_PERIODO / TMP_OVF;
    cnt_duty = duty = DUTY_90 / TMP_OVF;
    cnt_botao = TMP_BOTAO / TMP_PERIODO;

    enable_interrupts(INT_RTCC);
    enable_interrupts(GLOBAL);

    for (;;)
        ;
}

Alguns pontos de destaque:

• O pragma fast_io(A) indica que o programa será responsável pelo controle de direção dos pinos. Sem este pragma o código gerado pelo compilador gastará um byte a mais e conterá instruções para garantir a direção antes de cada acesso.
• Normalmente o timer conta de 0 a 255, volta a zero e recomeça a contagem. A interrupção de timer ocorre na passagem de 255 a 0. No meu programa estou forçando o timer a contar de 192 a 255, para reduzir o tempo entre as interrupções e obter uma precisão maior.

O processamento em si ocorre na rotina de interrupção, que ocorre a cada 64 microsegundos. A variável cnt_periodo conta as interrupções para determinar o período do PWM (20 milisegundos). Uma segunda variável, cnt_duty conta as interrupções para determinar o tempo que o sinal ficará em nível "1" (é este tempo que determina a posição do motor).

O botões são examinados apenas em intervalos "grandes" (a cada meio segundo). Isto fornece um debounce e deixa mais fácil observar o funcionamento do teste.

//////////////////////////////////////////////
// Interrupcao de tempo real
// Ocorre a cada 64 uSeg
//////////////////////////////////////////////
#int_RTCC
void RTCC_isr() 
{
    SET_TIMER0 (192);    // conta de 192 a 255
    cnt_periodo--;
    if (cnt_periodo == 0)
    {
        // fim de um ciclo
        cnt_periodo = TMP_PERIODO/TMP_OVF;
        cnt_duty = duty;
        output_high (MOTOR);

        // testa botões
        cnt_botao--;
        if (cnt_botao == 0)
        {
            cnt_botao = TMP_BOTAO / TMP_PERIODO;
            if (input (BOTAO_LF) == 0)
            {
                if (duty > ((DUTY_0 + TMP_OVF - 1) / TMP_OVF))
                    duty--;
            }
            else if (input (BOTAO_RG) == 0)
            {
                if (duty < ((DUTY_180 - TMP_OVF + 1) / TMP_OVF))
                    duty++;
            }
    }
    else if (cnt_duty != 0)
    {
        cnt_duty--;
        if (cnt_duty == 0)
            output_low (MOTOR);
    }
}

O Teste em Funcionamento

O vídeo abaixo mostra o projeto funcionando: