uint16_t 2 byte in LCD anzeigen

[Weider (Gast)]

Hallo,

ich bin seit Stunden an einem Problem und ich komme einfach nicht 
weiter, vielleicht könnt ihr mir helfen.

Hier mein Problem:
Ich bestimme in einer uint16_t eine EEPROM Adresse. Sprich 2Byte mit 
folgendem Code:

uint8_t enter(const char *frage, unsigned int MaxLen)
{
  uint8_t temp;
  if(atkeyb_buffcnt != 0)
  {
    temp = atkeyb_getchar();
  }

  unsigned short *Buffer[MaxLen];
  uint8_t StringLen = 0;
  lcd_spalte=0;
  lcd_zeile=0;
  lcd_clear();
  lprint("", frage, 1);
  lcd_command(LCD_SET_DISPLAY|LCD_DISPLAY_ON|LCD_CURSOR_ON|LCD_BLINKING_ON);

  unsigned int exit = 0;

  lcd_spalte = 0;
  lcd_zeile = 2;
  do {
    if(atkeyb_buffcnt != 0)
    {
      temp = atkeyb_getchar();
    }
    switch(temp)
    {

      case  8:
        if (lcd_spalte > 0)
        {
          lcd_spalte--;
          StringLen--;
          *Buffer[StringLen] = 0;
          lcd_setcursor(lcd_spalte, lcd_zeile);
          lcd_data(0xFE);
          lcd_setcursor(lcd_spalte, lcd_zeile);
        }
        break;

      case 13: //ENTER
        //*Buffer = '\0';
        exit = 2;
        break;

      default:
        if ((temp != 0) && (temp >= '0') && (temp <= '9'))
        {
          if (StringLen < MaxLen)
          {
            *Buffer[StringLen] = temp;
            lprintbk(temp);
              StringLen++;
            temp = 0;
          }
        }
        break;
    }

  } while (exit != 2);
  lcd_command(LCD_SET_DISPLAY|LCD_DISPLAY_ON|LCD_CURSOR_OFF|LCD_BLINKING_OFF);
  return *Buffer;
}

Jetzt möchte ich die Adresse die zuvor mittels PC-Tastatur eingegeben 
worden ist benutzen und als Dez.-Zahl im LCD anzeigen um zu überprüfen 
ob auch die richtig Adresse ausgelesen worden ist. Das Problem ist 
dabei, dass das LCD einfach nicht die richtig Zahl bzw. wirre Zeichen 
anzeigt.

void menu_rw_read(void)
{
  uint16_t adbyte, rdbyte;
//  unsigned int zahl;

  char LCDZahl[10];  

     adbyte = enter("Adresse: ", 8);
//  zahl = atoi(adbyte);

  utoa( adbyte, LCDZahl, 10 );

  lprint("ADD: ","Read EEPROM", 1);

  lcd_data(LCDZahl);

  long_delay(300);
  //rdbyte = exEEPROMRead(adbyte);
  lcd_clear();
  lcd_string("ADD: ");
  lcd_string(LCDZahl);
  lcd_setcursor(0, 2);
  lcd_string("Wert: ");

  lcd_data(rdbyte);
  wait_ofkey();
}

[Weider (Gast)]

Jemand eine Idee?

[Vn N. (wefwef_s)]

lcd_data erwartet offensichtlich keinen String als Argument.

[Weider (Gast)]

hmm..  mit lcd_string() gibt er auch nur komisches Zeugs raus.

[Hans Peter B. (Gast)]

Solange dein Code nicht fehler- bzw warnungsfrei übersetzt wird, darft 
du nicht erwarten, dass er fehlerlos ausgeführt wird.

z.B. Übergabewert an lcd_data() in einem Fall:
 "uint16_t rdbyte"
und im andern Fall:
 "char LCDZahl [10]"

Hans Peter

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

utoa will wie itoa ein Zeiger aufs Stringarray und den seh ich hier 
nicht!
http://www.cplusplus.com/reference/clibrary/cstdlib/itoa/
Dann musst du noch bedenken, dass du die Stellen auf dem LCD löschen 
musst, wenn die Adresszahl um eine Zehnerpotenz kleiner wird, das 
Display löscht ja nicht von alleine und dann irrt da ne alte Zahl rum.

[42er (Gast)]

Weider schrieb:
> Das Problem ist dabei, dass das LCD einfach nicht die richtig Zahl bzw.
> wirre Zeichen anzeigt.

Ohne konkrete Beispiele treibt die Phantasie wilde Blüten. Möchtest du 
das?

[Werner (Gast)]

Was spricht dagegen, die Umwandlung der Daten und die Übergabe an das 
LCD im Simulator zu verfolgen und den Fehler einzukreisen?

[Rolf M. (rmagnus)]

Weider schrieb:
> unsigned short *Buffer[MaxLen];

Bist du sicher, daß ein Array aus Zeigern hier das richtige ist?

[Weider (Gast)]

Nein, bin ich mir nich, das ist ja das Problem O.o  xD

[Weider (Gast)]

Jemand eine Idee / Lösung dazu?

[Weider (Gast)]

Also nach lesen mehrere Forumeinträge und dem überdenken des Problems 
bin ich zu folgender Überlegung gekommen: Da also ein uint16_t 
übertragen wird muss ich evtl. den Wert in zwei uint8_t umwandeln, 
danach über utoa(); laufen lassen und danach zu einer Dez.-Zahl 
zusammenfügen!? Würde das so funktionieren?

Und hier noch eine kleine Frage neben bei: Der Wert für die Adresse im 
EEPROM ist nun mal, auch der Funktion zu folge ein int16_t Übergabewert, 
eine Dez.-Zahl. Wie mach ich das aber mit dem Byte das ich beschreiben 
will bzw. lesen möchte? Ist es Sinnvoll das Byte (uint8_t) als Bitfolge 
auszulesen (anzeigen) zu lassen oder eher als Hex? Wie ist es mit dem 
Beschreiben einer Adresse? Binär, Hex ? Wie könnte ich das eingeben per 
Keyboard, anzeigen lassen auf dem LCD und dann mit der richtigen 
Varriable an die Funktion weitergeben ohne ständige umwandlungen zu 
machen?

[Karl H. (kbuchegg)]

Weider schrieb:
> Also nach lesen mehrere Forumeinträge und dem überdenken des Problems
> bin ich zu folgender Überlegung gekommen:

Ich weiß nicht was du liest, aber du solltest den Ankauf eines C-Buches 
und dessen Durcharbeitung ernsthaft in Erwägung ziehen. Wesentlich 
besser als sich anlassbezogenes 1/4 Wissen in Foren zusammenzusuchen.

> Da also ein uint16_t
> übertragen wird muss ich evtl. den Wert in zwei uint8_t umwandeln,

Nein, musst du nicht. Du musst dir nur im klaren darüber sein, was die 
Funktion enter() eigentlich zu liefern hat und das dann auch umsetzen. 
Soll enter() einen String liefern oder lieber doch gleich die fertige 
Zahl (in Form eines uint16_t), die dem entspricht was der Benutzer 
eingetippt hat.

Hinweis:
enter() eine fertige 16 Bit Zahl (als fertige Zahl) liefern zu lassen 
ist trivial. enter() einen String liefern zu lassen, ist alles andere 
als trivial. Bei letzterem muss man (mindestens) einen Tod sterben.

[Weider (Gast)]

Ja, ich möchte eine 16Bit Zahl von der Funktion enter() zurück geben 
lassen. Leider bekomme ich das nicht hin. Irgendwas stimmt in der 
Funktion nich beim eingeben. Da ja eine Zahl die größer ist als 9 zwei 
stellen bzw. mehrere benötigt. Diese Zahl (z.B. 1020) muss ja als 
komplette zurückgegeben werden von der Funktion aber muss einzell im LCD 
wiedergegeben werden, um auch eine Numer löschen zu können ASCII 8 
(Backspace).

L.g.

[Weider (Gast)]

Also wenn ich die Funktion enter() so lasse und einen String zurückgeben 
könnte ich mit dem Code 
http://home.htw-berlin.de/~junghans/cref/EXAMPLES/exponent.c#atoi den 
String in eine Zahl umwandeln. Ich verstehe nur nicht wie der Code 
funzt. Hilfe ich dreh durch! xD Ne, im Ernst. Kann mir irgendjemand bei 
dem Problem helfen??? Bitte.. ich weiß net mehr weiter! =(

[Karl H. (kbuchegg)]

Weider schrieb:
> Also wenn ich die Funktion enter() so lasse und einen String zurückgeben
> könnte ich mit dem Code
> http://home.htw-berlin.de/~junghans/cref/EXAMPLES/exponent.c#atoi den
> String in eine Zahl umwandeln. Ich verstehe nur nicht wie der Code
> funzt. Hilfe ich dreh durch! xD Ne, im Ernst. Kann mir irgendjemand bei
> dem Problem helfen??? Bitte.. ich weiß net mehr weiter! =(

in enter() die Einzelzeichen, die der Benutzer eingibt, in einem String 
sammeln. Aber das muss auch wirklich ein String bzw. ein char Array 
sein, das was du da hast mit deinem Buffer Array ist Murks.
Danach den String mittels atoi oder atol oder strtol oder einer 
Eigenbauroutine in eine echte Zahl umwandeln lassen und die dann 
zurückgeben.

[Weider (Gast)]

Ja, das versuche ich ja, aber wie kann ich die Eingaberoutine so 
umschreiben das das Funktioniert. Den das lesen auf dem Rom klappt, wenn 
ich die Eingaberoutine aus acht lasse.

void menu_rw_read(void)
{
  uint16_t adbyte = 0;
  uint8_t rdbyte = 0;
  char Buffer[17];
  unsigned int eezahl; //char LCDZahl[10];

     adbyte = enter("Adresse: ", 8);
  lprint("","ENTER:", 1);

  adbyte = "1023"; //<---  HIER Umgehe ich die Routine, es wird von adresse 1023 gelesen. Klappt auch super. Nur eben nicht mit der Eingabe.
    eezahl = atoi(adbyte);
  utoa( eezahl, Buffer, 10 ); //Kontrollumwandlung
  
  EEPWriteByte(eezahl, 0xED); //test-Eigener Rom
  
  lprint("ADD: ","Read EEPROM", 1);
  lcd_string(Buffer); //<-- Adresse wird klar dargestellt im LCD.
  rdbyte = EEPReadByte(eezahl);//exEEPROMRead(eezahl);
  long_delay(1000);
  
  lcd_clear();
  lcd_string("Adresse: ");
  lcd_string(Buffer);
  lcd_setcursor(0, 2);
  lcd_string("Wert: ");
  utoa( rdbyte, Buffer, 2);//10 );
  lcd_data('0');
  lcd_data('b');
  lcd_string(Buffer); //<-- Der richtige Wert des Byte's wird im LCD richtig dargestellt
  if (wait_ofkey() == 27)
  {
    utoa( eezahl, Buffer, 10 );
    lcd_clear();
    lcd_string("Adresse: ");
    lcd_string(Buffer);
    lcd_setcursor(0, 2);
    lcd_string("Wert: ");
    utoa( rdbyte, Buffer, 16);//10 );
    lcd_data('0');
    lcd_data('x');
    lcd_string(Buffer);
    if (wait_ofkey() == 27)
    {
      utoa( eezahl, Buffer, 10 );
      lcd_clear();
      lcd_string("Adresse: ");
      lcd_string(Buffer);
      lcd_setcursor(0, 2);
      lcd_string("Wert (dez.): ");
      utoa( rdbyte, Buffer, 10 );
      lcd_string(Buffer);
      while (wait_ofkey() != 13);
    }
  }
  menu_rw(2);
}

[W.S. (Gast)]

Weider schrieb:
> Ich bestimme in einer uint16_t eine EEPROM Adresse. Sprich 2Byte mit
> folgendem Code:

Hehehehe!

Haben da nicht andere Leute im Tone tiefster innerer Überzeugung in 
einem anderen Thread davon gefaselt, daß man mit goto immer nur 
Spaghetti-Code erzeugt? Der oben gepostete Code ohne goto wirkt auf 
mich mindestens genau so spaghettihaft wie der (damals in den 80er 
Jahren übliche) BASIC-Code mit goto.

Also mein Rat an den Weider:
1. Trenne die Funktionen in sinnvolle Stücke. Also schreibe 2 
Funktionen

bool CharAvail(int Portnum); und char GetChar(int Portnum); Das ist die 
unterste Ebene.
Darauf setzt eine Kommunikations-Ebene auf, die erstmal nur eine 
Kommandozeile zusammensammelt und ggf. Backspace zum Editieren kennt.

Wenn eine Zeile zusammengekommen ist, dann werte sie aus.
Schreib dir ne Funktion, die Integers aus Ziffernfolgen macht und eine, 
die Hex als Input hat. Meist braucht man beides und es ist gut, sowas im 
Repertoire zu haben.

log GetLong(void)
{ long L;
  L = 0;
  while (Kommandozeile[ptr] in ['0'..'9'])   /* ;-)  */
  { L = L*10 + (Kommandozeile[ptr] - '0');
    inc(ptr);
  }
  return L;
}

so ähnlich, mit Bereichsprüfung von ptr und von halb-Pascal nach C 
umgemodelt...

W.S.