Preciso montar um programa mas acho que não seria possível usar o delay(), gostaria de testar o millis(), mas me embolo toda na hora de montar o sketch com ele. Alguém poderia me auxiliar na montagem do sketch abaixo trocando o delay pelo millis()?ESte sketch e so um exemplo simplificado!!


int dir = 6;
int stepp = 7;
int tempo = 800;
int passos = 1200;

void setup() {
pinMode(dir, OUTPUT);
pinMode(stepp, OUTPUT);
}

void loop() {


for (int i = 0; i< passos; i++)
{
motormovimenta();
}


}

void motormovimenta()
{
digitalWrite(dir, HIGH);
digitalWrite(stepp, HIGH);
delayMicroseconds(tempo); //preciso trocar por millis//
digitalWrite(stepp, LOW);
delayMicroseconds(tempo);//preciso trocar por millis//
}

Exibições: 2541

Responder esta

Respostas a este tópico

Joao, o código abaixo pode ser melhorado, mas isso acho que já atende ao que você quer.

int dir = 6;
int stepp = 7;
int tempo = 800;

int passos = 1200;

long previousMillis = 0;

void setup() { 
pinMode(dir, OUTPUT); 
pinMode(stepp, OUTPUT);
}

void loop() {


for (int i = 0; i< passos; i++)
{
motormovimenta();
}


}

void motormovimenta()
{

previousMillis = millis();

if (millis()- previousMillis > tempo) {
digitalWrite(dir, HIGH);
digitalWrite(stepp, HIGH);

}

previousMillis = millis();

if (millis()- previousMillis > tempo) {

digitalWrite(stepp, LOW); 
}
}

Obrigado fabio, vou fazer uns testes amanha,, e te informo qual resultado...

Joao, acabei verificando o codigo e acho que desta maneira não irá rodar.

O tempo nunca será menor que o previous millis, mas o caminho é este, você pode adaptar utilizando a condição while().

essa função funciona para milissegundos, em microsssegundos vc vai ter que usar a função micros().

acho que a ideia de usar millis() é para não "pausar" o arduino, pq o delay() vai fazer aguardar, e se ele quiser executar qualquer outra coisa não dá...

Mano, não entendi pq tem um for dentro do loop(), uma vez que sempre vai ficar em loop mesmo, fiz esse codigo, testa ae:

int dir = 6;
int stepp = 7;

uint32_t timeHigh = 0;
uint32_t timeLow = 0;

void setup() {
    pinMode(dir, OUTPUT);
    pinMode(stepp, OUTPUT);
}

void loop() {

    if (millis() >= timeHigh) {

        digitalWrite(dir, HIGH);
        digitalWrite(stepp, HIGH);

        timeHigh = millis() + 1600;
        timeLow = millis() + 800;

    }

    if (millis() >= timeLow && timeLow != 0) {
        digitalWrite(stepp, LOW);
    }

}

NO fundo estou querendo colocar um endstop nesse motor de passo, ao encostar no endstop o motor deve parar> Usando a funcao com delay, o motor ate para mas nao sei por qual motivo ele da uns passos a mais ao encostar no endstop empurrando o endstop um pouco(nao para de imediato)...as vezes ele ate para no endstop sem empurra-lo, mas as vezes nao...estou pensando que pode ser por causa do delay, por isso estou querendo substituir o delay pelo millis.

o for e para determinar quantos passos serao realizados.

so com esta funcao o motor daria so um passo.

void motormovimenta()
{
digitalWrite(dir, HIGH);
digitalWrite(stepp, HIGH);
delayMicroseconds(tempo);

digitalWrite(stepp, LOW); 

delayMicroseconds(tempo);
}

quando coloco o for ele determina quantos vezes a funcao a cima sera repetida, fazendo o motor se movimentar para o lado escolhido!!!no caso acima(digitalWrite(dir, HIGH);)

E esses 1200 passos são só para ilustrar ou vc ta usando eles em seu programa mesmo?

e porque vc nao una a biblioteca stepper.h, ela facilita o controle dos passos do motor e velocidade do motor

Os passos sao só para ilustrar!!!nao sei ao certo quantos passos serão ainda!!!Então, estou apanhando bonito aqui, para dar um home nos motores, pois quando os motores estão se posicionando eles encostam no microswitch mas nao deligam instantaneamente, so desligam depois de uns milisegundos, mas o suficiente para empurrar o switch tirando- da posição e comprometendo a precisão dos movimentos que precisarei nos loops seguintes....

To ate tentando usar o Accelstepper.h, mas nao sou da area e tenho bastante dificuldade em compreender o que ocorre, fiz algumas simulações usando esta biblioteca, mas boiei na maionese...

To precisando de alguém pra me ajudar, mas aqui na cidade ta difícil encontrar alguém que entenda da parada.

vou dar uma estudadinha aqui no stepper.h, pra ser sincero nao olhei ainda esta biblioteca..

SE tiver alguem que interesse montar o sketch pra mim, sei la, via w.up, skipe, eu filmo a maquina aqui tento explicar o que vou precisar e a pessoa vai montando.

o equipamento que estou montando fara movimentos sililares a este...ja esta tudo montado so falta acertar estes endstops...

https://www.youtube.com/watch?v=ajNs_v28Uhk#aid=P-h2wrnlaqc

Valeu pelas dicas!!! 

meu sketch completo e esse ai!!!

LOgico os passos(distancias) ainda vou ter que calibrar!!!


////////////motorW//////////////////
int dirw = 4;
int passow = 5;
int veloxw = 2000;
int whome = 3000;
int sobew = 1200;
int descew = 1200;
//////////motorz////////////////////
int dirz = 6;
int passoz = 7;
int veloxz = 2000;
int zhome = 4000;
int sobez = 1000;
int descez = 1000;
//////////motory////////////////////
int diry = 8;
int passoy = 9;
int veloxy = 2000;
int yhome = 3000;
int frenteycurto = 400;
int frenteylongo = 1200;
int trazy = 1200;
//////////motorx////////////////////
int dirx = 10;
int passox = 11;
int veloxx = 2000;
int xhome = 9000;
int levax6 = 7100;
int levax5 = 7100;
int buscax6 = 7100;
int buscax5 = 7100;
///////////////endstop///////////////
int endstopw = A0;
int endstopz = A1;
int endstopy = A2;
int endstopx = A3;
#define trigPin 2
#define echoPin 3
long duration, distance;

void setup() {

Serial.begin(9600);
pinMode(dirw, OUTPUT);
pinMode(passow, OUTPUT);
pinMode(dirz, OUTPUT);
pinMode(passoz, OUTPUT);
pinMode(diry, OUTPUT);
pinMode(passoy, OUTPUT);
pinMode(dirx, OUTPUT);
pinMode(passox, OUTPUT);
pinMode(passow, OUTPUT);
pinMode(dirw, OUTPUT);
pinMode(endstopw,INPUT);
pinMode(endstopz,INPUT);
pinMode(endstopy,INPUT);
pinMode(endstopx,INPUT);
pinMode(echoPin,INPUT);
pinMode(trigPin,OUTPUT);


for (int i = 0; i< whome; i++)
{
setupwhome();
}

for (int i = 0; i< zhome; i++)
{
setupzhome();
}

for (int i = 0; i< xhome; i++)
{
setupxhome();
}

for (int i = 0; i< yhome; i++)
{
setupyhome();
}

}

void loop() {

digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distance = microsecondsToCentimeters(duration);
Serial.print("cm");
Serial.print(distance);
if (distance < 10);
{
primeiromovimento6mudas();//1
busca5mudas();//2
busca6mudas();//3
busca5mudas();//4
busca6mudas();//5
busca5mudas();//6
busca6mudas();//7
busca5mudas();//8
busca6mudas();//9
busca5mudas();//10
busca6mudas();//11
busca5mudas();//12
busca6mudas();//13
busca5mudas();//14
busca6mudas();//15
busca5mudas();//16
buscaultimafileiramudas();//17
}
}
////////////////////////////////////movimentos///////////////////


//////////////primeiro movimento//////////////////////
void primeiromovimento6mudas(){
///////////////motor y empurra bandeja longa distancia ////////////////
for (int i = 0; i< frenteylongo; i++)
{
motoryfrente();
}
//////////////motor z desce/////////////
for (int i = 0; i< descez; i++)
{
motorzdesce();
}
/////////////////motor w desce //////////////
for (int i = 0; i< descew; i++)
{
motorwdesce();
}
/////////////motor z sobe ////////////////////
for (int i = 0; i< sobez; i++)
{
motorzsobe();
}
///////////////motor x direita////////////////
for (int i = 0; i< levax6; i++)
{
motorxdireita();
}
/////////////////motor w sobe /////////////
for (int i = 0; i< sobew; i++)
{
motorwsobe();
}
///////////////motor x esquerda////////////////
for (int i = 0; i< buscax5; i++)
{
motorxesquerda();
}

}

//////////////segundo movimento//////////////////////
void busca5mudas(){
///////////////motor y empurra bandeja longa distancia ////////////////
for (int i = 0; i< frenteycurto; i++)
{
motoryfrente();
}
//////////////motor z desce/////////////
for (int i = 0; i< descez; i++)
{
motorzdesce();
}
/////////////////motor w desce //////////////
for (int i = 0; i< descew; i++)
{
motorwdesce();
}
/////////////motor z sobe ////////////////////
for (int i = 0; i< sobez; i++)
{
motorzsobe();
}
///////////////motor x direita////////////////
for (int i = 0; i< levax5; i++)
{
motorxdireita();
}
/////////////////motor w sobe /////////////
for (int i = 0; i< sobew; i++)
{
motorwsobe();
}
///////////////motor x esquerda////////////////
for (int i = 0; i< buscax6; i++)
{
motorxesquerda();
}

}

//////////////terceito movimento//////////////////////
void busca6mudas(){
///////////////motor y empurra bandeja longa distancia ////////////////
for (int i = 0; i< frenteycurto; i++)
{
motoryfrente();
}
//////////////motor z desce/////////////
for (int i = 0; i< descez; i++)
{
motorzdesce();
}
/////////////////motor w desce //////////////
for (int i = 0; i< descew; i++)
{
motorwdesce();
}
/////////////motor z sobe ////////////////////
for (int i = 0; i< sobez; i++)
{
motorzsobe();
}
///////////////motor x direita////////////////
for (int i = 0; i< levax6; i++)
{
motorxdireita();
}
/////////////////motor w sobe /////////////
for (int i = 0; i< sobew; i++)
{
motorwsobe();
}
///////////////motor x esquerda////////////////
for (int i = 0; i< buscax5; i++)
{
motorxesquerda();
}

}

//////////////terceito movimento//////////////////////
void buscaultimafileiramudas(){
///////////////motor y empurra bandeja longa distancia ////////////////
for (int i = 0; i< frenteycurto; i++)
{
motoryfrente();
}
//////////////motor z desce/////////////
for (int i = 0; i< descez; i++)
{
motorzdesce();
}
/////////////////motor w desce //////////////
for (int i = 0; i< descew; i++)
{
motorwdesce();
}
/////////////motor z sobe ////////////////////
for (int i = 0; i< sobez; i++)
{
motorzsobe();
}
///////////////motor x direita////////////////
for (int i = 0; i< levax6; i++)
{
motorxdireita();
}

/////////////////motor w sobe /////////////
for (int i = 0; i< sobew; i++)
{
motorwsobe();
}
///////////////motor x esquerda////////////////
for (int i = 0; i< buscax6; i++)
{
motorxesquerda();
}

///////////////motor y retorna////////////////
for (int i = 0; i< trazy; i++)
{
motorytraz();
}

}

///////////////////////////////////

void setupwhome()
{
if(analogRead(endstopw) == 0)
{
digitalWrite(dirw, HIGH);
digitalWrite(passow, HIGH);
delayMicroseconds(veloxw);
digitalWrite(passow, LOW);
delayMicroseconds(veloxw);
} else {
analogWrite(passow,LOW);
}
}

void motorwsobe()
{
digitalWrite(dirw, HIGH);
digitalWrite(passow, HIGH);
delayMicroseconds(veloxw);
digitalWrite(passow, LOW);
delayMicroseconds(veloxw);
}

void motorwdesce()
{
digitalWrite(dirw, LOW);
digitalWrite(passow, HIGH);
delayMicroseconds(veloxw);
digitalWrite(passow, LOW);
delayMicroseconds(veloxw);
}

// funçoes z//

void setupzhome()
{
if(analogRead(endstopz) == 0)
{
digitalWrite(dirz, HIGH);
digitalWrite(passoz, HIGH);
delayMicroseconds(veloxz);
digitalWrite(passoz, LOW);
delayMicroseconds(veloxz);
} else {
analogWrite(passoz,LOW);
}
}


void motorzsobe()
{
digitalWrite(dirz, HIGH);
digitalWrite(passoz, HIGH);
delayMicroseconds(veloxz);
digitalWrite(passoz, LOW);
delayMicroseconds(veloxz);
}

void motorzdesce()
{
digitalWrite(dirz, LOW);
digitalWrite(passoz, HIGH);
delayMicroseconds(veloxz);
digitalWrite(passoz, LOW);
delayMicroseconds(veloxz);
}

// funçoes y//

void setupyhome()
{
if(analogRead(endstopy) == 0)
{
digitalWrite(diry, HIGH);
digitalWrite(passoy, HIGH);
delayMicroseconds(veloxy);
digitalWrite(passoy, LOW);
delayMicroseconds(veloxy);
} else {
analogWrite(passoy,LOW);
}
}

void motoryfrente()
{
digitalWrite(diry, HIGH);
digitalWrite(passoy, HIGH);
delayMicroseconds(veloxy);
digitalWrite(passoy, LOW);
delayMicroseconds(veloxy);
}

void motorytraz()
{
digitalWrite(diry, LOW);
digitalWrite(passoy, HIGH);
delayMicroseconds(veloxy);
digitalWrite(passoy, LOW);
delayMicroseconds(veloxy);
}

// funçoes x//

void setupxhome()
{
if(analogRead(endstopx) == 0)
{
digitalWrite(dirx, LOW);
digitalWrite(passox, HIGH);
delayMicroseconds(veloxx);
digitalWrite(passox, LOW);
delayMicroseconds(veloxx);
} else {
analogWrite(passox,LOW);
}
}


void motorxesquerda()
{
digitalWrite(dirx, LOW);
digitalWrite(passox, HIGH);
delayMicroseconds(veloxx);
digitalWrite(passox, LOW);
delayMicroseconds(veloxx);
}

void motorxdireita()
{
digitalWrite(dirx, HIGH);
digitalWrite(passox, HIGH);
delayMicroseconds(veloxx);
digitalWrite(passox, LOW);
delayMicroseconds(veloxx);
}

long microsecondsToCentimeters(long microseconds)

{
return microseconds/29/2;
}

Entendi, nesse caso acho que o millis() não vai te ajudar, o delay() deve resolver... eu uso o millis() só quando eu quero parar determinada função mas continuar executando outras.

Agora na questão de motores eu não entendo nada... :/

RSS

Destaques

Registre-se no
Lab de Garagem
Clicando aqui

Convide um
amigo para fazer
parte

curso gratis de arduino

© 2018   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço