Übertragung von String (DX,Y,F)

[Luffy M. (monkeydluffy)]

Guten Tag,

ich versuche gerade ab dem PC Daten zum Atmega644p zu senden. Die Daten, 
die vom PC gesendet sind, sehen folgendermaße aus: "D X,Y F". Dh, der 
Atmega644p empfämgt nacheinander Befehle in Form von "D X,Y F".
D ---> Anfang der Daten
X----> X Position
Y----> Y Position
F----> Ende der Daten.

Der Atmega664p bekommt die Daten von PC über USART0 und leitet über 
USART1 die empfangenen Daten an zwei anderen Enheiten  weiter.

Wenn ich schritt für schritt der C-Code von Mikrocontroller  debugge, 
läuft die Datenübertragung in Atmega644p perfekt. Dh, der Atmega644p 
führt komplett aus, was er als Daten empfangen hat.

Aber wenn ich auf ein Mal mein  C-code von Atmega644p debugge, führt der 
Atmega644p nicht komplett aus, was er als Daten  empfangen hat.

Ich wäre sehr dankbar, wenn jemand mich unterstützt.

Mit besten Grüßen.

Mein C-Programm lautet:

#include <avr/io.h>
#include <avr/interrupt.h> 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h> 
#include <util/delay.h>

#define F_CPU 9.6e6
#define FOSC 8000000 // Clock Speed
#define BAUD 115200UL

#define UBRR_VAL ((FOSC+BAUD*8)/(BAUD*16)-1)   // clever runden
///////////////////////////////////////////////////////////////////
#define usart_buffer_max_size 64u
#define usart_command_max_size 10

char usart_command[usart_command_max_size + 1] = {0};
char usart0_tx_buffer[usart_buffer_max_size];
char usart1_tx_buffer[usart_buffer_max_size];
volatile uint8_t usart_command_size = 0;
volatile uint8_t usart0_tx_buffer_size = 0;
volatile uint8_t usart0_tx_buffer_start = 0;
volatile uint8_t usart1_tx_buffer_size = 0;
volatile uint8_t usart1_tx_buffer_start = 0;

// Configuration USART0, USART1 and setting Baudrate 

void USART_Init(unsigned int ubrr)
{
  UBRR0H = (unsigned char)(ubrr>>8);
  UBRR0L = (unsigned char) ubrr;
  UBRR1H = (unsigned char)(ubrr>>8);
  UBRR1L = (unsigned char) ubrr;
  UCSR0B = (1<<RXEN0) | (1<<TXEN0) | (1<<RXCIE0) | (0<<TXCIE0) | (0<<UDRIE0);
  UCSR0C = (1<<USBS0) | (1<<UCSZ01) | (1<<UCSZ00);
  UCSR1B = (1<<RXEN1) | (1<<TXEN1) | (0<<RXCIE1) | (0<<TXCIE1) | (0<<UDRIE1);
  UCSR1C = (1<<USBS1) | (1<<UCSZ11) | (1<<UCSZ10);
} 

// Eingang vom Ringpuffer 
void USART0_QueueIn(char c)
{
  int i;

  if (usart0_tx_buffer_size < usart_buffer_max_size)
  {
    i = (usart0_tx_buffer_size + usart0_tx_buffer_start) % usart_buffer_max_size;
    usart0_tx_buffer[i] = c;
    ++usart0_tx_buffer_size;
  }
}

// Ausgang vom Ringpuffer 
char USART0_QueueOut(void)
{
  char c;

  if (usart0_tx_buffer_size == 0)
    return 0;
  c = usart0_tx_buffer[usart0_tx_buffer_start];
  --usart0_tx_buffer_size;
  usart0_tx_buffer_start = (usart0_tx_buffer_start + 1) % usart_buffer_max_size;
  return c;
}

// Eingang vom Ringpuffer 
void USART1_QueueIn(char c)
{
  int i;

  if (usart1_tx_buffer_size < usart_buffer_max_size)
  {
    i = (usart1_tx_buffer_size + usart1_tx_buffer_start) % usart_buffer_max_size;
    usart1_tx_buffer[i] = c;
    ++usart1_tx_buffer_size;
  }
}

// Ausgang vom Ringpuffer 
char USART1_QueueOut(void)
{
  char c;

  if (usart1_tx_buffer_size == 0)
    return 0;
  c = usart1_tx_buffer[usart1_tx_buffer_start];
  --usart1_tx_buffer_size;
  usart1_tx_buffer_start = (usart1_tx_buffer_start + 1) % usart_buffer_max_size;
  return c;
}

// Sendung einer Antwort über der Ringpuffer zum USART0 
static void USART0_Send(const char *s)
{
  int i;
  
  for (i = 0; s[i] != 0; ++i)
    USART0_QueueIn(s[i]);
  if (usart0_tx_buffer_size > 0)
    UCSR0B |= 1 << UDRIE0;
}

// Sendung eines Befehls über der Ringpuffer zum USART1 
static void USART1_Send(const char *s)
{
  int i;
  
  for (i = 0; s[i] != 0; ++i)
    USART1_QueueIn(s[i]);
  if (usart1_tx_buffer_size > 0)
    UCSR1B |= 1 << UDRIE1;
}

// Verarbeitung eines Befehls
static void ProcessCommand(void)
{
  int i;
  int x;
  int y;
  char x_moteur[12];
  char y_moteur[12];

  
  for (i = 0; i < usart_command_size; ++i)
    if (usart_command[i] == ',')
      break;

  if (i <= 0 || i >= usart_command_size - 1)
  {
    // Man hat kein Kommazeichen in Mitte des Strings gefunden -> Fehler 
    USART0_Send("\x15");  // NAK, Sendung von Data hat nicht geklappt. 
    usart_command_size = 0;
    return;
  }
  // Ich wandle x und y in Integer um, um Berechnung durchzuführen, wenn es nötig ist
  // Extraktion von X und Y   
    usart_command[i] = 0;
    usart_command[usart_command_size] = 0;
    x = atoi(usart_command);
    y = atoi(usart_command + i + 1);
    usart_command_size = 0;
  itoa(x, x_moteur, 10);
    itoa(y, y_moteur, 10);

      // Sendung position x_moteur 
   USART1_Send("#1s");
   USART1_Send(x_moteur);
   USART1_Send("\r");

   USART1_Send("#1A\r"); // Losfahren der Platine auf die x-Achse
  
       // Sendung position y_moteur 
   USART1_Send("#2s");
   USART1_Send(y_moteur);
   USART1_Send("\r");

   USART1_Send("#2A\r"); // Losfahren der Platine auf die y-Achse
   USART0_Send("\x06"); // ACK ---> Freigabe: PC kann der nächste Data senden
  
  
  }

// La fonction d´interruption de reception du byte 
// Cette fonction est active lorsque RXCIE0 = 1  
ISR(USART0_RX_vect)
{
  char data;
  data = UDR0;

 // Verarbeitung des Befehls -->("D X,Y F") 
  // X = x_moteur und Y = y_moteur 
  if (data == 'F')
  {    
    ProcessCommand();
     
   }

  else if (data == 'D')
  {
    /* Erzeugung eines neuen Befehls */
    usart_command_size = 0;
  }

  else
  {
    // Als man weder F, noch D empfängt, speichert man 
  //die Koordinatenposition(X,Y) in einem Befehl 
    if (usart_command_size < usart_command_max_size)
    {
      usart_command[usart_command_size] = data;
      ++usart_command_size;
    }
  }
}

// Interruptsfunktion für Byte-Übertragung 
// Diese Funktion ist an, wenn UDRIE1 = 1 
ISR(USART0_UDRE_vect)
{
  UDR0 = USART0_QueueOut();
  // Sendung stoppen, wenn es keine Daten mehr gibt zu senden 
  if (usart0_tx_buffer_size == 0)
    UCSR0B &= ~(1 << UDRIE0);
}

// Interruptsfunktion für Byte-Übertragung 
// Diese Funktion ist an, wenn UDRIE1 = 1 
ISR(USART1_UDRE_vect)
{
  UDR1 = USART1_QueueOut();
  // Sendung stoppen, wenn es keine Daten mehr gibt zu senden 
  if (usart1_tx_buffer_size == 0)
    UCSR1B &= ~(1 << UDRIE1);
}

void VorEinstellungMotor(void)
 { 
   USART1_Send("#1|0\r"); // Deaktivierung von Antwort der Motorsteuerung Nr 1
   USART1_Send("#2|0\r"); // Deaktivierung von Antwort der Motorsteuerung Nr 2
   USART1_Send("#1D0\r"); // Festlegen der Position der Platine als Ursprung auf die x-Achse 
   USART1_Send("#2D0\r"); // Festlegen der Position der Platine als Ursprung auf die y-Achse
   USART1_Send("#1p2\r"); // Modus: Absolut Positionierung --> p=2 
   USART1_Send("#2p2\r"); // Modus: Absolut Positionierung --> p=2
           
 }

int main (void)
{ 
  USART_Init(UBRR_VAL); // Initialisierung von USART0 and USART1
  VorEinstellungMotor(); // Initialisierung Motorsteuerung
  sei(); // Aktierung Interruptsfunktion

  while (1) // Endlosschleife
  {
      
  }
  
}

[Daniel V. (danvet)]

Vielleicht liegt es daran, dass du in der Receive-Interruptroutine schon 
anfängst zu senden.
Besser: in der Mainloop schauen, ob was im Puffer steht und dann senden.
In der Interrupt-Routine so wenig machen wie möglich. Da solltest du 
schnell wieder raus kommen.

[Luffy M. (monkeydluffy)]

Danke  Daniel V. für deine schnelle Antwort.

>Besser: in der Mainloop schauen, ob was im Puffer steht und dann senden.
>In der Interrupt-Routine so wenig machen wie möglich. Da solltest du
>schnell wieder raus kommen.

Kannst du mir bitte ein Beispiel vorschlagen ??

Danke im Voraus.

[Daniel V. (danvet)]

Luffy Monkey schrieb:
> Danke  Daniel V. für deine schnelle Antwort.
>
>>Besser: in der Mainloop schauen, ob was im Puffer steht und dann senden.
>>In der Interrupt-Routine so wenig machen wie möglich. Da solltest du
>>schnell wieder raus kommen.
>
> Kannst du mir bitte ein Beispiel vorschlagen ??
>
> Danke im Voraus.

Echt jetzt? Ich hätte aus deinem Code vermutet, dass du diese 
Kleinigkeit auch noch hinbekommst.

volatile uint8_t command_ready = 0;



// La fonction d´interruption de reception du byte 
// Cette fonction est active lorsque RXCIE0 = 1  
ISR(USART0_RX_vect)
{
  char data;
  data = UDR0;

 // Verarbeitung des Befehls -->("D X,Y F") 
  // X = x_moteur und Y = y_moteur 
  if (data == 'F')
  {    
    command_ready = 1;
     
   }

  else if (data == 'D')
  {
    /* Erzeugung eines neuen Befehls */
    usart_command_size = 0;
  }

  else
  {
    // Als man weder F, noch D empfängt, speichert man 
  //die Koordinatenposition(X,Y) in einem Befehl 
    if (usart_command_size < usart_command_max_size)
    {
      usart_command[usart_command_size] = data;
      ++usart_command_size;
    }
  }
}


int main (void)
{ 
  USART_Init(UBRR_VAL); // Initialisierung von USART0 and USART1
  VorEinstellungMotor(); // Initialisierung Motorsteuerung
  sei(); // Aktierung Interruptsfunktion

  while (1) // Endlosschleife
  {
    if(command_ready)
    {
      ProcessCommand();
      command_ready = 0;
    }      
  }
  
}

nur so auf die Schnelle

[Luffy M. (monkeydluffy)]

Vielen Dank Daniel V. .

Ich probiere mal dein Vorschlag.

Danke noch mal.

[иммэр эин нэуёр намэ (Gast)]

Es gibt Verschiedenes zu bemaengeln.
- QueueIn() geht davon aus, dass die Queue eh genug Platz hat. Wenn 
voll, geht's in den Dreck.

[Karl H. (kbuchegg)]

Jungs - hatten wir alles schon

Beitrag "Empfangen und Übertragung von Daten über USART"

Ich will niemanden abhalten ihm zu helfen, aber wenn wir ehrlich sind, 
läuft es darauf hinaus, dass ihm das wer schreiben muss.

[Luffy M. (monkeydluffy)]

иммэр эин нэуёр намэ schrieb:

> Es gibt Verschiedenes zu bemaengeln.
> - QueueIn() geht davon aus, dass die Queue eh genug Platz hat. Wenn
> voll, geht's in den Dreck.

 Bei mir hat QueueIn() genug Platz, um Daten zu bekommen.
Dataform: "DX,YF"
X ----> Höchsten 5 Zeichen in ASCii
Y ----> Höchsten 5 Zeichen in ASCii

Die Übertragung von Daten erfolgt nacheinander, so dass die QueueIn() 
immer genug Platz hat, um Zeichen zu empfangen.