Módulo Driver ULN2003 + Motor de Passo 28BYJ-48 / 5VDC
Fala Pessoal! Tudo Beleza?! 😀
Bom, hoje vamos falar sobre um assunto que interessa a muita gente, principalmente aos atuais “makers“, sim, a nós que nos consideramos os próprios “fazedores de coisas em casa” (ou no laboratório, oficina, bancada…) 😎 !
CARACTERÍSTICAS GERAIS E ALGUNS DETALHES IMPORTANTES SOBRE O FUNCIONAMENTO DO MOTOR DE PASSO UTILIZADO NESTE POST (MODELO: 28BYJ-48 / 5VDC)
Bom pessoal, de cara já dá pra perceber que nosso motor de passo, o 28BYJ-48 funciona exatamente com uma tensão de 5V contínuos (como mostra a foto acima estampado na etiqueta do motor).
Sobre a corrente (A) consumida pelo motor, bem, esse é realmente um dado relativo e que pode sofrer variações de acordo ao modo de utilização do motor de passo, até mesmo porque, dependendo do tipo de “pulsos de acionamento” que enviemos às fases do motor, que é o que de fato vai definir o tipo de funcionamento do motor (half-step, full-step, wave-step), a corrente consumida varia, mas na prática, nos meus testes de bancada, esse motor de passo (28BYJ-48) não consumiu mais que 170mA (sem carga)!
Outro detalhe não menos importante, principalmente para o pessoal que está “começando” agora, que está “pegando” pela primeira vez em um motor “do tipo passo” (step motor em Inglês), é que este motor possui uma “redução na ordem de 1/64” 🙄 !
Beleza, mas afinal de contas o que é “redução” num motor de passo? 🙄
Boa pergunta!
💡 A resposta é a seguinte: quando um motor de passo faz uso de uma “caixa de redução“, de “uma redução“, para todos os casos, o eixo deste motor vai de encontro à uma série de mecanismos, normalmente rolamentos e engrenagens que realizam a “simples” tarefa de reduzir a velocidade de giro do motor, sim, isso mesmo, o motor faz uso de uma redução para diminuir seu RPM (rotações por minuto), MAS também faz uso desta mesma “redução“, e principalmente por isso, para garantir um aumento do TORQUE do motor! (PS: devido às leis da Física, quando existe uma redução na rotação do motor, aumenta-se então o torque disponível no sistema). ❗
E aí alguns de vocês podem estar se perguntando…:
Tá bom Rodrigo, vimos que a “redução” que o motor de passo faz uso, serve pra baixar a “velocidade” de giro dele (o famoso RPM) e que com as leis da física passamos a ter então uma “menor velocidade com maior torque“, beleza, mas tem algo mais a acrescentar nisso para dizer que essa chamada “redução” seja mesmo tão importante, ao ponto de gastarmos um tempo já neste assunto?
Sim meu Amigo, Amiga! Indo direto ao ponto, a redução utilizada neste motor de passo (28BYJ-48), como vem nas especificações do próprio motor, é na ordem de 1/64, ou seja, o RPM “original” do motor é “reduzido” em 64 vezes! Isso significa, que para nosso motor dar uma volta completa (360˚) em seu próprio eixo, ele vai precisar dar 4096 passos! O que nos leva invariavelmente a obter, uma precisão de “giro” tão alta quanto aproximadamente 0,088˚ por passo (isso mesmo, menos de 1˚)! 😮
Ahh! Precisamos saber também que o motor de passo que utilizamos, é um motor do tipo UNIPOLAR, ou seja, isso quer dizer que, este motor especificamente conta com 4 fases (que chamamos também de enrolamentos ou bobinas em seu interior) e deste fato resulta que este motor de passo unipolar possui 5 fios para interligar (4 fases + 1 comum). Veja a figura abaixo:
Fases e Comum (Red) no Motor de Passo
Dessa forma, o eixo do nosso motor de passo (assim como o de qualquer outro motor deste tipo), funcionará corretamente quando aplicarmos em seus enrolamentos internos (suas fases), um pulso, um comando elétrico seguindo uma sequência correta, de forma a fazer girar o eixo do motor em incrementos bem precisos (os mesmos que mencionamos acima sendo ao redor do 0,088˚ de precisão por passo).
A rotação do eixo do motor, tem enorme (senão total) relação com estes pulsos elétricos aplicados na entrada (fases) do motor de passo (fazendo variar tanto o RPM quanto o sentido de rotação do motor).
Aprofundando o conhecimento um pouco mais sobre a rotação do motor de passo…
Bom pessoal, tentando oferecer a vocês um pouquinho mais de conhecimento sobre este assunto, ainda que o tema possa parecer estar ficando “chato” para alguns, vejam só algumas características sobre o funcionamento deste motor de passo UNIPOLAR:
Por que UNIPOLAR?
Bom, este nosso motor de passo é do tipo Unipolar porque ele possui 4 FASES (que chamamos também de bobinas ou enrolamentos), o que faz com que o mesmo tenha 5 terminais (fios).
Cada pino do Arduino, configurado como saída (D08, D09, D10 e D11 em nosso caso), irá acionar cada uma das fases do motor de passo (fazendo seu eixo girar) através de um circuito Driver ULN2003A (maior corrente). Veja a figura abaixo:
Interligação entre FASES e Pinos Digitais do Arduino
E pra engrandecer o assunto, devemos saber que para motores de passo do tipo Unipolar, temos a possibilidade de “configurar“ como queremos que eles se comportem (alterando seu modo de operação, que consequentemente irá alterar o RPM, Torque e Passo). Temos então os seguintes modos de operação:
- Modo Full Step (passo completo com alto torque);
- Modo Half step (meio passo);
- Modo Wave Step (passo completo com baixo torque);
- Modo
Micro step(micro-passo).
Obs: Não se aplica pois nosso circuito não permite o controle de corrente.
Para que possamos visualizar melhor como cada uma das Fases são acionadas em seu devido momento (tudo deve ser muito sincronizado), para cada um dos tipos de operação mencionados acima, vamos observar e analisar as tabelas que seguem para cada operação, levando em consideração onde forem representados zeros (0) = (Fase desativada) e uns (1) = (Fase ativada) e claro, considerando também que nas linhas estão representadas as sequências dos passos e nas colunas, as respectivas Fases:
Passo completo com alto torque (Full step)
Observe que 2 Fases são acionadas ao mesmo tempo.
Meio Passo (Half step) Na sequência de oito passos, em alguns passos temos somente uma Fase acionada e em outros passos, temos 2 Fases acionadas.
Passo completo com baixo torque (Wave Step)
Somente uma Fase é acionada a cada vez.
Referência: Gustavo Murta – Lab de Garagem
E CONTINUANDO COM MAIS DETALHES SOBRE A ROTAÇÃO DO MOTOR DE PASSO…
Pessoal, e pra tentar deixar ainda mais “claro“, mais fácil de visualizar de fato como um motor de passo funciona internamente, uma vez aplicados os pulsos elétricos às suas fases (tudo de acordo ao que aprendemos acima), de forma sincronizada, isso faz com que “um ímã” interno seja literalmente “atraído/puxado” para a(s) bobina(s) que está(ão) sendo energizada(s) no momento, e desta forma, com a “repetição” dos pulsos e sincronicidade, o eixo do motor de fato irá girar. Vejam a animação abaixo:
Visão interna das fases (enrolamentos) do motor de passo.
(créditos imagem: talkingelectronics.com)
Nosso motor de passo (28BYJ-48) possui 5 fios, e motores deste tipo e número de fios, “nos diz” que este motor tem simplesmente um fio que se conecta/interliga, à todos os enrolamentos dentro do motor! Na figura abaixo fica representado como “common” (comum à todas as fases), além dos demais terminais como entradas dos enrolamentos/bobinas, representados como “live“, vejam:
Visão interna das fases (enrolamentos) do motor de passo.
(créditos imagem: talkingelectronics.com)
Fazendo a conexão entre o motor de passo e a placa Arduino (Roduino)
Bom pessoal, neste momento, eu poderia dizer a vocês que existem várias maneiras e métodos de “interligar” o nosso motor de passo à nossa placa Arduino UNO (Roduino no meu caso), pois certamente há! MAS, neste artigo trabalharemos com um pequeno módulo chinês, que conta com um circuito integrado driver “poderoso“, o conhecido ULN2003APG. Fazer uso do CI ULN2003A, torna mais simples a tarefa de realizarmos a interface do motor de passo unipolar com a placa Arduino (ou qualquer outra baseada no microcontrolador ATMega328P).
💡 O Circuito Integrado ULN2003APG contém em seu interior, 7 transistores do tipo Darlington fazendo com que ele possa “suportar” corrente da ordem de até 500 mA por canal, (o CI possui 7 canais mas utilizaremos apenas 4 deles) mantendo uma queda de tensão interna ao redor de 1V quando energizado).
Módulo driver contendo CI ULN2003APG para interface com Motor de Passo
Especificações do Motor de Passo e do Módulo Driver:
– Modelo: 28BYJ-48 (datasheet)
– Driver: ULN2003 (datasheet)
– Tensão de Operação: 5VDC
– Número de fases: 4
– Número de fios: 5
– Caixa de Redução: 1/64
– Diâmetro do eixo: 5mm
– Ângulo do Passo: 5,625°/64 ~ 0,088°
– Frequência: 100Hz
– Resistência DC: 50Ω ± 7%(25℃)
– Torque: 34,3 mN.m
– Peso: 40g
Observação: Uma das “vantagens” de se utilizar este módulo, é porque ele possui LEDs que indicam exatamente quando cada fase/enrolamento/bobina do motor é de fato acionada (ou seja, é energizada), além do detalhe importante, que é poder operar facilmente entre os 5V ou 12V, bastando para isso mudarmos um jumper de lugar.
PS: É completamente possível realizar a mesma interface entre o motor de passo e o Arduino sem a necessidade obrigatória do módulo, bastando montar o próprio CI ULN2003A sobre uma protoboard ou similar. 💡
REALIZANDO A INTERFACE ENTRE ULN2003 (COM OU SEM MÓDULO) E O ARDUINO
1 – COM MÓDULO:
Interface entre Módulo ULN2003 e Arduino (créditos imagem: Gustavo Murta – LabG)
1 – SEM MÓDULO (APENAS O CI ULN2003A):
INTERFACE do circuito integrado ULN2003 ao Arduino
3 – NA PROTOBOARD (COM MÓDULO DRIVER):
Esquemático Motor de Passo, Driver ULN2003A e Arduino UNO (créditos imagem: filipeflop.com) OBS: NÃO alimentar o módulo com os 5VDC da placa Arduino
4 – NA PROTOBOARD (SEM MÓDULO – APENAS O CI ULN2003A):
Esquemático Motor de Passo, CI ULN2003A e Arduino UNO (créditos imagem: dragaosemchama.com)
💡 Observação Importante!
Pessoal, apesar de ler e ver pela internet que muita gente utiliza (ou pelo menos tenta fazer o circuito funcionar de primeira), alimentando o driver e o motor de passo utilizando a mesma fonte de alimentação do Arduino (seja ela via USB – o que é ainda pior) ou pelo próprio plug “jack” presente na placa para alimentação externa, eu particularmente falando, em todos os meus testes (realmente não foram exagerados tampouco exaustivos), observei que o motor com driver e SEM carga, dependendo do tipo de operação e rotação, chegou a consumir em torno de 170mA 🙄 ,o que não considero como sendo um consumo irrisório de corrente elétrica, ENTÃO, a partir daí eu recomendo fortemente que vocês utilizem uma fonte de alimentação externa e independente do Arduino para alimentar o motor de passo, seja ela de 5VDC ou 12VDC, já que o CI ULN2003A suporta qualquer uma destas duas tensões de alimentação!
Bom, então pronto, chega de teoria e vamos finalmente a prática! 😀
Código (Sketch) para realizar o Controle do Motor de Passo:
Pessoal, para controle do motor de passo, dentro (“embutido“) na IDE do Arduino, já vem uma biblioteca primária para controlar nosso tipo de motor. Para IMPORTAR e utilizar a biblioteca, uma vez já dentro da IDE, basta acessar: Sketch > Incluir Biblioteca > Stepper. Caso ache mais rápido (apesar de não ser o método que eu indico), copie, cole e compile o código de exemplo abaixo para controlar o motor de passo via Arduino:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
// CONTROLANDO MOTOR DE PASSO UNIPOLAR COM ARDUINO // Changed and Reproduced by // BLOG: EletronicaParaTodos.com // ARDUINO`S STEP MOTOR CONTROL EXAMPLE SKETCH // MAO, 21-07-2017 // Credits: Filipeflop.com #include <Stepper.h> const int stepsPerRevolution = 500; //Utilizando as portas digitais 08 a 11 para conexao ao motor Stepper myStepper(stepsPerRevolution, 8,10,9,11); void setup() { // Velocidade inicial do motor (MAX 100) myStepper.setSpeed(60); } void loop() { //Gira o eixo do motor no sentido horario - 90 graus for (int i = 0; i<=3; i++) { myStepper.step(-512); delay(2000); } //Gira o eixo do motor no sentido anti-horario - 120 graus for (int i = 0; i<=2; i++) { myStepper.step(682); delay(2000); } //Gira o eixo do motor no sentido horario, aumentando a //velocidade gradativamente for (int i = 10; i<=60; i=i+10) { myStepper.setSpeed(i); myStepper.step(40*i); } delay(2000); } |
O sketch/código acima fará com que o motor de passo gire no sentido horário 4 vezes em ângulos de 90˚, depois 3 vezes no sentido horário em ângulos de 120˚, e por último vai fazer girar o eixo do motor aumentando sua velocidade gradativamente. Finalmente, depois de 2 segundos, todo o processo é reiniciado.
CONTROLANDO PROTÓTIPO DE ESTEIRA COM MOTOR DE PASSO, DRIVER ULN2003, SENSOR INFRA-VERMELHO (IR) E ARDUINO:
Código (Sketch) para realizar o Controle do Motor de Passo + IR Sensor:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
// Controle de Motor de Passo - Modo Passo Completo baixo torque (Wave step) // Motor 28BYJ48/5V com Módulo ULN20023 - DIGISPARK - MCU ATMEL ATtiny85 // Uma volta no eixo = 4075 pulsos / 512 x 8 = 4096 // Blog: https://eletronicaparatodos.com // Créditos: Gustavo Murta - LabGaragem // Matriz dos bytes das Fases do Motor - sentido Anti-Horário WaveStep byte AHO[4] = {0x08,0x04,0x02,0x01}; // Declaramos as variaveis para o sensor IR int pinoSensor = 12; // Pino do Sensor setado como PD12 do Arduino (NÃO o 13 da RODUINO porque ela é naturalmente setada como SAÍDA!) int leituraSensor; // Armazenamos o valor lido pelo sensor IR // Intervalo de tempo entre as fases do motor de passo em milisegundos - min 2 para Wave Step int atraso_fase = 3; // Função responsável pelo movimento/giro do Motor de Passo (Anti-Horario) void Motor_AHO() // Movimento no sentido anti-horário { for(int j = 0; j < 4; j++) // incrementa o contador j de 0 a 3 { PORTB = AHO[j]; // Carrega bytes da Matriz AHO na Porta B delay (atraso_fase); // Atraso de tempo entre as fases em milisegundos } } void setup() { DDRB = 0x0F; // Configura Portas D08,D09,D10 e D11 como saída pinMode(pinoSensor, INPUT); // Configuramos o Pino do Sensor como ENTRADA PORTB = 0x00; // Reset dos bits da Porta B (D08 a D15) Serial.begin(9600); // Iniciamos a Comunicação Serial da IDE } void loop() { leituraSensor = digitalRead(pinoSensor); // Armazenamos na variavel a atual leitura do sensor if(leituraSensor == 0) // Verifica se o objeto foi detectado { //Motor_AHO(); // Gira motor no sentido Anti-Horário Serial.println(leituraSensor); delay(30); } else { Motor_AHO(); // Gira motor no sentido Anti-Horário Serial.println(leituraSensor); } } |
Bom Pessoal, este artigo configura bem o que eu tinha e queria apresentar pra vocês sobre motores de passo, neste nosso caso, o do tipo unipolar. Sei que o assunto se estendeu até D+, mas pra vocês que já conhecem este Rodrigo Costa aqui, (risos), sabem até que fui relativamente “moderado” na escrita ou melhor, digitação deste post. 🙄 😀
Abração a Todos!
Gostaram? 😉
Comentem! 😀
Compartilhem! 😆
Técnico em Eletrônica Analógica com ênfase em Digital registrado no CREA/CFT.
- Medindo e Monitorando a Temperatura com Arduino (Sensor LM35) - 5 de setembro de 2021
- Controle de Cargas através de Entrada Analógica com Arduino - 30 de agosto de 2021
- REVIEW E DICAS – ALICATE AMPERÍMETRO (UNI-T UT210E PRO) - 28 de agosto de 2021
Boa noite, estou montando um projeto com 3 motores de passo, e eu preciso que eles girem independentes entre si com velocidade e direção. Eu consegui fazer eles girarem com velocidades independentes alterando as rpms, mais não consegui de nenhuma forma um comando para alterar a direção. Eu queria que o stepper3 girasse em sentido horário por 10segundos, depois em sentido anti horário por mais 10 segundos com uma pausa de 1 segundo entre a mudança de sentido. Como que eu faço?
Vou colocar abaixo o código para vcs me ajudarem.
#include
AccelStepper stepper1(AccelStepper::FULL4WIRE, 2, 4, 3, 5);
AccelStepper stepper2(AccelStepper::FULL4WIRE, 6, 8, 7, 9);
AccelStepper stepper3(AccelStepper::FULL4WIRE, 10,12,11,13);
void setup(){
stepper1.setMaxSpeed(1000);
stepper1.setSpeed(200);
stepper2.setMaxSpeed(1000);
stepper2.setSpeed(200);
stepper3.setMaxSpeed(1000);
stepper3.setSpeed(500); //Velocidade do motor em RPM
}
void loop()
{
// Change direction at the limits
if (stepper1.distanceToGo() == 0)
stepper3.moveTo(-stepper3.currentPosition());
stepper1.runSpeed();
stepper2.runSpeed();
stepper3.runSpeed();
}
Fala Dayner! Tudo Bom?
Seja muito bem vindo ao nosso Blog – Eletrônica Para Todos!
Rapaz, de início eu acredito que você tenha colocado o código fonte (incompleto) aqui. Até porque eu não sei o que vem depois do #include
Mas tudo bem, sem problemas para tentar entender a “lógica” do que você deseja realizar sem passar o código detalhadamente.
Bom, ao meu ver, TALVEZ (apenas talvez), a biblioteca que você está utilizando não seja a melhor para realizar este controle (de direção de rotação) do motor de passo.
Também não sei se a linha de código (
if (stepper1.distanceToGo() == 0);) pode ser implementada, ao invés de utilizar apenas ==0.Também não sei se a linha de código (
stepper3.moveTo(-stepper3.currentPosition());) pode fazer uso do "-"stepper, pois este acredito que seria o "objeto" da classe "posição", ou seja, o próprio motor de passo número 3.Enfim, como não posso fazer afirmativas absolutas sobre o seu código em si, particularmente recomendo que você acesse os dois links que deixo abaixo, pois neles você terá acesso a "outra biblioteca" para controle de motores de passo, tanto para direção da rotação, como velocidade, etc. Sendo assim, acredito que você possa no "mínimo" realizar TESTES, comparando estes códigos novos, com bibliotecas diferentes, com o seu próprio código, e a partir daí, tirar suas melhores conclusões, veja abaixo:
- Controle MOTOR DE PASSO - Arduino
- Controle Motor de Passo - Arduino (RoboCore)
É isso aí!
Espero que lhe auxilie de alguma forma. ;)
Ahh! Se ainda não for Inscrito no Canal, deixo o convite para se Inscrever e clicar no sininho para receber todas as próximas atualizações automaticamente!
Um Abraço,
Rodrigo Costa do Canal YouTube, Fanpage e Instagram,
-----------------------------------------------
https://youtube.com/EletronicaParaTodos
https://facebook.com/EletronicaParaTodosBR
https://instagram.com/EletronicaParaTodosBrasil
-----------------------------------------------
▶Colabore com o Crescimento do Blog e Canal:
➤https://apoia.se/eletronicaparatodos
➤https://pag.ae/7UyMZmYb4
Gostaria de saber se posso programar um motor de passo pra dar uma volta completa no sentido horário de 5 em 5 minutos
Fala Jair! Tudo Bom?
Seja muito bem vindo ao nosso Blog – Eletrônica Para Todos! 🙂
Rapaz, respondendo sua pergunta, a resposta é SIM.
Basicamente você pode começar tentando informar em seu código/sketch do Arduino um valor de 300000 milissegundos que é igual aos 5 minutos!
PS: Vai funcionar de primeira?! Não posso te afirmar que sim e nem que não! Precisa testar! 😉
PS1: Dá uma olhada neste link – http://bit.ly/2XiEuJ6
Vai adiante!
Todo o Sucesso!
Forte Abraço,
Rodrigo Costa do Blog, Fanpage e Instagram,
———————————————————————————
https://EletronicaParaTodos.com
https://facebook.com/EletronicaParaTodosBR
https://instagram.com/EletronicaParaTodosBrasil
———————————————————————————
▶Colabore para o Crescimento do Canal:
➤https://apoia.se/eletronicaparatodos
➤https://pag.ae/7UyMZmYb4
Olá Rodrigo, tudo bem?
Estou pesquisando sobre a implementação de motor de passo com Arduino e cai no seu site. Achei ótimo o modo como você explica e gostei bastante do vídeo tb. Parabéns.
Eu estou começando agora como Arduino, vai ser o meu primeiro projeto. Estou anotando tudo, fazendo as cotações e imaginando cenários antes de sair comprando para realizar testes.
Eu preciso ligar 6 motores como esse em uma placa arduíno UNO. Você poderia me ajudar com algumas dúvidas. Vamos lá:
Os motores funcionam assim. 2 pares em paralelo, ou seja, o que um faz o outro faz necessáriamente igual. Eles poderia (devem na verdade) estar ligado na mesma posição na placa. (É assim que fala? kkkk). Os outros 2 executam movimentos em rotações e sentidos diferentes portanto precisam estar ligados de forma separadas.
Então só para ver se estou pensando corretamente. Eu preciso de 4 saídas para o par um. mais 4 saídas para o par dois. mais 4 saídas para o motor 1 e mais 4 saídas para o motor 2, ou seja, preciso de 16 saídas no arruino. O Arduino UNO consegue dar conta disso?
Outro ponto que sou completamente leigo, comecei a estudar e pesquisar sobre isso agora. teremos 6 motores de 5v cada. Se eu usar esse esquema que você mostrou da fonte? Uma fonte de 9v com um regulador de tensão no pinboard ele daria conta de suportar tudo isso?
Os controladores, eu acredito que nem preciso de 6, mas o preço é tão ridículo (moro em Portugal) que nem vale a pena para uma pessoa inexperiente como eu ficar quebrando a cabeça com diodos, outros controladores etc.
Bom essas são as minhas dúvidas, se ficou difícil de entender por conta da minha completa ignorância no assunto, por favor, me escreva o que não entendeu que eu tento explicar melhor.
Mais uma vez, parabéns. Já salvei o site aqui para referencias nesse e em outros projetos.
Fala @Destinobr800! Tudo Bom?!
Primeiramente seja muito bem-vindo ao nosso Blog! Gratidão pelas palavras de Apoio! 🙂
Bom, vou tentar responder suas dúvidas de forma bastante pontual para que se torne o mais fácil possível você entender, vamos lá:
1) Eu preciso ligar 6 motores como esse em uma placa arduíno UNO. Você poderia me ajudar com algumas dúvidas. Vamos lá:
Os motores funcionam assim. 2 pares em paralelo, ou seja, o que um faz o outro faz necessáriamente igual. Eles poderia (devem na verdade) estar ligado na mesma posição na placa. (É assim que fala? kkkk).
Resposta: Sim, vou tentar lhe Ajudar. Não sei se é assim que se fala (risos), MAS, fique tranquilo que eu creio ter lhe entendido.
2) Os outros 2 executam movimentos em rotações e sentidos diferentes portanto precisam estar ligados de forma separadas.
Resposta: Entendido! Sem problemas, é bem por aí mesmo. Uma vez que você deseja que estes 2 “últimos” movimentem-se de “forma independente” com relação aos 2 primeiros pares.
3) Então só para ver se estou pensando corretamente. Eu preciso de 4 saídas para o par um. mais 4 saídas para o par dois. mais 4 saídas para o motor 1 e mais 4 saídas para o motor 2, ou seja, preciso de 16 saídas no arruino. O Arduino UNO consegue dar conta disso?
Resposta: Sim, você está pensando corretamente. Já que você deseja que cada PAR trabalhe de forma idêntica, então é isso mesmo, você vai precisar utilizar 4 pinos digitais do Arduino UNO para controlar 2 motores “conjuntamente”, depois destes, mais 4 pinos digitais para os outros 2 motores funcionarem “conjuntamente” e depois realizar a conexão de 1 motor que deseja que funcione de forma “independente”, utilizar outros 4 pinos digitais do Arduino e o último motor independente vai necessitar utilizar outros 4 pinos, sendo que 2 pinos serão digitais e outros 2 pinos serão “analógicos”. Por que Analógicos?! Porque na placa Arduino UNO temos literalmente/tecnicamente de acordo ao datasheet do mesmo, 14 pinos digitais “apenas” e outros 6 pinos analógicos, o que totaliza 20 pinos para trabalharmos. Bom, temos também que lembrar que os pinos analógicos, são “analógicos de fato” se considerarmos os mesmos configurados como “ENTRADA” (INPUT), MAS, se estes TAMBÉM podem ser configurados como “SAÍDA” (OUTPUT), que é exatamente o que você precisa neste projeto, e sendo assim assim, também de acordo ao datasheet do Arduino UNO, estes mesmos pinos “analógicos” podem ser configurados como “SAÍDAS DIGITAIS”, e é por isso que eu disse acima que você vai necessitar utilizar 2 deles configurados desta forma (Saída – OUTPUT) para poderes conectar o sexto motor, uma vez que o seu motor necessita de uma “saída” e não “entrada”. Ahh! E no final das contas ainda lhe restarão outros 4 pinos “analógicos”, que poderão ser utilizados como ENTRADA ANAlÓGICA mesmo ou então novamente configurados como SAÍDA DIGITAL (você decide e configura de acordo às suas necessidades). SIM, o Arduino UNO teoricamente conseguirá dar conta do recado.
4) Outro ponto que sou completamente leigo, comecei a estudar e pesquisar sobre isso agora. Teremos 6 motores de 5v cada. Se eu usar esse esquema que você mostrou da fonte? Uma fonte de 9v com um regulador de tensão no pinboard ele daria conta de suportar tudo isso?
Resposta: Utilizar a fonte de 9VDC com um Regulador de Tensão, TEORICAMENTE poderia fazer o circuito funcionar, MAS PARTICULARMENTE EU NÃO RECOMENDO! Por que? Pois o Regulador de Tensão mais “fácil” de ser encontrado seria o próprio 7805 por exemplo, e ele suporta, dependendo do modelo, até 1,5A na saída. Considero esta corrente baixa considerando a alimentação dos 6 DRIVERs (ULN2003A) + 6 MOTORES 28BYJ-48/5V + alimentação da própria placa Arduino UNO eventualmente! Temos que levar em consideração que “se faltar corrente elétrica” poderemos ter problemas “imprevisíveis”! Então recomendo que utilize mesmo 1 fonte de 5VDC capaz de prover a máxima corrente possível (digamos, por exemplo, uns 3A ou MAIS se possível). Pode ser que não seja necessário tanta corrente, MAS, é sempre melhor prevenir que remediar, até porque o “remédio” depois de termos um problema pode sair mais caro e trabalhoso que conseguir uma fonte com boa capacidade de corrente elétrica.
5) Os controladores, eu acredito que nem preciso de 6, mas o preço é tão ridículo (moro em Portugal) que nem vale a pena para uma pessoa inexperiente como eu ficar quebrando a cabeça com diodos, outros controladores etc.
Resposta: Você está “parcialmente” certo neste ponto, MAS, RECOMENDO FORTEMENTE que utilize sim 6 módulos Driver (ULN2003A), exatamente 1 para cada motor, inclusive para os motores que trabalharão “em paralelo”. Conversando com um Amigo meu, chegamos a conclusão de que caso não utilize nos “pares”, o circuito poderia sim continuar funcionando, MAS estaríamos “abrindo brecha” para problemas, uma vez que teríamos que obrigatoriamente “forçar” o módulo Driver a trabalhar num regime de maior “estresse” tendo que alimentar 2 motores ao mesmo tempo. Resumindo: como você mesmo disse que o preço destes componentes aí em Portugal é “irrelevante/barato”, então faça como você pensou, UTILIZE 1 módulo para cada motor, totalizando 6 módulos Driver (ULN2003A) e dessa forma ficando com a “consciência mais tranquila”! 🙂
PS: Não se preocupe, pois lhe entendi sim. Ahh! E não se considere um “ignorante” no assunto, pois com certeza depois de ler suas dúvidas, está provado que não és nenhum ignorante, pelo contrário, estás indo muito bem no seu aprendizado. Parabéns! 😉
É isso aí! Espero que lhe sirva de algum Auxílio!
Desejo Sucesso no Projeto!
Ahh! Se desejar se Inscreve em nosso Canal no Youtube: https://youtube.com/EletronicaParaTodos
Forte Abraço,
Rodrigo Costa.
https://facebook.com/EletronicaParaTodosBR
https://instagram.com/EletronicaParaTodosBrasil
Rodrigo, parabéns pelo artigo !!!
Foi muito esclarecedor para mim que estou fazendo meu TCC (Eng. da Computação) e praticamente quebrando a minha cabeça por causa de motor. A ideia é fazer um afinador automático para violão no qual um motor atue no braço do instrumento fazendo a afinação de acordo com a entrada de áudio, já tenho a parte do afinador pronta porém essa questão de motor é algo que não tenho muito domínio e estava sofrendo usando um servo motor.
Comecei a pesquisar ideia de outros motores para ter uma precisão maior, em especial o motor de passos, e achei abordagem que você propôs bastante direta e, sobretudo, didática.
Novamente parabéns.
Grande abraço.
Vinícius.
Fala Vinícius! Tudo Bom?!
Primeiramente agradeço sua presença e claro, seu tempo!
Rapaz, fico sem muitas palavras para agradecer após ler seu “depoimento”, seu comentário que apenas nos trás Força, Ânimo e tudo mais de Bom! 🙂
Deixo pra ti minha eterna gratidão por ter tomado seu tempo pra “deixar uma mensagem” positiva e dizendo que você conseguiu resolver seu problema com um pequeno auxílio nosso! Até porque com nosso artigo ou não, você venceria, MAS é “sem preço” saber que Ajudamos de alguma forma! 😉
Muito Obrigado!
Sucesso Sempre!
Forte Abraço,
Rodrigo Costa do Canal,
https://youtube.com/EletronicaParaTodos
Olá, gostei muito desse artigo.. Sou iniciante em Arduino e tenho um motor de passo genérico (tem apenas dois terminais, ele gira ao conectar no 5v e GND diretamente da placa), mas gostaria de saber se tem como controlá-lo (velocidade e ângulo) apenas com o módulo driver e a placa Arduino Uno, uma vez que o motor do artigo tem 4 fases.
Fala Rafael! Tudo Bom!?
Primeiramente seja muito bem-vindo! 🙂
Rapaz, pela sua descrição o seu motor aí não é “de passo” não. É um motor comum do tipo DC (Corrente Contínua), ou seja, funciona assim mesmo do jeito que você falou, é só ligar nos 5V e ele começa a girar!
De qualquer forma, é possível sim você controlar a velocidade dele, MAS como não é um motor-de-passo, controlar o “ângulo” não vai dar.
Não sei como é seu módulo driver, mas se ele funciona com pulsos do tipo PWM, creio ser possível você controlar a velocidade do motor com ele sim.
PS: Dá uma olhada neste artigo por favor, veja se auxilia em algo: https://eletronicaparatodos.com/controle-de-velocidade-de-motores-dc-atraves-de-um-circuito-eletronico-do-tipo-modulo-pwm-pulse-width-modulation-ou-modulacao-de-largura-de-pulso/
PS2: Como você mesmo disse, o motor que utilizei no artigo tem 4 fases (4 bobinas internas) e por isso podemos “controlar o passo dele”.
Espero que seja de algum auxílio!
Sucesso!
Um Abraço,
Rodrigo Costa do Canal Youtube,
https://EletronicaParaTodos.com
Gostaria de saber um pouco mais afundo como fazer o eixo girar os 0,088º por passo?
até agora todos os códigos que experimentei, o eixo gira bem mais do que isso!
Como faço para controlar a resolução deste motor através do arduino?
Fala Heiton! Tudo Bom?!
Rapaz, primeiramente agradeço sua visita e espero muito que já esteja Inscrito em nosso Blog e Canal Youtube! 🙂
Olha só, realmente não é “tão comum encontramos” esses graus de resolução que você precisa “por passo” do nosso motor… 🙁
Mas olhando meus “favoritos” aqui do navegador, também percebi que “um dia” cheguei a dar uma olhada no assunto (risos), veja você mesmo estes 2 links (em inglês, mas caso não entenda o idioma o Google Translator é nosso amigo)! 🙂
1) https://arduino.stackexchange.com/questions/31273/how-can-i-use-stepper-for-specific-degree
2) https://reprap.org/forum/read.php?160,63790
Acredito que o conteúdo dos links acima poderão lhe ajudar (espero mesmo)! 🙂
Votos de Sucesso! Ahh! Quando conseguir realizar o que deseja aí no seu motor, ou melhor, na resolução dele, pode ficar a vontade em voltar e comentar o que conseguiu! Muito bem-vindo por sinal! 🙂
Votos de Sucesso!
Um Abraço,
Rodrigo Costa do Canal Youtube,
https://www.youtube.com/EletronicaParaTodos
Primeiramente parabéns por contribuir com a comunidade!
Estou com uma dificuldade e talvez possa me ajudar, não consigo rodar estes script no arduino mega, no uno roda blz mas quando tento um full step no mega não roda o que poderia ser?
Fala Alex! Tudo Bom?!
Gratidão imensa pela sua visita e pelas palavras de Apoio! 🙂
Rapaz, olha só, qual mensagem de ERRO está apresentando na hora que vai carregar o código pro seu Arduino Mega? Ou ele compila mas não roda?! o.O
Eu sinceramente não sei te dizer assim “de cabeça” o que pode estar acontecendo por aí, MAS pelo menos uma coisa sabemos: o código está funcional ao menos no Arduino UNO. 🙂
Beleza, tenta fazer uma descrição detalhada do problema que você está passando, leia o LOG da IDE do Arduino, verifique JUMPERS em mal-contato, etc.
PS: Qual código estás utilizando para gerar o “Full Step”?
Este abaixo?
byte AHO[4] = {0x0C,0x06,0x03,0x09}; // Matriz dos bytes das Fases do Motor - sentido Anti-Horário Full StepCaso não esteja utilizando este código acima, então tente, veja o que acontece por favor.
No mais eu não tenho muito mais informações pra poder lhe passar Alex, mas espero que em algo esse meu comentário lhe seja útil. 🙂
Desejo Sucesso!
Um Abraço,
Rodrigo Costa do Canal YouTube,
https://www.youtube.com/EletronicaParaTodos
Boa tarde. Voce poderia me enviar um código para que meu motor de passo 28byj no arduino uno, funcione com um
1 rpm.
Agradeço muito
Elvis
Fala Elvis! Tudo Bom?!
Primeiramente agradeço sua visita e comentário! 🙂
Olha só, baseado no código do post, veja se você consegue obter o resultado desejado (1 RPM) utilizando esse código abaixo:
#includeconst int stepsPerRevolution = 4076;
Stepper myStepper(stepsPerRevolution, 8, 10, 9, 11);
//------------------------------------
void setup()
{
myStepper.setSpeed(1);
}
//------------------------------------
void loop()
{
myStepper.step(4076);
}
PS: Caso o resultado não seja ainda o ideal, por exemplo, ele pareça estar girando a 2RPM, então substitui o número (4076) por (2038).
Espero que seja de alguma ajuda!
Um Abraço,
Rodrigo Costa do Blog,
https://EletronicaParaTodos.com
Valeu Rodrigo, muito obrigado.
Boa Tarde Rodrigo, gostaria de aumentar o torque de Wave Step para Full Step, quais as mudanças em :
/ Matriz dos bytes das Fases do Motor – sentido Anti-Horário WaveStep
byte AHO[4] = {0x08,0x04,0x02,0x01}; Será apenas nessa linha de código ?
Obrigado.
Fala Alexandre! Tudo Beleza?!
Para utilizar o motor em modo “Full Step ou Passo Completo” basta alterar exatamente a linha de código que você mencionou, que ficará mais ou menos assim, veja:
byte AHO[4] = {0x0C,0x06,0x03,0x09}; // Matriz dos bytes das Fases do Motor - sentido Anti-Horário Full StepEspero que sirva de ajuda!
Obrigado pela Presença!
Um Abraço,
Rodrigo Costa do Blog,
https://EletronicaParaTodos.com
olá, tudo bem? fiquei bastante empolgado com o seu projeto, onde até agora não havia visto em nenhum outro site sobre arduino…
a mnha dúvida é sobre o sensor IR, eu gostaria de implementar no meu projeto de portão automático onde esse mesmo sensor será responsável em parar o motor de passo quando o veículo estiver passando pelo portão…
como eu adaptaria esse sensor no meu programa? vc teria como me ajudar nisso? estou usando a biblioteca AccelStepper…
ficaria muito grato pela atenção… segue o programa abaixo…
#include
#include
#include
#define HALFSTEP 8
#define sensor 7 //Define sensor infra-vermelho como 7
// Definições do pino do motor
#define motorPin1 2 // IN1 on the ULN2003 driver 1
#define motorPin2 3 // IN2 on the ULN2003 driver 1
#define motorPin3 4 // IN3 on the ULN2003 driver 1
#define motorPin4 5 // IN4 on the ULN2003 driver 1
//Inicialize com a sequência de pinos IN1-IN3-IN2-IN4 para usar o AccelStepper com 28BYJ-48
AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);
#define SS_PIN 10
#define RST_PIN 9
// Definicoes pino modulo RC522
MFRC522 mfrc522(SS_PIN, RST_PIN);
// Leds indicadores acesso liberado ou negado
int led_liberado = 6;
int led_negado = 1;
int pino_sensor = 7;
int estado_sensor = 0;
void setup() {
pinMode(led_liberado, OUTPUT);
pinMode(led_negado, OUTPUT);
stepper1.setMaxSpeed(1000.0);
stepper1.setAcceleration(100.0);
stepper1.setSpeed(100);
stepper1.moveTo(2048); // definição do número de passos _ 1 volta= 2048 passos
// Inicia a serial
Serial.begin(9600);
pinMode(sensor, INPUT); //Configura o pino 7 como entrada
// Inicia SPI bus
SPI.begin();
// Inicia MFRC522
mfrc522.PCD_Init();
// Mensagens iniciais no serial monitor
Serial.println(“Aproxime o seu cartao do leitor…”);
Serial.println();
}//–(end setup )—
void loop() {
// Aguarda a aproximacao do cartao
if ( ! mfrc522.PICC_IsNewCardPresent())
{
return;
}
// Seleciona um dos cartoes
if ( ! mfrc522.PICC_ReadCardSerial())
{
return;
}
// Mostra UID na serial
Serial.print(“UID da tag :”);
String conteudo= “”;
byte letra;
for (byte i = 0; i < mfrc522.uid.size; i++)
{
Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
Serial.print(mfrc522.uid.uidByte[i], HEX);
conteudo.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
conteudo.concat(String(mfrc522.uid.uidByte[i], HEX));
}
Serial.println();
Serial.print("Mensagem : ");
conteudo.toUpperCase();
// Testa se o cartao1 foi lido
if (conteudo.substring(1) == "9B 66 84 59"){
//Muda a direção quando o stepper atinge a posição de destino
stepper1.runToNewPosition(2048); // rotação sentido anti-horário
Serial.println("Cartao1 – Acesso liberado !");
Serial.println();
delay(1000);
{
stepper1.runToNewPosition(-2048); // rotação sentido horário
delay(2000);
}
}
else {
Serial.println(" Accesso negado…!");
delay(1000);
}
stepper1.run();
}
Fala Helio! Tudo Bom?!
Primeiramente agradeço sua presença e fico muito feliz de que o artigo/post tenha lhe ajudado de alguma forma! 🙂
Bom, analisando seu código, e sem “mexer” demais nele, apenas fiz acrescentar algumas linhas de código (que você vai perceber com mais clareza ao copiar e colar o código daqui da página para um editor, como o da IDE do Arduino), pois o editor possui a numeração das linhas.
Então, claro que não podemos afirmar que vai funcionar “de cara”, mas em se tratando do sensor IR modelo E18-D80NK, creio eu que se não funcionar, ainda assim algum caminho já foi andado. Por exemplo “trocando a lógica do sensor na programação, substituindo por exemplo 0 por 1 ou vice-versa.
Segue abaixo o código modificado:
//———————————————————————————
#include
#include
#include
#define HALFSTEP 8
#define sensor 7 //Define sensor infra-vermelho como 7
// Definições do pino do motor
#define motorPin1 2 // IN1 on the ULN2003 driver 1
#define motorPin2 3 // IN2 on the ULN2003 driver 1
#define motorPin3 4 // IN3 on the ULN2003 driver 1
#define motorPin4 5 // IN4 on the ULN2003 driver 1
//Inicialize com a sequência de pinos IN1-IN3-IN2-IN4 para usar o AccelStepper com 28BYJ-48
AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);
#define SS_PIN 10
#define RST_PIN 9
// Definicoes pino modulo RC522
MFRC522 mfrc522(SS_PIN, RST_PIN);
// Leds indicadores acesso liberado ou negado
int led_liberado = 6;
int led_negado = 1;
int pino_sensor = 7;
int estado_sensor = 1;
void setup() {
pinMode(led_liberado, OUTPUT);
pinMode(led_negado, OUTPUT);
stepper1.setMaxSpeed(1000.0);
stepper1.setAcceleration(100.0);
stepper1.setSpeed(100);
stepper1.moveTo(2048); // definição do número de passos _ 1 volta= 2048 passos
// Inicia a serial
Serial.begin(9600);
pinMode(sensor, INPUT); //Configura o pino 7 como entrada
// Inicia SPI bus
SPI.begin();
// Inicia MFRC522
mfrc522.PCD_Init();
// Mensagens iniciais no serial monitor
Serial.println(“Aproxime o seu cartao do leitor…”);
Serial.println();
}//–(end setup )—
void loop() {
// Aguarda a aproximacao do cartao
if ( ! mfrc522.PICC_IsNewCardPresent())
{
return;
}
// Seleciona um dos cartoes
if ( ! mfrc522.PICC_ReadCardSerial())
{
return;
}
// Mostra UID na serial
Serial.print(“UID da tag :”);
String conteudo= “”;
byte letra;
for (byte i = 0; i < mfrc522.uid.size; i++) { Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "); Serial.print(mfrc522.uid.uidByte[i], HEX); conteudo.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ")); conteudo.concat(String(mfrc522.uid.uidByte[i], HEX)); } Serial.println(); Serial.print("Mensagem : "); conteudo.toUpperCase(); // Testa se o cartao1 foi lido if (conteudo.substring(1) == "9B 66 84 59") { //Muda a direção quando o stepper atinge a posição de destino stepper1.runToNewPosition(2048); // rotação sentido anti-horário Serial.println("Cartao1 – Acesso liberado !"); Serial.println(); delay(1000); { stepper1.runToNewPosition(-2048); // rotação sentido horário delay(2000); // Edição por Rodrigo Costa - EletronicaParaTodos.com //--------------------------------------------------- estado_sensor = digitalRead(pino_sensor); if(estado_sensor == 0) { //stepper1.runToNewPosition(-2048); // rotação sentido horário ...> PODE SER QUE NÃO SEJA MESMO NECESSÁRIO SEU USO. DESCOMENTAR CASO O MOTOR NÃO PARE AO “ESTAR VENDO” ALGO (O CARRO) NA FRENTE DELE.
Serial.println(estado_sensor);
delay(30);
}
}
}
else {
Serial.println(” Accesso negado…!”);
delay(1000);
}
stepper1.run();
}
//———————————————————————————
É isso aí, agora mãos a obra! 🙂
Espero que seja de alguma ajuda.
Um Abraço,
Rodrigo Costa.
https://EletronicaParaTodos.com
Olá Rodrigo, obrigado pelo pronto atendimento…
fiz a alteração como segue o programa…
estado_sensor = digitalRead(pino_sensor);
if(estado_sensor == 1)
stepper1.runToNewPosition(-2048);
Serial.println(estado_sensor);
delay(30;
neste caso com o sensor em 1__ realmente ele bloqueia o motor, mas em seguida não volta ao normal…
quando altero o sensor para 0__ o programa não reconhece o sensor e não bloqueia o motor.
agora se eu fizer desta maneira…
stepper1.runToNewPosition(-2048); // rotação sentido horário
delay(1000);
}
estado_sensor = digitalRead(pino_sensor);
if(estado_sensor == 0)
Serial.println(estado_sensor);
delay(30);
}
em nenhuma das situações o sensor bloqueia o motor.
Fala Helio! Tudo Bom?!
Rapaz, eu acredito que o que está acontecendo é que eu talvez não esteja entendendo bem onde “implantar” o trecho de código corretamente “no seu código” para que a a gente consiga realizar a tarefa.
Bom, tentei dar uma “analisada” no seu código (ainda que existam partes “obscuras” no meu entendimento ainda, risos), e modifiquei algumas coisas, mas apenas na “estrutura” (por exemplo, onde vai cada função, chamada, etc). Peço a gentileza que copie e cole na sua IDE, antes de tentar “rodar”, analisa o código também com muita calma e veja se “alguma luz aparece”. 🙂
Segue abaixo:
#include
#include
#include
#define HALFSTEP 8
//////////////////////////#define sensor 7 //Define sensor infra-vermelho como 7
// Definições do pino do motor
#define motorPin1 2 // IN1 on the ULN2003 driver 1
#define motorPin2 3 // IN2 on the ULN2003 driver 1
#define motorPin3 4 // IN3 on the ULN2003 driver 1
#define motorPin4 5 // IN4 on the ULN2003 driver 1
//Inicialize com a sequência de pinos IN1-IN3-IN2-IN4 para usar o AccelStepper com 28BYJ-48
AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);
#define SS_PIN 10
#define RST_PIN 9
// Definicoes pino modulo RC522
MFRC522 mfrc522(SS_PIN, RST_PIN);
// Leds indicadores acesso liberado ou negado
int led_liberado = 6;
int led_negado = 1;
int pino_sensor = 7; // Pino do Sensor setado como PD12 do Arduino
int leitura_sensor; // Armazenamos o valor lido pelo sensor IR
//////////////////////int estado_sensor = 1;
void setup() {
pinMode(led_liberado, OUTPUT);
pinMode(led_negado, OUTPUT);
pinMode(pino_sensor, INPUT); //Configura o pino 7 como entrada
stepper1.setMaxSpeed(1000.0);
stepper1.setAcceleration(100.0);
stepper1.setSpeed(100);
stepper1.moveTo(2048); // definição do número de passos _ 1 volta= 2048 passos
// Inicia a serial
Serial.begin(9600);
// Inicia SPI bus
SPI.begin();
// Inicia MFRC522
mfrc522.PCD_Init();
// Mensagens iniciais no serial monitor
Serial.println(“Aproxime o seu cartao do leitor…”);
Serial.println();
}//–(end setup )—
void loop() {
leitura_sensor = digitalRead(pino_sensor);
// Aguarda a aproximacao do cartao
if ( ! mfrc522.PICC_IsNewCardPresent())
{
return;
}
// Seleciona um dos cartoes
if ( ! mfrc522.PICC_ReadCardSerial())
{
return;
}
// Mostra UID na serial
Serial.print(“UID da tag :”);
String conteudo= “”;
byte letra;
for (byte i = 0; i < mfrc522.uid.size; i++) { Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "); Serial.print(mfrc522.uid.uidByte[i], HEX); conteudo.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ")); conteudo.concat(String(mfrc522.uid.uidByte[i], HEX)); } Serial.println(); Serial.print("Mensagem : "); conteudo.toUpperCase(); // Testa se o cartao1 foi lido if (conteudo.substring(1) == "9B 66 84 59"){ //Muda a direção quando o stepper atinge a posição de destino stepper1.runToNewPosition(2048); // rotação sentido anti-horário Serial.println("Cartao1 – Acesso liberado !"); Serial.println(); delay(1000); } //--------------------------------------------------- // Edição por Rodrigo Costa - EletronicaParaTodos.com //--------------------------------------------------- //leitura_sensor = digitalRead(pino_sensor); if(leitura_sensor == 0) { stepper1.runToNewPosition(-2048); // rotação sentido horário Serial.println(estado_sensor); delay(30); } else { Serial.println(" Accesso negado…!"); stepper1.runToNewPosition(-2048); // rotação sentido horário delay(2000); } stepper1.run(); // EU NAO ENTENDI O QUE FAZ ESSA CHAMADA. R.Costa. } Vamos ver o que acontece. 😉 VOTOS de SUCESSO! Bom Domingo ou final dele né... Um Abraço, Rodrigo Costa. https://EletronicaParaTodos.com
Bom dia Rodrigo… mudei a programação e desta forma o sensor atua corretamente ao parar o motor, o problema agora é encaixar o RFId para iniciar o processo… deixei o sensor como pino 7 mesmo…
segue a programação sem o RFId… grato pela atenção…
#include
#define HALFSTEP 8
// Definição do Pino do Motor
#define motorPin1 2 // IN1 on the ULN2003 driver 1
#define motorPin2 3 // IN2 on the ULN2003 driver 1
#define motorPin3 4 // IN3 on the ULN2003 driver 1
#define motorPin4 5 // IN4 on the ULN2003 driver 1
// Inicialize com a sequência de pinos IN1-IN3-IN2-IN4 para usar o AccelStepper com 28BYJ-48
AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);
int pino_sensor = 7;
int estado_sensor = 1;
void setup() {
Serial.begin(9600);
// Define o pino do sensor como entrada
pinMode(pino_sensor, INPUT);
Serial.println(“Teste sensor infravermelho Arduino”);
stepper1.setMaxSpeed(1000.0);
stepper1.setAcceleration(100.0);
stepper1.setSpeed(200);
stepper1.moveTo(2048);
}//–(end setup )—
void loop() {
estado_sensor = digitalRead(pino_sensor);
if (estado_sensor == 1)
{
// Desligar o Motor
digitalWrite(HALFSTEP, LOW);
// Envia mensagem para o Serial Monitor
Serial.println(“Movimento detectado!”);
delay(1000);}
else
{
// Ligar Motor
digitalWrite(HALFSTEP, HIGH);
}
// Mude a direção quando o stepper atinge a posição de destino
if (stepper1.distanceToGo() == 0)
{
stepper1.moveTo(-stepper1.currentPosition());
delay(1000);
}
stepper1.run();
}
boa tarde Rodrigo, tudo bom?
eu fiz a programação agora inserindo um relé para desligar e ligar o motor… realmente funciona qd o sensor detecta objeto>> o relé desarma, o problema é que qd não tem mais objeto na frente do sensor, o relé não rearma… o que poderia ser, você poderia me ajudar?
segue o programa em si…
// Testa se o cartao1 foi lido
if (conteudo.substring(1) == “9B 66 84 59”){
//Muda a direção quando o stepper atinge a posição de destino
stepper1.runToNewPosition(-2048); // rotação sentido anti-horário
Serial.println(“Cartao1 – Acesso liberado !”);
Serial.println();
delay(100);
{
estado_sensor = digitalRead(pino_sensor);
if (estado_sensor == 0)
{//Desligar Motor
digitalWrite(pin1, LOW);
// Envia mensagem para o Serial Monitor
Serial.println(“Movimento detectado!”);
delay(1000);}
else {
// Ligar Motor
digitalWrite(pin1, HIGH);
}
stepper1.runToNewPosition(2048); // rotação sentido horário
delay(2000);
}
Fala Helio! Beleza?!
Rapaz, é complicado “decifrar” o problema com pouca info, mas vamos lá, vou lhe dar 2 “palpites”:
1) Se você está utilizando o sensor IR, modelo (E18-D80NK), então, tenha certeza de que o “pequeno parafuso” na parte traseira do sensor está devidamente “configurado”/”calibrado” para “identificar” a(s) distância(s) que você está desejando! PS: Já tivemos por aqui “muita dor de cabeça por conta desta pequena regulagem, ao ponto de que um determinado momento o sensor “detectava” e outros momentos “não detectava nada”;
2) Modifique seu código para o que segue abaixo (totalmente baseado no seu próprio):
// Testa se o cartao1 foi lido
if (conteudo.substring(1) == “9B 66 84 59”){
//Muda a direção quando o stepper atinge a posição de destino
stepper1.runToNewPosition(-2048); // rotação sentido anti-horário
Serial.println(“Cartao1 – Acesso liberado !”);
Serial.println();
delay(100);
{
estado_sensor = digitalRead(pino_sensor);
if (estado_sensor == 0)
{//Desligar Motor
digitalWrite(pin1, LOW);
// Envia mensagem para o Serial Monitor
Serial.println(“Movimento detectado!”);
delay(1000);}
else {
// Ligar Motor
digitalWrite(pin1, HIGH);
estado_sensor = 1
}
stepper1.runToNewPosition(2048); // rotação sentido horário
delay(2000);
}
Vamos ver o que vai dar?! 😉
Sucesso!
Um Abraço,
Rodrigo Costa.
https://youtube.com/EletronicaParaTodos
Olá. Gostei do artigo. Tudo bem explicado. Você poderia explicar como alimentar o driver (e o motor) externamente?
Fala Edu! Tudo Bom!?
Primeiramente muito obrigado pelo apoio!
Rapaz, para alimentar o módulo (drive – ULN2003) externamente (lembrando que o motor vai ligado ao módulo, ou seja, alimentando o módulo automaticamente temos o motor alimentado também), basta seguir o esquemático desta imagem
ou caso esteja sem o módulo, seguir este esquema aqui 
.
Qualquer coisa é só falar.
Feliz 2018!
Um Abraço,
Rodrigo Costa.
http://EletronicaParaTodos.com
Existe alguma forma de controlar isso sem o Arduino?
Fala Assis, Tudo Bom?!
Rapaz, indo diretamente ao ponto, a resposta para sua pergunta é SIM, absolutamente! 🙂
Imagina que a gente fosse obrigado a utilizar um microcontrolador toda vez que quiséssemos realizar o controle de um motor-de-passo?! o.O
Bom, então, aqui no nosso Blog não temos nenhum post específico que possa neste momento te ajudar a “visualizar” a construção deste circuito, MAS, tenho como referência um estimado professor brasileiro, chamado Prof. Newton C. Braga, e rapaz, existe um artigo escrito pelo professor, que simplesmente creio irá atender exatamente à sua necessidade ou no mínimo sanar um tanto das suas dúvidas! 🙂
Link direto: Controle Universal para Motores de Passo
É isso aí, espero que ajude!
Um Abraço,
Rodrigo Costa.
https://EletronicaParaTodos.com
Boa tarde! eu estou usando o código postado aqui e esta dando erros..você pode me ajudar?
Fala Jairo! Tudo Bom?!
Sim, claro!
Vamos tentar!
Qual especificamente o problema que você está encontrando? Em qual código especificamente? Na hora de compilar?
Enfim, explica mais um pouco, com detalhes que vai facilitar encontrarmos o possível erro.
Um Abraço,
Rodrigo Costa.
https://EletronicaParaTodos.com
Boa noite amigo! eu envie o código para o Arduíno e TX e TR acendeu conforme recebendo e enviando os dados.. Mas o motor não rotacionou.. nem se quer móvel..
Fala Jairo! Tudo Bom?!
Rapaz, vamos lá: se Tx e Rx acenderam, significa que ao menos “parece” que a placa está Transmitindo e Recebendo dados, e isso é um “bom sinal”…
Você precisa verificar se está utilizando exatamente os mesmos componentes que nós utilizamos aí no esquema eletrônico e de fato o mesmo código fonte!
De qualquer forma, um fator MUITO IMPORTANTE em todo esse contexto, é com que fonte de alimentação está sendo alimentado o motor, pois uma fonte que “falte corrente/tensão”, não vai deixar o motor funcionar, ou no “melhor” dos casos, o motor vai ficar como que “vibrando”…
Então a observação Importante: não alimente seu motor pela placa do ARDUINO. Utilize uma fonte de alimentação externa para garantir o funcionamento e evitar problemas.
Espero que seja de alguma ajuda!
Um Abraço,
Rodrigo Costa.
http://EletronicaParaTodos.org
Mestre Rodrigo Costa!
Eu usei uma fonte de pc e fiz o jumper nos pinos Driver ULN2003A e o motor de passos funcionou perfeitamente..
Estou usando o primeiro código postado no artigo..
Obrigado..
Eu li novamente o artigo e creio que dois erros eu cometi, um é a falta de jamp nos pinos livre de alimentação do drive, e alimentação estou usando do arduino..vou usar alimentação externa agora.
Fala Jairo!
Muito obrigado pelo feedback e principalmente por ter percebido a pequena falta de atenção!
Mas é assim mesmo, pequenos detalhes fazem a diferença! 🙂
OBS: Mas continuarei repetindo sobre uma coisa – não alimente praticamente nada utilizando a mesma alimentação da placa do seu Arduino! 😉
Sucesso!
Um Abraço,
Rodrigo Costa.
http://EletronicaParaTodos.org