Stringlänge von Zeichen und Buchstaben bestimmen

[Thorsten (Gast)]

Hallo,

ich stehe grade vor dem Problem, dass ich über UART eine Telefonnummer 
zum Atmega 32 geschickt bekomme. Diese Telefonnummer wird dann auf 
Plausibilität überprüft und auf einem LCD ausgegeben.

Jetzt möchte ich allerdings für die weitere Verarbeitung die genaue 
Länge des Strings erfahren, weil der String ins EEProm geschrieben und 
dann später immer wieder geladen werden soll.

Auf dem LCD lass ich mir auch die Länge des Strings ausgeben, es wird 
aber nur Müll angezeigt. Wo liegt hier mein Fehler ?

Also die über UART empfangene Telefonnumemr wird korrekt angezeigt....

#include <avr/io.h>
#define F_CPU 4000000
#include <util/delay.h>
#include "com74hc595.h"
#include "com74hc595_lcd.h"
#include <avr/interrupt.h>
#include <avr/eeprom.h>
#include <string.h>

#define BAUD 9600UL      // Baudrate
#define UART_MAXSTRLEN 14


// Konstanten fuer die Baudrate aus der Taktfrequenz berechnen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.

#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif

volatile uint8_t uart_str_complete = 0;     // 1 .. String komplett empfangen
volatile uint8_t uart_str_count = 0;
volatile char uart_string[UART_MAXSTRLEN + 1] = "";
volatile char Buffer[20];

uint8_t eeFooTelefonnummer[15] EEMEM;
uint8_t eeFooLaenge[4] EEMEM;

//**********************************************************//
//******************Funktionen UART*************************//
//**********************************************************//

int uart_putc( unsigned char c )
{
  while (!(UCSRA & (1<<UDRE)))  /* warten bis Senden moeglich */
    ;

  UDR = c;                      /* sende Zeichen */
  return 0;
}

uint8_t uart_getc(void)
{
    while (!(UCSRA & (1<<RXC)))   // warten bis Zeichen verfuegbar
        ;
    return UDR;                   // Zeichen aus UDR an Aufrufer zurueckgeben
}

uint8_t uart_getc_wait()
{
  // Warten, bis etwas empfangen wird
  while (!(UCSRA & (1 << RXC)))
    ;

  // Das empfangene Zeichen zurückliefern
  return UDR;
}

/* String senden */
void uart_puts( const char *s )
{
//  lcd_clear();
//  lcd_string(s);
  while (*s)
  {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen" */
    uart_putc(*s);
    s++;
  }
}

//**********************************************************//
//******************UART-Verbindung*************************//
//**********************************************************//

    void initUART()
    {
      UCSRB |= (1<<TXEN) | (1<<RXEN)|(1<<RXCIE);      // UART TX/RX einschalten
      UCSRC |= (1<<URSEL) | (1 << UCSZ1) | (1 << UCSZ0);//| (3<<UCSZ0);      // Asynchron 8N1

      UBRRH = UBRR_VAL >> 8;               // Baudrate setzen
      UBRRL = UBRR_VAL & 0xFF;
    }



int main(void)
{

  char Vergleich[]="+49";
  int StringVergleich = 0;
  int TelefonnummerLaenge;

    com74hc595_init();        // Porterweiterungen initialisieren
    com74hc595_lcd_init();      // Lcd initialisieren

    initUART();            // UART initialisieren BAUDRATE ist 9600 !!

   sei();

    while(1)
    {

    if( uart_str_complete == 1 )
    {
      com74hc595_lcd_clear();
      com74hc595_set_cursor(0,1);

      StringVergleich = strncmp(uart_string, Vergleich, 3);
      if ( StringVergleich == 0)
      {
         com74hc595_lcd_string(uart_string);

         TelefonnummerLaenge = strlen(uart_string);
         eeprom_write_byte(&eeFooLaenge,TelefonnummerLaenge);
         
         com74hc595_set_cursor(0,2);
         com74hc595_lcd_string(TelefonnummerLaenge);
         uart_str_complete = 0;
      }
      else
      {
        com74hc595_lcd_string("Fehler");
        uart_str_complete = 0;
      }
    }

    }
}

ISR(USART_RXC_vect)
{
  unsigned char nextChar;

  // Daten aus dem Puffer lesen
  nextChar = UDR;
  if( uart_str_complete == 0 ) {  // wenn uart_string gerade in Verwendung, neues Zeichen verwerfen

    // Daten werden erst in uart_string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
    if( nextChar != '\n' &&
        nextChar != '\r' &&
        uart_str_count < UART_MAXSTRLEN ) {
      uart_string[uart_str_count] = nextChar;
      uart_str_count++;
    }
    else {
      uart_string[uart_str_count] = '\0';
      uart_str_count = 0;
      uart_str_complete = 1;
    }
  }
}

[Sebastian H. (sebihepp)]

Die Variable TelefonnummerLaenge ist ein Integer und kein String.

[as (Gast)]

versuchs mal mit:
 " TelefonnummerLaenge = strlen( uart_string ); "

[Thomas E. (thomase)]

Du schliesst doch deinen zusammengebauten String mit 0 ab. Damit hast du 
alles, wa du brauchst. Beim Auslesen musst du nur bis 0 lesen.
Wo ist das Problem?

> uint8_t eeFooLaenge[4] EEMEM;
Das brauchst du nicht. Wenn du 4 mit 0 terminierte Nummern 
hintereinander ablegst, gehst du einfach durch den Speicher durch, bis 
du die richtige gefunden hast. Die zweite Nummer beginnt hinter der 
zweiten 0, die anderen entsprechend. Das geht Ratz-Fatz da einmal 
durchzunageln. Da kannst du auch den ganzen E²PROM vollschreiben.

mfg.

[Sebastian H. (sebihepp)]

Und ich sage es nochmal: TelefonnumerLaenge ist ein Integer und kein 
String. Du musst die Variable erst in einen String konvertieren, bevor 
du com74hc595_lcd_string() aufrufen kannst.

[Karl H. (kbuchegg)]

... wobei man sich am sinnvollsten gleich eine Funktion

void com74hc595_lcd_int( int wert )
{
  char str[7];
  itoa( wert, str, 10 );
  com74hc595_lcd_string( str );
}

baut, anstatt erst in main da groß rumzupfriemeln. So eine int Ausgabe 
braucht man immer wieder.

Wie hast du (Thorsten), das hier

  com74hc595_lcd_string(TelefonnummerLaenge);

eigentlich durch den Compiler gebracht? Da muss es doch an allen Ecken 
und Enden Alarm geklingelt haben!

[Sebastian H. (sebihepp)]

>Wie hast du (Thorsten), das hier
>>com74hc595_lcd_string(TelefonnummerLaenge);
>eigentlich durch den Compiler gebracht? Da muss es doch an allen Ecken
>und Enden Alarm geklingelt haben!

Nicht, wenn ein Integer die Größe eines Pointers hat. Wenn dann noch 
Warnungen ausgeschalten sind oder der Compiler etwas älter ist, dann 
wird trotzdem kompiliert.

[ich (Gast)]

Thorsten schrieb:
> uint8_t uart_getc(void)
> {
>     while (!(UCSRA & (1<<RXC)))   // warten bis Zeichen verfuegbar
>         ;
>     return UDR;                   // Zeichen aus UDR an Aufrufer
> zurueckgeben
> }
>
ist für mich das gleiche (außer dem Funktionsnamen) wie:

> uint8_t uart_getc_wait()
> {
>   // Warten, bis etwas empfangen wird
>   while (!(UCSRA & (1 << RXC)))
>     ;
>
>   // Das empfangene Zeichen zurückliefern
>   return UDR;
> }

Wo ist der Unterschied zwischen beiden Funktionen?

[Rufus Τ. F. (rufus)]

ich schrieb:
> Wo ist der Unterschied zwischen beiden Funktionen?

Der liegt im Namen. Mehr Unterschied ist nicht.