ASM51

Ola galera medonha.
Gostaria sugestão dos colegas do fórum.
2 potenciômetro canal analógico 0-5V
2 PWM controladas independentemente (cada potenciômetro controla um pwm)

O problema e que só consigo controlar as saídas se uma delas estiver com potenciômetro em 0V (0v em umas das saídas)
cpp code

//*************************************************************************************
   #include <LiquidCrystal.h>
   #include "Wire.h"
   const int rs = 11, en = 9, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
   LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
  //****************************************************************************************
  
  #include <Stepper.h>
  
  const int stepsPerRevolution = 200;              // mude isto para ajustar o número de passos por revolução para o seu motor
 
                                                  /
  Stepper myStepper(stepsPerRevolution, 6,8);   
  Stepper my_Stepper(stepsPerRevolution, 10,11);

  
  int stepCount = 0;                 // número de passos que o motor tomou
  
  void setup() {
   lcd.begin(16, 2);               // CONFIGURA DISPLAY LCD 16 COLUNAS 2 LINHAS
   // lcd.setCursor(1,0);         // POSICIONA MENSAGEM INICIAL DISPLAY
   // lcd.print("Gerador PWM");  // IMPRIME MENSAGEM pwm
    
   // lcd.setCursor(6,1);       // POSICIONA MENSAGEM INICIAL DISPLAY
   // lcd.print("HZ");         // IMPRIME MENSAGEM HZ
    
                                              
  }
  
  void loop() {  
     int sensorReading = analogRead(A0);                     // leia o valor do sensor:
                                           
    int motorSpeed = map(sensorReading, 0, 1023, 0, 100);  // mapeie para um intervalo de 0 a 100:
                                                         // ajuste a velocidade do motor:
    if (motorSpeed > 0) {
      myStepper.setSpeed(motorSpeed);
                                                       // passo 1/100 de uma revolução:
      myStepper.step(stepsPerRevolution / 100);
      
       lcd.setCursor(0,0);
       lcd.print(motorSpeed / 1.2);                 //CALCULO PARA EXIBIÇÃO FREQUENCIA NO DISPLAY

       //***********************************************************************************************

    }
    {  
     int sensorReading1 = analogRead(A1);                     // leia o valor do sensor:
                                           
    int motorSpeed1 = map(sensorReading1, 0, 1023, 0, 100);  // mapeie para um intervalo de 0 a 100:
                                                           // ajuste a velocidade do motor:
    if (motorSpeed1 > 0) {
      my_Stepper.setSpeed(motorSpeed1);
                                                        // passo 1/100 de uma revolução:
      my_Stepper.step(stepsPerRevolution / 100);
      
       lcd.setCursor(0,1);
       lcd.print(motorSpeed1 / 1.2);                 //CALCULO PARA EXIBIÇÃO FREQUENCIA NO DISPLAY

       //***********************************************************************************************

    }
    }
 }

Um palpite no escuro: Experimenta retirar a chave que inicia a partir da linha 46, pode ser que o programa esteja entendendo como um else (?!?) o que vem depois da chave fechada do primeiro if. A proposito não está claro o que faz as funções my_Stepper.step() e a myStepper.step(), em ambos os casos ambas jogam no argumento o mesmo valor stepsPerRevolution que não é alterado em parte alguma do programa.
.

Fiz desta forma mas continua mesmo problema.

cpp code

//*************************************************************************************
   #include <LiquidCrystal.h>
   #include "Wire.h"
   const int rs = 11, en = 9, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
   LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
  //****************************************************************************************
  
  #include <Stepper.h>
  
  const int stepsPerRevolution = 200;   // mude isto para ajustar o número de passos por revolução para o seu motor
                                                  // inicializa a biblioteca de passo nos pinos 6 a 11:
  Stepper myStepper(stepsPerRevolution, 6,8);   // Stepper myStepper (stepsPerRevolution, 10, )
  Stepper myStepper1(stepsPerRevolution, 10,11);

  
  int stepCount = 0;
  int stepCount1 = 0;  // número de passos que o motor tomou
  
  void setup() {
   lcd.begin(16, 2);            // CONFIGURA DISPLAY LCD 16 COLUNAS 2 LINHAS
   // lcd.setCursor(1,0);         // POSICIONA MENSAGEM INICIAL DISPLAY
   // lcd.print("Gerador PWM");  // IMPRIME MENSAGEM pwm
    
   // lcd.setCursor(6,1);       // POSICIONA MENSAGEM INICIAL DISPLAY
   // lcd.print("HZ");         // IMPRIME MENSAGEM HZ
    
                                              
  }
  
  void loop() {  
     int sensorReading = analogRead(A0);                     // leia o valor do sensor:
                                           
    int motorSpeed = map(sensorReading, 0, 1023, 0, 100);  // mapeie para um intervalo de 0 a 100:
                                                         // ajuste a velocidade do motor:
    if (motorSpeed > 0) {
      myStepper1.setSpeed(motorSpeed);
                                                        // passo 1/100 de uma revolução:
      myStepper1.step(stepsPerRevolution / 100);
      
       lcd.setCursor(0,0);
       lcd.print(motorSpeed / 1.2);                 //CALCULO PARA EXIBIÇÃO FREQUENCIA NO DISPLAY

       //***********************************************************************************************

    }
      
     int sensorReading1 = analogRead(A1);                     // leia o valor do sensor:
                                           
    int motorSpeed1 = map(sensorReading1, 0, 1023, 0, 100);  // mapeie para um intervalo de 0 a 100:
                                                         // ajuste a velocidade do motor:
    if (motorSpeed1 > 0) {
      myStepper.setSpeed(motorSpeed1);
                                                        // passo 1/100 de uma revolução:
      myStepper.step(stepsPerRevolution / 100);
      
       lcd.setCursor(0,1);
       lcd.print(motorSpeed1 / 1.2);                           //CALCULO PARA EXIBIÇÃO FREQUENCIA NO DISPLAY

       //***********************************************************************************************

    }

No seu primeiro código, na linha 45, após a "}", não deveria de ter um "else"?

*Edit:
Agora vi o que o André disse;
O código está estranho, começando com aquelas variáveis declaradas lá no meio dentro daquele segundo bloco de chaves mais estranho ainda no meio do programa.
Sugestões básicas:
Declarar variáveis todas no início;
Remover aquele bloco de chaves doido lá do meio;

Faça a leitura das duas entradas analógicas; depois verifique os valores de cada uma nos if() e faça as codificações pertinentes.

Uma ideia, não testei se funciona:

Código: Selecionar todos

//*************************************************************************************
   #include <LiquidCrystal.h>
   #include "Wire.h"
   const int rs = 11, en = 9, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
   LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
  //****************************************************************************************
   
  #include <Stepper.h>
   
  const int stepsPerRevolution = 200;              // mude isto para ajustar o número de passos por revolução para o seu motor
 
                                                  /
  Stepper myStepper(stepsPerRevolution, 6,8);   
  Stepper my_Stepper(stepsPerRevolution, 10,11);
 
   
  int stepCount = 0;                 // número de passos que o motor tomou
   
  void setup() {
   lcd.begin(16, 2);               // CONFIGURA DISPLAY LCD 16 COLUNAS 2 LINHAS
   // lcd.setCursor(1,0);         // POSICIONA MENSAGEM INICIAL DISPLAY
   // lcd.print("Gerador PWM");  // IMPRIME MENSAGEM pwm
     
   // lcd.setCursor(6,1);       // POSICIONA MENSAGEM INICIAL DISPLAY
   // lcd.print("HZ");         // IMPRIME MENSAGEM HZ
     
                                               
  }
   
  void loop()
  { 
    unsigned short int sensorReading = analogRead(A0);                     // leia o valor do sensor:                                       
    unsigned short int motorSpeed = map(sensorReading, 0, 1023, 0, 100);  // mapeie para um intervalo de 0 a 100:
                                                         
   unsigned short int sensorReading1 = analogRead(A1);                     // leia o valor do sensor:                                         
    unsigned short int motorSpeed1 = map(sensorReading1, 0, 1023, 0, 100);  // mapeie para um intervalo de 0 a 100:
   
    if (motorSpeed > 0)
   {
      myStepper.setSpeed(motorSpeed);
                                                       // passo 1/100 de uma revolução:
      myStepper.step(stepsPerRevolution / 100);
       
       lcd.setCursor(0,0);
       lcd.print(motorSpeed / 1.2);                 //CALCULO PARA EXIBIÇÃO FREQUENCIA NO DISPLAY
 
       //***********************************************************************************************
 
    }else                                                       
      if (motorSpeed1 > 0)
      {
        my_Stepper.setSpeed(motorSpeed1);
                                             // passo 1/100 de uma revolução:
        my_Stepper.step(stepsPerRevolution / 100);
         
         lcd.setCursor(0,1);
         lcd.print(motorSpeed1 / 1.2);                 //CALCULO PARA EXIBIÇÃO FREQUENCIA NO DISPLAY
   
         //***********************************************************************************************
   
      }
      
   delay(100);
   
 }

Achei esta biblioteca muito ruim. A rotina step é bloqueante.

Do jeito que está implementado, se a velocidade de um motor for muito baixo (quase zero mas maior que zero), pode demorar para executar os 2 passos (stepsPerRevolution / 100 = 2) e só então vai tratar do outro motor. A velocidade vai dimuinuindo conforme aumenta o número de motores e aumentando se você deixar de tratar algum(s) dos motores (com if(velocidade>0)). E se não usar o if(velocidade>0) a rotina vai ficar travada já que nunca vai executar o(s) passo(s) até bater no watchdog, isso se não der erro de compilação (divisão por zero ou coisa do tipo).

O problema persiste mesmo colocando os 2 potenciômetros no máximo?

eletroinf escreveu:Uma ideia, não testei se funciona:

Código: Selecionar todos

//*************************************************************************************
   #include <LiquidCrystal.h>
   #include "Wire.h"
   const int rs = 11, en = 9, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
   LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
  //****************************************************************************************
   
  #include <Stepper.h>
   
  const int stepsPerRevolution = 200;              // mude isto para ajustar o número de passos por revolução para o seu motor
 
                                                  /
  Stepper myStepper(stepsPerRevolution, 6,8);   
  Stepper my_Stepper(stepsPerRevolution, 10,11);
 
   
  int stepCount = 0;                 // número de passos que o motor tomou
   
  void setup() {
   lcd.begin(16, 2);               // CONFIGURA DISPLAY LCD 16 COLUNAS 2 LINHAS
   // lcd.setCursor(1,0);         // POSICIONA MENSAGEM INICIAL DISPLAY
   // lcd.print("Gerador PWM");  // IMPRIME MENSAGEM pwm
     
   // lcd.setCursor(6,1);       // POSICIONA MENSAGEM INICIAL DISPLAY
   // lcd.print("HZ");         // IMPRIME MENSAGEM HZ
     
                                               
  }
   
  void loop()
  { 
    unsigned short int sensorReading = analogRead(A0);                     // leia o valor do sensor:                                       
    unsigned short int motorSpeed = map(sensorReading, 0, 1023, 0, 100);  // mapeie para um intervalo de 0 a 100:
                                                         
   unsigned short int sensorReading1 = analogRead(A1);                     // leia o valor do sensor:                                         
    unsigned short int motorSpeed1 = map(sensorReading1, 0, 1023, 0, 100);  // mapeie para um intervalo de 0 a 100:
   
    if (motorSpeed > 0)
   {
      myStepper.setSpeed(motorSpeed);
                                                       // passo 1/100 de uma revolução:
      myStepper.step(stepsPerRevolution / 100);
       
       lcd.setCursor(0,0);
       lcd.print(motorSpeed / 1.2);                 //CALCULO PARA EXIBIÇÃO FREQUENCIA NO DISPLAY
 
       //***********************************************************************************************
 
    }else                                                       
      if (motorSpeed1 > 0)
      {
        my_Stepper.setSpeed(motorSpeed1);
                                             // passo 1/100 de uma revolução:
        my_Stepper.step(stepsPerRevolution / 100);
         
         lcd.setCursor(0,1);
         lcd.print(motorSpeed1 / 1.2);                 //CALCULO PARA EXIBIÇÃO FREQUENCIA NO DISPLAY
   
         //***********************************************************************************************
   
      }
      
   delay(100);
   
 }

Obrigado pela força amigo eletroinf
Desta forma funciona um por vez, na frequência máxima uns 30hz

Isso mesmo que está acontecendo caro colega edsont.
Qual seria a sua sugestão?
Tem alguma biblioteca mais adequada?

edsont escreveu:Achei esta biblioteca muito ruim. A rotina step é bloqueante.

Do jeito que está implementado, se a velocidade de um motor for muito baixo (quase zero mas maior que zero), pode demorar para executar os 2 passos (stepsPerRevolution / 100 = 2) e só então vai tratar do outro motor. A velocidade vai dimuinuindo conforme aumenta o número de motores e aumentando se você deixar de tratar algum(s) dos motores (com if(velocidade>0)). E se não usar o if(velocidade>0) a rotina vai ficar travada já que nunca vai executar o(s) passo(s) até bater no watchdog, isso se não der erro de compilação (divisão por zero ou coisa do tipo).

O problema persiste mesmo colocando os 2 potenciômetros no máximo?

Sim persiste.

menegola escreveu:

edsont escreveu:Achei esta biblioteca muito ruim. A rotina step é bloqueante.

Do jeito que está implementado, se a velocidade de um motor for muito baixo (quase zero mas maior que zero), pode demorar para executar os 2 passos (stepsPerRevolution / 100 = 2) e só então vai tratar do outro motor. A velocidade vai dimuinuindo conforme aumenta o número de motores e aumentando se você deixar de tratar algum(s) dos motores (com if(velocidade>0)). E se não usar o if(velocidade>0) a rotina vai ficar travada já que nunca vai executar o(s) passo(s) até bater no watchdog, isso se não der erro de compilação (divisão por zero ou coisa do tipo).

O problema persiste mesmo colocando os 2 potenciômetros no máximo?

Sim persiste.

Tem uma biblioteca que permite acionar multiplos motores, mas parece mais complicado de usar:

www.airspayce.com/mikem/arduino/AccelStepper/

No site até cita que a biblioteca Stepper do Arduino é indicado para aplicação com motor único.

Se for para apenas controlar a velocidade acho que é mais fácil implementar uma rotina (ou mesmo uma biblioteca) própria.

Fiz uma modificação na biblioteca. Como eu baixei somente a biblioteca não sei se funciona, mas faz o seguinte:

copia a biblioteca original para outro lugar, para o caso de dar algo errado.

No arquivo stepper.h acrescente após void step(int number_of_steps);

Código: Selecionar todos

    // move method:
    void move(int this_direction);

No arquivo stepper.cpp acrescente após a declaração de void Stepper::step(int steps_to_move) {... ...}

Código: Selecionar todos

/*
 * Moves the motor in set speed.  If the number is one moves forward,
 * if the number is zero the motor moves in the reverse direction.
 */
void Stepper::move(int thisDirection)
{
    unsigned long now = micros();
    // move only if the appropriate delay has passed:
    if (now - this->last_step_time >= this->step_delay)
    {
      // get the timeStamp of when you stepped:
      this->last_step_time = now;
      // increment or decrement the step number,
      // depending on direction:
      if (thisDirection == 1)
      {
        this->step_number++;
        if (this->step_number == this->number_of_steps) {
          this->step_number = 0;
        }
      }
      else
      {
        if (this->step_number == 0) {
          this->step_number = this->number_of_steps;
        }
        this->step_number--;
      }
      // step the motor to step number 0, 1, ..., {3 or 10}
      if (this->pin_count == 5)
        stepMotor(this->step_number % 10);
      else
        stepMotor(this->step_number % 4);
  }
}

E finalmente no seu sketch utilize:

Código: Selecionar todos

    if (motorSpeed > 0) myStepper.move(1); //1=forward, 0=reverse
    if (motorSpeed1 > 0) my_Stepper.move(1);


Edit:
Mais uma coisa. Só atualize o LCD se houver mudança de valor.

edsont escreveu:Fiz uma modificação na biblioteca. Como eu baixei somente a biblioteca não sei se funciona, mas faz o seguinte:

copia a biblioteca original para outro lugar, para o caso de dar algo errado.

No arquivo stepper.h acrescente após void step(int number_of_steps);

Código: Selecionar todos

    // move method:
    void move(int this_direction);

No arquivo stepper.cpp acrescente após a declaração de void Stepper::step(int steps_to_move) {... ...}

Código: Selecionar todos

/*
 * Moves the motor in set speed.  If the number is one moves forward,
 * if the number is zero the motor moves in the reverse direction.
 */
void Stepper::move(int thisDirection)
{
    unsigned long now = micros();
    // move only if the appropriate delay has passed:
    if (now - this->last_step_time >= this->step_delay)
    {
      // get the timeStamp of when you stepped:
      this->last_step_time = now;
      // increment or decrement the step number,
      // depending on direction:
      if (thisDirection == 1)
      {
        this->step_number++;
        if (this->step_number == this->number_of_steps) {
          this->step_number = 0;
        }
      }
      else
      {
        if (this->step_number == 0) {
          this->step_number = this->number_of_steps;
        }
        this->step_number--;
      }
      // step the motor to step number 0, 1, ..., {3 or 10}
      if (this->pin_count == 5)
        stepMotor(this->step_number % 10);
      else
        stepMotor(this->step_number % 4);
  }
}

E finalmente no seu sketch utilize:

Código: Selecionar todos

    if (motorSpeed > 0) myStepper.move(1); //1=forward, 0=reverse
    if (motorSpeed1 > 0) my_Stepper.move(1);


Edit:
Mais uma coisa. Só atualize o LCD se houver mudança de valor.

Obrigado.
Para leigos como eu, fica complicado esta biblioteca.

Cheio de erros na compilação.

Desabilitei display.
Ficou na mesma.

menegola escreveu:Desabilitei display.
Ficou na mesma.

Quando eu tiver um tempo vou baixar o IDE do Arduino aqui.