Strings in Array schreiben und in einer Zeile ausgeben

[Christian Bernhard (Gast)]

Hallo Fachleute,

ich würde gerne viele Werte in ein Array schreiben und diese dann in 
einer Zeile ausgeben.

[code]

uint8_t position;
const char werte[32];


while(1)
{
position++;
adcval=werte[position];

uart_puts(&werte[0]);

}


muss man das ganze villeicht mit Funktionen aus der pgmspace.h machen?

lg Christian

[Klaus W. (mfgkw)]

Hast du Grundkenntniisse in C?

[Blödmann (Gast)]

>ich würde gerne viele Werte in ein Array schreiben und diese dann in
>einer Zeile ausgeben.

Kannst Du machen, aber warum willst Du die "vielen Werte" erst in ein 
Array schreiben? Du kannst die Werte auch jeweils einzeln ausgeben. 
Spart Speicherplatz.

Bist Du sicher das Du die Werte ausgeben willst und nicht eine ihnen 
entsprechende Folge von ASCII-Zeichen? Denke daran dass uart_puts im 
aufhört zu senden, wenn es auf eine '0' im String trifft.

Wozu ist das array als const deklariert? Warum inkrementierst Du 
position? Warum erst den Wert umspeichern und dann ausgeben? Wozu 
"&werte[0]" wenn es "werte" auch tut? Deutet alles darauf hin, das Du C 
nicht kannst.


>muss man das ganze villeicht mit Funktionen aus der pgmspace.h machen?

Wenn Du einen konstanten String ausgeben willst, der zur Compile-Zeit 
bekannt ist schon. Aber das willst Du ja garnicht. Wie kommst Du darauf?

[Blödmann (Gast)]

Schreibfehler:

Denke daran dass uart_puts im
aufhört zu senden, wenn es auf eine '\0' im String trifft.

[Klaus W. (mfgkw)]

... und daß hier eine Endlosschleife steht, in der position hartnäckig 
hochgezählt wird und mit werte[position] entsprechend hinter das Feld 
gegriffen wird (ok, irgendwann kommt man von unten wieder in das Feld 
hinein), adcval (wo definiert?) gar nicht verwendet wird, und eigentlich 
beim besten Willen nicht klar ist, was eigentlich gemacht werden soll.
Sonst ist aber alles soweit ok...

Vielleicht fehlt es ja auch nur an einer nachvollziehbaren 
Problemstellung?

[Christian Bernhard (Gast)]

Ich möchte nur ein paar Werte über den ADC einlesen und die nacheinander 
in ein Array schreiben. Diese Sachen möchte ich dann noch nach 
Möglichkeit zur Kontrolle über den uart schicken.

der UART, ADC und I2C Bus funktionieren problemlos, ich weiß halt nur 
nicht, wie ich das mit dem array anstellen soll.

die Funktion für das adcval

uint16_t ADC_Read( uint8_t channel )
{
  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {}  // auf Abschluss der Konvertierung warten
  return ADCW;                    // ADC auslesen und zurückgeben
}

adcval=ADC_Read(0);

Der Wert des ADC wird momentan so herausgegeben

char wertadc[16];

itoa(adcval, wertadc, 10);
  uart_puts("\r\n");
  uart_puts("Wert des ADC: ");
  uart_puts(&wertadc[0]);
  uart_puts("\r\n");

[Karl H. (kbuchegg)]

Christian Bernhard schrieb:
> Ich möchte nur ein paar Werte über den ADC einlesen und die nacheinander
> in ein Array schreiben. Diese Sachen möchte ich dann noch nach
> Möglichkeit zur Kontrolle über den uart schicken.
>

Array anlegen und die Werte da nacheinander ablegen.
Ich versteh jetzt ehrlich gesagt auch noch nicht, wo da jetzt das große 
Problem sein soll. Jedes C-Lehrbuch lässt sich in einem der vorderen 
Kapitel des langen und des breiten über Arrays aus.

>

> uint16_t ADC_Read( uint8_t channel )
> {
>   // Kanal waehlen, ohne andere Bits zu beeinflußen
>   ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
>   ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
>   while (ADCSRA & (1<<ADSC) ) {}  // auf Abschluss der Konvertierung
> warten
>   return ADCW;                    // ADC auslesen und zurückgeben
> }
> 
> adcval=ADC_Read(0);
> 
>

soweit so gut.

Also brauchst du erst mal ein Array.
Da ist zb eines

uint16_t adcValues[100];

darin können 100 ADC Werte zwischengelagert werden. Da es wahrscheinlich 
schlau sein wird, mitzuzählen, wieviele da jetzt schon drinnen sind, 
installieren wir gleich noch einen Zähler für diesen Zweck

uint16_t adcValues[100];
uint8_t  nrADCValues;

und wenn vom ADC ein neuer Wert kommt, dann wird er im Array hinten 
angefügt (SIcherheitshalber mit einer Abfrage, damit es zu keinem 
Überlauf kommt)

int main()
{
  ....

    if( nrADCValues < 100 ) {
      adcValues[ nrADCValues ] = ADC_Read(0);
      nrADCValues++;
    }

  ....
}

soweit so gut.

> Der Wert des ADC wird momentan so herausgegeben
>
>

> 
> char wertadc[16];
> 
> itoa(adcval, wertadc, 10);
>   uart_puts("\r\n");
>   uart_puts("Wert des ADC: ");
>   uart_puts(&wertadc[0]);
>   uart_puts("\r\n");
> 
>

das hat ja erst mal nichts damit zu tun, dass die Werte 
zwischengespeichert wurden. Die Werte vom ADC zu speichern, ist eine 
Sache. Sie auszugeben ist eine ganz andere Sache.

Dazu macht man sich am besten gleich mal eine Funktion, die EINEN Wert 
ausgeben kann. Egal wo der her kommt.

void uart_puti( uint16_t value )
{
  char buffer[10];
  itoa( value, buffer, 10);
  uart_puts( buffer );
}

und mit dieser Hilfsfunktion ist es jetzt ein leichtes, alle im Array 
gespeicherten Werte auszugeben

int main()
{
  ....

    if( nrADCValues < 100 ) {
      adcValues[ nrADCValues ] = ADC_Read(0);
      nrADCValues++;
    }

  ....


    for( i = 0; i < nrADCValues; ++i ) {
      uart_puts( "Wert " );
      uart_puti( i );
      uart_puts( " : " );
      uart_puti( adcValues[i] );
      uart_puts( "\r\n" );
    }

}

> der UART, ADC und I2C Bus funktionieren problemlos, ich weiß halt nur
> nicht, wie ich das mit dem array anstellen soll.

Vielleicht doch ein wenig weniger Copy&Paste Programmierung betreiben 
und dafür die Grundlagen erst einmal lernen?