Kann mir jemand bei meinem Countdown helfen?

International Deutsch
1

Servus zusammen,
ich realisiere gerade einen Pulverofen in dem ich die Steuerung mit einem Arduino realisieren möchte. Ich bin soweit auch durch mit dem Programm.
Aber. Ich möchte gerne am LCD einen Counter über einen Potentiometer einstellen können in dem ich die Zeit einstellen kann die ablaufen soll sobald die gewünschte Temperatur erreicht ist.
Kurz zum Ablauf des Programms:

  1. Es gibt 2 Taster für jeweils eine Heizschlange oben und eine Heizschlange unten. Sobald diese Auswahl getroffen wurde geht es zum nächsten Schritt.
  2. Gewünschte Temperatur via Poti einstellen.
  3. Countdown der heruntergezählt werden soll sobald der verbaute Sensor innerhalbe des Ofens die Temperatur misst.

Schritt 1 und 2 sind erledigt. Auch der Sensor läuft.
Ich habe dann kurz ein kleines Prototypen-Programm geschrieben welcher 1:1 dem entspricht was im gesamten Code steht um zu sehen wie das Programm arbeitet.
Dieses sieht wie folgt aus:

bool CounterGo = true;
unsigned long int intervall = 1000; // 1000ms
unsigned long int start;
int CounterPin = A0;
int CounterValue;

void setup()
{
Serial.begin(9600);
}

void loop()
{
//Einstellen der Temperatur
int PotiRead = analogRead(CounterPin);
CounterValue = map(PotiRead, 0, 1023, 0, 100);

if(CounterGo)
{
unsigned long currentMillis = millis();
  if(currentMillis - start >= intervall)
  {
    start = currentMillis;
      if(CounterValue > 0)
    {
      CounterValue--;
      Serial.print("CounterValue = ");
      Serial.println(CounterValue);
    }
  }
  
}

}

So hätte ich mir das vorgestellt das es funktonieren soll. Tut es aber leider nicht da im Seriellen Monitor lediglich der Wert der über das Poti eingestellt wurde, ausgegeben wird.
Kann mir bitte jemand helfen... Ich bin echt am verzweifeln.

Wäre super von euch.
LG

2

Das, was du ausgeben bekommst, ist völlig richtig und logisch.

Das Problem liegt in der grundsätzlichen Logik der Hardware. Was heißt, ein Poti ist nix anderes wie ein Regelbarer Widerstand. Was zur Folge hat, das der Wert sich nicht selbst verändert. Also du kannst damit dein alten Wert nicht erhöhen, sondern er behält den Wert der Stellung. Was zur Folge hat, das der Heizwert von 10 auf 40 springen kann, wenn die Stellung des Wertes dem entspricht.

Was den Wert selbst angeht. Den musst du eh errechnen. 0 = min Wert. 1023 = max Wert.
Irgendwas dazwischen = dein Wert. Was i.d.R. bedeutet du musst den Wert in einen %-Wert umrechnen, und dann deinen Wert dazu ims Verhältnis setzen.

Wenn du mein Rat willst, ich würde das Poti weglassen, und es gegen 2 Extra-Taster ersetzen.
Auf diese würde ich PLUS + MINUS schreiben.

Wenn Taster "Heizschlange oben" gedrückt wird, würde ich eine Markierung im Display machen, das "Heizschlange oben" ausgewählt wurde. Nun den aktuellen Wert von "Heizschlange oben" nehmen, und bei Druck auf PLUS den Wert um "was auch immer" erhöhen, und bei Druck auf MINUS halt senken.

Wenn der Wert erhalten bleiben sollte, würde ich ein temporären Timer programmieren, und nach Zeit x den neuen Wert in das EEprom speichern, falls der MC ein hat.

Leider hast du nicht geschrieben was für ein MC(Board) du hast.

Es gibt mit Sicherheit auch andere Hardware mit der man das Lösen kann. Aber das ist in meinen Augen die Preiswerteste Lösung.

Kleiner Tipp am Rande. Ich habe etwas sehr Ähnliches Mal gebaut und dazu eine Membranentastatur zum Aufkleben genutzt. Diese Tastatur würde bei deinem Problem vieles erleichtern.
So was meine ich .
https://www.amazon.de/DollaTek-Universial-Schlüsselschalter-Tastatur-Arduino/dp/B07DK57KVM

Gibt es auch mit 4er + 12er Feld. Andere fallen mir momentan nicht ein, gibt es aber sicher auch.

Du kannst mit einem selbsterstellten Aufkleber dir selbst das/die Feld beschriften.
In dem Falle würde ich einfach ein Feld machen "oben +" und darauf reagieren.
Ein zusätzliches Feld "Speichern" würde bei Druck halt die Daten in das EEprom speichern.
Das spart dir den Timer. Und es gibt eine Libs für das Teil. Was dir die Abfrage sehr erleichtern würde.

Um Strom zu sparen, würde ich eine Taste als Schalter programmieren, und sie "Display an/aus" beschriften. Damit schalte ich bei dem LED die BLACKLIGHT-Funktion an/aus.

Bei meinem Projekt habe ich sogar eine Menu-Taste gemacht, die andere Funktionen aufruft.

Ich hoffe, ich konnte dir helfen.

Gruß

Pucki
3

@Puki: Macht er doch mit der Map-Funktion. Und nein, er braucht kein Tastenfeld , odertaster um die Haltezeit des Ofens einzustellen. Das geht problemlos mit dem Potiund der richtigen Programmierung.
@fabiwxyz Das Problem liegt daran, dass Du CounterValue in jedem Loopdurchgang wieder auf den, der Potistellung entsprechenden Wert setzt, aber in jedem Intervall versuchst, den CounterValue runter zu zählen, was natürlich durch das ständige neu besetzen mit der Potistellung nicht so funktionieren kann, wie Du das möchtest.
Natürlich kannst Du das Poti nutzen, um die abzulaufende Zeit einzustellen, nur darf er das Poti dann NUR einlesen, wenn der Ofen die Temp das Erste mal erreicht hat. Da muss er dann einen Merker setzen, damit das Program ab nun den Timer überwacht und bei erreichen von 0 den Ofen abschalten.

4

@fabiwxyz Wenn Du ausführlichere Hilfe Benötigst. solltest Du deinen gesammten Sketc, also auch die restliche Steuerung des Ofens hier in codeTags hochladen, damit wir auch alle verwendeten Variablen, sowie die benutzen Ein- und Ausgänge sehen können, weil es sonst sehr schwierig wird, Code Empfehlungen zu geben, ohne das dann bei Dir konflikte und fehler beim Kompilieren auftreten. BEnenn uns auch noch, mit welchem Arduino du das machst und eventuelle weitere Hardware, die am Arduino angeschlossen ist. Bedenke, wir können nicht sehen, was Du da alles hast.

5

@Puki: sorry, dass ich da kurz gegen Dich geschossen habe, aber fabiwxyz hat nicht danach gefragt, wie er das Problem mit dem Countdoun mit anderen Eingabekomponenten lösen kann, sondern wie er Das mit dem Poti machen muss. Wenn Dich jemand fragt. wie er am besten mit dem Auto von Frankfurt nach Berlin kommt , erzählst Du ihm sicher auch nicht, er soll in den Flieger nach New York steigen.

6

Richtig

ABER :wink: Das war keine theoretische Frage, sondern ein Gedanke für ein Realer Projekt.
Und da gibt eine Tastatur viel mehr Möglichkeiten.
Davon abgesehen hat er ja bereits Tasten im Einsatz. Also sollte er einfach nur das Tastenfeld erweitern.

Das hätte 3 Vorteile.

  1. Viel saubere Einstellung der Werte. Wer schonmal versucht hat, mit ein Poti sauber scharf einzustellen weiß was ich meine.

  2. Allein die Tatsache, dass er eine Einstellung braucht, lässt darauf schließen, dass er mehre Möglichkeiten der Einstellung braucht.
    Diese kann er in Schritt 2 dann ganz einfach dauerhaft speichern mit der Tastatur, und logoweis auch abrufen.

  3. Die Programmierung ist einfacher, die Tastatur kostet weniger als 2 Euro.

Ich denke einfach, dass man eine TO der hier Fragen stellt, auch mal Alternativen aufzeigen sollte. Besonders dann, wenn diese einen zu niedrigeren Kosten wesentlich bessere Möglichkeiten bieten.

Gruß

Pucki

7

Widerspruch meine Ehren :wink:
Man muss nur passenden Poti nehmen.
Potentiometer haben in seiner Bezeichnung nicht nur den R Wert und W Wert sondern es ist noch ein Buchstaben drauf A oder B (zB. 10k, 0,25W A) manchmal auch C (mittlerweile sehr selten)
Die Buchstaben bedeuten:

A Der Widerstand ändert sich Logarithmisch (Im Radio als Lautsterkeregler genutzt)
B Der Widerstand ändert sich Lineal
Die B Potis sind für unsere zwecke besser geeignet == leichter einzustellen.

Alles zum Nachlesen bei Wikipedia und nicht nur :slight_smile:
Noch eine Bemerkung, die Zusatzbuchstabenbedeutung hat sich mit der Zeit geändert.

8

Bitte setze Dein Programm in #1 in Code-Tags, damit es lesbar wird.

Eventuell hilft Dir meine Anleitung: Endlicher Automat mit millis() .

9

Ein weiterer Vorschlag:
Wenn du etwas zum "Drehen" haben möchtest, um deine Einstellungen zu ändern, kannst du auch über einen Drehimpulsegeber nachdenken. Damit lassen sich Einstellungen sehr präzise durchführen.

10

Danke für dir Nachricht. Ich habe mir schon gedacht das der Wert im loop ständig überschrieben wird. Ich schicke euch mal den ganzen Sktech.

11 
#include <LCD_I2C.h>
LCD_I2C LCD1(0x27, 20, 4);

//Taster für Heizschlangen unten
const int Taster_Heizschlangen_unten = 50;
int tasterStatus = HIGH;    
int Tasterzaehler = 0;      
bool LEDSTATUS = false; 
int entprellZeit = 100;                     //Hier wird die Zeit die entprellt wird eingestellt. 
unsigned long tasterZeit = 0;               //Hier wird die Zeit in ms abgespei
int LCD_Variable_HeizenOben_1 = 0;

//Taster für Heizschlangen oben
const int Taster_Heizschlangen_oben = 48;
int tasterStatus_1 = HIGH;    
int Tasterzaehler_1 = 0;      
bool LEDSTATUS_1 = false; 
int entprellZeit_1 = 100;                     //Hier wird die Zeit die entprellt wird eingestellt. 
unsigned long tasterZeit_1 = 0;               //Hier wird die Zeit in ms abgespeichert
int LCD_Variable_HeizenUnten = 0;

//Temperatursimulation
int Heizen = A7;
int Heizen_MIN = 0;
int Heizen_MAX = 400;
int HeizenState;
int HeizenValue; //Müsste eigentlich der Mittelwert aus den Sensorwerten sein

//Counter-Poti Parameter
int CounterValue;
int CounterState;
bool CounterStarted = false;
int Poti_Counter_MIN = 0;
int Poti_Counter_MAX = 120;

//Temperatur-Poti Parameter
int TemperaturValue;
int TemperaturState;
int Poti_Temperatur_MIN = 100;
int Poti_Temperatur_MAX = 400;

//"Relaisausgaenge"
int Heizschlange_KF1 = 6;
int Heizschlange_KF2 = 32;
int Heizschlange_KF3 = 33;
int Heizschlange_KF4 = 7;
int Heizschlange_KF5 = 34;
int Luefter_oben = 9;
int Luefter_unten = 8;
int Summer = 28;

//Funktionsvariablen 
int selectedHeater = 0; //0 fuer untere Heizschlangen, 1 fuer obere Heizschlangen. Wenn beide angewaehlt Wert = 3
bool HeizschlangenStatus = false;
bool CounterGO = false;
long unsigned int start;
long unsigned int intervall = 1000; // 1 Sekunde = "delay"



void setup()
{
  LCD1.begin();
  LCD1.backlight();
  Serial.begin(9600);
  pinMode(Heizschlange_KF1, OUTPUT);
  pinMode(Heizschlange_KF2, OUTPUT);
  pinMode(Heizschlange_KF3, OUTPUT);
  pinMode(Heizschlange_KF4, OUTPUT);
  pinMode(Heizschlange_KF5, OUTPUT);
  pinMode(Luefter_oben, OUTPUT);
  pinMode(Luefter_unten, OUTPUT);
  pinMode(Summer, OUTPUT);
  pinMode(Taster_Heizschlangen_oben, INPUT_PULLUP);
  pinMode(Taster_Heizschlangen_unten, INPUT_PULLUP);
}

void loop()
{
  //*******************************************Einschalten der Luefter im Einschaltmoment der Steuerung**************************
  digitalWrite(Luefter_oben, HIGH);
  digitalWrite(Luefter_unten, HIGH);
  //*****************************************************************************************************************************

  //********************************************************Tasterabfrage fuer Taster Heizschlagen oben**************************
 tasterStatus_1 = digitalRead(Taster_Heizschlangen_oben);
  
  if(tasterStatus_1 == LOW)
  {
    tasterZeit_1 = millis();
    Tasterzaehler_1 = 1;
  }
    if ((millis() - tasterZeit_1 > entprellZeit_1) && Tasterzaehler_1 == 1)
    {
      LEDSTATUS_1 = !LEDSTATUS_1;
      Tasterzaehler_1 = 0;
    }

      if(LEDSTATUS_1 == true)
      {
        selectedHeater = 1; //Oberen Heizschlangen angewaehlt
        LCD_Variable_HeizenOben_1 = 1;
        digitalWrite(Heizschlange_KF1, HIGH);
        digitalWrite(Heizschlange_KF2, HIGH);
      }
      else
      {
        LCD_Variable_HeizenOben_1 = 0;
        digitalWrite(Heizschlange_KF1, LOW);
        digitalWrite(Heizschlange_KF2, LOW);
      }

  //************************************************************Heizschlangen unten**********************************************FERTIG!!!!!!
  tasterStatus = digitalRead(Taster_Heizschlangen_unten);
  
  if(tasterStatus == LOW)
  {
    tasterZeit = millis();
    Tasterzaehler = 1;
  }
    if ((millis() - tasterZeit > entprellZeit) && Tasterzaehler == 1)
    {
      LEDSTATUS = !LEDSTATUS;
      Tasterzaehler = 0;
    }

      if(LEDSTATUS == true)
      {
        selectedHeater = 2; //Untere Heizschlangen angewaehlt
        LCD_Variable_HeizenUnten = 1;
        digitalWrite(Heizschlange_KF5, HIGH);
        digitalWrite(Heizschlange_KF4, HIGH);
        digitalWrite(Heizschlange_KF3, HIGH);
      }
      else
      {
    
        LCD_Variable_HeizenUnten = 0;
        digitalWrite(Heizschlange_KF5, LOW);
        digitalWrite(Heizschlange_KF4, LOW);
        digitalWrite(Heizschlange_KF3, LOW);
      }
    //******************************************************************************************************************************
   



    //******************************************************Verweis auf Funktion je nach Auswahl der Heizschlangen******************

    	if (LEDSTATUS && LEDSTATUS_1) // Bedingung wenn beide Taster betätigt wurden.
      {
        selectedHeater = 3; 
        Temperaturstabilisierung_both(); // Fertig
      }

      else if (LEDSTATUS)  // Bedingung wenn Heizschlangen unten angewählt wurden
      {
       selectedHeater = 1;
       Temperaturstabilisierung_unten(); // Fertig
      } 

      else if (LEDSTATUS_1) 
      {
      selectedHeater = 2; // Bedingung wenn Heizschlangenoben angewählt wurden
      Temperaturstabilisierung_oben();
      } 

      else // Bedingung wenn kein taster betätigt wurde
      {
       selectedHeater = 0;
      }

  //Potiabfrage für Counter
  CounterState = analogRead(A0);
  CounterValue = map(CounterState, 0, 1023, Poti_Counter_MIN, Poti_Counter_MAX  );

  //Potiabfrage für Temperatur
  TemperaturState = analogRead(A1);
  TemperaturValue = map(TemperaturState, 0, 1023, Poti_Temperatur_MIN, Poti_Temperatur_MAX);

  //Simulation Heizschlange mit Poti 
  HeizenState = analogRead(A7);
  HeizenValue = map(HeizenState, 0, 1023, Heizen_MIN, Heizen_MAX);
  Serial.print("Temperatur =");
  Serial.println(HeizenValue);

  //*********************************************************Verweis auf LCD-Funktion************************************************
  updateLCD();
  //*********************************************************************************************************************************



  //*********************************************************Verweis auf TimerFunction sobald die eingestellte Temperatur erreich wurde*******
  if(CounterGO)
  {
    unsigned long currentMillis = millis();  // Aktuelle Zeit abrufen

    if(currentMillis - start >= intervall) // Intervall = 1 Sekunde.
    {
      start = currentMillis;
       if(CounterValue > 0)
      {
        CounterValue--;
        Serial.print("CounterValue");
        Serial.println(CounterValue);
      }
    }
  }
  //*****************************************************************************************************************************************



}//Loop geschlossen




  /*currentMillis wird initalisiert und bekommt im Moment der initialisierung den Wert aus millis(). Dadurch das aber millis logischerweise im Startmoment = 0 ist, hat die Variable currentMillis auch den Wert = 0.
  innerhalb der if-Abfrage wird dann die Startzeit (currentMillis) - der letzten Zeit abgezogen. Beim ersten durchlauf ergibt das also 0-0 = 0 (if-Abfrage nicht erfüllt). Jetzt wird vor der if-Abfrage solange gewartet (1000ms)
  bis currentMillis > als intervall ist. Das bedeutet die if-Abfrage ist somit true. Innerhalb der if-Abfrage wird der Wert von currentMillis an start übergeben. Das bedeutet also das start nun den Wert 1000 hat. Da ja die 
  if-Abfrage erst true war wenn der intervall >= der Berechnung war. Im nächsten Durchlauf passiert nun das selbe. Der wird von currentMillis wird wieder auf 0 gesetzt und die if-Abfrage ist erst dann true wenn 1000ms vergangen
  sind. Somit wird statt einem delay(1000); bei dem das Programm stehen bleibt übergangen. Kurz gesagt ist die Variable intervall gleich dein delay() denn man normalerweise eintellt.*/


//********************************************************Fertig*********************************************************************
void Temperaturstabilisierung_oben()
{
  if(HeizenValue < TemperaturValue && !HeizschlangenStatus)
    {                               
        HeizschlangenStatus = true;
    }

    else if(HeizenValue >= TemperaturValue && HeizschlangenStatus) 
    {
      HeizschlangenStatus = false;
      CounterGO = true;
    }

    if(HeizschlangenStatus == true)
    {
        digitalWrite(Heizschlange_KF1, HIGH);
        digitalWrite(Heizschlange_KF2, HIGH);
    }

    if(HeizschlangenStatus == false)
    {
        digitalWrite(Heizschlange_KF1, LOW);
        digitalWrite(Heizschlange_KF2, LOW);
    }
}
//********************************************************************************************************************************

//********************************************************Fertig****************************************************************
void Temperaturstabilisierung_unten()
{
  if(HeizenValue < TemperaturValue && !HeizschlangenStatus)
    {                                                
        HeizschlangenStatus = true;
    }

    else if(HeizenValue >= TemperaturValue && HeizschlangenStatus) 
    {
      HeizschlangenStatus = false;
      CounterGO = true;
    }

    if(HeizschlangenStatus == true)
    {
        digitalWrite(Heizschlange_KF5, HIGH);
        digitalWrite(Heizschlange_KF4, HIGH);
        digitalWrite(Heizschlange_KF3, HIGH);
    }

    if(HeizschlangenStatus == false)
    {
        digitalWrite(Heizschlange_KF5, LOW);
        digitalWrite(Heizschlange_KF4, LOW);
        digitalWrite(Heizschlange_KF3, LOW);
    }
}
//********************************************************************************************************************************

//********************************************************Fertig****************************************************************
void Temperaturstabilisierung_both() 
{
    if(HeizenValue < TemperaturValue && !HeizschlangenStatus)
    {                                                
        HeizschlangenStatus = true;
    }

    else if(HeizenValue >= TemperaturValue && HeizschlangenStatus) 
    {
      HeizschlangenStatus = false;
      CounterGO = true;
    }

    if(HeizschlangenStatus == true)
    {
        digitalWrite(Heizschlange_KF5, HIGH);
        digitalWrite(Heizschlange_KF4, HIGH);
        digitalWrite(Heizschlange_KF3, HIGH);
        digitalWrite(Heizschlange_KF2, HIGH);
        digitalWrite(Heizschlange_KF1, HIGH);
    }

    if(HeizschlangenStatus == false)
    {
        digitalWrite(Heizschlange_KF5, LOW);
        digitalWrite(Heizschlange_KF4, LOW);
        digitalWrite(Heizschlange_KF3, LOW);
        digitalWrite(Heizschlange_KF2, LOW);
        digitalWrite(Heizschlange_KF1, LOW);
    }
}
//********************************************************************************************************************************


void updateLCD()
{
  delay(500);
  switch(10*LCD_Variable_HeizenUnten + 1*LCD_Variable_HeizenOben_1 )
  {
    case 11:LCD1.clear();
             LCD1.setCursor(0,0);
             LCD1.print("Counter = ");
             LCD1.print(CounterValue);
             LCD1.setCursor(13,0);
             LCD1.print("Minuten");
             LCD1.setCursor(0,1);
             LCD1.print("Temperatur =");
             LCD1.setCursor(13,1);
             LCD1.print(TemperaturValue);
             LCD1.setCursor(0,2);
             LCD1.print("Heizen oben = EIN");
             LCD1.setCursor(0,3);
             LCD1.print("Heizen unten EIN");
            
    break;

    case 10: LCD1.clear();
             LCD1.setCursor(0,0);
             LCD1.print("Counter = ");
             LCD1.print(CounterValue);
             LCD1.setCursor(13,0);
             LCD1.print("Minuten");
             LCD1.setCursor(0,1);
             LCD1.print("Temperatur =");
             LCD1.setCursor(13,1);
             LCD1.print(TemperaturValue);
             LCD1.setCursor(0,2);
             LCD1.print("Heizen oben = AUS");
             LCD1.setCursor(0,3);
             LCD1.print("Heizen unten EIN");
             
    break;

    case 1: LCD1.clear();
             LCD1.setCursor(0,0);
             LCD1.print("Counter = ");
             LCD1.print(CounterValue);
             LCD1.setCursor(13,0);
             LCD1.print("Minuten");
             LCD1.setCursor(0,1);
             LCD1.print("Temperatur =");
             LCD1.setCursor(13,1);
             LCD1.print(TemperaturValue);
             LCD1.setCursor(0,2);
             LCD1.print("Heizen oben = EIN");
             LCD1.setCursor(0,3);
             LCD1.print("Heizen unten AUS");
           
    break;

    default: LCD1.clear();
             LCD1.setCursor(0,0);
             LCD1.print("Counter = ");
             LCD1.print(CounterValue);
             LCD1.setCursor(13,0);
             LCD1.print("Minuten");
             LCD1.setCursor(0,1);
             LCD1.print("Temperatur =");
             LCD1.setCursor(13,1);
             LCD1.print(TemperaturValue);
             LCD1.setCursor(0,2);
             LCD1.print("Heizen oben = AUS");
             LCD1.setCursor(0,3);
             LCD1.print("Heizen unten AUS");
            
    break;       
  }
}

Falls ihr euch wundern solltet wo die Temperatur gemessen wird, einfach nicht beachten. Der steckt noch in einem anderen Teil. Stattdessen habe ich ganz einfach die Variable "HeizenValue" verwendet um die Temperatur innerhalb des Ofens schneller simulieren zu könne. Und das funktioniert auch so. Verwendet wird im übrigen der Arduino Mega 2560. Bei Fragen einfach kommentieren. Ich versuche schnellstmöglich darauf zu reagieren.
Danke im Vorraus!

12

Du solltest z.B. deinen Sketch in Code-Tags posten. Das kannst du auch noch nachträglich ändern.
Sketch markieren und die Schaltfläche "< code >" klicken. Dann wird dieser besser lesbar.

13

Ebengenau NICHT. Genau diise Tatsache sagt das nicht aus. Die Temperatureinstellung kann ja z-B. bereits im Ofen eingebaut sein, und er braucht nur noch den Timer, um die benötigte 'Back-Zeit nach erreichen der soll Temperatur' einstellen zu können. der TO hat nur vom CauntDown gesprochen, dass er den Aufm LCD anzeigen und mit dem Poti einstellen will. Er hat überhaupt nichts davon gesagt, dass er noch mehrere andere einstellungen da machen will. Zudem: Im gegensatz zu ner Tastatur benötigt ein Poti keine Speicherung des eingestellten Wertes, denn das ist da ja konstruktionsbedingt bereits im Poti mit eingebaut. Dazu kommt; Wenn das Poti Richtig gewählt ist, keine all zu grosse Wert(hier Zeit-)-Spanne benötigt wird , oder bei grösserer Zeit-Spanne keine Sekunden-Auflösung nötig ist, dann ist ein Pote mehr als getechfertigt. Und benötigt Flächen-Mässig noch sehr viel weniger Platz als ne Tastatur.
Zu deinem 3. Argument: das einlesen eines Analogwertes ist sicher nicht unbedingt komplizierter in der PRogrammierung als das Einlesen , auswerten zu einem gesamtwert zusammenfügen und anschliessender speicherung des Wertes bei einer Folientastatur.. Du kannst mir das sonst gerne mit einem Beispielsketch zeigen, wie viel einfacher dies mit ner Tastatur im gegensatz zu nem Poti zu programieren ist.

14

Da wäre ich mir bei Pucki007 nicht sicher.

Gruß Tommy

1 Like
15

Ich wollte hier keine große Diskussion beginnen :joy: aber freut mich das ihr so engagiert seid!
Kann mir jemand trotz allem vielleicht eine Lösung vorschlagen für mein Problem.
@all ich habe den Poti zur Bestimmung des CounterValue bereits verbaut. Was darauf hinweisen sollte das ich Hardwaretechnisch keine Änderung mehr vornehmen möchte.. ich bin der Meinung das es für alles eine Lösung gibt. Nur bin ich mittlerweile an meine Grenzen gekommen..

16

Hallo fabiwxyz, ja, ich lade mir Deinen Sketch in die IDE runter und schaue mir das mit Deinem Countdown an. Meine kurze Beschreibung, wie es klappt war anscheinend etwas zu knapp gehalten, um Dir ausreichend zu helfen. Ich setz mich Jetzt gleich ran, bin aber echt nicht grade der schnellste Coder, weiss aber im Prinzip schon, wie sowas zu lösen ist, Ach Ja, mit welchem Arduino machst Du das? Damit ich es , falls nötig kurz nachbauen kann zum testen, wegen Positionierung auf dem Display usw.

17

Ist mir bekannt sogar. Aber bei seinen Problem ändere ich meine Meinung nicht. Weil es einfach zu unpraktisch ist, hier überhaupt mit ein Poti zu arbeiten.

Ich stimme aber @HotSystems zu. Ein Drehimpulsgeber (**EDIT:**ich muss man ein paar Sachen bei meiner neuen Rechtschreibkorrektur überwachen, Danke für den Hinweis:) wäre eine Alternative wenn man unbedingt ein Knöpfchen zum Spielen braucht. :wink:

Eben NICHT. Das geht aus der Beschreibung des TO klar hervor. Er will ja die 2 Heizungen einzeln regulieren.

Und selbst wenn du recht haben solltest. Eine Regelung braucht man nur wenn es was zu regeln gibt. Und das ist nur der Fall wenn man mehre Unterschiedliche Arbeiten mit den Gerät verrichtet.
Ist genau so wie meine Heißluftfriteuse. Die vorgebenene Werte für Fritten und Grillhähnchen sind schlicht und ergreifend Mist. Ich kann zwar Temperatur und Zeit manuell einstellen aber NICHT die vorgebenen Werte überschreiben. Ergo, hängt am Kühlschrank ein 1-Euro-Whiteboard damit ich mir die passenden Werte aufschreiben kann.

Und mein "erweiterter" Vorschlag war nur das er für gewisses Materie die idealen Werte (die er vermutlich mit Tests heraus gefunden hat) permanent abspeichern kann.
Wozu hat man ein EEprom wenn man es nicht nutzt. Hat man doch immerhin mit bezahlt. :wink:

Gruß

Pucki

18

Aua! Der ist ja noch schlimmer, als das Poti. Außerdem hat @HotSystems dieses Bauteil nie erwähnt.

Gruß Tommy

19

Wow super da freue ich mich. Ich Verwende einen Arduino Mega 2560. Soll ich dir ein wiring Diagram schicken?

20

Dann stellt sich die Frage nach den Buchstaben des Poti. (Siehe Beitrag von Fony an mich).

Wenn es aber unbedingt sein soll dann mache folgendes.

Wähle mit einer Taste Heizung OBEN bzw. Heizung UNTEN.
Dann lese den aktuellen Wert aus, und schreibe folgendes ins Display (ich gehe von ein 2 x 16 aus)
Zeile 1:
"Heizung Oben (bzw. Heizung unten)."
Zeile 2: "Alt W. : alt Akt. Wert : yy

Wobei:
ALT = aktueller SPEICHER-Wert der Heizung ist
YY = Neuer Heizwert, der der aktuelle aufgrund der Stellung des Poti berechnete Wert ist.

Eine 2 Taste (oder Langzeitdruck) übernimmt dann den neuen Heizwert wenn du ihn fertig eingestellt hast, in den Festspeicher.
Festspeicher (EEprom) ist expliziert wichtig, da du bei den winzigsten Stromhusten schon ein Stromausfall hast und die Einstellungen dann verlierst.

Stromhusten = Netzausfall für weniger als 1 Sekunde. Erkennt man wenn eine echte Glühbirne flackert. Und der PC abstürzt, ohne Fehlermeldung.

Deshalb nach den Starten in die Setup-Routine einfach die gespeicherten Werte auslesen und setzen und alles ist gut.

Gruß

Pucki