... ein Testprogramm in Bascom geschrieben, das nicht erst auf CrLf warten soll ... allerdings kam so keine Kommunikation zustande.
Schon klar dass es so nicht geht. Die üblichen Bibliotheken warten eben auf einen Standard-Abschluss. Da muss man schon selbst aktiv werden. Bei mir stehen die empfangenen Daten noch dazu in einem FIFO und die Kommunikation läuft "im Hintergrund" interruptgesteuert. Geht recht fix.

Mal ein paar rausgeschnibbelte Code-Zeilen um das Vorgehen zu skizzieren:

Code:
     // ==================================================
     /* ... auf Inhalt im FIFO ... wartem */
     if ( ! ukbhit0 () )
       continue;


     // ==================================================
     /* EIN EINZIGES Zeichen aus FIFO lesen.    */
     zeichen_aus_fifo = ugetchar0();


     // ==================================================
     /* Wenn noch kein Kommando bekannt ist, muessen wir erst einen 
        Kommando-Buchstaben erkennen.

        Randbemerkung
        Hier ist auch ein switch/case-Dingsda erlaubt, da zeichen_aus_fifo und
        auch der Define genau ein char-Zeichen bzw. ein numerisch auswertbarer
        einfacher Datentyp sind.                     */
     if (zeiger == 0)
     {                                          //
       if (zeichen_aus_fifo == KOMMANDO_APPS)   // Fahre Anwendungsprogramme
         telegrammlaenge = KOMMANDO_APPS_LEN;   //   mit und ohne Parameter

       if (zeichen_aus_fifo == KOMMANDO_DATS)   // Servo Daten von allen
         telegrammlaenge = KOMMANDO_DATS_LEN;   //   Servos anzeigen

       if (zeichen_aus_fifo == KOMMANDO_NORM)   // Servo Normposition
         telegrammlaenge = KOMMANDO_NORM_LEN;   //   anfahren

       if (zeichen_aus_fifo == KOMMANDO_OFFA)   // Offsetwert A nzeigen
         telegrammlaenge = KOMMANDO_OFFA_LEN;   //   von Servo x
....
     }


     // ==================================================
     /* Wenn keine Telegrammlaenge bekannt ist, dann ist auch kein Kommando
       bekannt, dann muss auch nichts weiter gemacht werden, als auf das 
       naechste Zeichen zu warten bzw. es abzuholen und dann wieder auf 
       einen Kommando-Buchstaben zu testen                      */
     if (telegrammlaenge == 0)
       continue;

     // ==================================================
     /* Wenn ein erkanntes Kommando seine Telegrammlaenge angegeben hat, dann
       muessen wir nun die EINZELN aus dem FIFO abgeholten Zeichen in den BUFFER
       schreiben. Da ja schon der erkannte Kommando-Buchstabe in der Variablen 
       "zeichen_aus_fifo" steht, und "zeiger" noch nicht veraendert wurde, wird 
       auch zum Glueck der Kommando-Buchstabe direkt als erstes Zeichen in
       unserem BUFFER landen.
       Und alle weiteren Zeichen werden dank "zeiger++" dahinter geschrieben. */
     mein_rx_buff [zeiger] = zeichen_aus_fifo;
     zeiger++;

     // ==================================================
     /*  Und jetzt das geniale Ergebnis:
       Wenn nun "zeiger" und "telegrammlaenge" gleich sind,
       dann haben wir ein fertig empfangenes Kommando mit
       seiner erwarteten Laenge.        */
     if (zeiger == telegrammlaenge)
     {
       /*  DIESE INITIALISIERUNGEN SIND LEBENSWICHTIG  */
       zeiger          = 0;
       telegrammlaenge = 0;

       /*  Die Funktionen koennen nun gemuetlich das
           Telegramm auswerten.       */

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//    Fahre verschiedene Anwendungsprogramme, je nach Nummer 
    if (mein_rx_buff [0] == KOMMANDO_APPS)      // Tastatur-Eingabe "Annkkkk"
    {                                   //   Annkkkk
                                        //    nn =:  01..99 - Programm-Casenummer
                                        //      kkkk  Parameter für Prog
//      Dekodiere Programmkennziffer im Byte mein_rx_buff 1 und 2
      for ( u8 i=0; i<=1; i++) { s[i] = mein_rx_buff [i + 1]; }
      s[2]  = 0;                        // Markiere Stringende "0"
      nmbr  = atoi ( s );               //

// - - - - - - - - - - - - - - -
//    case
//      10      Augen rollen k mal (erstes "k")
//      11      Alle Lider auf, full speed
//      12      Alle Lider  zu, full speed
....
//                  Fahrgeschwindigkeit "Servo-Standard+SloMo"
//      43      Augenprogramm AuP43 = ähnlich 42, eher langsamer

// - - - - - - - - - - - - - - -
      switch (nmbr)     // Fahre gewählte Aktionen
      {                         //
        case 10:                // Augen rollen k-mal
          s[0]  = mein_rx_buff [3]; s[1] = 0;   // Dekodiere 1stes k
          npar1 = atoi ( s );   //
          AuRoll ( npar1 , 100 );       // Augen rollen mit Standard-slow
          for ( u8 i=1; i<=6; i++) {mein_rx_buff [i]  =  '9'; }
          mein_rx_buff [7]  =  0;       // Hilft das bei unvollständiger Eingabe ?
          break;

        case 11:                // Alle Lider auf, full speed
//        s[0]  = mein_rx_buff [3]; s[1] = 0;   // Dekodiere 1stes k
//        npar1 = atoi ( s );   //
          Srv_tm [ 5]   =  2400;
          Srv_tm [ 6]   =  4800;
          Srv_tm [ 8]   =  5400;
          wms (  500);          //
          break;                //
.....
        case 51:        // NUR ANSCHLUSS SERVO 1 mit TasteA/3 auf- und abdrehen
//        AuP51 ( );                    // Fahre AuP51                         r4n
          N1Srvo ();                    // Fahre Servo-Einzel-Einrichtung      r2n
          break;                        //

// - - - - - - - - - - - - - - -
        default:
          break;
      }                         // Ende switch (nmbr)
    }        // Ende if (mein_rx_buff [0] == KOMMANDO_APPS)

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//      Wurde "KOMMANDO_DATS" = "D" erkannt ?   DatenAusgabe Servos
    if (mein_rx_buff [0] == KOMMANDO_DATS)      // Tastatur-Eingabe "D"
    {                                           //
//    Daten für ALLE zehn Servos ausgeben
      uputs0 ("\r\tServodaten");   //
      dat_aus ();               // Servodaten ausgeben
    }        // Ende if (mein_rx_buff [0] == KOMMANDO_DATS)

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//      Wurde "KOMMANDO_NORM" = "N" erkannt ?   Normposition der Servos anfahren
    if (mein_rx_buff [0] == KOMMANDO_NORM)      // Tastatur-Eingabe "N"
    {                                           //
      uputs0 ("\r\tServonormposition,");       //
      kal_0();                          // Initialiswerte einstellen           kal
      uputs0 ("\tneue Servodaten :");   //
      dat_aus ();                       // Servodaten ausgeben

    }        // Ende if (mein_rx_buff [0] == KOMMANDO_NORM)


und so weiter
Ist das so (andeutungsweise) verständlich ?