String umwandlung und auffüllen

[René K. (tesla24)]

Hallo liebe Gemeinde:

Ich habe mehrere int Variablen, diese wandel ich jeweils mit itoa() in 
strings um. Dann möchte ich die einzelnen strings in einen großen String 
verketten und diesen großen sende ich dann mit UART raus.

Manche Variablen können mal einen Wert von 5 bis 255 haben, nun muss 
aber der String immer die gleiche Länge haben um ihn am Empfänger 
auswärten zu können!

Bsp.:

int a=5;
char a_str[];

itoa(a,a_str,10);

Ergebnis: '5'
Ich hätte gerne: '005'

Vielen Dank im voraus !

[J. F. (Firma: Père Lachaise) (rect)]

Sowas?

    int a = 3;
    char buffer[4];
    snprintf(buffer, 4, "%03d", a);

[Nop (Gast)]

zum Beispiel so, ohne printf:

void to_string(char *str, uint8_t val)
{
  str[0] = val / 100;
  val %= 100;
  str[1] = val / 10;
  val %= 10;
  str[3] = val;
  str[4] = 0;
}

Bedingung: Der Buffer, den man als str da reingibt, muß wenigstens 4 
Zeichen fassen können:

char my_str[4];
uint8_t my_val;

my_val = 42;
to_string[my_str, my_val);

Ergebnis: "042" in my_str, und nullterminiert.

[Nop (Gast)]

argh..

void to_string(char *str, uint8_t val)
{
  str[0] = val / 100 + '0';
  val %= 100;
  str[1] = val / 10 + '0';
  val %= 10;
  str[3] = val + '0';
  str[4] = 0;
}

[Harlekin (Gast)]

René K. schrieb:
> Manche Variablen können mal einen Wert von 5 bis 255 haben, nun muss
> aber der String immer die gleiche Länge haben um ihn am Empfänger
> auswärten zu können!

Alternative wäre, ein Trennzeichen zwischen die Variablen setzen. 
Stichwort csv

[René K. (tesla24)]

Hallo wieder....

Ja stimmt dass mit dem Trennzeichen klingt auch gut!

Ich habe nun folgendes Problem:
Die Zusammensetzung und Umwandlung der verschiedenen Variablen in einen 
String funktioniert auch das mit den "Nullen" auffüllen. Ich habe mit 
einem anderen Compiler ein c-Programm geschrieben und mit printf zur 
Kontrolle ausgegeben.

Wenn ich einen char teststring[]="Hallo Welt" über die UART ausgebe wird 
es mir auch in HTerm angezeigt, also funktioniert die "uart_puts()"

Die Übertragung des von mir generierten String klappt aber leider nicht 
und ich komme nicht drauf. Mittlerweile habe ich auch schon alles ins 
main geschrieben.

#include <util/setbaud.h>

//Standardbibliotheken
#include <avr/io.h>
#include <util/delay.h>
#include <string.h>
#include <avr/interrupt.h>



//Eigene Bibliotheken
#include "defines.h"
#include "init.h"
#include "globals.h"
#include "pwm.h"

char test_string[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ";

int main(void)
{
//Globale setzen nach Neustart
bga_go=1;
bga_power_bit=255;
led_go=1;
frost=1;
bga_stufen=7;
bga_max_power_bit=255;
bga_timer=123;
pwm_rot=1023;
pwm_gruen=1023;
pwm_blau=1023;
  
  
portinit();
timer0_init();
serial_init();
  


sei();
  
  
 while (1) 
{
//Umwandlung und Speichern der Globalen in die Strings
snprintf(bga_go_str,1,"%01d",bga_go);
snprintf(bga_power_bit_str,3,"%03d",bga_power_bit);
snprintf(frost_str,1,"%01d",frost);
snprintf(bga_stufen_str,1,"%01d",bga_stufen);
snprintf(bga_max_power_bit_str,"%03d",bga_max_power_bit);
snprintf(bga_timer_str,3,"%03d",bga_timer);
snprintf(led_go_str,1,"%01d",led_go);
snprintf(pwm_rot_str,4,"%04d",pwm_rot);
snprintf(pwm_gruen_str,4,"%04d",pwm_gruen);
snprintf(pwm_blau_str,4,"%04d",pwm_blau);

//strings verketten zu einem String 21 Einzelzeichen 
send_to_PI[0]=  bga_go_str[0];      
send_to_PI[1]=  bga_power_bit_str[0];      
send_to_PI[2]=  bga_power_bit_str[1];      
send_to_PI[3]=  bga_power_bit_str[2];      
send_to_PI[4]=  frost_str [0];
send_to_PI[5]=  bga_timer_str[0];
send_to_PI[6]=  bga_timer_str[1];
send_to_PI[7]=  bga_timer_str[2];
send_to_PI[8]=  led_go_str[0];
send_to_PI[9]=  pwm_rot_str[0];
send_to_PI[10]= pwm_rot_str[1];
send_to_PI[11]= pwm_rot_str[2];
send_to_PI[12]= pwm_rot_str[3];
send_to_PI[13]= pwm_gruen_str[0];
send_to_PI[14]= pwm_gruen_str[1];
send_to_PI[15]= pwm_gruen_str[2];
send_to_PI[16]= pwm_gruen_str[3];
send_to_PI[17]= pwm_blau_str[0];
send_to_PI[18]= pwm_blau_str[1];
send_to_PI[19]= pwm_blau_str[2];
send_to_PI[20]= pwm_blau_str[3];
send_to_PI[21]= bga_max_power_bit_str[0];
send_to_PI[22]= bga_max_power_bit_str[1];
send_to_PI[23]= bga_max_power_bit_str[2];

}
  
}



ISR(TIMER0_OVF_vect) 
{
  cli();
    
  //uart_puts(send_to_PI); //Das noch nicht !
  uart_puts(test_string); //Das Funktioniert perfekt !
  sei();

}

[Frank M. (ukw) (Moderator)]

Warum erst in verschiedene Strings per snprintf und dann diese wieder 
zusammenkopieren? Warum nicht direkt raussenden?

char buf[16];

snprintf(buf,1,"%01d",bga_go);
uart_puts(buf);
snprintf(buf,3,"%03d",bga_power_bit);
uart_puts(buf);
....

> send_to_PI[23]= bga_max_power_bit_str[2];

Hier fehlt die Terminierung:

send_to_PI[24] = '\0';

> ISR(TIMER0_OVF_vect)
> {
>   cli();
>
>   //uart_puts(send_to_PI); //Das noch nicht !
>   uart_puts(test_string); //Das Funktioniert perfekt !
>   sei();
>
> }

Das ist böse: Einen ganzen String in einer ISR rauskloppen macht man 
nicht. Das dauert viel zu lang.

Man setzt in der ISR ein Flag. In der Hauptschleife wertet man dann 
dieses Flag aus und sendet dann den String.

[René K. (tesla24)]

Vielen Dank,

ich wollte das in eins rausschicken damit ich den String am Empfänger 
wieder in die Variablen aufdröseln und abspeichern kann.

Mit der ISR hatte ich auch schon bedenken, auch weil ich dort eine 
Schleife drin habe, was ja auch gefährlich ist.

Ich weiß irgendwie selber nicht warum mir das so Schwierigkeiten 
macht....klar ist schon etwas her das Ganze.

[Johnny B. (johnnyb)]

René K. schrieb:
> Vielen Dank,
>
> ich wollte das in eins rausschicken damit ich den String am Empfänger
> wieder in die Variablen aufdröseln und abspeichern kann.
>
> Mit der ISR hatte ich auch schon bedenken, auch weil ich dort eine
> Schleife drin habe, was ja auch gefährlich ist.
>
> Ich weiß irgendwie selber nicht warum mir das so Schwierigkeiten
> macht....klar ist schon etwas her das Ganze.

Wenn Dein Empfänger auf einem grösseren Betriebssystem basiert ist aber 
auch nicht garantiert, dass Du den kompletten String als einen einzigen 
"Block" erhälst. Da musst Du eh damit umgehen können, dass der String 
unterteilt sein könnte, also alles was empfangen wird zusammensetzen, 
bis das Endzeichen (\0) empfangen wird.

[Walter K. (Gast)]

Nur mal so interessehalber...

dieses Array send_to_PI[...]
ist was?  Klar, wenn es ein char-array sein soll fehlt die 
Null-Terminierung
- aber wo sehe ich was das ist, wie gross es deklariert wurde?

ist das auch in globals.h ?

[René K. (tesla24)]

Das send_to_PI[] ist in den globals.h deklariert und ist ja der String 
den ich in eins übertragen möchte.

also mit dev-c Compiler funktioniert snprintf() aber in AVR nicht!

ich habe das mal mit atoi() gemacht und es klappt. Den funktionierenden 
Code poste ich gleich. Zuvor habe ich noch eine Frage:

nach jedem uart_puts() setzt er am Ende "\0" warum? liegt das irgendwie 
am Zeiger ?

Wie bekomme ich das hin das dort ein "\n" anstatt dem "\0" angehängt 
wird?

[c}
void uart_puts (const char *s)
{
   do
   {
     uart_putc (*s);
   }
   while (*s++);
   uart_putc('\n');
}
[/c]

[Nop (Gast)]

René K. schrieb:

> nach jedem uart_puts() setzt er am Ende "\0" warum?

Weil Du eine do-while-Schleife anstatt einer while-do-Schleife 
verwendest.

[René K. (tesla24)]

int main(void)
{
  //Globale setzen nach Neustart
  bga_go=1;
  bga_power_bit=128;
  bga_max_power_bit=255;
  bga_stufen=7;
  bga_timer=45;
  frost=0;
  led_go=1;
  pwm_rot=1023;
  pwm_gruen=1023;
  pwm_blau=1023;
  
  portinit();
  timer0_init();
  serial_init();
  


  sei();
  
    /* Replace with your application code */
    while (1) 
    {
    
    if(flag_uart_tx)
    {
      char buffer[7];
      
      uart_puts("A");
      
      //Umwandlung und Speichern der Globalen in die Strings
      itoa(bga_go,buffer,10);
      uart_puts(buffer);
      
      itoa(bga_power_bit,buffer,10);
      uart_puts(buffer);
      
      itoa(bga_max_power_bit,buffer,10);
      uart_puts(buffer);
      
      itoa(bga_stufen,buffer,10);
      uart_puts(buffer);
      
      itoa(bga_timer,buffer,10);
      uart_puts(buffer);
      
      itoa(frost,buffer,10);
      uart_puts(buffer);
      
      itoa(led_go,buffer,10);
      uart_puts(buffer);
            
      itoa(pwm_rot,buffer,10);
      uart_puts(buffer);
      
      itoa(pwm_gruen,buffer,10);
      uart_puts(buffer);
      
      itoa(pwm_blau,buffer,10);
      uart_puts(buffer);
      
      uart_puts("E");
      
      flag_uart_tx=0;    
    }


    }
  
}



ISR(TIMER0_OVF_vect) 
{
  cli();
    flag_uart_tx=1;

  sei();

}

[René K. (tesla24)]

Nop schrieb:
> René K. schrieb:
>
>> nach jedem uart_puts() setzt er am Ende "\0" warum?
>
> Weil Du eine do-while-Schleife anstatt einer while-do-Schleife
> verwendest.

Stimmt...
so geht es:

void uart_puts (const char *s)
{
   while (*s)
   {
     uart_putc (*s);
     *s++;
   }
   uart_putc('\n');

}

[Nop (Gast)]

René K. schrieb:

> so geht es:void uart_puts (const char *s)
> {
>    while (*s)
>    {
>      uart_putc (*s);
>      *s++;
>    }
>    uart_putc('\n');
>
> }

Etwas aufgeräumter wäre:

{
   while (*s)
   {
     uart_putc (*s);
     s++;
   }
   uart_putc('\n');

}

Und falls uart_putc nicht irgendein verstecktes Macro ist, sondern eine 
Funktion:

{
   while (*s)
   {
     uart_putc (*s++);
   }
   uart_putc('\n');

}

[Frank M. (ukw) (Moderator)]

René K. schrieb:
> uart_putc('\n');

Das würde ich gar nicht in uart_puts() schreiben, dann wird das ja nach 
jeder Zahl gesandt. Da Du die zu sendenden Werte bereits auf feste 
Längen ausrichtest, brauchst Du einen solchen Trenner nicht.

Wenn doch, eignet sich '\n' eher nicht als Feldttrenner, da würde ich 
eher ein Leerzeichen ' ' oder ein Tab '\t' bevorzugen.

'\n' wird üblicherweise als Satztrenner benutzt, also am Ende Deines 
Datensatzes, also da, wo Du ein 'E' für Ende-des-Datensatzes sendest.