Programar em C pic

1. Tutorial Motores – Parte 1: Lógica de
programação para motores elétricos
Ao iniciarmos qualquer projeto é necessário, primeiramente, saber qual o tipo de motor a ser utilizado.
Logo em seguida é preciso saber algumas especificações do mesmo tal como tensão e corrente
máxima e, caso seja um motor de passo, o ângulo de giro por passo, se trabalhamos com um motor de
ímã permanente, relutância variável ou híbrido e, se possível, a sequência dos cabos para manter o
giro do motor.
Uma boa referência para estudo dos motores elétricos é o livro “Motores Eléctricos – António
Francisco”.
Para ilustrar programação aplicada a motores elétricos, serão apresentados dois projetos: um com um
motor de passo, e outro com um motor dc. Os motores utilizados têm características especificas como
será apresentado. Por isso, se você for aplicar o que está nesse tutorial na prática, confira as
especificações de seu motor e ajuste o que for necessário.
Nos projetos que se seguem utilizaremos Linguagem C e PICs como nossas unidades de
processamento de dados. Assim sendo, é importante também que conheçamos as especificações do
microcontrolador, essas podem ser facilmente encontradas em seus datasheets disponíveis na
internet. Os circuitos de controle para implementação dos microcontroladores serão tema de uma
próxima postagem!
PROJETO 1
Precisamos que um motor gire um determinado eixo de uma máquina em 36°, no sentido horário,
sempre que o controlador aperte um botão no painel. Para tal utilizaremos um motor de passo híbrido
de 1,8°/passo. O motor conta com oito cabos de cores diferentes (Amarelo, Vermelho, Branco, Laranja,
Preto, Azul, Verde e Marrom).
Ao estudarmos as especificações do motor, soubemos que os cabos Amarelo, Branco, Azul e Verde
estão sempre conectados ao terminal de menor potencial de nossa fonte. Portanto devemos nos
preocupar em criar uma lógica de programação para energizar apenas os cabos Preto, Laranja,
Vermelho e Marrom.
Ainda estudando o datasheet do motor vemos que para manter um movimento do motor no sentido
horário devemos energizar os cabos na seguinte ordem: Vermelho, Laranja, Preto, Marrom (e
reiniciarmos o ciclo). E para um movimento no sentido anti-horário basta que os energizemos na
ordem inversa: Marrom, Preto, laranja, Vermelho.
Podemos tratar dessa ordem de cores agora como uma palavra binária de quatro bits sendo o cabo
vermelho o LSB e o cabo marrom o MSB, assim, na saída do microcontrolador poderemos usar o
equivalente binário para a sequência numérica: 1, 2, 4, 8.
Agora, em posse desses dados sobre o motor, construiremos a nossa lógica. O programa utilizado foi
o PIC C COMPILER. A vantagem desse programa é que podemos utilizar a função Project Wizard
(PW) e através dessa interface configurar o PIC da forma que quisermos (inserindo quais serão os
terminais de entrada e saída de dados, freqüência de trabalho do PIC, se queremos o Master Clear
ativado ou não, etc.) sem precisar gastar várias linhas de programação o fazendo manualmente.
Utilizaremos aqui o PIC 16F628a.
Desenvolvimentodoprojeto:
Parte 1- Programa Lógico:
Quando utilizamos o recurso do PW o programa gera para o programador uma biblioteca já com as

2. especificações do projeto. Essa biblioteca terá o mesmo nome do projeto e será automaticamente
inserida na página de programação, como pode ser visto na figura 2. Uma boa ideia é separar sempre
uma pasta para cada projeto, pois cada programa gera uma série de auxiliares de mesmo nome,
porém com extensões diferentes, com o tempo e acumulo de programas pode se tornar uma grande
bagunça.
Caso o programador queira ele pode também incluir outras bibliotecas para o programa, mas para
esse nosso caso não se faz necessário. Segue então a nossa lógica:
– O que se segue em vermelho foi gerado pelo programa ao finalizarmos a configuração do
microcontrolador no PW.
– O que se segue após o “//” até a quebra de linha (parágrafo) são comentários e não afetam na lógica
do programa.
– É válido lembrar que quando dizemos que na saída do controlador sairá um número inteiro, ex.: 7, o
mesmo fará a conversão para binário, logo na saída teríamos: 111.
#include <motor4.h>// O nome do nosso projeto é “motor4”. Portanto, o compilador gerou uma
biblioteca de mesmo nome e a inseriu em nosso programa logo após finalizarmos a configuração do
microcontrolador através do PW.
int s, k, botao; //variaveis inteiras (int) declaradas para execução do programa
void main()//inicio do programa
{
s=1;//condição inicial da variável s (Saída para os cabos do motor)
while (1){//início do infinite loop – Forma utilizada para que o programa nunca chegue ao fim já que 1=1
a todo momento.
botao=input(PIN_A0); //Com esse comando a variável botao sempre assumirá o valor lógico da porta
A0
if(botao){ //[ou “if(botão==1)”]condição para iniciar o movimento de 36°
for(k=1;k<=21;k++){ // número k de passos para o movimento de 36° – Como cada passo tem 1,8°, são
necessários 20 passos para completar os 36° – Aqui fizemos um contador de passos do motor.
if(s>=16){
s=1;
}
//A lógica para o movimento no sentido horário é 1, 2, 4, 8 – Podemos facilmente perceber a
progressão com o multiplicador 2. Entretanto, ao atingir o ultimo fio, queremos que o motor reinicie o
ciclo para manter o movimento. Assim, o número seguinte da progressão seria 16, mas com esse
regulador fazemos com que o ciclo seja retomado.
output_B(s);// Aqui determinamos que nas portas da família B (B0-B7)saia o valor de s (em binário)
s=s*2;//Aqui está a nossa progressão dos valores da saída em B. Ao atingir essa linha, a nossa
variável s assumirá um valor duas vezes maior que o anterior.
delay_ms(100);// Aqui determinamos uma pausa em milissegundos (100 ms) para que o programa
reinicie o loop. Esse delay varia de motor para motor, pois alguns motores foram projetados para ter
menos velocidade que outros. É importante que se faça uma pesquisa do limite de velocidade do
motor para não comprometer o equipamento. Caso o motor comece a esquentar ou perca o passo,
significa que você excedeu o limite do mesmo. Essa velocidade é controlada pelo programador,
supondo que nosso motor suporte eu poderia ter escrito: “delay_ms(30);”.
}
}
}
}//Fim do Programa

3. Figura 1: Criando um novo projeto (Project Wizard)
Figura 2: Tela de programação após configuração do microcontrolador com a função Project Wizard
PROJETO 2
Precisamos de um motor que faça um movimento horizontal em um trilho. Esse motor deve ir numa
direção ou outra do trilho sempre que exigido, obedecendo o final do percurso. O sistema deve permitir
que o motor assuma duas velocidades diferentes. Nota: O motor a ser utilizado é um motor DC de 12V.
Assim como utilizamos o PIC e a programação em C para criar um sistema de controle pra um motor
de passo, podemos fazer o mesmo para o controle de um motor de corrente contínua (DC).

4. O motor DC é muito mais simples que um motor de passo. Só possui dois cabos e pode girar num
sentido ou em outro a depender de qual cabo estará no terminal positivo da fonte. Entretanto o
problema nos exige que seja oferecida uma mudança dinâmica do estado do motor. Para isso
utilizaremos um circuito conhecido como ponte H. Esse circuito cuidará para que a polaridade do motor
seja alterada sempre que o controlador exija.
Uma segunda condição do problema é o controle de velocidade. Diferente do motor de passo que o
controle de velocidade tem que ser feito durante a programação, o motor DC possui sua velocidade
alterada pela ddp aplicada em seus terminais. Assim podemos construir um circuito auxiliar contanto
com relés de forma que cada um forneça uma tensão diferente para a alimentação do motor. Vamos
inserir também um comando no controlador para evitar que as duas chaves sejam abertas
simultaneamente.
Utilizaremos nesse projeto um componente chamado chave de fim de curso. Esta será utilizada para
evitar que por algum erro do controlador o motor tente extrapolar o final do trilho.
Assim como no controle do motor de passo utilizaremos o PIC C COMPILER e o Project Wizard para
esse novo projeto.
Parte1-ProgramaLógico:
Teremos nesse circuito então seis entradas de dados e quatro saídas. As entradas e saídas cumprirão
os papéis:
1) Duas entradas serão as chaves de fim de curso para parar o motor sempre que ativadas e evitar
que o motor saia do trilho.
2) Duas entradas serão atribuídas para o controle de velocidade. Esse controle será feito por um
divisor de tensão associado a dois relés ativados distintamente a depender da entrada.
3) Duas entradas serão atribuídas para o comando de ir e voltar.
4) Duas saídas levarão aos relés para controla-los.
5) Duas saídas levarão aos terminais de entrada da ponte H para inversão da polaridade do motor.
Quando configuramos o microcontrolador através do PW desativamos a entrada Master Clear
(PIN_A5) assim podemos utilizar o pino como uma simples entrada de dados.
#include <motortrilho.h>// O nome do nosso projeto é “motortrilho”. Portanto, o compilador gerou uma
biblioteca de mesmo nome e a inseriu em nosso programa logo após finalizarmos a configuração do
microcontrolador através do PW.
int a, b, ir, voltar, v1, v2;//variaveis declaradas para execução do programa
void main()//inicio do programa
{
while (1)//início do infinite loop
{
ir=input(PIN_A0);//alocando a variável ‘ir’ ao valor na porta A0
voltar=input(PIN_A1);//alocando a variável ‘voltar’ ao valor na porta A1
a=input(PIN_A2);//alocando a variável ‘a’ ao valor na porta A2 – Chave de fim de curso 1
b=input(PIN_A3);//alocando a variável ‘b’ ao valor na porta A3 – Chave de fim de curso 2
v1=input(PIN_A4);//alocando a variável ‘v1 ao valor na porta A4 – maior velocidade′
v2=input(PIN_A5);//alocando a variável ‘v2 ao valor na porta A5 – menor velocidade′
if(v1==1)//Caso ativemos a velocidade 1 colocaremos na saída que levará ao relé de maior tensão o
nível lógico alto (high ou 1), logo esse será ativado enquanto que o outro relé estará desativado.
{
output_high(PIN_B5);//associando o nivel lógico high (1) à saída
output_low(PIN_B4);//associando o nivel lógico low (0) à saída
}
if(v2==1) // Nesse momento ocorre exatamente o inverso. Caso ativemos a velocidade 2 colocaremos

5. na saída que levará ao relé de menor tensão o nível lógico alto (high ou 1), logo esse será ativado
enquanto que o outro relé de maior tensão estará desativado.
{
output_low(PIN_B5); //associando o nivel lógico low (0) à saída
output_high(PIN_B4); //associando o nivel lógico high (1) à saída
}
if(v1==1 && v2==1)//condição para evitar sobrecarga e apenas as duas velocidades predefinidas.
Assim, caso as duas chaves sejam acionadas ao mesmo tempo, não haverá tensão sobre o motor. As
duas saídas apresentarão nível lógico baixo, logo os dois relés estarão desativados.
{
output_low(PIN_B5);
output_low(PIN_B4);
}
if(a==1) //Chave de fim de curso ativada. Ok, nosso motor atingiu o final do trilho e pressionou a chave
que lá se encontra marcando o final do caminho, impedimos assim que o motor continue seu percurso.
A chave de fim de curso nada mais é que um push button próprio para “choques mecânicos” e que
marca o final de um percurso. Com ela ativada cortaremos a tensão nas entradas da Ponte H, não
mais dos relés, e impedimos que haja uma tensão sobre os terminais do motor.
{
output_low(PIN_B6);
output_low(PIN_B7);
ir=0;//Essa chave será colocada no sentido do movimento “ir” do motor, assim enquanto a chave
estiver ativada será impossível mandar o motor seguir neste sentido
}
if(b==1) //Agora construímos a lógica para a chave de fim de curso do outro lado do trilho. Da mesma
forma que a primeira ela será ativada com o contato do motor. Nesse momento a chave enviará um
pulso ao microcontrolador para cortar a tensão sobre os terminais do motor e voltamos ao estado
“parado”.
{
output_low(PIN_B6);
output_low(PIN_B7);
voltar=0;//Essa chave será colocada no sentido do movimento “volta” do motor, assim enquanto a
chave estiver ativada será impossível mandar o motor seguir neste sentido
}
if(ir==1) //condição para o movimento do motor em um sentido
{
output_low(PIN_B6);
output_high(PIN_B7);
delay_ms(100); //Esse delay é uma forma de garantir que o motor possa sair da condição imposta pela
chave de fim de curso. Supondo que 100ms seja suficiente para que a chave volte para seu estado
normal. Assim quando a chave “b” estiver acionada podemos usar o botão “ir” para retirá-la da posição.
}
if(voltar==1)//condição para o movimento do motor em outro sentido
{
output_low(PIN_B7);
output_high(PIN_B6);
delay_ms(100);//Esse delay é uma forma de garantir que o motor possa sair da condição imposta pela
chave de fim de curso. Supondo que 100ms seja suficiente para que a chave volte para seu estado
normal. Assim quando a chave “a” estiver acionada podemos usar o botão “voltar” para retirá-la da
posição.
}
}
}//Fim do programa
Em uma próxima postagem trabalharemos com a construção dos circuitos onde esses
microcontroladores deverão ser implementados!