Serial.read --> client.print

Hallo alle zusammen,

ich habe gerade ein Problem, bei welchem ich mir die Zähne ausbeisse. Folgender Hintergrund:
Mittels eines ATMEGA328PB-Breakoutboards von Watterott erfasse ich Daten von einem Stromsensor. Diese Daten schicke ich über die (Hardware)serielle-Schnittstelle an einen ESP8266, auf welchem ich die Daten (wieder mit der seriellen Schnittstelle) einlese. Ziel ist der Aufbau eines Webserver um die Daten darzustellen.

Das Ganze läuft wunderbar und stabil, ich habe jedoch noch ein Problem: Ich Sketch des ESP lese ich die Daten, die ich vom ATMEGA schreibe mittels:

if (Serial.available()) {
     incomingByte = Serial.read();
     Serial.print(incomingValue);
 }

ein. Clientseitig versende ich die Daten wieder mittels

client.println(incomingByte);

Dargestellt wird das in Abbildung 1.

Der gesamte Code (ESP-seitige Code) ist hier:

#include <ESP8266WiFi.h>            

const char* ssid  = "XXX";    
const char* password = "XXX"; 

WiFiServer server(80);                     

int incomingByte; // for incoming serial data
int loopi = 0;
float val1 = 0.0;

char receivedChar;

void setup()                               
                                     
{
     // Open serial communications and wait for port to open:
     Serial.begin(115200);          
                                                                            
     while (!Serial) {
     ; 
     }
     
     Serial.println();
     Serial.print("Verbinde zu ");
     Serial.println(ssid);           
     
     WiFi.begin(ssid,password);      

     while (WiFi.status() != WL_CONNECTED)  
     {
      delay(500);
      Serial.print(".");                    
     }

     Serial.println(" ");
     Serial.println("WiFi verbunden");   
     
     server.begin();                     
     
     Serial.println ("Webserver laeuft, warte auf ESP8266..."); 

     delay(10000);                      
     Serial.println();
     Serial.println("Die IP-Adresse des Webservers lautet ");
     Serial.println(WiFi.localIP());     
}

void loop()            

{
 WiFiClient client = server.available();    
 
 if (Serial.available()) {
     incomingByte = Serial.read();
     Serial.print(incomingByte);
 } 

  if (client)                              
  {
    Serial.println("Neuer Client");       
    
    while (client.connected())             
    {
        if (client.available())           
        
        {
         client.println("<!DOCTYPE HTML>");                   
         client.println("<html>");                            
         client.println("<HEAD><meta http-equiv=\"refresh\" content=\"5\"></HEAD>");
         client.println("Leistungsaufnahme"); 
         client.println("
");                              
         client.println("
");                              
         client.println("Aktuelle Leistungsaufnahme ");
         client.println(loopi);                              // Testvariable
         client.println(incomingByte);
         
         break;                              
        }        
    }
  }

  delay(1000);                          
 
  client.stop();                        
  
  loopi++;
  
}

Leider werden keine Werte angezeigt (Abbildung 2) - mutmaßlich aufgrund des falschen Datentyps, den ich an client.println() übergebe.

Ich habe schon verschiedenes ausprobiert, z.B. Charakter-Datentypen, float oder Serial.parseFloat(). Leider hat nichts geholfen. Man findet unzählige Beispiele, bei denen (z.B. mittels analogread()) ein Integer-Wert an client.println() übergeben wird, aber keine unmittelbare Übergabe des Serial.read-Wertes an den Client.

Was mache ich falsch? Ich habe doch meine Variable auch als Integer deklariert?

Es würde mich sehr freuen, wenn mir jemand einen Denkanstoß geben könnte.

Vielen Dank Euch und Grüße

Bire

ESP8266_Webserver_HW_Forum.ino (2.33 KB)

Stelle Deinen Sketch bitte in Codetags.
Wie das geht, steht hier.
Das kannst Du auch noch nachträglich ändern.

Dein Messwert ist doch bestimmt nicht nur 1 Byte lang. Also lies doch erst mal den gesamten Messwert auf dem ESP ein. Wenn er fertig ist, stellst Du ihm dem Webserver zur Verfügung.

Welcher Variablentyp ist denn der Messwert? Wie überträgst Du denn den? Binär oder als ASCII?

Gruß Tommy

Hallo Tommy56,

danke für Deine schnelle Antwort. Den Code habe ich mittlerweile ergänzt. ATMEGA-seitig übergebe ich die Daten folgendermaßen als Double:

void loop()
{
  double Irms = calcIrms(1480);  // Calculate Irms only
  
  Serial.println(Irms*227.0);	   // Apparent power
  
  Serial1.println(Irms*227.0);  // Write to hardware serial interface
}

Fällt Die hier schon was auf? Bin ich mit dem Datentyp auf der richtigen Spur?

Danke Dir nocheinmal und Grüße

Bire

Also sendest Du in ASCII mit '\n' als Abschluss. Ich würde lieber den Wert * 100 als Ganzzahl benutzen. Sind negative Werte möglich? Wenn nein, dann benutze unsigned long.

Auf der Enpfangsseite musst Du dann die Zeichen erst mal in einem Puffer abspeichern, bis '\n' kommt. Da schließt Du die Zeichenkette mit '\0' ab. Dann wandelst Du sie nach unsigned Long und teilst sie durch 100.

Hier sind ein paar Grundlagen zu Zeichenketten und zum seriellen Einlesen bis '\n' drin.

Gruß Tommy

Hallo Tommy56,

erneut danke für Deine Hilfe. Ich habe mir mal Deine Quelle angeschaut. Ich denke, die "Empfangsseite" ist klar, hier muss ich wohl das Ganze als "Char" durchgehen und jeweils den Zeilenumbruch holen.

Was ich aber nicht ganz verstehe, ich den Faktor den Du erähnt hast: Meinst Du, ich muss meinen Double-Wert in einen unsigned long-Wert umwandeln (es gibt keine negativen Werte), so:

void loop()
{
  double Irms = calcIrms(1480);  // Calculate Irms only
  double Irms2 = Irms;
  unsigned long Test = (unsigned long)Irms*100;

  Serial.println(Test);     // Apparent power
  Serial1.println(Test);     // Apparent power
}

Oder verstehe ich Dich falsch?

Viele Grüße und DANKE

Bire

Das hast Du richtig verstanden. Mit unsigned long kannst Du vom Arduino mehr signifikante Stellen übertragen (bis 4,294,967,295 als Maximumwert) während float nur 6 signifikante Stellen hat.

Gruß Tommy

Hallo Tommy56,

darf ich Dich noch einmal behelligen?

Ich dachte, ich habe Deine Hinweise eingepflegt. Aber offensichtlich ist immer noch etwas falsch. Dies äußert sich, dass immer nur eine "0" angezeigt wird.

Die neuralgischen Stellen, die Du beschrieben hast sind wie gesagt, denke und hoffe ich, korrekt:

  1. Lesen bis ein \n kommt oder der Puffer voll ist
char recvWithEndMarker() {
 static byte ndx = 0;
 char endMarker = '\n';
 char rc;
 
 // if (Serial.available() > 0) {
 while (Serial.available() > 0 && newData == false) {
 rc = Serial.read();

 if (rc != endMarker) {
 receivedChars[ndx] = rc;
 ndx++;
 if (ndx >= numChars) {
 ndx = numChars - 1;
 }
 }
 else {
  receivedChars[ndx] = '\0'; // terminate the string
  ndx = 0;
  newData = true;
 }
 }
  1. Umwandlung (in loop()) von char in unsigned int und teilen durch 100:
 if (newData == true) {
   //Serial.print("This just in ... ");
   //Serial.println(receivedChars);
   i = (unsigned int)receivedChars;
   newData = false;
 }
  1. Ausgabe zum Client und Berücksichtigung von Faktor 100:
client.println(i/100);

Wo ist mein Fehler? Der komplette Code ist angehängt.

Wäre super, wenn Du mir noch einen Hinweis geben könntest. Aber bis hier her einmal VIELEN DANK!

Grüße Bire

#include <ESP8266WiFi.h>            

const char* ssid  = "";    
const char* password = ""; 

WiFiServer server(80);                     

double incomingByte; // for incoming serial data
int loopi = 0;

const byte numChars = 32;
char receivedChars[numChars]; // an array to store the received data

boolean newData = false;

unsigned int i; 

void setup()                               
                                     
{
     // Open serial communications and wait for port to open:
     Serial.begin(115200);          
                                                                            
     while (!Serial) {
     ; 
     }
     
     Serial.println();
     Serial.print("Verbinde zu ");
     Serial.println(ssid);           
     
     WiFi.begin(ssid,password);      

     while (WiFi.status() != WL_CONNECTED)  
     {
      delay(500);
      Serial.print(".");                    
     }

     Serial.println(" ");
     Serial.println("WiFi verbunden");   
     
     server.begin();                     
     
     Serial.println ("Webserver laeuft, warte auf ESP8266..."); 

     delay(10000);                      
     Serial.println();
     Serial.println("Die IP-Adresse des Webservers lautet ");
     Serial.println(WiFi.localIP());     
}

void loop()            

{
 WiFiClient client = server.available();    

 recvWithEndMarker();
 
 if (newData == true) {
   //Serial.print("This just in ... ");
   //Serial.println(receivedChars);
   i = (unsigned int)receivedChars;
   newData = false;
 }
 
  if (client)                              
  {
    Serial.println("Neuer Client");       
    
    while (client.connected())             
    {
        if (client.available())           
        
        {
         client.println("<!DOCTYPE HTML>");                   
         client.println("<html>");                            
         client.println("<HEAD><meta http-equiv=\"refresh\" content=\"5\"></HEAD>");
         client.println("Leistungsaufnahme"); 
         client.println("
");                              
         client.println("
");                              
         client.println("Aktuelle Leistungsaufnahme ");
         client.println(loopi);                              // Testvariable
         client.println(i/100);
         
         break;                              
        }        
    }
  }

  delay(1000);                          
 
  client.stop();                        
  
  loopi++;
}

char recvWithEndMarker() {
 static byte ndx = 0;
 char endMarker = '\n';
 char rc;
 
 // if (Serial.available() > 0) {
 while (Serial.available() > 0 && newData == false) {
 rc = Serial.read();

 if (rc != endMarker) {
 receivedChars[ndx] = rc;
 ndx++;
 if (ndx >= numChars) {
 ndx = numChars - 1;
 }
 }
 else {
  receivedChars[ndx] = '\0'; // terminate the string
  ndx = 0;
  newData = true;
 }
 }

}

Warum benutzt Du nicht den Code, aus dem verlinkten Text?
Hänge Dir Serial.print rein und zeige Dir jedes empfangene Zeichen an.

Schicke auf der Sendeseite erst mal eine konstante Zahl, bis Du die Zeichenkette sauber empfängst. Dann gehe an die Umwandlung. Nicht alles auf einmal, da verlierst Du den Überblick.

Gruß Tommy

Hallo Tommy56,

danke für Deine Geduld mit mir. Ich habe Deinen Code nun benutzt (auch hier Danke). Mittlerweile glaube ich aber, dass ich da einen gravierenden Fehler drin habe, bzw. einen Denkfehler: Ich schicke ja über die weitere Hardware-Schnittstelle des ATMEGA (serial1) die Daten an die serielle Schnittstelle des ESP. Ich schreibe nun einen konstanten Wert, wie Du es empfohlen hast:

 Serial1.println(2104);  // Write to hardware serial interface

Jetzt ist mir aufgefallen, dass da überhaupt keine Werte auf meine serielle Schnittstelle geschrieben werden (bzw. nur der konstante Wert vom ATMEGA), da dieser Programmteil gar nicht ausgeführt wird (das von Dir empfohlene "reingehängte" Serial.print. Dann kann das doch nicht funktionieren, oder?

 boolean anzeigen = readSerialNL();
 if (anzeigen){
  Serial.println("Hello");
  Serial.println(puffer);
 }

Hast Du noch eine Idee? Code ist im Anhang

Vielen, vielen Dank Dir und Grüße

Bire

#include <ESP8266WiFi.h>            

const char* ssid  = "";    
const char* password = ""; 

WiFiServer server(80);                     

double incomingByte; // for incoming serial data
int loopi = 0;

// Länge Nutzdaten + 1
const uint8_t BUFLEN = 32;
char puffer[BUFLEN];




void setup()                               
                                     
{
     // Open serial communications and wait for port to open:
     Serial.begin(115200);          
                                                                            
     while (!Serial) {
     ; 
     }
     
     Serial.println();
     Serial.print("Verbinde zu ");
     Serial.println(ssid);           
     
     WiFi.begin(ssid,password);      

     while (WiFi.status() != WL_CONNECTED)  
     {
      delay(500);
      Serial.print(".");                    
     }

     Serial.println(" ");
     Serial.println("WiFi verbunden");   
     
     server.begin();                     
     
     Serial.println ("Webserver laeuft, warte auf ESP8266..."); 

     delay(10000);                      
     Serial.println();
     Serial.println("Die IP-Adresse des Webservers lautet ");
     Serial.println(WiFi.localIP());     
}

void loop()            
{

 // solange lesen lassen, bis Zeilenende erkannt wurde
 boolean anzeigen = readSerialNL();
 if (anzeigen){
  Serial.println("Hello");
  Serial.println(puffer);
 }
  
 WiFiClient client = server.available();    
 
  if (client)                              
  {
    Serial.println("Neuer Client");       
    
    while (client.connected())             
    {
        if (client.available())           
        {
         client.println("<!DOCTYPE HTML>");                   
         client.println("<html>");                            
         client.println("<HEAD><meta http-equiv=\"refresh\" content=\"5\"></HEAD>");
         client.println("Leistungsaufnahme"); 
         client.println("
");                              
         client.println("
");                              
         client.println("Aktuelle Leistungsaufnahme ");
         client.println(loopi);                              // Testvariable
        // client.println(i/100);
       
         break;                              
        }        
    }
  }

  delay(1000);                          
 
  client.stop();                        
  
  loopi++;
}

// liest bis zum Zeilenende oder bis der Puffer voll ist und gibt dann true zurück
boolean readSerialNL() {
static uint8_t idx = 0;
static boolean fertig = false;
char c;
unsigned long result = 0;

  // Neubeginn initialisieren
  if (fertig && idx > 0) {
    idx = 0;
    fertig = false;
  }
  if (Serial.available()) {  // hier könnte man evtl. auch while nehmen
    c = Serial.read();
    if (c == '\n' || idx == BUFLEN -1) { // Zeilenvorschub oder voll
      puffer[idx] = '\0';
      fertig = true;
    }
    else if (c >= 0x20 && idx < BUFLEN -1) { // keine Steuerzeichen
      puffer[idx++] = c;
      //Serial.print(c);
      result = (unsigned long)c;
      Serial.println(result/100);
    }
  }
  return fertig;
}

Wenn Du beim Senden schon ein Problem hast, dann hilft es uns (und Dir) nichts, immer nur Fragmente zu zeigen.
Baue Dir einen Sketch, der einfach nur eine konstante Zahl sendet.
Mit diesem Baust Du dann erst mal die Empfangsroutine auf und testest sie.

Gruß Tommy

Hallo Tommy56,

das hatte ich ja schon gemacht, so wie Du es empfohlen hattest. Ich sende jetzt konstant den Wert 2104 mittels Serial1.println(). Dieser Wert wird auch in der Console des ESP angezeigt (siehe Abbildung 3).

Was ich jetzt weiter festgestellt habe ist, dass der Code teil nach

if (Serial.available()) {

nicht ausgeführt wird, das heißt, dass überhaupt kein Wert vorhanden ist? Das verstehe ich nun überhaupt nicht?

Anbei beide Codes, vollständig (der vom ATMEGA und ESP)

Code ESP:

#include <ESP8266WiFi.h>            

const char* ssid  = "";    
const char* password = ""; 

WiFiServer server(80);                     

double incomingByte; // for incoming serial data
int loopi = 0;

// Länge Nutzdaten + 1
const uint8_t BUFLEN = 32;
char puffer[BUFLEN];

void setup()                               
                                     
{
     // Open serial communications and wait for port to open:
     Serial.begin(115200);          
                                                                            
     while (!Serial) {
     ; 
     }
     
     Serial.println();
     Serial.print("Verbinde zu ");
     Serial.println(ssid);           
     
     WiFi.begin(ssid,password);      

     while (WiFi.status() != WL_CONNECTED)  
     {
      delay(500);
      Serial.print(".");                    
     }

     Serial.println(" ");
     Serial.println("WiFi verbunden");   
     
     server.begin();                     
     
     Serial.println ("Webserver laeuft, warte auf ESP8266..."); 

     delay(10000);                      
     Serial.println();
     Serial.println("Die IP-Adresse des Webservers lautet ");
     Serial.println(WiFi.localIP());     
}

void loop()            
{
 // solange lesen lassen, bis Zeilenende erkannt wurde
 boolean anzeigen = readSerialNL();
 if (anzeigen){
  Serial.println(puffer);
 }
  
 WiFiClient client = server.available();    
 
  if (client)                              
  {
    Serial.println("Neuer Client");       
    
    while (client.connected())             
    {
        if (client.available())           
        {
         client.println("<!DOCTYPE HTML>");                   
         client.println("<html>");                            
         client.println("<HEAD><meta http-equiv=\"refresh\" content=\"5\"></HEAD>");
         client.println("Leistungsaufnahme"); 
         client.println("
");                              
         client.println("
");                              
         client.println("Aktuelle Leistungsaufnahme ");
         client.println(loopi);                              // Testvariable
        // client.println(i/100);
       
         break;                              
        }        
    }
  }

  delay(1000);                          
 
  client.stop();                        
  
  loopi++;
}

// liest bis zum Zeilenende oder bis der Puffer voll ist und gibt dann true zurück
boolean readSerialNL() {
static uint8_t idx = 0;
static boolean fertig = false;
char c;
unsigned long result = 0;

  // Neubeginn initialisieren
  if (fertig && idx > 0) {
    idx = 0;
    fertig = false;
  }
  if (Serial.available()) {  // hier könnte man evtl. auch while nehmen
     Serial.println("Hello");
    c = Serial.read();
    if (c == '\n' || idx == BUFLEN -1) { // Zeilenvorschub oder voll
      puffer[idx] = '\0';
      fertig = true;
    }
    else if (c >= 0x20 && idx < BUFLEN -1) { // keine Steuerzeichen
      puffer[idx++] = c;
      //Serial.print(c);
      result = (unsigned long)c;
      Serial.println(result/100);
    }
  }
  return fertig;
}

Code ATMEGA

// EmonLibrary examples openenergymonitor.org, Licence GNU GPL V3

#ifndef READVCC_CALIBRATION_CONST
#define READVCC_CALIBRATION_CONST 1126400L
#endif

#define ADC_BITS    10

#define ADC_COUNTS (1<<ADC_BITS)

int sampleI;
double filteredI;
double offsetI; //Low-pass filter output

unsigned int inPinI;

double sqI,sumI; //sq = squared, sum = Sum, inst = instantaneous

double Irms;

double ICAL;

void setup()
{  

  inPinI = 1;
  ICAL = 33.3;
  Serial.begin(500000);  
  Serial1.begin(115200);
  //Serial1.begin(500000);
}

//--------------------------------------------------------------------------------------
double calcIrms(unsigned int Number_of_Samples)
{

  #if defined emonTxV3
    int SupplyVoltage=3300;
  #else
    int SupplyVoltage = readVcc();
  #endif

  // Serial.println(SupplyVoltage);

  for (unsigned int n = 0; n < Number_of_Samples; n++)
  {
    sampleI = analogRead(inPinI);
    
    // Digital low pass filter extracts the 2.5 V or 1.65 V dc offset,
    //  then subtract this - signal is now centered on 0 counts.
    offsetI = (offsetI + (sampleI-offsetI)/1024);
    filteredI = sampleI - offsetI;

    // Root-mean-square method current
    // 1) square current values
    sqI = filteredI * filteredI;
    // 2) sum
    sumI += sqI;
  }
  
  double I_RATIO = ICAL *((SupplyVoltage/1000.0) / (ADC_COUNTS));
  Irms = I_RATIO * sqrt(sumI / Number_of_Samples);
  
  //Reset accumulators
  sumI = 0;
  //--------------------------------------------------------------------------------------

  return Irms;
}

//  2019-05-09: added the AVR_ATmega328PB_processor

long readVcc() {
  long result;

  //not used on emonTx V3 - as Vcc is always 3.3V - eliminates bandgap error and need for calibration http://harizanov.com/2013/09/thoughts-on-avr-adc-accuracy/

  #if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328__) || defined (__AVR_ATmega328P__) || defined (__AVR_ATmega328PB__)
  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  #elif defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)
  ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  #elif defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) || defined(__AVR_AT90USB1286__)
  ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  ADCSRB &= ~_BV(MUX5);   // Without this the function always returns -1 on the ATmega2560 http://openenergymonitor.org/emon/node/2253#comment-11432
  #elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
  ADMUX = _BV(MUX5) | _BV(MUX0);
  #elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
  ADMUX = _BV(MUX3) | _BV(MUX2);

  #endif


  #if defined(__AVR__)
  delay(2);                                        // Wait for Vref to settle
  ADCSRA |= _BV(ADSC);                             // Convert
  while (bit_is_set(ADCSRA,ADSC));
  result = ADCL;
  result |= ADCH<<8;
  result = READVCC_CALIBRATION_CONST / result;     //1100mV*1024 ADC steps http://openenergymonitor.org/emon/node/1186
  return result;
  #elif defined(__arm__)
  return (3300);                                  //Arduino Due
  #else
  return (3300);                                  //Guess that other un-supported architectures will be running a 3.3V!
  #endif
}

void loop()
{
  double Irms1 = calcIrms(1480)*227.0;  // Calculate Irms only
   
  // "Trick": Unwandlung in eine Ganzzahl https://forum.arduino.cc/index.php?topic=614888.new#new
  // Serial.println(Irms1*227.0);     // Apparent power
  
  unsigned long Irms = (unsigned long)(Irms1*100);
  
  Serial.println(Irms);     // Apparent power
  
  //Serial.print(" ");
  //Serial.println(Irms);     // Irms
  //sampleI = analogRead(inPinI);
  //Serial.println(Irms);
  //Serial.println(sampleI);

  //Serial1.println(Irms);  // Write to hardware serial interface

  Serial1.println(2104);  // Write to hardware serial interface
   
}

Vielen Dank für Deine Geduld und viele Grüße

Bire

Das kann ja so auch nicht funktionieren, weil Du in Routinen rum schreibst, die Du nicht ansatzweise verstanden hast. Weiterhin fehlen Dir jegliche Grundlagen zu Datentypen. Du solltest Dein Projekt weg legen und die Grundlagen lernen.

// liest bis zum Zeilenende oder bis der Puffer voll ist und gibt dann true zurück
boolean readSerialNL() {
static uint8_t idx = 0;
static boolean fertig = false;
char c;
unsigned long result = 0;

  // Neubeginn initialisieren
  if (fertig && idx > 0) {
    idx = 0;
    fertig = false;
  }
  if (Serial.available()) {  // hier könnte man evtl. auch while nehmen
     Serial.println("Hello");
    c = Serial.read();
    if (c == '\n' || idx == BUFLEN -1) { // Zeilenvorschub oder voll
      puffer[idx] = '\0';
      fertig = true;
    }
    else if (c >= 0x20 && idx < BUFLEN -1) { // keine Steuerzeichen
      puffer[idx++] = c;
      //Serial.print(c);
    }
  }
  return fertig;
}


im loop:

if (readSerialNL()) {  // wenn alles eingelesen ist
  unsigned long z = strtoul(puffer,NULL,10);
  float f = 1.0 * z /100;
  Serial.println(f); 
}

Deine Ergänzung ist Unsinn, weil c ein einzelnes Zeichen aus Deinen gesendeten 4 Zeichen ist.

      result = (unsigned long)c;
      Serial.println(result/100);

Gruß Tommy

Guten Abend Thommy56,

vielen Dank für Deine Antwort - auch wenn Du mich auf meine klaren Defizite hin gewiesen hast. Du hast aber recht: Ich bin nicht vom Fach und in der Tat tue ich mich mit den Datentypen etwas schwer. Deinen Hinweis zu meiner Änderung habe ich verstanden. Das macht natürlich keinen Sinn, da ich ja warten muss bis der Puffer voll, bzw. das Zeilenende erreicht ist.

Danke für die konstruktive negative Kritik. Ich habe schon viel gelernt. Ich möchte Dir nicht Deine Zeit stehen - auch wenn Du es vielleicht nicht glaubst, ich strenge mich wirklich an.

Ich werde Deine Hinweise morgen früh einarbeiten - ich hoffe, ich darf Dich trotz Deiner Kritik noch einmal behelligen wenn ich noch einmal Hilfe brauche. Würde mich freuen - wie gesagt ich strenge mich wirklich an und mein Anspruch ist es das auch nachzuvollziehen - evtl. brauche ich dazu einfach etwas länger.

VIELEN DANK FÜR DEINE HILFE!!!

Grüße

Bire

Kannst Du, auch wenn ich evtl. zwischenzeitlich mal nicht erreichbar bin. Es gibt auch noch andere hilfreiche Foristen. Die Grundlagen solltest Du trotzdem lernen.

Gruß Tommy

Hallo Tommy,

vielen Dank für Dein Angebot und Dein Engagement für alle die Hilfe nötig haben! Ich bin immer wieder beeindruckt wie viel hier einige auf dem Kasten haben und wie hilfsbereit Ihr seid! Auch für Fälle wie mich. Und glaube mir: Ich werde Deinen Rat beherzigen und mir das genauer anschauen! Mein eigener Anspruch ist es das alles auch wirklich zu verstehen!
Dir noch einen schönen Abend!

Grüße Bire

Guten Morgen,

@Tommy56: Ich möchte mich noch einmal ganz recht herzlich bei Dir bedanken. Nachdem ich Deine Hinweise eingearbeitet (und nachvollzogen) habe, klappt nun alles wunderbar.

VIELEN DANK noch einmal!

Grüße

Christian

Schön und Danke für die Rückmeldung.

Gruß Tommy