[gelöst] Hängt sich nach kurzer Zeit auf

International Deutsch
21

uwefed:
Sind das nicht DO WHILE Schleifen? Also richtig.

Upps, peinlich, stimmt. :confused: Vielleicht weil ich do while noch nie verwendet habe.

22

Doc_Arduino:
Upps, peinlich, stimmt.

Wobei das eigentlich gar nicht mal schlecht gedacht ist.
Die Idee dahinter ist nachvollziehbar.
Und nicht lachen, aber das scheint dem Speicher gut zu tun.

23

paulpaulson:
Hallo
die Funktionen hoch() und runter() kann zusammengefügt werden in dem in der Parameterleiste auch die Richtung übergeben wird.

Kann man machen...
Versuch es mal.
komm mal mit den Speicherverbräuchen.

void HochRunter(const unsigned long stepperspeed, bool richtung)

Nö. Das wird nichts.

24

my_xy_projekt:
Kann man machen...
Versuch es mal.
komm mal mit den Speicherverbräuchen.
Nö. Das wird nichts.

Mensch, das is ja Mist.
Versuch macht aber klug :slight_smile:

und danke für Deine Antwort

25

Doc_Arduino:
Vielleicht weil ich do while noch nie verwendet habe.

Ohh !
Dann hast du wirklich was verpasst.

Ich rate dir: Teste es!
Das ist geiles Zeugs.
Richtig guter Stoff!
Da kommste nie wieder von los, wenne das mal getestet hast.

26

Hallo,

irgendwann wird sich sicherlich ein Grund dafür finden. Der war bis jetzt noch nicht da. :slight_smile:

27

do while ist halt eine while Schleife die mindestens 1 mal mehr als eine while Schleife (mit gleicher Bedingung) ausgeführt wird.

Vieleicht findet man so eine Grund mal do while zu nutzen.

Grüße Uwe

PS: Auch ich erinnere mich nicht, wann ich mal do while verwendet habe.

28

Hallo,

na was die macht weiß ich schon. :wink:

29

uwefed:
PS: Auch ich erinnere mich nicht, wann ich mal do while verwendet habe.

Die Logik die sich in diesem Einsatz darstellt ist schon nachvollziehbar.

Der Code macht schon, was der TO will.
Taste gedrückt - führe langsam aus... - Zeit abgelaufen und noch immer gedrückt - führe schnell aus
Das Problem ist, das er nicht gegenseitig verriegelt und nur NACHEINANDER abfragt.

Ungeachtet dessen, ist DAS nicht das Problem des TO.

30

Da hab ich doch gestern getönt...

my_xy_projekt:

Der Sketch verwendet 21250 Bytes (69%) des Programmspeicherplatzes.

Globale Variablen verwenden 915 Bytes (44%) des dynamischen Speichers

und vergessen zu schreiben wie's geht.
mache aus alt:

U8G2_SH1106_128X64_NONAME_F_HW_I2C OLED_1(U8G2_R0, U8X8_PIN_NONE); // U8G2 OLED_1
U8G2_SH1106_128X64_NONAME_F_HW_I2C OLED_2(U8G2_R0, U8X8_PIN_NONE); // U8G2 OLED_2

neu:

U8G2_SH1106_128X64_NONAME_2_HW_I2C OLED_1(U8G2_R0, U8X8_PIN_NONE); // U8G2 OLED_1
U8G2_SH1106_128X64_NONAME_2_HW_I2C OLED_2(U8G2_R0, U8X8_PIN_NONE); // U8G2 OLED_2

und schon ist alles in Butter.

31

my_xy_projekt genial. Vielen Dank.

Mir ist warum auch immer nicht in den Sinn gekommen die Buffer Größe von (F) Full Frame Buffer auf 1 für Only one Page zu setzen. Ich Freu mich schon auf den Feierabend wenn ich das Zuhause testen kann. ;D 8)
Dankeschön.

LG
Celleron

32

Schade, das Problem besteht weiterhin.

Ich habe das sketch wie folgt geändert:

#include <U8g2lib.h>
#include <Wire.h>
const byte ENA {9};
const byte STP {3};
const byte DIR {2};
const byte MS1 {8};
const byte MS2 {7};
const byte MS3 {6};
const byte HOCH {10};
const byte RUNTER {12};
const byte RESET {13};
const byte START {11};
const byte ENDU {4};
const byte ENDO {5};
bool bHOCH {LOW};
bool bRUNTER {LOW};
int poscount {0};
const int stepperspeed_l {500};
const int stepperspeed_h {250};
int LaserPowerSetting {0};
U8G2_SH1106_128X64_NONAME_2_HW_I2C OLED(U8G2_R0, U8X8_PIN_NONE);

void setup() {
  OLED.setI2CAddress(0x3C * 2);
  OLED.begin();
  OLED.setI2CAddress(0x3D * 2);
  OLED.begin();
  drawOLED_2();
  pinMode(ENA, OUTPUT);
  pinMode(STP, OUTPUT);
  pinMode(DIR, OUTPUT);
  pinMode(MS1, OUTPUT);
  pinMode(MS2, OUTPUT);
  pinMode(MS3, OUTPUT);
  pinMode(HOCH, INPUT);
  pinMode(RUNTER, INPUT);
  pinMode(RESET, INPUT);
  pinMode(START, INPUT);
  pinMode(ENDO, INPUT);
  pinMode(ENDU, INPUT);
  digitalWrite(ENA, HIGH);
  digitalWrite(MS1, HIGH);
  digitalWrite(MS2, HIGH);
  digitalWrite(MS3, LOW);
}

void loop() {
  LaserPowerSetting = analogRead(A3);
  LaserPowerSetting = map(LaserPowerSetting, 60, 1023, 0, 100);
  bHOCH = digitalRead(HOCH);
  bRUNTER = digitalRead(RUNTER);
  drawOLED_1();

  if (bRUNTER == HIGH && !digitalRead(ENDU)) {
    Runter(stepperspeed_l);
    drawOLED_2();
    while (digitalRead(RUNTER) && !digitalRead(ENDU)) {
      delay (1000);
      do {
        Runter(stepperspeed_h);
        drawOLED_2();
      }
      while (digitalRead(RUNTER) && !digitalRead(ENDU));
    }
  }

  if (bHOCH == HIGH && !digitalRead(ENDO)) {
    Hoch(stepperspeed_l);
    drawOLED_2();

    while (digitalRead(HOCH) && !digitalRead(ENDO)) {
      delay (1000);
      do {
        Hoch(stepperspeed_h);
        drawOLED_2();
      }
      while (digitalRead(HOCH) && !digitalRead(ENDO));
    }
  }

  if (digitalRead(START) == HIGH) {
    for (;0 < poscount;)
    {
      Runter(stepperspeed_h);
      drawOLED_2();
    }
    for (; 0 > poscount;)
    {
      Hoch(stepperspeed_h);
      drawOLED_2();
    }
  }

  if (digitalRead(RESET) == HIGH) {
    poscount = 0;
    drawOLED_2();
  }
}

void Hoch(const unsigned long stepperspeed)
{
  digitalWrite(ENA, LOW);
  for (int index = 0; index <= 200; index++)
  {
    digitalWrite(DIR, LOW);
    digitalWrite(STP, HIGH);
    delayMicroseconds(stepperspeed);
    digitalWrite(DIR, LOW);
    digitalWrite(STP, LOW);
    delayMicroseconds(stepperspeed);
  }
  poscount++;
}

void Runter(const unsigned long stepperspeed)
{
  digitalWrite(ENA, LOW);
  for (int index = 0; index <= 200; index++)
  {
    digitalWrite(DIR, HIGH);
    digitalWrite(STP, HIGH);
    delayMicroseconds(stepperspeed);
    digitalWrite(DIR, HIGH);
    digitalWrite(STP, LOW);
    delayMicroseconds(stepperspeed);
  }
  poscount--;
}

void drawOLED_1(void) {
  OLED.setI2CAddress(0x3C * 2);
  char buf[9];
  sprintf (buf, "%d %%", LaserPowerSetting);
  OLED.firstPage();
  do {
  OLED.setFont(u8g_font_10x20);       
  OLED.drawStr(7, 15, "Laser Power");
  OLED.setFont(u8g_font_ncenR24);     
  OLED.drawStr(30, 55, buf);
  } while ( OLED.nextPage() );
}



void drawOLED_2(void) {
  OLED.setI2CAddress(0x3D * 2);
  char buf[9];
  sprintf (buf, "%d mm", poscount);
  OLED.firstPage();
  do {
  OLED.setFont(u8g_font_10x20);
  OLED.drawStr(5, 15, "Laser Tisch");
  OLED.setFont(u8g_font_ncenR24);
  OLED.drawStr(10, 55, buf);
  } while ( OLED.nextPage() );
}

Funktioniert in soweit prima, das der Speicher nicht mehr so hoch ausgelastet ist.
Mit dem Serial Monitor fand ich heraus, das er immer genau zwischen drawOLED_1 und drawOLED_2 Abschmiert.
Egal wie hoch die Speicherauslastung ist.

Irgendwie ist der Wurm drin. :confused:

verbrauch.JPG
verbrauch.JPG1023×54 12.4 KB

verbrauch.JPG
verbrauch.JPG1023×54 12.4 KB

33

Vielen Dank an alle. Das Problem ist gelöst.
Leider lag es von Anfang an nicht am Sketch. (Obwohl die Verbesserungen schon spitze sind)
Es mussten jeweils einfach ein Pull-Up Wiederstand zwischen 3,3V & SDA und 3,3V & SCL eingelötet werden.
Jetzt funktioniert alles ohne das es nach einer Zeit abschmiert.

LG
Celleron

34

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.