hulp gevraagd bij sketch - Combinatie stepper en display

[Chimel Profiel Privébericht]

Hi Forumleden,

Ik ben sedert een paar maand bezig met Arduino en heb al wat projectjes kunnen maken. Tot vreugd van iedereen en vooral mezelf
Nu ben ik bezig met iets waar ik op vast loop.
Ik zou nl berekende waardes willen laten zien op een lcd display. Niet moeilijk op het eerste zicht.
Maar wel een stuk ingewikkelder als er ondertussen een steppermotor draait.
Via een keypad worden parameters verstrekt die worden omgerekend tot een toerental van de motor.
De parameters die ik op het display wil zijn: rpm (aantal toeren per minuut), de waarde van een pot meter, en het aantal gedraaide meters.
Door het aanroepen van het display hapert de motor even en dat is net wat ik niet wil. De motor moet continu blijven draaien zonder schokken.
Hieronder een stuk van de code.

Kan er mij iemand op weg zetten hierbij. Ik vrees dat ik met interrupts zal moeten werken, maar dat is mij net iets te moeilijk.

Wat doet het programma.
Na de verwelkoming krijgt men het "Layoutscreen"
Hier kan men via het keypad en A,B,C,D parameters ingeven en bevestigen met #
Aan de hand van die parameters bekomt men de waarde (uitkomst)

Deze waarde wordt gebruikt als delay voor de steppermotor.
Wanneer de motor draait krijgt men lcd scherm "uitlezingdisplay" met als info de berekende waardes.

Hier loopt het fout, en gaat de motor schokkend draaien. Dit vanwege de vertraging van het display.

Ik weet dat de berekeningen nog niet op punt staan en er wat "rommel" in de code staat, maar het is work in progress.
Bedoeling is dat de structuur wordt uitgezet, de afwerking komt dan als het systeem werkt.

Code: Alles selecteren




```cpp
#include "LiquidCrystal_I2C.h"
#include "Keypad.h"
#include "EEPROM.h"
// keypadsetting

const byte ROWS = 4;  //four rows
const byte COLS = 4;  //three columns


char keys[ROWS][COLS] = {
  { '1', '2', '3', 'A' },
  { '4', '5', '6', 'B' },
  { '7', '8', '9', 'C' },
  { '*', '0', '#', 'D' }
};

byte rowPins[ROWS] = { 2, 3, 4, 5 };  //connect to the row pinouts of the keypad
byte colPins[COLS] = { 6, 7, 8, 9 };  //connect to the column pinouts of the keypad
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

// display setting

LiquidCrystal_I2C lcd(0x27, 20, 2);

// start of relay settings
// Definieer de pinnen waarop de stappenmotoren zijn aangesloten
const int motor1_step_pin = 24;  // geel
const int motor1_dir_pin = 22;   // oranje
const int motor1_en_pin = 26;    // groen
const int motor2_step_pin = 13;  // geel
const int motor2_dir_pin = 12;   // oranje
const int motor2_en_pin = 11;    // groen

const int BUTTON = 52;      // drukknop start motor
const int home = 30;        // drukknop om winder naar de home te brengen
const int buttonhome = 32;  // input switch homing bereikt


const int potValue = A0;


// Definieer variabelen om de huidige positie van de motoren bij te houden
long motor1_position = 0;
long motor2_position = 0;
bool homer = false;

int metermin;
int diameter;
int wspeed;
int dspeed;
int address;
int breedte;
int uitkomst;


float motor1_steps_remaining = uitkomst;

void opStartScherm() {

  Serial.println("dit is de opstart");
  lcd.init();
  lcd.begin(20, 4);
  lcd.backlight();
  String message = "  *** opstart  *** ";
  for (byte i = 0; i < message.length(); i++) {
    lcd.print(message[i]);
    delay(50);
  }
  delay(1000);
  lcd.setCursor(4, 2);
  lcd.print("Michel");
 

  delay(5000);
}


void layoutScreen() {

  lcd.clear();
  lcd.setCursor(0, 0);
  int diameter;
  EEPROM.get(0, diameter);
  int wspeed;
  EEPROM.get(2, wspeed);
  int dspeed;
  EEPROM.get(4, dspeed);
  int breedte;
  EEPROM.get(6, breedte);

  lcd.print("A:Filament     " + String(diameter));
  lcd.setCursor(0, 1);
  lcd.print("B:Feed        " + String(wspeed));
  lcd.setCursor(0, 2);
  lcd.print("C:Drum diam    " + String(dspeed));
  lcd.setCursor(0, 3);
  lcd.print("D:Drum width   " + String(breedte));
}

void keuzeA() {

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(" Filament diameter");
  lcd.setCursor(0, 1);
  lcd.print(" in micron (50-200)");
  lcd.setCursor(0, 3);
  lcd.print("Diameter: ");

  String result = "";
  while (true) {
    char key = keypad.getKey();
    if (key >= '0' && key <= '9') {
      result += key;
      lcd.print(key);
    } else if (key == '#') {
      int diameter = result.toInt();
      if (diameter >= 50 && diameter <= 200) {
        lcd.setCursor(14, 3);
        lcd.print("micron");
        delay(1500);

        EEPROM.put(0, diameter);
        Serial.println(diameter);
        Serial.println("diameter weggeschreven");
        layoutScreen();
        break;
      } else {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    Out of range   ");
        lcd.setCursor(0, 1);
        lcd.print("  Range 50-200 mm");
        delay(2500);
      }

      keuzeA();
      break;
    }
  }
}

void keuzeB() {

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("    Filament feed");
  lcd.setCursor(0, 1);
  lcd.print("(in mm/min 0-10000)");
  lcd.setCursor(0, 3);
  lcd.print("Feed: ");

  String result = "";
  while (true) {
    char key = keypad.getKey();
    if (key >= '0' && key <= '9') {
      result += key;
      lcd.print(key);
    } else if (key == '#') {
      int wspeed = result.toInt();
      if (wspeed >= 0 && wspeed <= 10000) {
        lcd.setCursor(14, 3);
        lcd.print("mm/min");
        EEPROM.put(2, wspeed);
        Serial.println(wspeed);
        Serial.println("draadtoevoer weggeschreven");
        delay(1500);
        layoutScreen();
        break;
      } else {
        lcd.clear();
        lcd.setCursor(0, 1);
        lcd.print("   Out of range");
        lcd.setCursor(0, 2);
        lcd.print("Range 0-10000 mm/min");
        delay(1500);
      }

      keuzeB();
      break;
    }
  }
}

void keuzeC() {

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("  Drumdiameter  ");
  lcd.setCursor(0, 1);
  lcd.print("in mm (100-200)");
  lcd.setCursor(0, 3);
  lcd.print("Diameter: ");

  String result = "";
  while (true) {
    char key = keypad.getKey();
    if (key >= '0' && key <= '9') {
      result += key;
      lcd.print(key);
    } else if (key == '#') {
      int dspeed = result.toInt();
      if (dspeed >= 100 && dspeed <= 200) {
        lcd.setCursor(15, 3);
        lcd.print("mm");
        EEPROM.put(4, dspeed);
        Serial.println("drumdiameter weggeschreven");
        Serial.println(dspeed);
        delay(1500);

        layoutScreen();
        break;
      } else {
        lcd.clear();
        lcd.setCursor(0, 1);
        lcd.print("   Out of range");
        lcd.setCursor(0, 2);
        lcd.print("Range 100-200 mm");
        delay(1500);
      }

      keuzeC();
      break;
    }
  }
}

void keuzeD() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("   Drumwidth");
  lcd.setCursor(0, 1);
  lcd.print("in mm (100-200)");
  lcd.setCursor(0, 3);
  lcd.print("Width: ");

  String result = "";
  while (true) {
    char key = keypad.getKey();
    if (key >= '0' && key <= '9') {
      result += key;
      lcd.print(key);
    } else if (key == '#') {
      int breedte = result.toInt();
      if (breedte >= 100 && breedte <= 200) {
        lcd.setCursor(15, 3);
        lcd.print("mm");


        EEPROM.put(6, breedte);
        Serial.println(breedte);
        Serial.println("drumbreedte  weggeschreven");
        delay(1500);

        layoutScreen();
        break;
      } else {
        lcd.clear();
        lcd.setCursor(0, 1);
        lcd.print("    Out of range");
        lcd.setCursor(0, 2);
        lcd.print("Range 100-200 mm");
        delay(1500);
      }

      keuzeD();
      break;
    }
  }
}
void Bereken() {


  Serial.println("berekenen");
  int diameter;
  EEPROM.get(0, diameter);  // diameter draad in mircon
  Serial.println(diameter);
  int wspeed;
  EEPROM.get(2, wspeed);  // snelheid draadtoevoer in mm/min
  Serial.println(wspeed);
  int dspeed;
  EEPROM.get(4, dspeed);  // diameter van de bobijn
  Serial.println(dspeed);
  int breedte;
  EEPROM.get(6, breedte);  // breedte van de bobijn
  Serial.println(breedte);

  float pi = 3.14;
  float uitkomst = 1 / (((wspeed / (dspeed * pi)) * 200) / 60);
  Serial.println(uitkomst, 4);

  EEPROM.put(8, uitkomst);

  Serial.println("waarde uitkomst weggeschreven");
}

void winderRun() {

  Serial.println("winderrun aangeroepen");
  float uitkomst;
  EEPROM.get(8, uitkomst);
  //uitkomst = uitkomst *10;

  //int potValue = analogRead(A0);

  //Serial.println("we zijn in loop winderrun");  // Laat motor 1 één volledige toer draaien
  //Serial.println(potValue);
  Serial.println(uitkomst, 4);

  // Bereken een offset voor het toerental van Motor 1 op basis van de potentiometerwaarde
  //float offset = (potValue / 1023.0) * 10;  // 0.1 is de factor die de maximale offset van 10% vertegenwoordigt

  //lcd.clear();
 
  uitlezingdisplay();



  for (int i = 0; i < 200; i++) {
    digitalWrite(motor1_step_pin, HIGH);
    delay(uitkomst);
    digitalWrite(motor1_step_pin, LOW);
    // Pas de wachttijd tussen stappen aan met de berekende offset
   // delayMicroseconds((uitkomst + (offset * uitkomst)));
    delay(uitkomst);

    //Serial.println(uitkomst + (offset * uitkomst));
   

    if (digitalRead(BUTTON) == LOW) {
      digitalWrite(motor1_step_pin, LOW);
      break;
    }
  }
  // Laat motor 2 1/10 toer draaien
  for (int i = 0; i < 20; i++) {
    digitalWrite(motor2_step_pin, HIGH);
    delayMicroseconds(25);
    digitalWrite(motor2_step_pin, LOW);
    delayMicroseconds(25);
   

    if (digitalRead(BUTTON) == LOW) {
      digitalWrite(motor2_step_pin, LOW);

      layoutScreen();
      break;
    }
  }
 
}

void uitlezingdisplay(){



 
  //EEPROM.get(2, wspeed);
  //EEPROM.get(4, dspeed);
 

  //float pi = 3.14;
  //float metermin = wspeed / (dspeed * pi);
 
  lcd.setCursor(0, 0);
  lcd.print("RPM winder: ");
  lcd.print(metermin, 2);
  lcd.print("rpm");

  lcd.setCursor(0, 1);
  lcd.print("Uitkomst: ");
  lcd.print(uitkomst);
  lcd.print("    mm");

  lcd.setCursor(0, 2);
  lcd.print("Offset:    ");
  lcd.print(potValue);
  lcd.print("  %      ");

  lcd.setCursor(0, 3);
  lcd.print("                   ");









}







void homing() {

  const int step_delay = 150;  // constante vertraging voor motorstappen
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(" Winder is homing ");
  while (homer == true) {
    //digitalWrite(motor2_step_pin, LOW);
    Serial.println("homing aangeroepen");
    Serial.println(homer);

    for (int i = 0; i < 200; i++) {
      digitalWrite(motor2_step_pin, HIGH);
      delayMicroseconds(step_delay);
      digitalWrite(motor2_step_pin, LOW);
      delayMicroseconds(step_delay);
      motor2_position++;

      if (digitalRead(buttonhome) == HIGH) {
        homer = false;
        Serial.println(homer);
        digitalWrite(motor2_step_pin, LOW);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print(" Winder in positie");
        delay(2500);

        layoutScreen();
      }
    }
  }
}




void setup() {

  Serial.begin(9600);

  int diameter = 0;
  int wspeed = 0;
  int dspeed = 0;

  // Configureer de pinnen als uitgangen
  pinMode(motor1_step_pin, OUTPUT);
  pinMode(motor1_dir_pin, OUTPUT);
  pinMode(motor2_step_pin, OUTPUT);
  pinMode(motor2_dir_pin, OUTPUT);
  pinMode(BUTTON, INPUT);
  pinMode(home, INPUT);
  pinMode(buttonhome, INPUT);


  // Stel de richting van de motoren in
  digitalWrite(motor1_dir_pin, HIGH);  // motor 1 draait met de klok mee
  digitalWrite(motor2_dir_pin, HIGH);  // motor 2 draait met de klok mee



  EEPROM.get(0, diameter);

  Serial.println(diameter);

  EEPROM.get(2, wspeed);

  Serial.println(wspeed);

  EEPROM.get(4, dspeed);

  Serial.println(dspeed);

  EEPROM.get(6, breedte);

  Serial.println(breedte);

  opStartScherm();
  layoutScreen();
}


void loop() {


  if (digitalRead(home) == HIGH && digitalRead(BUTTON) == LOW && homer == false) {  //|| digitalRead(buttonhome) == LOW)
    homer = true;
    Serial.println("knop homing hoog");
    homing();
  }

  if (digitalRead(BUTTON) == HIGH) {
    homer = false;
    Serial.println("knop start hoog");
    winderRun();
  }


  char key = keypad.getKey();
  if (key != NO_KEY) {
    switch (key) {
      case 'A':
        Serial.println("Draaddikte gekozen");
        keuzeA();
        Bereken();
        break;
      case 'B':
        Serial.println("Snelheid draadtoevoer gekozen");
        keuzeB();
        Bereken();
        break;
      case 'C':
        Serial.println("Spoeldiameter gekozen");
        keuzeC();
        Bereken();
        break;
      case 'D':
        Serial.println("Spoelbreedte gekozen");
        keuzeD();
        break;
    }
  }
}

```


















[shooter Profiel Privébericht]

Code: Alles selecteren

for (int i = 0; i < 200; i++) {
    digitalWrite(motor1_step_pin, HIGH);
    delay(uitkomst);
    digitalWrite(motor1_step_pin, LOW);
    // Pas de wachttijd tussen stappen aan met de berekende offset
   // delayMicroseconds((uitkomst + (offset * uitkomst)));
    delay(uitkomst);

zet high maar op een wachttijd van 25 microseconds want nu staat het er dubbel in.
je hebt zelf een stepper gemaakt prima misschien is accelstepper wat slimmer met vertragen etc,
en opletten met serieel versturen zowel serial als je display dat het niet tevol stroomt dan gaat het spul haperen, dus beter met een timer elke seconde updaten