Go Down

Topic: Progress Bar Problem (Read 3447 times) previous topic - next topic

dony

#30
Jan 30, 2018, 10:29 pm Last Edit: Jan 30, 2018, 10:36 pm by dony
Hast du die Zeile eingefügt?
Code: [Select]
aktuellerWert = neuerWert;
Hab ich leider vergessen.
lg
edit: Ich arbeite daran...
edit2: so ich habs, Variablen vertauscht, definier das oben so:
Code: [Select]

int minWert = 50;
int maxWert = 800;
int neuerWert = 400;
int aktuellerWert; // Damit wird gearbeitet.^^
Grüße, Donny

dony

#31
Jan 30, 2018, 10:47 pm Last Edit: Jan 30, 2018, 11:03 pm by dony
Der Übersichtswillen, hier nocheinmal der komplette Code:
agmue's for Schleife ist drinnen aber in /* */.
Aber wie agmue schon gesagt hat, kommt es auch auf die Library an.
Code: [Select]
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Variablen definieren
const uint16_t minWert = 50;
const uint16_t maxWert = 800;
uint16_t neuerWert = 268;
uint16_t aktuellerWert;
 
  const int LCD_NB_ROWS = 4 ;
  const int LCD_NB_COLUMNS = 20 ;
 
  LiquidCrystal_I2C lcd(0x27, 20,4);

  byte START_DIV_0_OF_1 [ 8 ] = {
  B01111 ,
  B11000 ,
  B10000 ,
  B10000 ,
  B10000 ,
  B10000 ,
  B11000 ,
  B01111
  };  // Char start 0/1

  byte START_DIV_1_OF_1 [ 8 ] = {
  B01111 ,
  B11000 ,
  B10011 ,
  B10111 ,
  B10111 ,
  B10011 ,
  B11000 ,
  B01111
  };  // Tank beginning 1/1

  byte DIV_0_OF_2 [ 8 ] = {
  B11111 ,
  B00000 ,
  B00000 ,
  B00000 ,
  B00000 ,
  B00000 ,
  B00000 ,
  B11111
  };  // Medium tank 0/2

  byte DIV_1_OF_2 [ 8 ] = {
  B11111 ,
  B00000 ,
  B11000 ,
  B11000 ,
  B11000 ,
  B11000 ,
  B00000 ,
  B11111
  };  // Medium tank 1/2

  byte DIV_2_OF_2 [ 8 ] = {
  B11111 ,
  B00000 ,
  B11011 ,
  B11011 ,
  B11011 ,
  B11011 ,
  B00000 ,
  B11111
  };  // Medium tank 2/2

  byte END_DIV_0_OF_1 [ 8 ] = {
  B11110 ,
  B00011 ,
  B00001 ,
  B00001 ,
  B00001 ,
  B00001 ,
  B00011 ,
  B11110
  };  // late tank 0/1

  byte END_DIV_1_OF_1 [ 8 ] = {
  B11110 ,
  B00011 ,
  B11001 ,
  B11101 ,
  B11101 ,
  B11001 ,
  B00011 ,
  B11110
  };  // Char end 1/1

 void setup_progressbar() {


  lcd.createChar(0, START_DIV_0_OF_1);
  lcd.createChar(1, START_DIV_1_OF_1);
  lcd.createChar(2, DIV_0_OF_2);
  lcd.createChar(3, DIV_1_OF_2);
  lcd.createChar(4, DIV_2_OF_2);
  lcd.createChar(5, END_DIV_0_OF_1);
  lcd.createChar(6, END_DIV_1_OF_1);
}

void draw_progressbar(byte lcdwert) {


  lcd.setCursor(0, 0);
  lcd.print(lcdwert);
  lcd.print(" %  ");

  lcd.setCursor(0, 1);


 // byte nb_columns = map(lcdwert, 0, 100, 0, LCD_NB_COLUMNS * 2 - 2);
   byte nb_columns = map(lcdwert, 0, 100, 0, LCD_NB_COLUMNS * 2 - 2);
  // Chaque caractére affiche 2 barres verticales, mais le premier et dernier caractére n'en affiche qu'une.


  for (byte i = 0; i < LCD_NB_COLUMNS; ++i) {

    if (i == 0) { // Premiére case
 

      if (nb_columns > 0) {
        lcd.write(1); // Char début 1 / 1
        nb_columns -= 1;
 
      } else {
        lcd.write((byte) 0); // Char début 0 / 1
      }
 
    } else if (i == LCD_NB_COLUMNS -1) { // Derniére case
 

      if (nb_columns > 0) {
        lcd.write(6); // Char fin 1 / 1
 
      } else {
        lcd.write(5); // Char fin 0 / 1
      }
 
    } else { // Autres cases
 

      if (nb_columns >= 2) {
        lcd.write(4); // Char div 2 / 2
        nb_columns -= 2;
 
      } else if (nb_columns == 1) {
        lcd.write(3); // Char div 1 / 2
        nb_columns -= 1;
 
      } else {
        lcd.write(2); // Char div 0 / 2
      }
    }
  }
}

void setup(){
  //lcd.begin(20, 4);
  lcd.init();
  lcd.backlight();

  setup_progressbar();
  lcd.clear();
}
void loop(){

/* * if Abfrage by dony * */
  if(aktuellerWert != neuerWert) {  // Wenn ein neuer Wert kommt, Progress Bar ändern
    aktuellerWert = neuerWert;
    draw_progressbar(aktuellerWert/(maxWert/100));
    // Ob und was da steht ist Geschmackssache
    lcd.setCursor(0, 2);
    lcd.print(minWert );
    lcd.setCursor(15, 2);
    lcd.print(maxWert);
    lcd.setCursor(0, 3);
    lcd.print("Wert: ");
    lcd.print(aktuellerWert);
}

/* * for Schleife by agmue * */
/* 
  for (uint16_t zahl = 0; zahl <= 5000; zahl += 10)
  {
    byte lcdwert = zahl / 50;
    draw_progressbar(lcdwert);
    lcd.setCursor(0, 2);
    lcd.print("Wert: ");
    lcd.print(zahl);
    lcd.print("   ");
    delay(100);
  }
  */
  delay(5000);  // Diese lange Wartezeit ist nur da, damit das Bild nicht x mal pro Sekunde neu aufgebau wird <- gehört raus.
}

lg dony
Quote
Alles OK
Freut mich! Den BarGraph kann ich auch ganz gut gebrauchen, daher kommt der Dank auch von mir.  ;)
Grüße, Donny

TSW68

Super so sollte es sein .

Vielen Dank an alle die hier im Thema so hart gearbeitet haben.

spitze super sache

Bis die Tage keine frage !  :D

dony

#33
Jan 30, 2018, 11:43 pm Last Edit: Jan 31, 2018, 05:42 am by dony
Achtung!

Ganz so einfach ist es dann doch nicht, da du auch einen minWert hast, muss das bei der Prozent Berrechnung berücksichtigt werden.
50-----|----800
       400 != 50% es sind nur 46%

Da Jeder eine andere lib verwendet, es sind nur 3 Zeilen die geändert werden müssen. Die min, max, wert Variablen müssen allerdings definiert sein (siehe letzten Code von mir).
edit: Ich habe noch zwei Abfragen eingebaut bzgl. des lcdwert reingeschrieben.
Code: [Select]
void draw_progressbar(uint16_t lcdwert) { // den aktuellenWert übergeben, nicht die Prozent
  if((minWert >= maxWert) || !maxWert) { return false; }  // Abfrage ob die Werte kein Blödsinn sind.
  if(minWert > lcdwert || maxWert < lcdwert) { return false; }  // Abfrage ob der lcdwert im Bereich ist
/*   in der loop   */
  lcdwert = map(lcdwert, minWert, maxWert, 0, 100); // ausrechnen der Prozent

byte ist zu klein für den richtigen Wert (zB.: 400).
Natürlich muss beim Funktionsaufruf der wirkliche Wert anstelle der Prozent übergeben werden.
Code: [Select]
draw_progressbar(aktuellerWert); // einfach nur den Wert übergeben, nicht die %
So, jetzt ist es hoffentlich Perfekt. Wer bei 0 beginnen will, einfach den minWert ändern.

lg dony
Nachtrag: Mit der for Schleife sieht man das viel schöner.
Code: [Select]
for (neuerWert = minWert; neuerWert <= maxWert; neuerWert += 5) {
  if(aktuellerWert != neuerWert) {  // Wenn ein neuer Wert kommt, Progress Bar ändern
    aktuellerWert = neuerWert;
    draw_progressbar(aktuellerWert); // einfach nur den Wert übergeben, nicht die %

    lcd.setCursor(0, 2); // Das gehört eigentlich ins Setup <----
    lcd.print(minWert );
    lcd.setCursor(16, 2);
    lcd.print(maxWert); // bis hierher ------->

    lcd.setCursor(0, 3);
    lcd.print("Wert: ");
    lcd.print(aktuellerWert);
  }
  delay(300);  // damit sich die Leiste nicht so schnell aufbaut
}
Grüße, Donny

TSW68

#34
Feb 02, 2018, 09:52 am Last Edit: Feb 02, 2018, 09:58 am by TSW68
Hallöchen,

habe da noch eine frage wie man denn wert der Progress Bar Speichert ( EEPROM )
Ich verwende die Progress Bar ja zum einstellen eines wertes.
Der eingestellte wert endert sich dann ja um Plus,Minus eingestellter wert.
Wenn Ich meinen Anduino aus uns wider ein schalte soll der eingestellte wert wider da sein.

Der wert liegt bei mir immer zwischen 50 - 800

hab im internet das hier gefunden weiss aber nicht wo und wie ich es einbinde.


Schreiben :

Code: [Select]
void EEPROMWritelong ( int address , long value )
{
//Decomposition from a long to 4 bytes by using bitshift.
//One = Most significant -> Four = Least significant byte
byte four = ( value & 0xFF ) ;
byte three = ( ( value >> 8 ) & 0xFF ) ;
byte two = ( ( value >> 16 ) & 0xFF ) ;
byte one = ( ( value >> 24 ) & 0xFF ) ;

//Write the 4 bytes into the eeprom memory.
EEPROM. write ( address , four ) ;
EEPROM. write ( address + 1 , three ) ;
EEPROM. write ( address + 2 , two ) ;
EEPROM. write ( address + 3 , one ) ;
}



Lesen ;

Code: [Select]
long EEPROMReadlong ( long address )
{
//Read the 4 bytes from the eeprom memory.
long four = EEPROM. read ( address ) ;
long three = EEPROM. read ( address + 1 ) ;
long two = EEPROM. read ( address + 2 ) ;
long one = EEPROM. read ( address + 3 ) ;

//Return the recomposed long by using bitshift.
return ( ( four << 0 ) & 0xFF ) + ( ( three << 8 ) & 0xFFFF ) + ( ( two << 16 ) & 0xFFFFFF ) + ( ( one << 24 ) & 0xFFFFFFFF ) ;
}




Nachtrag !!

Verwende immoment Die Progress Bar

Code: [Select]
// *********************************************************************
void balken_value_klein(uint8_t line)
// *********************************************************************
{

byte balken5[8] = {B11011,B00000,B10000,B10000,B10000,B10000,B00000,B11011};   

byte balken6[8] = {B11011,B00000,B11000,B11000,B11000,B11000,B00000,B11011};   

byte balken7[8] = {B11011,B00000,B11100,B11100,B11100,B11100,B00000,B11011};

byte balken8[8] = {B11011,B00000,B11110,B11110,B11110,B11110,B00000,B11011};

byte balken9[8] = {B11011,B00000,B11111,B11111,B11111,B11111,B00000,B11011};

byte balken10[8] = {B11011,B00000,B00000,B00000,B00000,B00000,B00000,B11011};

byte balken11[8] = {B00001,B00010,B00010,B00010,B00010,B00010,B00010,B00001};

byte balken12[8] = {B10000,B01000,B01000,B01000,B01000,B01000,B01000,B10000};
 
     lcd.createChar(0, balken5);
    lcd.createChar(1, balken6);
    lcd.createChar(2, balken7);
    lcd.createChar(3, balken8);
    lcd.createChar(4, balken9);
    lcd.createChar(5, balken10);
    lcd.createChar(6, balken11);
    lcd.createChar(7, balken12);

   lcd.setCursor(1, 2);               
   lcd.setCursor(3, 3);
   lcd.write((byte)5);
   lcd.write((byte)5);
   lcd.write((byte)5);
   lcd.write((byte)5);
   lcd.write((byte)5);
   lcd.write((byte)5);
   lcd.write((byte)5);
   lcd.write((byte)5);
   lcd.write((byte)5);
   lcd.write((byte)5);
   lcd.write((byte)7);
     
  // set Cursor to line   
  lcd.setCursor (0, line);
  // set Cursor symbol 
  if (line == LCDML.MENU_getCursorPos())
  {
    lcd.write(_LCDML_DISP_cfg_cursor);

    // Enter Button überprüfen
    if(LCDML.BT_checkAny())
    {
     
      if(LCDML.BT_checkLeft()) { // Füllmenge verkleiner in 50 ml Schritten

        if(g_FillValueSmall-schritte >= 50) { // Überprüfen ob eine Mindestmenge vorhanden ist (größer 50 ml)
         g_FillValueSmall -= schritte;
        } else {
          g_FillValueSmall = 50; // Ansonsten mindestmenge festlegen
        }
        LCDML.BT_resetLeft();
      }
      if(LCDML.BT_checkRight()) { // Füllmenge vergrößern in 50 ml Schritten

        if(g_FillValueSmall+schritte >= maximum_k+schritte) { // Überprüfen ob eine Maximale Menge festgelegt ist (kleiner 400 ml + Schritte)

        } else {
          g_FillValueSmall += schritte; // Maximale Menge setzen
        }

        LCDML.BT_resetRight();
      }
    }             
  }
  else
  {
    lcd.print(F(" "));
  }

  lcd.setCursor (1, line);
 
  // ausgabe des Inhaltes
  lcd.print(F("kl. Glas: "));

        if(g_FillValueSmall >= 400) { // Überprüfen ob eine Maximale Menge festgelegt ist (kleiner 800 ml + Schritte)
  lcd.print(F("400"));
    lcd.setCursor(12, 3);
    lcd.write((byte)4);
        } else {
           lcd.print(g_FillValueSmall, DEC);
        } 
 
    lcd.setCursor(18, 3);
    lcd.print(F(" ml"));   
    lcd.setCursor(0, 3);
    lcd.print("50");
    lcd.write((byte)6);
    lcd.setCursor(14, 3);
    lcd.print(maximum_k);
    lcd.setCursor(18, 3);
    lcd.print("ml");
 
//  lcd_balken(Balkengröße von der Mindestmänge ,anfang , ende , Zeile 0,1,2,3);
  lcd_balken(g_FillValueSmall, 3, 13, 3);
}
   int lcd_balken(int balken, int cursor_x, int cursor_x_end, int cursor_y){
   int calc = (balken*cursor_x_end*5/maximum_k)-(balken*cursor_y*5/400); // 400 = Mindestmänge/ muß angepast werden
 
  while(calc >= 5){
    lcd.setCursor(cursor_x,cursor_y);
    lcd.write((byte)4);
    calc-=5;
    cursor_x++;
 } 
  while(calc >= 4 && calc < 5){
    lcd.setCursor(cursor_x,cursor_y);
    lcd.write((byte)3);
    calc-=4;
}
  while(calc >= 3 && calc < 4){
    lcd.setCursor(cursor_x,cursor_y);
    lcd.write((byte)2);
    calc-=3;
}
  while(calc >= 2 && calc < 3){
    lcd.setCursor(cursor_x,cursor_y);
    lcd.write((byte)1);
    calc-=2;
}
  while(calc >= 1 && calc < 2){
    lcd.setCursor(cursor_x,cursor_y);
    lcd.write((byte)0);
    calc-=1;
}
}   


Liebe Grüße tsw68



dony

Hallo,

Hast Du die 3 Zeilen (5 mit den if Abfragen) geändert (mein letztes Post). Bei einem Anfangswert von 50 fällt das zwar kaum auf, aber es ist einfach nicht richtig! Und wer will ein Fehlerhaftes Programm verwenden?

Was das Speichern und EEPROM angeht, gibt es hier Leute die mehr drauf haben als ich. ;)

lg dony
Grüße, Donny

TSW68

verwende eine andere PeogressBar wie hier besprochen
ist aber so ähnlich.

Dann hoffe ich das sich einer meldet der das Theme EEPROM behärscht.

mfg

michael_x

Und warum guckst du nicht die Original-arduino Referenz zum EEPROM an? (put)

Nicht alles was man im Internet findet, ist sinnvoll.

combie

#38
Feb 02, 2018, 11:44 am Last Edit: Feb 02, 2018, 11:48 am by combie
Quote
hab im internet das hier gefunden weiss aber nicht wo und wie ich es einbinde.
Und wir sollen das jetzt für dich machen....




Aus meiner Wühlkiste:
Code: [Select]
#include <EEPROM.h>

struct Configuration
{
  char name[20];
  float  temperature;
};

const Configuration eepconfig  EEMEM {"Gast",47.11}; // Arduino legt eine *.eep Datei an

Configuration buffer;

void setup()
{
  Serial.begin(9600);
  Serial.println("Start");
 
  EEPROM.get(reinterpret_cast<int>(&eepconfig),buffer);
  Serial.println(buffer.name);
  Serial.println(buffer.temperature);
}

void loop()
{

}


Äää ..
Und zum schreiben:
> EEPROM.put(reinterpret_cast<int>(&eepconfig),buffer);
Säge kein Sägemehl.

skorpi080

Ich denke ein ottonormal (oder noch normaler) wird keine eep brauchen ;)
playground.arduino.cc/PmWiki/433Mhz-Funkmodule
[Arduino IDE] Feinheiten und Tricks  forum.arduino.cc/index.php?topic=632403.0

TSW68

Habe noch kein gutes Tutorial gefunden wenn ich es könnte würde ich auch nicht fragen .

Meine Einstellungen sollen erhalten bleiben nach Neustart .

Lg.



combie

Ich denke ein ottonormal (oder noch normaler) wird keine eep brauchen ;)
Darum dreht es sich doch gar nicht!
Aber ok, wenn das ein Grund ist, den Rest auszublenden, von mir aus!

Macht doch was ihr wollt!
(macht ihr doch sowieso)


-----------------



Quote
void EEPROMWriteInt ( unsigned int eeAdresse , unsigned int wert )
{
  EEPROM.put(eeAdresse, wert);
}
Das ist doch eine unsinnige Transformation.
Oder, welchen Sinn soll das machen?

Außerdem fehlt da der Cast.
Es wird eine Warnung mehr werfen.
Säge kein Sägemehl.

TSW68

Habe noch einwenig im Internet gesucht und habe das gefunden

eeprom read write functions

währe das was für mich und kann ich das irged wie benutzen ?

an soeinem Beispiel würde ich es besser verstehen.

Lg


uxomm

Habe noch einwenig im Internet gesucht und habe das gefunden
eeprom read write functions
währe das was für mich und kann ich das irged wie benutzen ?
Das Beispiel ist aus 2013. Seither ist die EEPROM-Library ein wenig weiter entwickelt worden.
Schau dir doch die aktuellen Beispiele in der Referenz an:
https://www.arduino.cc/en/Reference/EEPROM
https://www.arduino.cc/en/Tutorial/EEPROMPut
Always decouple electronic circuitry.

Go Up