implementação de kit didático para ensino de motores de passo
TRANSCRIPT
UNIVERSIDADE ESTADUAL DE CAMPINASFACULDADE DE ENGENHARIA MECÂNICA
DEPARTAMENTE DE MECÂNICA COMPUTACIONAL – DMC
Desenvolvimento de Kit Didático para Ensino de Teoria de Motores de Passo
Autor: Thiago Augusto Bento da Silva CamargoOrientador: Luiz Otávio Saraiva Ferreira
Curso: Engenharia de Controle e Automação
Trabalho de graduação apresentado à comissão de Graduação da Faculdade de Engenharia Mecânica, como requisito para conclusão do curso de graduação em Engenharia de Controle e Automação.
Campinas, 2007S.P. – Brasil
i
FICHA CATALOGRÁFICA ELABORADA PELA
BIBLIOTECA DA ÁREA DE ENGENHARIA - BAE - UNICAMP
F884p
Freitas, José da Silva
Título / José da Silva Freitas –Campinas, SP: [s.n.], 2004.
Orientador:
Dissertação/Tese - Universidade Estadual de Campinas, Faculdade de Engenharia Mecânica.
1. 2. 3. 4. I. , . II. Universidade Estadual de Campinas. Faculdade de Engenharia Mecânica. III. Título.
Titulo em Inglês:
Palavras-chave em Inglês:
Área de concentração:
Titulação:
Banca examinadora:
Data da defesa:
ii
UNIVERSIDADE ESTADUAL DE CAMPINASFACULDADE DE ENGENHARIA MECÂNICA
DEPARTAMENTO DE MECÂNICA COMPUTACIONAL
TRABALHO DE GRADUAÇÃO
Desenvolvimento de Kit Didático para Ensino de Teoria de Motor de Passo
Autor: Thiago Augusto Bento da Silva CamargoOrientador: Luiz Otávio Saraiva Ferreira
A Banca Examinadora composta pelos membros abaixo aprovou esta Dissertação:
_______________________________________________________Prof. Dr. XXXXXXXXXXXUNIVERSIDADE ESTADUAL DE CAMPINAS
_______________________________________________________Prof. Dr. XXXXXXXXXXXUNIVERSIDADE ESTADUAL DE CAMPINAS
_______________________________________________________Prof. Dr. XXXXXXXXXXXUNIVERSIDADE ESTADUAL DE CAMPINAS
Campinas, 15 de dezembro de 2007
iii
iv
Dedicatória:
Dedico este trabalho aos meus queridos filho e esposa. Além de todos aqueles alunos que
possam crescer e melhorar o seu aprendizado.
v
Agradecimentos
Agradeço a sdfsdgddfasdfadfasdfasdfa
Sdfasdfasdfasdfasdfa
Sdfasdfasdfasdfasdf
sdfasdfasdfasdfasdfdssdfasdfasdf
vi
Olhando para frente ihijhijhihlkjhlkj....
vii
Resumo
CAMARGO, Thiago Augusto Bento da Silva, Desenvolvimento de Kit Didático para Ensino de
Teoria de Motor de Passo, Campinas, Faculdade de Engenharia Mecânica, Universidade
Estadual de Campinas, 2007. XXXp. Trabalho de Graduação.
Esse trabalho tem o objetivo de tornar mais simples e fácil o aprendizado e ensino da teoria
de motores de passo. Para isso, foi desenvolvido um kit composto por um protótipo de motor de
passo, por um driver de acionamento e softwares de interface para comunicação entre o micro
controlador, computador e driver. Toda a arquitetura do kit foi voltada e documentada ao
aprendizado simples e intuitivo. Com esse kit, o aluno poderá compreender de maneira bastante
visual o funcionamento de um motor de passo além de também ter a possibilidade de desenvolver
um modelamento matemático para tanto.
Palavras Chave
- Motor de Passo, Kit Didático, ????
viii
Abstract
CAMARGO, Thiago Augusto Bento da Silva, Didactic kit development for Steppers Motors
Lectures , Campinas, Faculdade de Engenharia Mecânica, Universidade Estadual de Campinas,
2007. XXXp. Trabalho de Graduação.
kjhlkjhlkjhlkj
Key Words
Xxxxxxxxxxxxxxxxxxxxxx
ix
Índice
Dedicatória: ...................................................................................................................................... v
Agradecimentos ............................................................................................................................... vi
Resumo .......................................................................................................................................... viii
Abstract ............................................................................................................................................ ix
Índice ................................................................................................................................................ x
Lista de Figuras ............................................................................................................................... xi
1. Introdução ..................................................................................................................................... 1
2. Revisão Bibliográfica ................................................................................................................... 4
2.1 Introdução ................................................................................................................ 4
2.2 Modos de Acionamento ........................................................................................... 7
2.3 Tipos de Motores ................................................................................................... 11
2.4 Curva Torque Vs. Velocidade de um Motore de Passo ......................................... 15
2.5 Modelamento Matemático ..................................................................................... 16
3. Material e Métodos ..................................................................................................................... 21
3.1 Kit Didático ........................................................................................................... 21
3.2 Simulação computacional ...................................................................................... 40
Anexos ............................................................................................................................................ 46
Anexo 1. Programa para PIC na linguagem “C” ......................................................... 46
x
Anexo.2 Programa para Visual Basic .......................................................................... 57
Anexo 3 Programa para simulação computacional ..................................................... 62
Lista de Figuras
- Motores de Passo.........................................................................................................2
- Rotor............................................................................................................................5
- Estator..........................................................................................................................5
- Bobinas em Pares (2 ou 3)...........................................................................................6
- Fluxo Magnético por Corrente....................................................................................6
- Configuração Unipolar................................................................................................7
- Configuração Bipolar..................................................................................................7
- Acionamento Unipolar com Passo Inteiro...................................................................7
- Acionamento Bipolar com Passo Inteiro.....................................................................8
- Acionamento Unipolar de Meio Passo........................................................................8
- Acionamento Bipolar de Meio Passo..........................................................................9
- Acionamento Bipolar..................................................................................................9
- Acionamento Binível1...............................................................................................10
- Acionamento Binível 2..............................................................................................10
- Acionamento com Choppers.....................................................................................10
- Motor de Relutância Variável...................................................................................11
- Passo de um VR........................................................................................................12
- Motor PM..................................................................................................................13
- Uma Revolução do Motor PM..................................................................................13
xi
- Motor Híbrido............................................................................................................14
- Curva Torque vs. Velocidade....................................................................................15
- Curva Torque vs. Velocidade (com carga)................................................................16
– Modelo Elétrico de uma Fase...................................................................................18
- Esquema de Fluxo de Informações...........................................................................21
- Esquema do Protótipo...............................................................................................22
- Protótipo na Posição A..............................................................................................23
- Protótipo na Posição B..............................................................................................23
- Protótipo na Posição C..............................................................................................23
- Componentes.............................................................................................................26
- Ponte-H......................................................................................................................26
- Sentido A...................................................................................................................27
- Sentido B...................................................................................................................28
- Byte de Comunicação................................................................................................30
- Seqüenciamento (Byte).............................................................................................31
- Função Passo Completo............................................................................................33
- Função Meio Passo....................................................................................................36
- Função Máquina de Estados......................................................................................38
- Programa de Interface VB.........................................................................................39
- Detalhe de Interface...................................................................................................40
- SDL - Simulação Computacional..............................................................................43
- Iterações da Simulação (Perfil de Velocidades)........................................................43
- Dados da Curva.........................................................................................................44
- Curva Exemplo..........................................................................................................44
- Simulação Exemplo...................................................................................................45
xii
xiii
1. Introdução
Quando Hans Christian Oersted, em 1820, observou uma interessante relação entre a
eletricidade e magnetismo, as portas para o desenvolvimento de motores elétricos foram abertas.
Desde então, inúmeros tipos de motores foram patenteados e desenvolvidos; cada um com seu
modo de acionamento, peculiaridade, vantagens e desvantagens.
Os primeiros motores elétricos eram acionados por corrente contínua e, geralmente, tinham
um imã permanente em sua constituição. Posteriormente, os motores começaram a utilizar
eletroímãs e possibilitar diversas formas de acionamento: por corrente contínua ou alternada.
Os motores elétricos convencionais são, hoje, largamente utilizados em todas as áreas,
desde em aplicações industriais até em eletrodomésticos, como é o exemplo de trens elétricos e
liquidificadores domésticos.
Contudo, com o avanço da tecnologia, necessidades especiais, como: precisão de
posicionamento e controle de velocidade, começaram a surgir, foi quando o motor de passo
surgiu para auxiliar nesses casos. Apesar dos motores elétricos de corrente alternada ou contínua
também possibilitarem certo controle de posição, a eficiência, nesse aspecto, do motor de passo é
superior.
O motor de passo nada mais é do que um motor elétrico especial (vide exemplos na figura
1). Isso quer dizer que, devido a sua arquitetura, ele possibilita inúmeros tipos de controle mais
precisos que os motores convencionais. Ou seja, esse motor foi desenvolvido e projetado para
atender necessidades de controle, mais especificamente de posicionamento. Posteriormente, neste
trabalho, as características que conferem aos motores de passo esses controles serão mais
detalhadamente elucidadas.
1
Figura 1 - Motores de Passo
Os motores de passo têm o seu princípio básico de funcionamento baseado no alinhamento
eletromagnético da parte girante (rotor) com a parte fixa (estator). E é esse alinhamento que
garante a principal característica diferencial do motor de passo: a alta precisão no
posicionamento.
Com essas características, o motor de passo começou a ser largamente explorado em
aplicações industriais que exigiam bom posicionamento como mesas xy, bobinadeiras e etc...
Além de ser muito usado na industria, esse atuador também é muito usado em eletrodomésticos
como impressoras, scanners, dispositivos computacionais entre outros. Pode-se dizer também que
os motores de passo conquistaram tanto espaço devido ao seu baixo custo em detrimento dessa
precisão de posicionamento e sua boa interface com sistemas digitais, que fazem o seu
acionamento, o que será abordado durante este trabalho.
Analisando tantas possibilidades e essa larga empregabilidade do motor de passo, torna-se
indispensável para o profissional ou estudioso das áreas tecnológicas, um conhecimento mais
aprofundado das diretrizes de um motor de passo.
Por isso, é de grande importância que aquelas pessoas que pretendam trabalhar ou se inserir
na área tecnológica ou industrial tenha um conhecimento sólido dos princípios de funcionamento
2
desse tipo de atuador. O que possibilitará ao conhecedor julgar sobre as possibilidades de
emprego, considerando os limites e vantagens desse tipo de motor elétrico.
O ensino desse tipo de motor, como mostrado acima, envolve a aplicação de conceitos
como o eletromagnetismo que não são visuais ou intuitivos. Ou seja, são conceitos cujos efeitos é
que podem ser visualizados e materializados.
No intuito de trazer mais estímulos para o aluno durante o aprendizado e apresentação da
teoria, foi desenvolvido um kit didático bastante visual. Esse kit é composto, principalmente, por
um protótipo de motor com seu interior transparente (vide figura 2) para que o aluno possa, em
uma visão macro, compreender a estrutura de um motor de passo.
O kit foi desenvolvido para que, além da estrutura, também pudessem ser de fácil
entendimento as formas de acionamento desse tipo de motor. O motor é constituído de 3 pares de
bobinas independentes que permitem acionamento também independente. E, além de usar um
driver aberto, toda sua lógica foi implementada em micro controlador passível de alteração.
Com todas essas possibilidades, o kit proporcionará ao aluno uma visão geral, porém, de
fácil aprendizado, dos princípios básicos do funcionamento do motor de passo.
3
2. Revisão Bibliográfica
2.1 Introdução
Os motores de passo, antes de tudo, são motores elétricos que também utilizam o princípio
do eletromagnetismo como força motriz. Este é um princípio bastante simples, mas que requer
certo nível de abstração.
O eletromagnetismo é o nome da teoria unificada desenvolvida por James Maxwell, que
relaciona a eletricidade com o magnetismo. Para o caso aqui estudado, é interessante salientar um
aspecto dessa teoria: sempre que há uma corrente elétrica é gerada também uma variação de fluxo
de campo magnético. Isso quer dizer que quando há a movimentação ordenada de elétrons
(corrente elétrica) é formado um campo magnético. Como pode ser visto pela lei de Ampère-
Maxwell com a equação abaixo (Eq.: 1.1):
Onde ienv é a corrente que induzirá o campo e B é o campo magnético.
A partir desse conceito, o motor de passo pôde ser desenvolvido. Diferentemente dos
motores elétricos convencionais, os motores de passo oferecem uma precisão de posicionamento
muito maior, além de possibilitar um controle de sua velocidade, suas acelerações e
desacelerações. Isso é possível, pois o motor trabalha constantemente se “alinhando” com um
campo eletromagnético apropriadamente criado, entre uma parte girante e uma fixa quando
4
energizado; o que difere, basicamente, de um motor elétrico convencional, que, quando
energizado, gira.
Os motores de passo são compostos basicamente por um estator e um rotor:
Rotor: é a denominação para o conjunto eixo-imã que roda solidariamente à parte móvel
do motor.
Estator: é definido como a trave fixa onde as bobinas são enroladas. Abaixo segue uma
figura onde podemos ver as partes mencionadas:
Figura 2 - Rotor
Figura 3 - Estator
Os motores de passo podem ser de 3 tipos, que serão logo elucidados, mas de um modo
geral, podem ter seu funcionamento explicado pelo alinhamento entre um imã-permanente ou
eletroímã e um campo gerado por pares de bobinas transpassadas por corrente elétrica.
As bobinas do estator estão posicionadas sempre em pares, podendo ser comumente
encontradas em 2 ou 3 pares, como no esquema abaixo:
5
Figura 4 - Bobinas em Pares (2 ou 3)
Para que o campo eletromagnético seja criando, as bobinas são acionadas separadamente ou
em pares. Sendo um par, por exemplo, acionado, uma corrente elétrica passa pelo fio que está
enrolado ao redor do material ferro-magnético (bobinas) e assim o campo é gerado (vide figura
5). Lembrando que esse campo segue a lei de Lenz: o sentido da corrente é o oposto da variação
do campo magnétic.
Figura 5 - Fluxo Magnético por Corrente
Com isso, basta que o campo eletromagnético formado fique variando de posição para que
o rotor se alinhe e dê movimento ao motor de passo.
Essa troca de acionamento de bobinas é outra peculiaridade do motor de passo. O
ligamento ou desligamento de um par de bobinas é feito através de um driver de potência que
pode ter inúmeras configurações e será abordado posteriormente. De qualquer forma o
acionamento das bobinas pode ser de um ou meio passo e unipolar ou bipolar.
6
2.2 Modos de Acionamento
Basicamente, como dito acima, os motores podem ter seu acionamento com configurações
entre unipolares ou bipolares e de passo inteiro ou meio passo. A configuração unipolar significa
que para cada bobina, só haverá um sentido de corrente e portanto de campo eletromagnético. Já
para a bipolar, a corrente e o campo poderão assumir as duas direções. Outro tipo de acionamento
é o com passo inteiro ou meio passo. Para o acionamento de passo inteiro as bobinas deverão ser
acionadas ou unicamente ou em pares. Já o acionamento com meio passo requer um acionamento
de uma única bobina e de um par, intercaladamente. A escolha do tipo de acionamento dependerá
da exigências da aplicação e do tipo de motor de passo com que se esteja trabalhando.
As possibilidades de acionamento foram exemplificadas conforme as figuras abaixo:
Figura 6 - Configuração Unipolar Figura 7 - Configuração Bipolar
Figura 8 - Acionamento Unipolar com Passo Inteiro
7
Figura 9 - Acionamento Bipolar com Passo Inteiro
Figura 10 - Acionamento Unipolar de Meio Passo
8
Figura 11 - Acionamento Bipolar de Meio Passo
Comercialmente, já existem algumas soluções de acionamento de motores de passo mais
comuns, como as mostradas abaixo:
Figura 12 - Acionamento Bipolar
9
Figura 13 - Acionamento Binível1
Figura 14 - Acionamento Binível 2
Figura 15 - Acionamento com Choppers
10
2.3 Tipos de Motores
Os motores de passo podem ser divididos em 3 grupos: o motor de relutância variável, o de
imã permanente e um motor híbrido.
2.3.1 Motor de Relutância Variável (VR)
No motor de relutância variável, sempre que há a energização das bobinas, o rotor tenta se
alinhar e se manter em uma posição de maior estabilidade. Essa posição de maior estabilidade é
sempre aquela aonde há a menor relutância entre estator e rotor. Isso quer dizer que quando as
bobinas conduzem corrente, um campo eletromagnético é formado e o rotor tenta se alinhar com
o mesmo.
Nesse tipo de motor, temos o estator trabalhando com bobinas em pares e todas voltadas
para o centro. Já o rotor é uma peça com um formato de uma engrenagem, que, dependendo do
modelo de motor, pode ter mais ou menos dentes que pares de bobinas, é constituído de material
ferro magnético, mas não é imã permanente. Abaixo, a ilustração mostra claramente esses
componentes:
Figura 16 - Motor de Relutância Variável
11
Para a movimentação desse motor, um par de bobinas é acionado após o outro. Sempre que
o campo magnético muda, o rotor tenta se alinhar com esse campo. Assim, o rotor estará sempre
buscando a posição de menor relutância (que é a resistência à passagem do campo magnético),
que é quando há a menor distância entre os dentes do rotor e o par de bobinas acionado.
O torque estático de um motor de passo pode ser medido quando o mesmo não está em
funcionamento, ou não tem nenhuma bobina sendo acionada. E, justamente pelo fato de ser um
motor sem imã permanente, o seu torque inicial é nulo.
Comercialmente esse motor é encontrado com passos que podem variar de 5º a 15º por
passo.
A figura abaixo salienta o funcionamento desse tipo de motor de passo, assim que o par de
bobinas acionadas muda, o rotor tende a se alinhar e gira até encontrar o ponto de menor
relutância, como mostra a figura:
Figura 17 - Passo de um VR
12
Motor de Imã Permanente (PM)
A grande diferença entre os motores PM e os motores VR é que o seu rotor é magnetizado e
não tem “dentes”. Ou seja, o seu torque estático não é mais nulo como no caso anterior. Sendo
assim, apesar de ser comumente encontrado funcionando com passos grandes e à baixas
velocidades, ele exibe um grande torque. Abaixo podemos ver um motor (PM):
Figura 18 - Motor PM
Esse modelo se movimenta tendo suas bobinas sendo acionadas seqüencialmente, a seguir a
uma seqüência de movimentação desse motor é mostrada:
Figura 19 - Uma Revolução do Motor PM
13
Motor Híbrido
Como o próprio nome sugere esse é um motor que combina a estrutura dos dois motores,
ou seja, possui rotor dentado e magnetizado. Essa configuração confere a esse tipo de motor uma
grande versatilidade de aplicações além de ter um custo barato em relação aos motores elétricos
tradicionais.
Figura 20 - Motor Híbrido
Para facilitar uma rápida comparação desses motores, seque a tabela com suas principais
características:
Motor de Relutância Variável (VR) - Rotor de aço doce multipolar- Enrolamentos no estator- Inércia de rotor baixa- Inércia inicial (desenergizado) nula
Motor de Imã permanente (PM) - Rotor magnetizado radialmente- Apresenta torque residual (de
retenção)- Materiais: Ferrite e Alnico- Enrolamentos no estator
Motor Híbrido - Rotor e estator multidentados- Alta precisão de posicionamento- Mistura os dois motores anteriores.
14
2.4 Curva Torque Vs. Velocidade de um Motore de Passo
Além de conhecer o seu funcionamento, é importante que o aluno aprenda a obter e
entender as informações intrínsecas ao motor. Isso quer dizer que quando em funcionamento, o
motor deve ser bem conhecido para que possa ser corretamente dimensionado e aplicado.
Todo motor de passo possui características que são inerentes a sua arquitetura e
acionamento. Pode-se dizer que a identidade de um motor de passo possa ser traçada pela curva
de torque vs. velocidade (figura abaixo).
Figura 21 - Curva Torque vs. Velocidade
Essa curva fornece quase todos os dados importantes para se aplicar um motor de passo,
pois ela sempre representará o máximo de torque “disponível” àquela velocidade. Além de ajudar
a estipular a sua rampa de aceleração, velocidade de cruzeiro e torque. Após a carga ser aplicada,
ela provavelmente agregará uma inércia ao sistema, que deverá ser calculada ou estipulada. Com
esses novos dados, pode-se traçar outra curva que agora trará o torque relativo àquela velocidade
com carga. Abaixo segue uma figura com o gráfico de curva torque vs. velocidade para duas
cargas diferentes sendo comparadas com a curva de um motor em vazio.
15
Figura 22 - Curva Torque vs. Velocidade (com carga)
2.5 Modelamento Matemático
Para um estudo mais detalhado do motor de passo é interessante que seja feito um
modelamento matemático de quanto e como seriam suas correntes, torques, deslocamentos,
velocidades e acelerações.
É interessante também que sejam feitos vários tipos de modelamento, alguns mais
abrangentes e outros mais aprofundados. Todos esses modelos deverão receber dados obtidos
experimentalmente como inputs. Basicamente podem ser feitos 3 tipos de modelamento.
Primeiramente, um modelo mais genérico pode ajudar no cálculo da melhor velocidade a
ser utilizada para um carregamento e um número de passos dado. Sendo que nesse modelo a
entrada de dados é a curva de velocidade vs. toque e as velocidades de teste. Um outro modelo
onde a inércia da carga, durante o movimento, é variável. E um terceiro, onde podemos calcular
as correntes e tensões que passam pelo motor, sendo que nesse tipo de modelamento, dependendo
do circuito de acionamento (ou de controle), temos uma aproximação boa ou não da realidade.
No primeiro modelo, basta calcular alguns parâmetros como: a velocidade, distâncias e
tempos de aceleração, desaceleração e andamento. Para isso é interessante levar em conta
algumas equações:
16
Lembrando torque de aceleração (Tac) é sempre igual ao torque da curva levantada (Tcurva)
vezes a porcentagem de utilização (Tu) de torque menos a frição de Coulomb (Tc).
Tac = Tcurva * Tu - Tc
A variação de velocidade = torque de aceleração/inércia do sistema*intervalo de tempo:
dw = Tac * dt / (Jr+Jl)
Distância percorrida = velocidade média do intervalo * intervalo de tempo:
dS = (w + dw/2)* dt
Torque de desaceleração = torque da curva negativo * porcentagem de utilização – frição
de Coulomb.
Tdc = Tcurva * Tu - Tc
Assim, o torque gerado (Tg) pode ser determinado pela multiplicação da inércia da carga,
somado com o atrito viscoso e com a frição Coulomb e torque gravitacional (se houve):
Tg = J * dw/dt + Fv * w + Tc + Tgr
No segundo moldelo, a inércia da carga varia de acordo com a posição do motor, e ela será
levada em conta com:
Tg = Tm * - sen (θe)
17
Sendo que Tm não é igual ao torque de “pullout” (Tpo), mas pode ser derivado dele.
Tpo = -Tm/ θse * int (sen θe dθe, - pi + θse/2, - pi - θse/2)
derivado => Tm = (Tpo * θse )/ ( 2sen(θse/2)).
No terceiro modelo, para o motor de imã permanente, aonde entram as correntes das fases,
deve-se interpretar as fases como um circuito como o abaixo:
Figura 23 – Modelo Elétrico de uma Fase
Para facilitar, aqui, serão apresentadas as equações para um motor de duas fases.
Va = ia* R + L *dia/dt - NB * sen Nθ * dθ/dt
Vb = ib* R + L *dib/dt - NB * sen Nθ * dθ/dt
Obs.: O “N” indica o número de ciclos elétricos por revolução mecânica, e “B” a força do
imã permanente.
Ta = NB * ia * - sen Nθ
Tb = NB * ib * cos Nθ
Td = D * -sen (4* Nθ)
18
Tg = Ta + Tb + Td
Para o motor hibrido as equações das fases são:
Va = ia* R + L *dia/dt + Kea * dθ/dt
La = L – C * Z * cos Nθ (“Z” = sinal da corrente)
Onde:
Kea = - N* (B – C * ia) * sen Nθ
Vb = ib* R + L *dib/dt + Keb * dθ/dt
Lb = L – C * Z * sen Nθ (“Z” = sinal da corrente)
Onde:
Keb = - N* (B – C * ib) * cos Nθ
Para os torques ficam as equações:
Ta = Kta * ia
Onde:
Kta = N * ( B – C/2 * |ia|) * - sen Nθ
Tb = Ktb * ib
Onde:
19
Ktb = N * ( B – C/2 * |ib|) * cos Nθ
Torque perdido:
Td = D * -sen (4* Nθ)
E o torque total:
Tg = Ta + Tb + Td
Aplicado ao modelo mecânico:
Tg = J * dw/dt + Fv * w +Tc + Td
20
3. Material e Métodos
3.1 Kit Didático
Para o desenvolvimento de atividades didáticas voltadas ao estudo de motores de passo,
muitos conceitos acima expostos poderão ser revisados através dos experimentos criados.
Para que o aluno pudesse compreender cada etapa do funcionamento do motor de passo, ele
terá que entender as etapas de monitoramento e geração dos comandos e seqüência de
acionamento, arquitetura interna e drivers de acionamento.
Focado nesses aspectos, o kit didático segue o seguinte diagrama com o fluxo de
informações (comandos):
Figura 24 - Esquema de Fluxo de Informações
21
O Protótipo
O protótipo de motor de passo é do tipo de um motor de imã permanente. Ou seja, o campo
eletromagnético formado pelas bobinas do estator força a movimentação do rotor. Nesse sentido,
o protótipo foi construído com o seu estator em 3pares de bobinas alinhadas formando 60º entre
si. Para mostrar como um rotor se comportaria perante a variação da posição do campo, foi
colocada uma bússola, que mostrará a direção do campo. A figura abaixo ilustra o protótipo:
Figura 25 - Esquema do Protótipo
Nesse protótipo, as bobinas trabalharão em pares, podendo ser acionadas na configuração
bipolar. Sendo assim, o motor poderá assumir se acionado com meio passo, 12 posições
diferentes, sendo algumas posições aqui exemplificadas quando apenas um par estiver acionado
de cada vez:
22
Figura 26 - Protótipo na Posição A
Figura 27 - Protótipo na Posição B
Figura 28 - Protótipo na Posição C
23
Dados técnicos do protótipo:
O protótipo foi feito em ferro doce, com um cano de XXmm de espessura e XXmm de
altura. Do lado interno foram postos cilindros de ferro doce também, dispostos todos voltados
para o centro e perpendiculares à tangente do círculo sendo todos eqüidistantes uns dos outros e
formando 60º entre si. E sobre cada barra de metal foram feitas as bobinas sendo que cada bobina
foi confeccionada com:
- fio de cobre envernizado com diâmetro de 0,06mm
- 200 voltas
- XXmm de comprimento de barra de metal
- 8 ohms de resistência.
- XX H de indutância
Sendo a indutância uma característica intrínseca do conjunto todo, a permeabilidade
magnética do material pode ser estimada. Esse dado pode ser interessante para algumas
comparações futuras. Para calculá-la usou-se a fórmula: .
Tendo a indutância como valor medido experimentalmente.
Que resulta em
O Driver de Potência
Para o kit didático, um driver de potência se torna necessário, pois, os sinais de controle
enviados pelo micro controlador não teriam potência ou corrente suficiente para alimentar as
24
bobinas e conseguir um campo magnético eficiente. E esse driver de potência é que fará a
interface entre o micro controlador e o protótipo. Ou seja, ele é o estágio que amplifica os sinais
enviados e alimenta com correntes adequadas as bobinas.
Cada bobina será acionada de maneira bipolar, isso quer dizer, conforme dito acima, que a
corrente deverá fluir nos dois sentidos. Para tanto, usou-se o conceito de acionamento por ponte-
H que, nada mais é, do que um circuito que permite a ligação nos dois sentidos através do envio
de sinais de controle para transistores e será mais bem explicado mais a frente.
Lista de Materiais:
- 1 protoboard com 550 pontos
- 6 transistores NPN (BC548)
- 6 transistores PNP (BC558)
- 12 diodos (1N914)
- 12 resistores de 1Kohm
- 1 resistor de 4r
- 6 resistores de 10ohm
- 1 cabo “flatcable” de 14 vias (com conectores macho e fêmea)
Nos esquemas elétricos a seguir os componentes usados serão representados como na
figura:
25
Figura 29 - Componentes
Para montar o circuito foi usado o seguinte esquema de ligação para a ponte-H:
Figura 30 - Ponte-H
26
A seguir serão dadas explicações detalhadas dos motivos e de cada componente, bem como
os seus dimensionamentos.
O funcionamento da ponte-H é bastante simples. Os transistores deverão ser acionados
sempre em pares para que haja a passagem de corrente e geração do campo. Para exemplificar o
acionamento da ponte-H, algumas ilustrações foram montadas.
Nos dois casos a seguir serão mostrados os acionamento dos transistores para que a haja a
possibilidade de passagem de corrente nos dois sentidos das bobinas. Para que a ponte-H
funcione corretamente, os transistores deverão ser acionados em pares e em “x” como mostrado a
seguir:
Figura 31 - Sentido A
E no sentido oposto:
27
Figura 32 - Sentido B
Para simbolizar o acionamento dos transistores, foram usadas as chaves S1 e S2, aonde
seus estados representam sinal alto ou baixo, representados por um ou zero respectivamente. Vale
lembrar que o acionamento de transistores PNP é dado em nível baixo (0) e os NPN em nível
alto(1). Também é interessante salientar que as bases dos transistores foram curto-circuitadas
convenientemente, e essa junção será posteriormente explicada.
Para esse circuito, os resistores de 1k são apenas limitadores de corrente de acionamento.
Pois como esses componentes têm ganhos muito grandes, uma corrente de base da ordem de
5mA será o suficiente. Além desses componentes, há a presença de quatro diodos que permitem
que a correntes parasitas e decorrentes do regime transiente do indutor sejam dissipadas, uma vez
que o circuito será chaveado e as correntes reversas devido à variação de tensão no indutor
poderão representar campos magnéticos contrários ao desejado.
Nesse circuito, algumas precauções deverão ser tomadas. Os transistores nunca poderão ser
acionados em linha, pois isso representa um curto circuito entre a fonte e o terra. Mesmo
tomando esse cuidado, devido ao tempo de chaveamento de cada transistor pode ser que um
28
transistor demore mais ou menos para mudar o seu estado de condução, o que caracterizaria um
curto instantâneo e de curta duração. Nesse sentido, foi colocado um resistor de 4 ohms para que
a corrente de curto seja limitada minimamente para minimizar danos. Ainda no intuito de evitar o
acionamento em linha as bases dos transistores foram curto-circuitadas, garantindo que na mesma
linha, os transistores nunca recebam sinal para conduzirem.
Para o dimensionamento da linha principal desse circuito, foram feitos alguns experimentos
práticos para se definir uma corrente que fosse suficiente para movimentar a bússola mas que
também não fosse demasiadamente intensa para danificar o sistema. Sendo assim, chegou-se a
conclusão que a melhor corrente seria de 200mA. Por tanto, considerando o circuito total,
precisar-se-ia de mais 10 ohms para o circuito, que foi acrescentado pelo resistor.
Esse foi o circuito de acionamento de uma bobina e, por tanto, ele se repetirá três vezes,
sendo uma ponte para cada bobina. Combinado com 3 circuitos, o driver de potência ficou assim:
Para que possa haver uma seqüência de acionamento foi montado uma espécie de protocolo
de comunicação entre o driver e os sinais de comando. Essa comunicação chegará sempre através
de um cabo do tipo “flatcable” de quatorze vias das quais só serão usadas seis (dois bits para cada
par de bobinas). Os 6 bits estarão separados por um bit inativo por motivos construtivos do
experimento. Esse byte estará representando cada chave de comando para cada bit. Novamente,
os sinais de zero e cinco volts serão aqui representados na forma de bits (zeros e ums). A figura a
baixo ilustra a relação entre os bits e as chaves. Sendo elas representadas da forma ABC para as
bobinas e um e dois para as respectivas chaves.
29
Figura 33 - Byte de Comunicação
A seguir, será usada uma forma de representar as posições possíveis do campo magnético.
Sendo a AA’ a representação para a bobina A acionada em um sentido e A’A em no outro
sentido. Também poderão ser acionadas duas bobinas ao mesmo tempo e elas serão representadas
com aspas simples para mostrar o sentido da corrente em cada par, por exemplo, AB serão as
bobinas A e B sendo acionadas no mesmo sentido, já o caso A’B é a bobina A sendo acionada em
sentido oposto ao anterior.
Portanto o padrão de acionamento ficaria assim:
30
Figura 34 - Seqüenciamento (Byte)
Programa de Controle (PIC)
A seguir será apresentado o programa que fará o controle seqüencial do motor. A idéia
básica do programa será interpretar os comandos enviados via seria do computador e transformá-
los em saída através do byte de comando para o driver de potência. Assim, basicamente haverá
dois modos de operação do motor. Um deles será o acionamento “manual” que a cada comando o
motor se moverá um passo. E outro modo aonde será passada uma quantidade de passos e uma
velocidade máxima (de cruzeiro) a ser executada, e assim o micro controlador se encarregará de
passar os sinais corretamente para o driver.
O PIC, micro controlador, usado será o modelo: 16F877. Esse é um modelo bastante
completo e com muitos recursos, apesar de utilizar poucos deles nesse experimento, esse foi o
controlador usado, pois no laboratório da faculdade de engenharia mecânica já o disponibiliza
com alguns recursos estruturais como os pinos de expansão, adequados para os conectores de
31
flatcable. Nesse projeto, serão usadas 6 saídas digitais no port D do controlador. Sendo as saídas
D00 a D07 as escolhidas para o experimento.
As funções do programa serão apresentadas na linguagem SDL e o programa original na
linguagem “C” será colocado nos anexos.
Basicamente o motor de passo poderá ser utilizado com meio passo ou passo inteiro. Para
cada caso será usada uma função diferente.
Para o caso do passo inteiro o programa fica assim:
32
Figura 35 - Função Passo Completo
Nesse caso, foram usadas as variáveis “Motor_Pas” e Motor, sendo a primeira que diz em
que posição o motor se encontra e a segunda imprime o byte de comando nos pinos de saída do
PIC. Como nesse modo, o motor anda com passo completo, a variável Motor_Pas só assume seis
valores diferentes (0-5). Já a variável Motor, pode assumir, dentro dessa função também apenas
33
seis valores. Obs.: os valores de “Motor” são expressos em hexadecimais para uma simples
adequação à linguagem de programação usada.
Para a função de meio passo será usada a mesma variável de saída de comandos (Motor),
porém será usada uma variável Motor_MPass, que também guardará a posição em que o motor se
encontra. Também é interessante ressaltar que ao termino da função, deverá ser feita uma
conversão entre as variáveis Motor_MPass e Motor_Pass, para que não haja perda de
posicionamento. Sendo assim, nas duas funções, uma etapa de correção de valores é feita.
A figura a seguir mostra o SDL para a função de meio passo.
A partir das duas funções de deslocamento, pode-se construir uma máquina interpretadora
de comandos que além de processar os comandos recebidos, executa uma rotina para realizar os
pedidos.
Para que os comandos fossem recebidos e tivessem o mínimo tratamento para erros o
programa principal funciona como uma máquina de estado. Ou seja, a cada comando, ele recebe
o dado, verifica se é realmente uma comunicação e muda de estado esperando o comando
seguinte.
Para o primeiro modo, basta que seja enviado pela serial o comando “N”, o motor já
responde e anda um passo apenas e fica aguardando novas instruções.
No segundo modo, o primeiro comando deverá ser o “P” e logo após cinco algarismos
sendo os três primeiros representando o número de passos a serem dados e os dois últimos a
velocidade máxima a ser desenvolvida.
34
35
Figura 36 - Função Meio Passo
36
37
Figura 37 - Função Máquina de Estados
Vale salientar que a máquina interpretadora de comandos é feita recebendo cada comando
separadamente e muda de estado a cada comando. Isso foi feito assim, devido a diferenças de
velocidades entre o processamento de um PIC e um PC, sendo que se fossem passados os
comandos diretamente pelo PC o buffer de saída serial estaria lotado e não receberia os
protocolos de handshake que o PIC não oferece nesse tipo de comunicação.
É interessante também explicar o funcionamento da configuração da velocidade máxima
entrada pelo usuário. Para que fosse feito o acionamento correto do motor, há uma rampa de
aceleração, um período em que o motor desenvolve a sua velocidade máximo ou de cruzeiro e
posteriormente desacelera. Para tanto, os pulsos de troca de configuração possuem um delay
variável. E é através desse delay variável que a velocidade é controlada. Isso quer dizer que a
velocidade vai de 0 a 99% do delay máximo estipulado (1s).
Essa função que trata da velocidade, acelerações e contagem do número de passos é
chamada de “Anda()”.
Programa de interface(Visul Basic)
Para criar uma interface agradável e de fácil entendimento, foi criado no Visual Basic uma
interface amigável que envia os comandos para o micro controlador e mostra a posição do motor.
É nesse programa que o aluno pode selecionar o modo a ser trabalhado. Se será acionado
passo a passo ou será através de objetivos.
A interface básica do programa está ilustrada abaixo. Nela, pode-se observar que há um
botão de opção aonde poderá ser selecionado o modo de trabalho. Sendo que quando um modo
foi escolhido o outro permanecerá inativo e vice-versa.
Esse programa segue o mesmo padrão de comandos que o PIC, uma vez que entre eles será
estabelecida a comunicação de comandos. Com isso, essa interface se encarregará de enviar, via
38
seria, os comandos “N” e “PpppVV”. Sendo “ppp” o número de passo e “VV” a velocidade
máxima a ser desempenhada.
Figura 38 - Programa de Interface VB
39
Figura 39 - Detalhe de Interface
O programa com todos os detalhes e explicações de cada evento está colocado no anexo 2.
É importante ressaltar que o programa em Visual Basic 6.0 foi desenvolvido para fazer a
comunicação via serial até o micro controlador. Porém, não pode-se ter acesso direto aos pinos de
saída da porta comm1 (usada nesse experimento), o que tem que ser feito é usar uma biblioteca
chamada MSComm32.ocx que realiza esse protocolo de interface.
3.2 Simulação computacional
Introdução
Além do kit didático, foi desenvolvido um programa simples para simulação de um motor
de passo.
Durante o estudo de motores de passo, é preciso que o seu funcionamento seja bem
entendido, para que também possa se dimensionado de forma correta, sem que haja super ou sub-
dimensionamento.
40
Para o dimensionamento de motores, antes de construir ou testar fisicamente alguns
modelos, é necessário que se possa fazer algumas simulações que sejam próximas o suficiente da
realidade.
Atualmente, a prototipagem rápida tem ganhado bastante importância no desenvolvimento
de novos produtos e/ou aplicações. E, nesse tipo de trabalho, as simulações computacionais têm
sido muito empregadas para poupar tempo e recursos desses projetos.
Por isso, o estudo mostrado a diante tem faz uma simulação de aceleração e velocidade e
cruzeiro.
Para um modelo inicial e mais simples de simulação de motores de passo, só serão
considerados alguns fatores dinâmicos como as inércias do motor e da carga. A parte elétrica de
acionamento e controle, por enquanto, não serão levadas em conta.
Nesse primeiro modelo de simulação adotado, foram feiras algumas aproximações e
considerações listadas a baixo:
Curva Pullout (Torque vs. Velocidade) / Obtido experimentalmente
Torque do rotor e carga fixos / Aproximações *
Torque inicial e perdas viscosas / Aproximações
Esses torques foram aproximados para não variarem devido a sua posição em relação a
gravidade.
Para a simulação computacional desse modelo, serão usadas como dados a serem entrados
de acordo com os objetivos pretendidos:
- Distância total percorrida, ou distância final.
41
- Velocidade máxima de acionamento do motor.
Obs.: Além das entradas, aqueles dados adotados também foram inseridos no programa.
Tendo disponíveis todos os dados, o programa fará, através de cálculo numérico, a
simulação do comportamento do motor. Esses cálculos são realizados através de iterações de
intervalos de tempo muito pequenas, assim, pode-se aproximar as curvas de aceleração,
velocidade e distância de modo a se obter o comportamento do motor durante toda a simulação.
Assim, a cada iteração, todos os valores de “status” do motor são recalculados e o tempo é
incrementado com uma unidade de tempo.
Para facilitar o entendimento e visualização, a simulação foi baseada no seguinte diagrama
na linguagem SDL:
42
Figura 40 - SDL - Simulação Computacional
Para visualizar as iterações e maneira de compilação da simulação há uma figura que
mostra um exemplo sobre cada iteração até a formação do perfil de velocidades.
Figura 41 - Iterações da Simulação (Perfil de Velocidades)
43
Durante toda a simulação é gerado um arquivo (*.txt) com todos os dados de velocidade e
distância percorrida por tempo, que, posteriormente será usado para a geração de gráficos no
Excel ou MatLab.
O programa para a simulação foi feito em linguagem “C” e está integralmente exposto no
anexo 3.
Como exemplo foi feita uma simulação com curva de motor:
Figura 42 - Dados da Curva
Figura 43 - Curva Exemplo
44
Após a geração dos arquivos em TXT, os dados podem ser plotados pelo Excel, como
mostrado logo abaixo:
Ex:
Velocidade máxima: 5000
Distância requerida : 2000
Figura 44 - Simulação Exemplo
O gráfico mostra apenas o período de aceleração e em velocidade de cruzeiro pois apenas
um arquivo de dados foi lido em modo de demonstração.
Para ajudar a demonstração foi criada uma macro em Excel que lê o arquivo gerado pela
simulação e plota um gráfico com esses dados.
A macro é bastante simples, com apenas essa linha de comando já se tem a atualização do
gráfico.
Sub Execulta Macro_Clique()Range("B2").SelectSelection.QueryTable.Refresh BackgroundQuery:=False
45
Anexos
Anexo 1. Programa para PIC na linguagem “C”
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Trabalho de Grauação - 2o Semestre 2007 * Universidade Estadual de Campinas - UNICAMP * Faculdade de Egenharia Mecânica - FEM * Curso de Engenharia de Controle e Automação * Aluno: Thiago Augusto Bento da Silva Camargo * Orientador: Luiz Otávio Saraiva Ferreira * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Programa: Motor de Passo.c * VERSÃO : 1.0 * DATA : 04/11/2007 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Descrição geral * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//*
Este programa, a partir de caracteres enviados, via serial, controla um protótipo de motor de passo. Os caracteres são enviados e interpretados por uma máquina de estados.Basicamente o acionamento se dá de duas formas:1 - Passo a Passo. (Um passo)2 - Ou com objetivos de velocidade e número de passos. Assim, o motor seráacionado até atingir o número de passos com velocidade máxima de cruzeiro setada pelo usuário.
*//***===================================================================
46
** 1 Informações Gerais** 1.1 Revisões****===================================================================*/
/***===================================================================** 1.2 Referências**** No Identificação Nome ou Descrição** =======================================================** 1 Datasheet do microcontrolador** PIC16F877, da Microchip****===================================================================*/
/***===================================================================** 2. Bibliotecas a incluir**===================================================================*/#include <io16f877.h> /* Definições dos registradores do processador */#include <inpic.h> /* Definição das funções intrínsecas do compilador */#include <stdlib.h> /* Definição das funções padrão do ANSI C */#include <ctype.h> /* Definição da conversão aSCII para HEXADECIMAL */
/***===================================================================** 3. DECLARAÇÕES** 3.1 Definições de tipos internas**===================================================================*/
#define RXFLAG RCIF /* Flag de chegada de byte pela serial */#define TXFLAG TXIF /* Flag de esvaziamento de TXREG */#define MOTOR PORTD //Saída de dados para o LCD.#define ENABLE RE1 //Sinal de enable para o LCD. Ativo na borda de subida.#define RS RE0 //Sinal de envio de dados (RS=1) ou comando (RS=0) para o LCD.
#define INIT 0 //Estados do Máquina Interpretadora de Comandos
#define P1 1 #define P2 2
47
#define P3 3#define V1 4#define V2 5
char MOTOR_PAS; // Posição do Motor (Passo)char MOTOR_MPAS; // Posição do Motor (Meio - Passo)char PASSOS[3], VELOCIDADE[2]; // Velocidade de cruzeiro e quantidade de passos objetivo.
/***===================================================================** 3.2 Protótipos de funções internas (definidas na Seção 5)**===================================================================*/void Beep(char PITCH[3]);void Delay_1ms(char TEMPO);char Recebe(void);void Transmite(char DADO_TX);void Comando(void);char Le_Tecla(void);void Aciona_Led (char LUZ[2] );void Inicializa_LCD (char vias, char modo, char cursor);void Escreve_LCD (const char *str, char tamanho, char linha, char coluna);void Escreve_Char_LCD (char caractere);void Um_Passo (void);void Meio_Passo (void);void Anda(void);
/***===================================================================** 3.3 Variáveis Internas**===================================================================*/
char CHAR_RX; // Caractere recebido pela serialchar NUM_TECLA, COD_TECLA; // Variáveis utilizadas para ler as teclaschar STT_INTERPRETADOR; // Estado do interpretador de comandos
/***===================================================================** 4. FUNÇÕES GLOBAIS ** (declaradas como 'extern' em algum arquivo de cabeçalho)**===================================================================*/
48
/* FUNÇÃO PRINCIPAL */ void main( void )/***---------------------------------------------------------------------------****** Parâmetros:** Nenhum**** Retorna:** Nada****---------------------------------------------------------------------------*/{ /* **------------------------------------------------------------------ ** Inicia o sistema **------------------------------------------------------------------ */
/***---------------------------------------------------------------------------** IMPORTANTE: programar os Configuration bits da seguinte forma:** Oscillator: XT** Watchdog Timer Off** Debug On** Power Up Timer On** Brown Out Detect Off** Low Voltage Program Disabled** Flash Program Write Disabled** Data EE Read Protect Off** Code Protect Off**---------------------------------------------------------------------------*/ __set_configuration_word(CP_OFF&CPD_OFF&DEBUG_ON&LVP_OFF&BODEN_OFF&PWRTE_ON&WDT_OFF&XT_OSC);
/*** NOTA: dispositivos que têm conversor A/D podem precisar** configurar os pinos assinalados a 'in' e 'out' como E/ digital */ADCON1 = 0x07;
49
INTCON = 0x00; //Desabilita todas as interrupções /*** É aconselhável primeiramente se escrever o valor inicial das portas** de E/S para depois se definir as configurações de E;S, de modo a se** evitar transientes nos pinos de saida. */
PORTA = 0x00; /* Zera os latchs de saída do PORTA */PORTB = 0x00; /* Zera os latchs de saída do PORTB */PORTC = 0x00; //0b.0000.0000TRISC = 0xBD; //0b.1011.1101 //Configura-se os pinos 7 r 6 do PORTC
//como saida e entrada, respectivamente,//da porta serial
PORTD = 0x00;TRISD = 0x00; // Configura PORTD como saída de comandos para o driver de potênciaPORTE = 0x00;TRISE = 0x00;
/* Inicialização da porta serial */TXSTA = 0x26; //0b.0010.0110 = Modo assíncrono 8 bitsSPBRG = 0x19;RCSTA = 0x90; //0b.1001.0000 = Habilita a transmissão serial
/* Inicializa LCD */Inicializa_LCD (0x38, 0x06, 0x0C);
/* Escreve LCD (mensagem, tamanho, linha, coluna) */Escreve_LCD ("Thiago Camargo", 14,0,0);Escreve_LCD ("TG Step Motor", 13,1,0);Delay_1ms(100);
/* Inicialização dos Processos */STT_INTERPRETADOR = INIT; //Estado inicial do interpretador
MOTOR_PAS = 0;MOTOR_MPAS = 0;MOTOR = 0x80;
/* **---------------------------------- ** Inicia as rotinas de interrupção **---------------------------------- */
/*
50
**------------------------------------ ** O código da sua aplicação vai aquí. **------------------------------------ */ while (1) {
Comando();}
} /* FIM DA FUNÇÃO PRINCIPAL */
/***===================================================================** 5. FUNÇÕES INTERNAS (prototipadas na Seção 3.2)**===================================================================*/
//*****************************************************************************// Função Delay_1ms( tempo )// tempo = quantidade de milissegundos//-----------------------------------------------------------------------------
void Delay_1ms(char TEMPO){ char i,j;
if (TEMPO==0) return;do { TEMPO--; for (i=255; i>0; i--); for (j=90; j>0; j--);
} while(TEMPO!=0);}
//*****************************************************************************/* Função que recebe caractere pela serial *//* Não tem argumento de entrada, e o argumento de saida é caractere ASCII *//* recebido ou o número 0 em caso de nenhum caractere recebido *///-----------------------------------------------------------------------------
char Recebe(void){ if (RXFLAG == 0) { return 0; }
51
else { return RCREG; } }
//*****************************************************************************/* Função que transmite caractere pela serial *///-----------------------------------------------------------------------------
void Transmite(char DADO_TX){ while (TXFLAG == 0) {}; TXREG = DADO_TX;}
//****************************************************************************/* Função que interpreta os comandos vindos do teclado *///----------------------------------------------------------------------------
void Comando(void){
CHAR_RX = Recebe(); // Lê caractere na porta serial// Início da máquina de estados interpretadora de comandos.
switch (STT_INTERPRETADOR) { case(INIT):
if (CHAR_RX == 0) break;if (CHAR_RX == 'N') { Um_Passo(); Delay_1ms(100); MOTOR_MPAS =
2*MOTOR_PAS; break;}if (CHAR_RX == 'P') { STT_INTERPRETADOR = P1; break;}
break;
case(P1):
if (CHAR_RX == 0) break;if (isdigit (CHAR_RX)) { PASSOS[0] = CHAR_RX; STT_INTERPRETADOR =
P2; break;}break;
case(P2):
if (CHAR_RX == 0) break;if (isdigit (CHAR_RX)) { PASSOS[1] = CHAR_RX; STT_INTERPRETADOR =
P3; break; }break;
52
case(P3):
if (CHAR_RX == 0) break;if (isdigit (CHAR_RX)) { PASSOS[2] = CHAR_RX;
STT_INTERPRETADOR = V1; break; }break;
case(V1):
if (CHAR_RX == 0) break;if (isdigit (CHAR_RX)) { VELOCIDADE[0] = CHAR_RX;
STT_INTERPRETADOR = V2; break; }break;
case(V2):
if (CHAR_RX == 0) break;if (isdigit (CHAR_RX)) { VELOCIDADE[1] = CHAR_RX;
STT_INTERPRETADOR = INIT; Anda(); break; }break;
}}
/* Função Escreve_Char_LCD (caractere) *///------------------------------------------------------------------------------------------------------------
void Escreve_Char_LCD (char caractere){
MOTOR = caractere;ENABLE = 1;ENABLE = 0;Delay_1ms(1);
}
/* Função Escreve_LCD (string, linha, coluna) *///-----------------------------------------------------------------------------------------------------------
void Escreve_LCD (const char *str, char tamanho, char linha, char coluna){
char i;coluna=coluna & 0x0F;if (linha == 0) coluna = coluna + 0x80; //Linha 0else coluna = coluna + 0xC0; //Linha 1RS = 0;
53
MOTOR = coluna;ENABLE = 1;ENABLE = 0;Delay_1ms(1);RS = 1;for (i=0; i < tamanho; i++){
Escreve_Char_LCD (str[i]);}
}
/* Função Inicializa o LCD *///-----------------------------------------------------------------------------------------------------------
void Inicializa_LCD (char vias, char modo, char cursor){
RS = 0;Escreve_Char_LCD (vias);Delay_1ms (3);Escreve_Char_LCD (modo);Escreve_Char_LCD (cursor);Escreve_Char_LCD (0x01);Delay_1ms (1);
}
/* Função Um_Passo () *///------------------------------------------------------------------------------------------------------------
void Um_Passo (){ if (MOTOR_PAS > 4) MOTOR_PAS = 0; else MOTOR_PAS++;
switch (MOTOR_PAS) { /* Seleciona Posição do Motor */case (0):
MOTOR = 0x37; /* Posiciona em A-A' */break;
case (1):MOTOR = 0x57; /* Posiciona em B-B' */break;
case (2):MOTOR = 0x67; /* Posiciona em C-C' */break;
case (3):MOTOR = 0x73; /* Posiciona em A'-A */
54
break;case (4):
MOTOR = 0x75; /* Posiciona em B'-B */break;
case (5):MOTOR = 0x76; /* Posiciona em C'-C */break;
default:MOTOR = 0x77; /* Erro: Mantem em A-A' */break;
}
}
/* Função Meio_Passo () *///------------------------------------------------------------------------------------------------------------
void Meio_Passo (){ if (MOTOR_MPAS > 10) MOTOR_MPAS = 0; else MOTOR_MPAS++;
switch (MOTOR_MPAS) { /* Seleciona Posição do Motor */case (0):
MOTOR = 0x37; /* Posiciona em A-A' */break;
case (1):MOTOR = 0x17; /* Posiciona em AB */break;
case (2):MOTOR = 0x57; /* Posiciona em B-B' */break;
case (3):MOTOR = 0x47; /* Posiciona em BC */break;
case (4):MOTOR = 0x67; /* Posiciona em C-C' */break;
case (5):MOTOR = 0x63; /* Posiciona em A'C */break;
case (6):MOTOR = 0x73; /* Posiciona em A'-A */break;
case (7):
55
MOTOR = 0x71; /* Posiciona em A'B' */break;
case (8):MOTOR = 0x75; /* Posiciona em B'-B */break;
case (9):MOTOR = 0x74; /* Posiciona em B'C' */break;
case (10):MOTOR = 0x76; /* Posiciona em C'-C */break;
case (11):MOTOR = 0x36; /* Posiciona em AC' */break;
default:MOTOR = 0x77; /* Erro: Mantem em A-A' */break;
}
}
/* Função Anda () *///------------------------------------------------------------------------------------------------------------
void Anda (){
char i;char Steps;char Vel;
for (i=0; i < 3; i++) {
if (PASSOS[i] >= 'A') PASSOS[i] = PASSOS[i] - 0x37; else PASSOS[i] = PASSOS[i] - 0x30;
}
if (VELOCIDADE[0] >= 'A') VELOCIDADE[0] = VELOCIDADE[0] - 0x37; else VELOCIDADE[0] = VELOCIDADE[0] - 0x30;
if (VELOCIDADE[1] >= 'A') VELOCIDADE[1] = VELOCIDADE[1] - 0x37; else VELOCIDADE[1] = VELOCIDADE[1] - 0x30;
Steps = 100*PASSOS[0]+10*PASSOS[1]+PASSOS[2];
56
Vel = 100*VELOCIDADE[0]+10*VELOCIDADE[1];
if (Steps>2*Vel)
{ for (i=0; i < Vel; i++) { Meio_Passo(); Delay_1ms(1000-i); }for (i=Vel; i < (Steps-Vel); i++) { Meio_Passo(); Delay_1ms(1000-Vel);}for (i=Vel; i > 0; i--) { Meio_Passo(); Delay_1ms(1000-i);}}
else{for (i=0; i < Steps/2; i++) { Meio_Passo(); Delay_1ms(1000-i); }for (i=Steps/2; i > 0; i--) { Meio_Passo(); Delay_1ms(1000-i); }}
if (MOTOR_MPAS%2) MOTOR_PAS = (MOTOR_MPAS-1)/2;else MOTOR_PAS = MOTOR_MPAS/2;
}
/***===================================================================** FIM DO ARQUIVO**===================================================================*/
Anexo.2 Programa para Visual Basic
‘Variaveis usadas
Dim Vel As Double ‘define o valor da velocidadeDim Pas As Double ‘define a quantidade de passosDim P1 As Integer ‘ primeiro algarismo do número de passosDim P2 As Integer ‘ segundo algarismo do número de passosDim P3 As Integer ‘ terceiro algarismo do número de passosDim V1 As Integer ‘ primeiro algarismo do valor de velocidadeDim V2 As Integer ‘ segundo algarismo do valor de velocidadeDim T1 As Integer ‘ variáveis para espero de um segundoDim T2 As Integer
57
‘Função que manda os dados na saída da serial‘Interessante salientar que os comandos são separados por uma espera de 1 segundo para garantir ‘a comunicação.
Private Sub cmdEnviar_Click()
MSComm1.Output = "P"Espera_1sMSComm1.Output = CStr(P1)n1.Caption = P1Espera_1sMSComm1.Output = CStr(P2)n1.Caption = P2Espera_1sMSComm1.Output = CStr(P3)n1.Caption = P3Espera_1sMSComm1.Output = CStr(V1)n1.Caption = V1Espera_1sMSComm1.Output = CStr(V2)n1.Caption = V2Espera_1sEnd Sub
‘Botão para 1 passo
Private Sub cmdProx_Click()MSComm1.Output = "N"End Sub
‘Função do botão de saída
Private Sub cmdSair_Click()
resp = MsgBox("Tem certeza que deseja sair?", vbYesNo, "Confirmação")
If resp = vbYes Then
Unload frmMotor
End If
End Sub
58
‘Função de espera de 1 segundo, esse é um laço que se repete até transcorrer 1segundo, porém ‘durante a sua execução os eventos poderão acontecer normalmente pela função “DoEvent”.‘Apesar de esse tipo de laço ser uma perda de processamento, ele garante que os comandos sejam ‘repassados de maneira segura e com o intervalo de tempo adequado.
Sub Espera_1s()T1 = Second(Time)T2 = Second(Time)DoEventsDo Until (T2 = T1 + 1)T2 = Second(Time)LoopEnd Sub
‘Função de carregamento e configuração inicial
Private Sub Form_Load()
MSComm1.CommPort = 1MSComm1.Settings = "9600,N,8,1"MSComm1.CommPort = 1MSComm1.PortOpen = TrueLoad frmSobrefrmSobre.Visible = False
End Sub
‘Função de finalização
Private Sub Form_Unload(Cancel As Integer)
MSComm1.PortOpen = False
End Sub
‘Função de visualização de objetos
Private Sub optObjetivos_Click()
If optObjetivos = True Then
frmPassoapasso.Enabled = FalsecmdProx.Enabled = False
Label9.Enabled = TrueLabel10.Enabled = TruefrmObjetivos.Enabled = True
59
txtPos.Enabled = TruetxtVel.Enabled = TrueLabel11.Enabled = TrueLabel14.Enabled = True
Else
frmPassoapasso.Enabled = TrueoptLigado.Enabled = TrueoptDesligado.Enabled = TruecmdProx.Enabled = True
Label9.Enabled = FalseLabel10.Enabled = FalsefrmObjetivos.Enabled = FalsetxtPos.Enabled = FalsetxtVel.Enabled = FalseLabel11.Enabled = FalseLabel14.Enabled = False
End If
optPaP.Value = False
End Sub
Private Sub optPaP_Click()
If optPaP = True Then
frmPassoapasso.Enabled = TruecmdProx.Enabled = True
Label9.Enabled = FalseLabel10.Enabled = FalsefrmObjetivos.Enabled = FalsetxtPos.Enabled = FalsetxtVel.Enabled = FalseLabel11.Enabled = FalseLabel14.Enabled = False
Else
frmPassoapasso.Enabled = FalseoptLigado.Enabled = FalseoptDesligado.Enabled = FalsecmdProx.Enabled = False
60
Label9.Enabled = TrueLabel10.Enabled = TruefrmObjetivos.Enabled = TruetxtPos.Enabled = TruetxtVel.Enabled = TrueLabel11.Enabled = TrueLabel14.Enabled = TrueEnd IfoptObjetivos.Value = False
End Sub
‘Função do botão de saída
Private Sub Sair_Click()
resp = MsgBox("Tem certeza que deseja sair?", vbYesNo, "Confirmação")If resp = vbYes ThenUnload frmMotorEnd If
End Sub
‘Função que mostra dados sobre o programa
Private Sub Sobre_Click()
frmSobre.Enabled = TruefrmMotor.Enabled = FalsefrmSobre.Visible = TrueEnd Sub
‘Função que testa os dados entrados pelo usuário e retira apesar três números para a quantidade ‘de passo e dois números para a velocidade.
Private Sub txtVel_Change()Vel = Left(Val(txtVel.Text), 2)Pos = Left(Val(txtPos.Text), 3)
If (Pos <> 0) Then If (Vel <> 0) Then cmdEnviar.Enabled = True Else cmdEnviar.Enabled = False End If
61
End IfEnd Sub
Private Sub txtPos_Change()Vel = Left(Val(txtVel.Text), 2)Pos = Left(Val(txtPos.Text), 3)
P3 = Pos Mod 10P2 = ((Pos - P3) / 10) Mod 10P1 = Left((Pos - P3) / 10, 1)
‘Nesse momento, foi feita uma seqüência de códigos que separa os algarismos do valor de número de passos a serem dados.
If (Pos <> 0) Then If (Vel <> 0) Then cmdEnviar.Enabled = True Else cmdEnviar.Enabled = False End IfEnd IfEnd Sub
‘Função que separa os comandos a serem repassados
Private Sub txtVel_LostFocus()V2 = Vel Mod 10V1 = (Vel - V2) / 10End Sub
Anexo 3 Programa para simulação computacional
#include <stdio.h>#include <stdlib.h>///////////////////////////////////Declaração de variáveis globais/////////////////////////////////
float Deltat=0.001; //Tamanho da interação em tempo
float Rotorj=0.000185, Loadj=0.00025; // Inércia do rotor e carga
float Friction=0.5, Torqueut=0.5; // Torque inicial e atrito viscoso
62
float SlewTime=0, SlewDist=0, TotalTime=0;// Velocidade, tempo e distância em velocidade
// de cruzeirofloat Distance, SlewSpeed; // Valores objetivosfloat AccelTime=0, DecelTime=0; // Tempos de aceleração e desaceleraçãofloat AccelDist=0, DecelDist=0; // Distâncias de aceleração e desaceleraçãofloat AccelVel=0, DecelVel=0; // Velocidade de aceleração e desaceleraçãofloat AccelNum=0, DesacelNum=0;float pi=3.141592; // Valor de pifloat Speed=0; // Velocidade atual do motor
/////////////////////////// //Função de aproximação da curva Torque vs. Velocidade//Parametros de entrada: Velocidade//Parametros de saida: Torque aproximado///////////////////////////float CalcTorque(float vel){
float speed1=500, speed2=2000, speed3=4000, speed4=6000;float torque1=2.8, torque2=2.5, torque3=2.1, torque4=1.4;
if (vel < speed1) return torque1; else{ if (vel < speed2) return (torque1+(torque2-torque1)/((speed2-speed1)*(vel-speed1))); else { if (vel < speed3) return (torque2+(torque3-torque2)/((speed3-speed2)*(vel-
speed2))); else return (torque3+(torque4-torque3)/((speed4-speed3)*(vel-speed3))); } } return 0;}//////////////////////////////////
/////////////////////////////////////Função que calcula os parâmetros de aceleração a cada iteração
void AccelRate(){ float PoTorque=CalcTorque(AccelVel);float AccelTorque = PoTorque*Torqueut-Friction;float SpeedChange = AccelTorque/(Rotorj+Loadj)*Deltat*100/pi;AccelDist = AccelDist + (AccelVel + SpeedChange/2)*Deltat;AccelVel = AccelVel+SpeedChange;AccelTime = AccelTime+Deltat;
63
}///////////////////////////////////
/////////////////////////////////////Função que calcula os parâmetros de desaceleração a cada iteração
void DecelRate(){
float PoTorque=CalcTorque(DecelVel);float DecelTorque = PoTorque*Torqueut-Friction;float SpeedChange = DecelTorque/(Rotorj+Loadj)*Deltat*100/pi;DecelDist = DecelDist + (DecelVel + SpeedChange/2)*Deltat;DecelVel = DecelVel+SpeedChange;DecelTime = DecelTime+Deltat;
}//////////////////////////////////
////////////////////////// Loop de Calculo//////////////////////////Parâmetros : arquivos como referência//Função: chamar as funções de cálculo e escrever no arquivo////////////////////////void Calculo(FILE *arquivo,FILE *arquivo2){
float i;
if ((AccelDist+DecelDist) > Distance) { DecelDist=Distance-AccelDist; TotalTime = AccelTime + DecelTime + SlewTime; return; }else { if (AccelVel>DecelVel) { DecelRate(); fprintf(arquivo2,"%7.3f %7.3f %7.3f\n",DecelTime,DecelVel,DecelDist); Calculo(arquivo,arquivo2); }
else {
64
if (AccelVel>SlewSpeed) { SlewDist = Distance-AccelDist-DecelDist; SlewTime = SlewDist/SlewSpeed; TotalTime = AccelTime + DecelTime + SlewTime; for (i=Deltat;i<(SlewTime);i=i+Deltat) { fprintf(arquivo,"%7.3f %7.3f %7.3f\n",i+AccelTime,SlewSpeed,(AccelDist
+i*SlewSpeed)); } return; } else { AccelRate(); fprintf(arquivo,"%7.3f %7.3f %7.3f\n",AccelTime,AccelVel,AccelDist); Calculo(arquivo,arquivo2); }} }
return ;}
/////////////////////// Programa Principal/////////////////////
int main (){////////////////////////////////////////// //Entrada de Valores-Objetivo
printf(" Entre com os objetivos pretendidos:\n\n\n");printf(" Entre com a distancia que o motor percorrera: ");scanf("%f",&Distance);printf("\n Entre com velocidade máxima do motor:");scanf("%f",&SlewSpeed); //////////////////////////////////////////
///////////////////////////////////////////// Abertura de arquivos (gravados no disco)///////////////////////////////////////////
/////////////////////////////////////////////Arquivo: conterá os dados de tempo, distância e velocidade
65
// durante a aceleração e em velocidade de "cruzeiro" (objetivo)FILE *arquivo;arquivo = fopen("grafico.txt","w");fprintf(arquivo," Tempo Velocidade Distância\n");fprintf(arquivo,"000.000 000.000 000.000\n");/////////////////////////////////////////////Arquivo2: conterá os dados de tempo, distância e velocidade // de desaceleração (porém em ordem invertida, que será trabalhada// no programa de plot dos dados (MatLab).FILE *arquivo2;arquivo2 = fopen("decel.txt","w");////////////////////////////////////////////
///////////////////////////////////////Chamada para início dos cálculos (iterativamente)Calculo(arquivo,arquivo2);/////////////////////////////////////
////////////////////////////// Fechamento dos arquivos fclose(arquivo);fclose(arquivo2);////////////////////////////
system("PAUSE");return 0;}
66