Problem beim Testsender

[Fef F. (Firma: Gast) (fef)]

Hallo zusammen,


Ich versuche gerade, ein Testsender via POCSAG-Normen mit einem ATMEGA32 
auf einem LCD zu implementieren.
es geht um die Übertragung der Präambel und der Codewortgruppe mit der
POCSAG-Normen wie unter steht.


|PRÄ|S| CW0a | CW0b | CW1a | CW1b |CW2a | CW2b |...| CW7a |CW7b |
    <----- 17 mal 32 Bit - Worte = 544 Bits bzw. 68 Bytes  ----->

PRÄ = Präambel ist folgendermaßen
576 Bit 10101010...
bzw.
18 Wörter 0xAAAAAAAA
bzw.
72 Bytes 0xAA

Die Ausgabe der zweien Codewortgruppen mit 136 Byte-Größe ist wie folg
[0] 7CD215D8   [17] 7CD215D8
[1] 7A89C197   [18] 7A89C197
[2] 7A89C197   [19] 7A89C197
[3] 7A89C197   [20] 7A89C197
[4] 7A89C197         .
[5] 50001F           .
[6] 7E400038         .
[7] 7A89C197
[8] 7A89C197
[9] 7A89C197
[10] 7A89C197
[11] 7A89C197
[12] 7A89C197
[13] 7A89C197
[14] 7A89C197
[15] 7A89C197
[16] 7A89C197  [135] 7A89C197

Es müssen zuerst die Präambel geschickt werden, dannach die
Codewortgruppe komplett übertragen.

ich habe folgendermaßen überlegen.
char * Packet;
uint16_t P_Msg[136];

/*first send preamble ..... 72 bytes=576 bits of 101010..... */

for (i=0; i<72; i++)
{
/*Send POCSAG_PREAMBLE_CODEWORD*/
Packet = POCSAG_PREAMBLE_CODEWORD;
}

USART_Transmit(Packet);

for (i=0; i<136; i++)
{
/*Send POCSAG-Msg[i]*/
Packet = P_Msg[i];
}
USART_Transmit(Packet);

kopieren 136 Byte in einen Charakter, den anschließend versenden

Was mache ich den da Falsch? bzw. wie könnte man es noch machen?

Gruss fef

[Stefan P. (form)]

Fef F. schrieb:
> kopieren 136 Byte in einen Charakter, den anschließend versenden

Das macht keinen Sinn - Du versendest nur einen einzigen Wert.

[Fef F. (Firma: Gast) (fef)]

Danke Stefan für deine schnelle Antwort.

Stefan sagt:
>Du versendest nur einen einzigen Wert.

das heißt, ich muss direkt der Inhalt der P_Msg[i]
in der Funktion USART_Tranmit() als Parameter nehmen?
Und wenn ich das ganze in der While-Schleife führe, wäre das besser?

[randy (Gast)]

hallo,

also sowas:

for (i=0; i<136; i++)
{
  /*Send POCSAG-Msg[i]*/
  USART_Transmit(P_Msg[i]);
}

HTH,
-- randy

[Fef F. (Firma: Gast) (fef)]

ich verstehe nicht warum soll ich noch ein for-schleife verwenden.
denn es wurde schon in die USART_Transmit berücksichtigt.

hier ist die zweie verwendete Übertragungsfunktionen.


/*
 *
 */
void USART_Init(uint16_t baud)
  {
         uint16_t ubrr = (((uint8_t)F_CPU+baud*8UL)/(baud*16)-1);

    /* Set baud rate */
    UBRRH = (uint8_t)(ubrr >> 8);
    UBRRL = (uint8_t)(ubrr)  ;
    /* Enable transmitter */
    UCSRB |= (1<<TXEN);
    /* Set frame format: 8data, 2stop bit */
    UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0);

  }

/*
 *
 */
void USART_Transmit(char* data)
  {
    int8_t i;
    for(i=0; i<strlen(data); i++)
    {
      // Wait for      empty transmit buffer
                        while ( !( UCSRA & (1<<UDRE)) )
      {

      }
    UDR = data[i];  // Put data into buffer, sends the data
    }
  }

Bitte können Sie mir sagen, ob es sich noch nötig der For-Schleife?

[Stefan F. (Gast)]

> USART_Transmit(char* data)
> for(i=0; i<strlen(data); i++)

Diese Funktion kannst du mit einem Zeiger aufrufen, der auf einen String 
zeigt. Ein String ist ein Array von Zeichen (oder Bytes), wo das letzte 
Zeichen den Wert 0 hat.

Dein Byte-Array muss also mit 0 enden und darf mittendrin keine 0 haben.

Der korrekte Aufruf lautet:

USART_Transmit((char*)P_Msg);

P_Msg ist nämlich das Array von 16bit Integern, was einem Zeiger auf 
viele 16bit Integer entspricht. Durch den Typecast machen wir daraus 
einen Zeiger auf viele Zeichen.

Du wirst aber sicher schnell Probleme bekommen, sobald dein Array ein 
Null-Byte enthält, weil nur bis dahin gesendet wird. Wenn z.B. einer 
deiner 16bit Werten kleiner als 256 ist oder ein exaktes vielfaches von 
256 ist, dann hast du schon ein überwünschtes Null-Byte selbst wenn der 
16bit Integer größer als Null ist.

> USART_Transmit(P_Msg[i]);

Das passt nicht zur von Dir genannten Funktion. Das passt nur zu so 
einer Funktion:

void USART_Transmit(uint16_t data)
{
    while ( !( UCSRA & (1<<UDRE)) )
    UDR = data && 0xFF; 
    while ( !( UCSRA & (1<<UDRE)) )
    UDR = data>>8; 
}

Denn P_Msg[i] ergibt einen 16bit Integer.

[Fef F. (Firma: Gast) (fef)]

ich bedanke mir für Zeit und Mühe, um die zahlreichen Information zu 
geben.

Nun ich habe eine Frage.
wie wird die Funktion sich ändert,
wenn die datentype der Variable P_Msg int32_t
also
int32_t P_Msg[136];

Sieht die Funktion so?

void USART_Transmit(int32_t data)
{
    while ( !( UCSRA & (1<<UDRE)) )
    UDR = data && 0xFF;
    while ( !( UCSRA & (1<<UDRE)) )
    UDR = data>>8;
}

[Dietrich L. (dietrichl)]

Fef F. schrieb:
> Sieht die Funktion so?
>
> void USART_Transmit(int32_t data)
> {
>     while ( !( UCSRA & (1<<UDRE)) )
>     UDR = data && 0xFF;
>     while ( !( UCSRA & (1<<UDRE)) )
>     UDR = data>>8;
> }

Nein, sondern so:

void USART_Transmit(int32_t data)
{
    while ( !( UCSRA & (1<<UDRE)) )
    UDR = data && 0xFF;
    while ( !( UCSRA & (1<<UDRE)) )
    UDR = data>>8 && 0xFF;
    while ( !( UCSRA & (1<<UDRE)) )
    UDR = data>>16 && 0xFF;
    while ( !( UCSRA & (1<<UDRE)) )
    UDR = data>>24;
}

 (ohne Garantie ;-)

[Wolfgang (Gast)]

Dietrich L. schrieb:
> Nein, sondern so:
> void USART_Transmit(int32_t data)
> {
>     while ( !( UCSRA & (1<<UDRE)) )
>     UDR = data && 0xFF;
>     while ( !( UCSRA & (1<<UDRE)) )
>     UDR = data>>8 && 0xFF;
>     while ( !( UCSRA & (1<<UDRE)) )
>     UDR = data>>16 && 0xFF;
>     while ( !( UCSRA & (1<<UDRE)) )
>     UDR = data>>24;
> }
>  (ohne Garantie ;-)

Oder gleich in dieser Art:

void USART_Transmit(int32_t data)
{
  for (int i=4;i>0;i--)
  {
    while ( !( UCSRA & (1<<UDRE)) )
    UDR = data && 0xFF;
    data = data>>8; 
  }
}

[Jay (Gast)]

Hallo,

2 kurze Fragen:
a) Sicher, dass da 'data &&' stehen sollte und nicht 'data &', also nur 
ein statt zwei Ampersands?
b) Zugegeben habe ich den Text nur überflogen, aber wo wird etwas über 
Endianess von AVR und der Gegenstelle erwähnt?

CU,
Jay

[Stefan F. (Gast)]

Da fehlen Klammern:

while ( !( UCSRA & (1<<UDRE)) )
{
    UDR = data && 0xFF;
    data = data>>8; 
}

[Stefan F. (Gast)]

a) Sicher, dass da 'data &&' stehen sollte und nicht 'data &', also nur
ein statt zwei Ampersands?

Jetzt, wo du nachfragst... Ich bin sicher, dass es & heissen muss. && 
ist falsch.

b) Zugegeben habe ich den Text nur überflogen, aber wo wird etwas über
Endianess von AVR und der Gegenstelle erwähnt?

Nirgendwo. Das sollte man natürlich auch noch hinterfragen.