Seriell: Daten > 64 Byte verarbeiten

International Deutsch
1

Moin zusammen !
Der absolute Arduino-Newbie macht sich grade nen Kopf über die Programmstruktur seines 1. (Arduino-) Programms.
Es soll eine (später zu erweiternde) "semi-intelligente" Schrittmotor-Steuerung werden.
Zunächst soll diese von einem PC via USB/COM mit elemntaren Daten gefüttert werden.
Da fangen meine Probs schon an ....

Ein Steuer-Kommando soll in etwa so aussehen:

  • Steuer-/Initalisierungszeichen
  • Befehlsnummer (danach wertet der Arduino aus)
  • Nr. in Array (0 oder 1 bis 255)
  • ca. 6 "Daten-Bytes" (ges. ein Array)
  • Checksumme des Kommandos
    In Summe also 10 Byte. Nicht weltbewegend riesig ....

Wenn ich das bisher durch eifiges Lesen richtig verstanden habe, ist der serielle Puffer lediglich 64 Byte groß.
Frage 1)
Was passiert denn, wenn der voll ist ?
Werden weitere Bytes einfach ignoriert oder werden die ersten Bytes gelöscht und neue hinen dran gehängt ?

Weil:
Neben gelegentlich (hoffentlich) zeitunkritisch geschickten Kommandos soll auch mal eine ganze Reihe von Kommandos am Stück geschickt werden.
Das wäre z.B. der Fall, wenn ich eine Steuersequenz abschicke. D.h., der Arduino bekommt eine Latte von Daten (ein ganzes Array), welche er dann selbsttätig ausführen soll - sprich der Motor bekommt einen ganzen Befehlssatz, wie oft er sich wann in welche richtung wie lange und wie schnell zu bewegen hat.
Das können mal max. 5 Kommandos sein (50 Byte, passt ja noch) oder auch 100 oder mehr. (> 500 Byte).

Auf PC-Basis habe ich da kein Probleme - mache ich für jeden KrimsKrams nen neuen Thread auf und alles läuft (quasi) parallel ohne Zeitprobleme.
Frage 2)
Um beim seriellem Empfang Datenverlust vorzubeugen müsste ich doch eine Lese- und Auswerteroutine schon als Interrupt ausführen ?
Was passiert denn dann mit der Auführung des restlichen Programms, wenn z.B. grade eine Schleife abläuft, welche das Sequenz-Array abarbeitet und darin wiederum eine Schleife läuft, welche den Motor mit Impulsen füttert ?
Was hat Vorrang ? Die Interrupt-Routine ? Gibts so was wie ne "Zeitscheibe" ala PC ?
Fängt der Motor ggf. an zu stottern ?

Nächste Quizfrage 3)
Kommt ein Interrupt auf der Seriellen bei jedem Zeichen ? Also bei einem Kommando (s.o.) 10x ?
Dann könnte ich mir ja ohne explizit nachzufragen die Anzahl der Bytes im Puffer in einer globalen VAR merken und fortlaufen BTW prüfen. Dito die Zeit seit wann das letzte Zeichen gekommen ist und selbst entscheiden "jetzt wird's Zeit, den Puffer abzufragen !"
D.h. in einer "Langsamfahrzeit" des Motors, wo kurze Störungen nicht stören oder wenn der Motor Pause hat ?!

Quizfrage 4)
Kann ich selbst so etwas wie einen eigen definierten Interrupt auslösen ?
Sprich aus einer Routine eine andere aufrufen, welche dann wie bei Seriell in einer Art Zeitscheibe abläuft und die rufende Routine nicht blockiert ?
Ich denke da an so etwas wie "PostMessage" unter Windows. (SendMessage wartet auf Rückkehr !)

Meine Abfrage stelle ich mir dann in der Art vor, wenn der Empfangspuffer >= 10 Zeichen hat:
(es wird in globales Array kopiert)

  • Steuer-/Initalisierungszeichen ? (NEIN: solange weiterlesen, bis ... 1 oder mehr Kommando's nicht angekommen ! Rückfrage beim PC !)
  • Befehlsnummer lesen
  • Nr. in Array lesen (und dort auch eintragen)
  • 6 Daten-Bytes lesen
  • Checksumme prüfen (Kommando korrekt gelesen ? Falls nicht -> Rückfrage beim PC !)

Sofern der Motor sich noch in einer Steuersequenz befindet, wird diese logo erst mal abgearbeitet.
Gibt es zwischenzeitlich eine neue, wird damit "nahtlos" fortgesetzt.
Natürlich kann es Einzelbefehle wie EMERGENCY-STOP, GOTO-ZERO, RECALIBRATE uvm. an Kommandos geben.

Das ALLERWICHTIGSTE an diesem Programm / Steuerung ist, das ALLE Kommandos einwandfrei richtig "verstanden" werden MÜSSEN und keines fehlen darf !
Da auf der mechanischen Seite sehr kraftvolle Stepper arbeiten und es nur einen mechanisch begrenzten Weg gibt, könnte das fatale Folgen haben !
.... logo kommen Not- und Endschalter zum Einsatz, die der Arduino selber im Auge behalten muss.
Aber auch schon fehlende oder falsche Steuerkommandos im Sequenz-Array könnten den Stepper zu einen unbeabsichtigten Fahrweg veranlassen, was nicht passieren darf.

Ich würde mich sehr freuen, wenn die Wissenden hier auf meine Fragen antworten / dazu Stellung nehmen.
Logo ist jede weiterhelfende Antwort sehr willkommen.

Fast vergessen: Ich hab mir einen Arduino Mega2560 bestellt. Ist leider heute immer joch nicht angekommen

2

TERWI:
Wenn ich das bisher durch eifiges Lesen richtig verstanden habe, ist der serielle Puffer lediglich 64 Byte groß.

Ja, der Puffer ist 64 Zeichen gross und es passen maximal 63 Zeichen hinein.

TERWI:
Was passiert denn, wenn der voll ist ?

Dann ist er voll und es passiert erstmal gar nichts. Wenn weitere Zeichen eintreffen, bevor was aus dem Puffer ausgelesen wird, gehen Zeichen verloren.

TERWI:
Werden weitere Bytes einfach ignoriert oder werden die ersten Bytes gelöscht und neue hinen dran gehängt ?

Weitere Zeichen werden ignoriert.

TERWI:
Auf PC-Basis habe ich da kein Probleme - mache ich für jeden KrimsKrams nen neuen Thread auf und alles läuft (quasi) parallel ohne Zeitprobleme.

Auf Arduino-Basis habe ich auch keine Probleme: Ein Arduino taktet mit 16 MHz und kann pro Sekunde 16 Millionen Instruktionen ausführen. Wenn das nicht reicht, um bei maximaler Baudrate von 115200, entsprechend 11520 Zeichen pro Sekunde auszulesen, dann ist mit dem Programm irgendwas krumm.

Du musst eben die Funktion "delay" aus den zur Programmierung erlaubten Funktionen verbannen: Wenn Du 16 Millionen Instruktionen pro Sekunde damit verbrauchst, das Ablaufen von Millisekunden zu zählen und das Programm währenddessen für alle anderen Aktionen zu blockieren, dann brauchst Du Dich nicht zu wundern, wenn es irgendwo plötzlich nicht mehr reicht, um schlappe (maximal) 11520 Zeichen pro Sekunde aus einem seriellen Eingangspuffer zu ziehen.

3

Danke dir für die informelle Antwort, jurs ! Wäre die Frage zum Puffer schon mal geklärt.
Ob nun 64 oder 63 Byte reinpassen wäre bei einer Abfrage auf >10 eh wurscht.

Delay: So was gibts ja in nahezu jeder Prog-Sprache. Und zu 99% hält dieser Befehl den ganzen Thread eben für besagte Zeit in (meistens) Millisekunden an.
Es sei denn, man bastelt sich (unter Windoof) selber was mit Abfrage des HighPrecisionCounters selber was und baut ein Applikation.ProcessMessage mit ein, was die Zeitscheide(n) sich weiterdrehen lässt und die Kiste in der Pause nicht zum absolutem Stillstand bringt.

Das gibt es aber wahrscheinlich beim Arduino nicht - oder ?

Die kleinste hier zu erwartende Zeit wäre 35-70 µs für den H/L-Impuls des Steppers.
Die größte sinnvolle Schrittzahl für einen "normalen" Stepper scheint irgendwo bei 4-5 kHz zu liegen. Also max. 200 µs.

Auf ein Delay werde ich aber trotzdem nicht verzichten können und möchte dazu meinen altbewährten Delphi-Code in dieser Form adaptieren:

  • Lese & merke micros() zum Start
  • DO "machwas" WHILE " aktuelle micros() < gemerkte Micros + Zeit (in µs)"
    Das ganze dann als Funktion: bool DoDelay(µs) oder auch void - return heisst fertig !

Das micros() nur im 4er-Takt kommt, ist hier völlig "piepe".
Auch in "Schnellfahrsequenzen" (max. 2,5 kHz/400µs je Stepp ?) wird ein Zeitfehler sicherlich noch unter 20% liegen - wertet DoDelay doch minimal auf 1% aus.
Sollten sich unter "machwas" zeitintensive Funktionen befinden, halt eben ein wenig länger.
Damit kann ich aber locker leben.

In "machwas" können dann zb. globale Deklarationen & Funktionsaufrufe stehen:

  • NOT-STOPP ?
  • Delay ist busy !
  • Sequenz in Bearbeitung (der Motor muss noch was wecharbeiten)
  • Wie geht's der Seriellen in Sachen Puffer ?
  • Hat sonst jemand noch ne Frage oder was zu tun, was hier zeitlich grade reinpasst ?
    .... u.v.m.
    Das wäre zumindestens ansatzweise so was wie Threading - zumindestens verschwendet man keine nutzlose Wartezeit.

Wie schnell bekommt denn die Serielle Daten ?
Volle Lotte mit 115200 muss das nun wirklich nicht sein. 9600 reichen sicher locker aus. Eher noch weniger ....

Wenn das nicht reicht, um bei maximaler Baudrate von 115200, entsprechend 11520 Zeichen pro Sekunde auszulesen, dann ist mit dem Programm irgendwas krumm.

... das sehe ich auch so 8)

4

hi,

Du bastelst Dir selbst ein delay, und siehst nicht, daß Du da inzwischen andere sachen machen kannst?
schau Dir in der IDE die beispiele "Blink" und "BlinkwithoutDelay" an. die machen im endeffekt das gleiche, aber eine bremst den prozessor aus, die andere hat zeit, um andere dinge zu tun...

gruß stefan

5

Stefan, einen Daumen hoch für dich ! (Wie geht das hier ?)
Ich bitte zu beachten und zu berücksichtigen, das ich betreff Arduino noch blutiger Anfänger bin, noch nicht mal die Hardware ist da (trommel, trommel) und ich mich aktuell noch lediglich in einer anfänglichen Denkphase zur Programmumsetzung befinde.
Hoffentlich verständlicherweise versuche ich erstmal alles aus meiner Delphi-Ebene so gut wie es geht umzusetzen ....
Wenn das logo auch einfacher geht ..... ich danke jedem für hilfreiche Tipps !

.... prinzipiell ist das aber die Routine, wie ich sie mir vorgstellt habe.
Allerdings gibt es da noch den Knackpunkt, das micros() irgendwann (nach 70 Minuten oder wie war das ?) über null läuft.
Das sollte man dann auch schon berücksichtigen ..... !

6

Zum Überlauf:
Schau dir mal folgendes an:
http://playground.arduino.cc/Code/TimingRollover

es liegt nur an der Programmierung, dann ist der Überlauf kein Problem mehr.

7

hi,

der millis-zähler läuft erst nach einigen wochen über, also nichts, worüber man sich bei einer robotersteuerung sorgen machen müßte (außer es ist ein autarker robo auf dem mars).

gruß stefan

8

BTW noch mal ne NewBie-Frage zum verfügbaren Speicher des MEGA2560 und wie damit umgegangen wird.
Flash Memory = 248 KB (+ 8 KB used by bootloader), SRAM = 8 KB, EEPROM = 4 KB.

Wo geht denn da eigentlich das Programm hin ?
Wo werden allokierte Daten(strukturen) hingepackt ?
Kann man das beim Compilieren & Uploaden beeinflussen ?
Muss man sich eher nen Kopf über eine schlanke Programmstruktur machen ?
Oder darf man nicht so mit (globalen) Variablen "rumasen" ?
(oder beides gleichzeitig ...)

Wie gesagt bin ich langjähriger PC-Progger. Mit (Pascal) DELPHI ! C geht auch ganz gut, Basic ist lange her und für ASM müsste ich echt noch mal die verstaubten Bücher hervorkramen.
"Mal eben schnell" ein paar MegaBytes für irgendwas temporär an Speicher holen ist ja offensichtlich nicht angesagt....
....sonst würde ich mal eben fix so 1-10KB oder noch viel mehr pro forma für nen Puffer allokieren, und ....

Worauf muss der NewBie achten ? Gebt mir sinnliche Links ohne Ende ....

9

@ Jomelo
... das ist mir als langjähriger Progger seit den "Basics" seit ca. 1980 schon klar ! :grin:
Beim Arduino bin ich (noch !) ein Dummie, was das proggen allgemein betrifft, sicher nicht. 8)

Gruß an den "Nachbarn" in OS aus Bramsche ! :grin:

@ Eisebaer
Hier unter http://arduino.cc/en/Reference/Micros steht was anderes: .... after approximately 70 minutes.
Wir sprechen über MICROS !
.... kann durchaus (regelmäßig) vorkommen, das die Kiste (deutlich) länger läuft als 70 Minuten.

10

hi,

Wir sprechen über MICROS !

hatte ich überlesen. micros wird eher selten verwendet, schon garnicht bei einer im vergleich dazu unendlich trägen motorsteuerung.

gruß stefan

11

Wo geht denn da eigentlich das Programm hin ?

in den Flash Speicher also da wo am meisten von vorhanden ist.

Wo werden allokierte Daten(strukturen) hingepackt ?

Je nachdem wie man sie anlegt. Sie können im Flash abgelegt werden. Das bedeutet sie können zur Laufzeit des Programms nicht mehr verändert werden.
Oder im Ram (8 KB), wenn sie verändert werden sollen.

Kann man das beim Compilieren & Uploaden beeinflussen ?

Ja (indirekt). Das kann man eher mit dem Programm aufbau beeinflussen. Such mal nach "PROGMEM"

Muss man sich eher nen Kopf über eine schlanke Programmstruktur machen ?

Bei Mikrocontrollern ist es sehr wichtig schlanke Programme zu schreiben. Speicher mit new und delete zu verwalten ist nicht ratsam.
Eine dynamische Speicherverwaltung gibt es nicht. Globale Variablen sollten nur dann Verwendung finden wenn es nicht anders geht.

Oder darf man nicht so mit (globalen) Variablen "rumasen" ?

Man kann schon viele Variablen anlegen. Du solltest aber immer auf den Datentype achten. Wenn der Inhalt in ein Byte passt, dann liber uint8_t oder int8_T oder char oder unsigned char
Verwenden.
Der Datentype int ist 2 Byte groß
long = 4 byte

Wenn du das Programm von Anfang an strukturiert aufbauen willst: Dann schau dir mal das hier an:
Projektvorstellung: einfache Threads auf dem Arduino mit Hilfe von Makros

12

Was du Grundstrukturen anbetrifft funktioniert der Arduino auch nicht anders als die meisten anderen Architekturen und Sprachen. Da steckt ja letztlich ein Atmega dahinter. Die Arduino IDE und Sprachmittel sind eine Abstraktion, aber du kannst da fast alles machen wie wenn du in C/AVR-Studio programmieren würdest. Nur ist es gegebenenfalls langsamer. Aber du kannst sogar auf die Mikrocontroller-Register direkt zugreifen wenn du die Geschwindigkeit oder bestimmte Funktionen brauchst (z.B. Timer, ADC oder I/O-Ports).

13

Da auf der mechanischen Seite sehr kraftvolle Stepper arbeiten und es nur einen mechanisch begrenzten Weg gibt, könnte das fatale Folgen haben !
.... logo kommen Not- und Endschalter zum Einsatz, die der Arduino selber im Auge behalten muss.
Aber auch schon fehlende oder falsche Steuerkommandos im Sequenz-Array könnten den Stepper zu einen unbeabsichtigten Fahrweg veranlassen, was nicht passieren darf.

Die Steuerung eines Passagier-Flugzeugs wird nie einen Arduino enthalten, auch in der Medizintechnik findet man sie "selten".
Wenn deine Stepper-Steuerung wirklich gefährlich werden kann, muss der Not-Aus und andere Sicherungen natürlich unabhängig realisiert sein.

Aber davon abgesehen, kann man viel Spannendes mit einem MicroController machen.
Der Grundansatz ist eben ein anderer als beim (high-level) PC Programmieren:
Ein MicroController hält alles unter Kontrolle indem seine Programm-Schleife nur erfasst und bei Bedarf Aktionen anstösst, und dadurch sehr schnell bleibt.
Das hat Stefan schon gesagt:

schau Dir in der IDE die beispiele "Blink" und "BlinkwithoutDelay" an. die machen im endeffekt das gleiche, aber eine bremst den prozessor aus, die andere hat zeit, um andere dinge zu tun...

Blinkwithoutdelay kann leicht auf beliebig viele unabhängige Aktionen parallel erweitert werden.

P.S. Bezüglich Stefan fragst du zurecht: Statt "Daumen hoch" gibt es hier "Karma" (was nur erhöht werden kann). Rate mal, wofür das + Zeichen darunter gedacht ist.

14

Wie gesagt bin ich langjähriger PC-Progger. Mit (Pascal) DELPHI ! C geht auch ganz gut

Da können wir uns die Hand geben, habe damals mit Pascal begonnen und als Dos Programme out waren, auf Delphi umgestiegen.
Auch die Microkontroller habe ich lange mit Pascal programmiert (leider sind die Compiler meist buggy und die guten sehr teuer.)

Durch den Arduino bin ich zu C gekommen, wenn man die Eigenheiten dieser Sprache mal inne hat klappt es immer besser.

Mircokontroller Programmierung:
Als ich damit angefangen habe, haben mich die Interruptmöglichkeiten gleich in den Bann gezogen.
Die Externen Interruptquellen zum Abtasten von Signalen, dann die Timerinterrupts z.b zum Auslösen eigener Ereignisse oder auch zum Erzeugen vpm PWM Signalen.

Schau mal ins Datenblatt deiner CPU was man alles damit machen kann und spiele damit rum. :slight_smile:
Du kannst die betreffenden Cpu Register zwar manuell bescchreiben, es gibt aber auch Timer Lib's mit denen es einfacher geht.
Oder es ist von Haus aus dabei. z.b attachInterrupt()

Ps:
Ist zwar keine Antwort auf das Thread Thema, aber der Thread hat sich hat eher in diese Richtung entwickelt so das meine Antwort nicht ganz so OT ist. :wink:

15

(AT)Mega Dank für die vielen Info's.

@Eisebaer:
Stimmt - prinzipiell ist so ein Stepper ein träger Apparat. Die max. zu erwartende Impulsfolge läge allerdings schon bei ca. 2500Hz/0,4ms. Der Taktimpuls sollte max die Häflte sein - also 200µs. Darf beim Toshi Motortreiber min 30µs für 15 kHz Takt sein.
Dazu würde ich ein einfach einen Out setzen, delaymicros(50), Out löschen verwenden.
Was die Frequenzeinstellung an sich betrifft, müsste ich sogar micros und millis kobinieren, weil delaymicros nur bis 16383µs (im 4er Takt) zählen kann.
Nur mit delaymillis wären die Geschwindigkeitssprünge im oberen Bereich dann doch schon recht heftig.
(Ist zwar keien CNC-Maschine, stört aber doch)
... oder doch besser mit einem Timer, der mit micros umgehen kann und eine Funktion statt pin ruft.

@Jomelo:
Besonder Dank an dich für die Tipps & Links.
Sehr genial, dein Thread-Projekt ! Das werde ich mir auf jeden Fall detaillierter zu Gemüte führen.

@michael_x
Was las ich die Tage hier: "Hab nen Robot aus nem Rolli gebastelt, Der macht glatt nen Zaun platt" :smiley:
So krass ist es hier nicht. Betreff des eigentlichen Themas:
Wenn ich ne Latte Kommandos verschicke, und eines oder gar mehrere würden im Nirwana verschwinden, wäre das ganze "Bild" des Fahrweges im Eimer.
Steht der Schlitten z.B. dicht vor Ende Links und er vergisst "rechts, 5000, langsam" und "rechts, 1000, zügig" und fährt dann div Befehle nach links, hängt der Schlitten in der Endabschaltung und das Programm soll/muss stoppen.

Dank dir für den Tip zur Erhöhung des Karma's. Eures werde ich beizeiten ein wenig pimpen. Meins muss ich erstmal internregenerieren.

@rudirabbit
Ich muss mich erst mal wieder an "think small" gewöhnen. Vor ca. 25 Jahren hab ich es auch geschafft, eine Kabel-TV-Netzberechnung inkl. Gebäudeveraltung mit GW-Basic auf nem AT zu schreiben. Da gingen auch nur 64 KB und kein Bit mehr.

Dass das hier alles ein wenig OT geht, war bei der 1. NewBie-Frage doch zu erwarten - oder ? :grin:
Wenn's der Admin nicht so verkniffen sieht ... ich jedenfalls nicht.
Beizeiten kommen weitere Fragen - aber erstmal muss der Mega hier sein. Stepper-Treiber sind gestern gekommen (gleicher Händler !).

16

.... logo kommen Not- und Endschalter zum Einsatz, die der Arduino selber im Auge behalten muss.

Das halte ich für eine schlechte Idee. Ich würde Not- und Endschalter vom Arduino unabhängig machen. Wenn Dein Programm Amok läuft, woher willst Du dann noch sicher sein, daß die Notabschaltung noch funktioniert?

Davon abgesehen hört sich Dein Projekt nach etwas wie dem hier an: http://www.openmoco.org/

17

Moin Udo !
Natürlich kommt da noch ein 64A selbsthaltendes Schütz mit dem dicken, roten NOT-AUS-Pilz in die Starkstromzuleitung ..... kleiner Scherz. :grin:
Ich hoffe nicht, das ich zuletzt derart versteckte Bugs drin haben werde, welche die Schaltung eigenintelligent macht und die Menschheit bedroht wird. 8)
Als Not-Aus war hier eher ein kleiner Taster gedacht, der eine Sequenz manuell vorab beenden kann, sowie Lichtschranken zur Enlagenkontrolle.

Dein Link sagt mir

Site off-line
OpenMoCo.org is currently under maintenance. We will be back by 6PM CDT on 11/13/2011. Thank you for your patience.

Schon ein bischen länger offline ...

18

Ist noch nicht so lange offline. Die Zeitangabe stimmt definitiv nicht. Aber sowas ist doch eh kein Problem, das Internet vergisst niemals: Internet Archive: Wayback Machine, oder direkt: OpenMoCo | The Open-Source Photographic Motion-Control Community

19

Ich greif mich hier mal selbst wieder auf.
Zum Daten-Einlesen und Parsen hab ich mal den Messenger versucht. Klappt so weit prima.
Folgendes ist mit dem Zurücksenden der empfangenen Werte erst mal nur zu Testtwecken drinn und fliegt irgendwann raus.

#include <Messenger.h>

Messenger message = Messenger(','); 

void messageCompleted() 
{
  int val[20];
  int cmd, mot, num, i = 0;
  if ( message.checkString("##") ) 
  {
    Serial.println(" Start - Command recognized !");
    Serial.print("Command-Number: ");
    cmd = message.readInt();
    Serial.println(cmd,DEC); 
    Serial.print("Motor-Number: ");
    mot = message.readInt();
    Serial.println(mot,DEC); 
    while ( message.available() ) 
    {
      Serial.print("Value #");
      Serial.print(i,DEC);
      Serial.print(": ");
      val[i] = message.readInt();
      Serial.println(val[i],DEC); 
      if ( message.checkString("**") ) { 
        Serial.println(" Stop - Command recognized !"); }
      i++;
    } 
    // Hier die Daten validieren und wenn OK an den Motor schicken
  } 
  else 
    Serial.println("Command must begin with  ##");
}

void setup() {
  Serial.begin(115200); 
  message.attach(messageCompleted);
}

void loop() {
  while ( Serial.available( ) ) message.process(Serial.read( ) );

}

Schicke ich ein Komanndo ala

##,5,0,3,1,15000,2500,**

dann kommt das zurück:

Start - Command recognized !
Command-Number: 5
Motor-Number: 0
Number of values: 3
Value #0: 1
Value #1: 15000
Value #2: 2500
Stop - Command recognized !

Erst wenn nach weiterer Prüfung alles soweit (halbwegs) logisch ist gehts ab an den Motor.

Jetzt habe ich hier in Ermangelung von C++-KnoffHoff erst mal wild mit dem Serial.Printf gebastelt, um mir Zahlen in einen String zu wandeln.
In Delphi schreibe ich einfach z.B. : S (ist ein String) := 'BlaBlaBla mit nem Wert dabei ' + inttostr(i) + ' noch Text dazu';
Wie geht das in C ? Ich hab da schon mit itoa rumhantiert - dazu bin ich zu blöd.