Uart/Itoa-Problem

[Dominik (Gast)]

Hallo,

ich sitze derzeit an einem Problem mit meiner itoa- und puts-Funktion 
und komme einfach nicht weiter.

Ich nutze einen MSP430-F2274 und versuche Daten von einem Transciever 
über UART (USCI-Modul) auszugeben.

Die Daten einzulesen funktioniert und sie über UART auszugeben 
ebenfalls.
Nun wollte ich nur bestimmte Daten ausgeben lassen.
Also eine if-Bedingung eingefügt und es ging nichts mehr.
Also die Daten erstmal zwischenspeichern und schauen ob es dann 
funktionert (wundert euch deshalb bitte nicht über das große Array).

Und nun hänge ich an meinem Problem:
Die itoa-Funktion funktioniert eigentlich. Die Puffer-Arrays für die 
UART-Ausgabe werden korrekt gefüllt. Allerdings springt die Laufvariable 
nach dem Befehl "Buffer[i] = '\0';" auf einen Wert über 500. Da es erst 
nach diesem Befehl passiert und danach die Funktion verlassen wird, 
sollte es eigentlich nicht schaden; auch wenn es seltsam ist.

Nach der ersten UART-Ausgabe, wird aber mein zweites Puffer-Array an 
einer Stelle mit '\0' überschrieben, obwohl in der zwischenzeit 
keinerlei Schreibbefehle ausgeführt wurden.

Lasse ich die if-Abfrage weg, und gebe alle Werte direkt nach dem 
auslesen aus, so funktioniert die UART-Ausgabe tadellos. Die Probleme 
begannen mit der Überprüfung auf bestimmte werde, die zur Ausgabe 
weitergeleitet werden sollten.

Ich würde mich freuen, wenn ihr mir bitte helfen könntet.

#include <msp430.h>
#include "CC2500\cc2500.h"
#include "UART\uart.h"


const int THRESHOLD = -75;

//#define DEBUG


void t_itoa(int z, unsigned char* Buffer);

unsigned char RSSI_A[10] = { 0 };
unsigned char Channel[10]  = { 0 };



/*
 * main.c
 *
 */
void main(void) {

  volatile int rssi_value = 0;
  volatile unsigned char state = 0;
  volatile unsigned int i = 0;
  volatile int rssi_array[500] = {0};

  WDTCTL = WDTPW | WDTHOLD;  // Stop watchdog timer

  UART_INIT();
  SPI_INIT();
  cc2500_sendCmdStrobe(SRES);
  cc2500_init();
  P1DIR |= 0x01;



    P1OUT = 0x01;

    cc2500_sendCmdStrobe(CC2500_RX);

    for(;;)
    {

      for(i = 0; i <= 250; i++)
      {
        state = cc2500_readReg(MARCSTATE);
        while((cc2500_readReg(MARCSTATE) & 0x1F) != 0x0D);
        state = cc2500_readReg(MARCSTATE);
        rssi_value = cc2500_readRssi();
        cc2500_sendCmdStrobe(CC2500_IDLE);
        cc2500_writeReg(CHANNR, i);
        cc2500_sendCmdStrobe(CC2500_RX);

        rssi_array[i] = rssi_value;
      }

      cc2500_sendCmdStrobe(CC2500_IDLE);

      cc2500_writeReg(FREQ2, 0x5D);
      cc2500_writeReg(FREQ1, 0xF0);
      cc2500_writeReg(FREQ0, 0x10);

      cc2500_sendCmdStrobe(CC2500_RX);

      for(i = 0; i <= 247; i++)
      {
        while((cc2500_readReg(MARCSTATE) & 0x1F) != 0x0D);
        rssi_value = cc2500_readRssi();
        cc2500_sendCmdStrobe(CC2500_IDLE);
        cc2500_writeReg(CHANNR, i);
        cc2500_sendCmdStrobe(CC2500_RX);

        rssi_array[i + 251] = rssi_value;
      }


      cc2500_sendCmdStrobe(CC2500_IDLE);
      cc2500_writeReg(FREQ2, 0x5C);
      cc2500_writeReg(FREQ1, 0x4F);
      cc2500_writeReg(FREQ0, 0xBB);
      cc2500_sendCmdStrobe(CC2500_RX);

      for(i = 0; i <= 499; i++)
          {
            if(rssi_array[i] >= (-75))
            {
              t_itoa(i,&Channel[0]);        //funktioniert
              t_itoa(rssi_array[i],RSSI_A); //funktioniert
              uart_puts(&Channel[0]);       //funktioniert überschreibt aber RSSI_A teilweise
              uart_putc(':');
              uart_puts(&RSSI_A[0]);
              uart_putc('\n');
            }
          }
    }
}

void t_itoa(int z, unsigned char* Buffer)
{
  int i = 0;
  int j;
  char tmp;
  unsigned int u;

  //zahl negativ?
    if( z < 0 ) {
      Buffer[0] = '-';
      Buffer++;
      u = ( (unsigned int)(-(z+1))) + 1;
    }
    else {
      u = (unsigned int)z;
    }

    //Stellen berechnen
    do {
      Buffer[i++] = '0' + u % 10;
      u /= 10;
    } while( u > 0 );


    //spiegeln
    for( j = 0; j < i / 2; j++ )
    {
      tmp = Buffer[j];
      Buffer[j] = Buffer[i-j-1];
      Buffer[i-j-1] = tmp;
    }

    //Stringende einfügen
    Buffer[i] = '\0';
}

/////in uart.h definiert
void uart_putc(unsigned char data)
{

  while (!(IFG2&UCA0TXIFG));   // USCI_A0 TX buffer ready?
  UCA0TXBUF = data;      // write TX buffer
}

void uart_puts(unsigned char *data)
{
  volatile unsigned int i = 0;

  do
  {
    while (!(IFG2&UCA0TXIFG));  // USCI_A0 TX buffer ready?
    UCA0TXBUF = *(data + i++);  // write TX buffer
  }
  while(*(data + i) != '\0');

}

[Rufus Τ. F. (rufus)]

Dominik schrieb:
> volatile int rssi_array[500] = {0};

Das geht auf einem Controller, der gerade mal 1024 Bytes RAM hat, 
ziemlich gnadenlos in die Hose.

[Dominik (Gast)]

Immer dann, wenn man schon nach Hilfe gefragt hat, findet man den Fehler 
selber.

In der puts-Funktion wurde das "volatile" entfernt. Allerdings frage ich 
mich dennoch, warum dies zum Fehler geführt hat?

[Dominik (Gast)]

Rufus Τ. Firefly schrieb:
> Das geht auf einem Controller, der gerade mal 1024 Bytes RAM hat,
> ziemlich gnadenlos in die Hose.

Oh man, im Eifer des Gefechts überhaupt nicht darüber nachgedacht.
Danke für den Hinweis!

[Rufus Τ. F. (rufus)]

Nicht das "volatile" führt zum Fehler, sondern Dein durch Dein 1000 Byte 
großes Array plattgemachter Stack.

[Dirk B. (dirkb2)]

Dominik schrieb:
> In der puts-Funktion wurde das "volatile" entfernt. Allerdings frage ich
> mich dennoch, warum dies zum Fehler geführt hat?

Willst du wirklich die '\0' vom Stringende mitsenden?
Wenn nicht, dann musst du zuerst auf das Ende prüfen.

Und mach es ohne i.

void uart_puts(unsigned char *data)
{
  while(*data);
  {
    while (!(IFG2&UCA0TXIFG));  // USCI_A0 TX buffer ready?
    UCA0TXBUF = *data;  // write TX buffer
    i++; 
  }
}

[Dominik (Gast)]

Also war es wohl Zufall, dass das Entfernen von "volatile" den Fehler 
behoben hat und es war Glück, dass es überhaupt noch soweit lief.
Sowas mit dem zu großen Array sollte wirklich nicht passieren.
Vielen Dank!

[Dominik (Gast)]

Dirk B. schrieb:
> Willst du wirklich die '\0' vom Stringende mitsenden?

Mache ich doch gar nicht oder habe ich noch einen Denkfehler?

do
  {
    while (!(IFG2&UCA0TXIFG));  // USCI_A0 TX buffer ready?
    UCA0TXBUF = *(data + i++);  // write TX buffer
  }
  while(*(data + i) != '\0');

i erhöht sich doch nachdem ein Zeichen in den TXBuffer geschrieben wurde 
und zeigt somit bereits auf das nächste Element. Sollte dieses '\0' 
sein, bricht die Schleife doch ab und das Stringende wird nicht 
gesendet.
Es könnte höchstens passieren, dass ein leerer String übergeben wird 
aber darüber bin ich mir bewusst.

[Dirk B. (dirkb2)]

Dominik schrieb:
> Es könnte höchstens passieren, dass ein leerer String übergeben wird
> aber darüber bin ich mir bewusst.

Ok. Trotzdem nicht fein, da man es umgehen kann.

Das i++; bei mir da oben soll natürlich ein data++; sein. (schäm)

[Dominik (Gast)]

Hast du auch wieder recht und werde es noch dahingehend ändern, dass es 
in allen Fällen funktioniert. :)

[Karl H. (kbuchegg)]

Und wenn du schon dabei bist.
Du hast eine Funktion uart_putc. Ein uart_puts funktioniert im Prinzip 
so, dass er alle Zeichen ausgibt. Ein Zeichen auszugeben ist aber die 
Domäne der Funktion uart_putc. Die weiss wie das geht und was es da 
alles zu beachten gibt. Das ist nichts worüber sich uart_puts Gedanken 
machen muss oder machen sollte (wie zum Beispiel irgendwann mal die 
Behandlung eines Handshakes)

void uart_puts(unsigned char *data)
{
  while( *data )
    uart_putc( *data++ );
}

fertig.

Du musst anfangen deine Funktionen als 'Build Blocks' zu sehen. 
'komplexere Funktionen' bedienen sich der Services, die 'simplere 
Funktionen' zur Verfügung stellen.


Genauso wie diese Sequenz in deinem Hauptprogramm

              t_itoa(i,&Channel[0]);        //funktioniert
              t_itoa(rssi_array[i],RSSI_A); //funktioniert
              uart_puts(&Channel[0]);       //funktioniert überschreibt aber RSSI_A teilweise
              uart_putc(':');
              uart_puts(&RSSI_A[0]);
              uart_putc('\n');

eine Zahl ausgeben zu können stinkt förmlich danach, dass es eine 
Basisfunktionalität darstellt, genauso wie die Ausgabe eines Strings 
förmlich danach gestunken hat.
Es wird daher sinnvoll sein, sich dafür eine eigene Funktion zu 
schaffen, die genau das kann: einen int ausgeben.
Die Funktion an sich ist trivial

void uart_puti( int value )
{
  char buff[7];    // -32768,   6 Zeichen + '\0'

  t_itoa( value, buff );
  uart_puts( buff );
}

aber sie vereinfacht dir die Sequenz im Hauptprogramm (und in weiterer 
Folge dann nicht nur diese) zu

              uart_puti( i );
              uart_putc( ':' );
              uart_puti( rssi_array[i] );
              uart_putc( '\n' );

und du brauchst dir hier schon wieder keine Gedanken darüber machen, 
dass du zur Ausgabe eines int einen char Buffer brauchst, der dann auch 
noch groß genug sein sollte - das alles weiß die Funktion uart_puti und 
befreit dich damit an dieser Stelle davon, dir darüber Gedanken machen 
zu müssen. Dafür kannst du dich hier darauf konzentrieren, was du 
eigentlich tun willst. Nämlich eine Zahl auszugeben, gefolgt von einem 
Doppelpunkt, gefolgt von einer weiteren Zahl und einem Zeilenvorschub. 
Genau das, und nur das, liest du aber hier im Code bzw. genau über diese 
Dinge hast du nachgedacht, als du die einfachere Sequenz geschrieben 
hast.

[Eric B. (beric)]

Dirk B. schrieb:

>

> void uart_puts(unsigned char *data)
> {
>   while(*data);
>   {
>     while (!(IFG2&UCA0TXIFG));  // USCI_A0 TX buffer ready?
>     UCA0TXBUF = *data;  // write TX buffer
>     i++;
>   }
> }

Da sind mindestens 3 Fehlder drinne.
- Das ; nach dem while(*data) soll weg
- Das i++ nutzt nix
- data wird nicht erhöht

[Dirk B. (dirkb2)]

Eric B. schrieb:
> Da sind mindestens 3 Fehlder drinne.

Danke.