www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik sinnvoll rechnen mit floats


Autor: Peterle Anonym (Firma: keine) (wanderameise)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
morgen,

ich habe auf meinem at90can128 eine kleine routine implementiert, die 
mir, abhängig von den eingelesenen adc werten, etwas berechnet. die 
berechnung findet mit floatwerten statt. hier nun meine erste frage:
ist es sinnvoll, die werte, welche im bereich -30.0 bis +30.0 liegen 
können, mit 100 (2 nachkommastellen) zu multipliziern, um mit int zu 
rechnen?

das ergebnis muss in einem char buffer gespeichert werden, welcher via 
usb an den client gesendet wird. hier meine nächste frage:
meine idee, zB die zahl 22.44, mittels sprintf() in eine zeichenkette zu 
konvertieren hat ganz gut funktioniert. ich lege fest, das eine zahl aus 
max. 5 stellen besteht(zB -22.44 = -2244) und kann beim empfang einfach 
wieder durch 100 teilen. sollte theoretisch klappen oder?

die 2. "platzsparendere"- und eigentliche urpsrungsidee wäre gewesen, 
einfach den wert wieder mal 100 zu nehmen und dann durch shiften erst 
das obere, dann das untere byte zu senden. der client ver-ODERt dann 
beide(erstes byte zurückshiften); allerding weiss ich nicht, wie ich 
hier mit negativen zahlen umzugehen habe!

wie ist die übliche vorgensweise bei sowas?
danke

Autor: Sven P. (haku) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peterle Anonym schrieb:
> morgen,
>
> ich habe auf meinem at90can128 eine kleine routine implementiert, die
> mir, abhängig von den eingelesenen adc werten, etwas berechnet. die
> berechnung findet mit floatwerten statt. hier nun meine erste frage:
> ist es sinnvoll, die werte, welche im bereich -30.0 bis +30.0 liegen
> können, mit 100 (2 nachkommastellen) zu multipliziern, um mit int zu
> rechnen?
Ja, du kannst sie auch mit 1000 multiplizieren, wenn das in die Integer 
hereinpasst. Das wäre weitaus sparsamer und schneller auf einem AVR, als 
Fließkommazahlen.

> das ergebnis muss in einem char buffer gespeichert werden, welcher via
> usb an den client gesendet wird. hier meine nächste frage:
> meine idee, zB die zahl 22.44, mittels sprintf() in eine zeichenkette zu
> konvertieren hat ganz gut funktioniert. ich lege fest, das eine zahl aus
> max. 5 stellen besteht(zB -22.44 = -2244) und kann beim empfang einfach
> wieder durch 100 teilen. sollte theoretisch klappen oder?
Jo. Lässt sich auf diese Art auch angenehmer debuggen, als wenn du die 
Zahlen als Binärdaten senden würdest. Alles eine Frage der Basiseinheit.


> die 2. "platzsparendere"- und eigentliche urpsrungsidee wäre gewesen,
> einfach den wert wieder mal 100 zu nehmen und dann durch shiften erst
> das obere, dann das untere byte zu senden. der client ver-ODERt dann
> beide(erstes byte zurückshiften); allerding weiss ich nicht, wie ich
> hier mit negativen zahlen umzugehen habe!
Auch richtig. Es kann Einer- oder Zweier- oder garkein Komplement sein. 
Am sichersten und 'schönsten' ist daher m.M.n. deine bisherige Variante, 
die Zahlen im Klartext zu senden. Auch umgehst du damit Probleme mit 
Endianess, also der Reihenfolge der Einzelbytes im Speicher.
Du löst das zwar arithmetisch, aber das hilft dann immer noch nicht 
weiter bei der Darstellung der negativen Beträge.


> wie ist die übliche vorgensweise bei sowas?
Vorher festlegen. Im Zweifelsfall muss dann einer der beiden umrechnen.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peterle Anonym schrieb:

> ich habe auf meinem at90can128 eine kleine routine implementiert, die
> mir, abhängig von den eingelesenen adc werten, etwas berechnet. die
> berechnung findet mit floatwerten statt. hier nun meine erste frage:
> ist es sinnvoll, die werte, welche im bereich -30.0 bis +30.0 liegen
> können, mit 100 (2 nachkommastellen) zu multipliziern, um mit int zu
> rechnen?

Kommt drauf an.
Wenn dein µC massig Zeit hat und Float Rechnerei kein Flaschenhals ist, 
kann die einfachste Variante, nämlich einefach in float zu rechnen 
sinnvoll sein.
Oder auch nicht. Wenn dann hintennach mit dem Wert noch 200 Berechnungen 
gemacht werden, kann es aus Gründen der Rundungsgenauigkeit wieder 
sinnvoll sein, auf float zu verzichten.

> das ergebnis muss in einem char buffer gespeichert werden, welcher via
> usb an den client gesendet wird. hier meine nächste frage:
> meine idee, zB die zahl 22.44, mittels sprintf() in eine zeichenkette zu
> konvertieren hat ganz gut funktioniert. ich lege fest, das eine zahl aus
> max. 5 stellen besteht(zB -22.44 = -2244) und kann beim empfang einfach
> wieder durch 100 teilen. sollte theoretisch klappen oder?

Ja. klar
Kann man so machen. Muss man aber nicht. Hängt auch davon ab was der 
Wert repräsentiert und ob es da eine 'natürliche' Erklärung für den 
Faktor 100 gibt.
Must du zb Euro übertragen, dann kann man anstelle von Euro 5.20 einfach 
520 Cent übertragen, also grundsätzlich festlegen, dass nicht Euro 
sondern Cent auf die Reise gehen.
Gibt es keine derartige 'natürliche' Erklärung für einen Faktor von zb 
100, dann sollte man auch daran denken, dass man sich bei Tricksereien 
an einer Schnittstelle durch 'unübliche' Darstellungsweisen auch schon 
mal ein Eigentor schiessen kann, wenn mehrere Leute gemeinsam an einem 
Projekt arbeiten. Die Nase hat eine Mars-Sonde verloren, weil ein Teil 
der Entwickler in Meilen und der andere in Kilometer gerechnet hat, 
obwohl eigentlich überall Kilometer vorgeschrieben gewesen wären :-)

> die 2. "platzsparendere"- und eigentliche urpsrungsidee wäre gewesen,
> einfach den wert wieder mal 100 zu nehmen

welchen Wert?
int oder float?

> und dann durch shiften erst
> das obere, dann das untere byte zu senden. der client ver-ODERt dann
> beide(erstes byte zurückshiften);

> allerding weiss ich nicht, wie ich
> hier mit negativen zahlen umzugehen habe!

brauchst du nicht speziell zu behandeln.
Solange der Empfänger die beiden Bytes wieder zu einer 2-Byte Zahl 
zusammensetzt, kommt bei ihm wieder dasselbe Bitmuster raus. Und da 
heutzutage alle Welt 2-er Komplement benutzt, kriegt er damit auch die 
richtige Zahl.

Autor: Εrnst B✶ (ernst)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Je nach Rechenweg kann es auch besser sein, statt einem Faktor von 100 
z.B. 128 zu nehmen. Ist für den µC viel "natürlicher" und einfacher zu 
handhaben.
Wenn der Hauptzweck jedoch die Anzeige als Dezimalzahl auf einem LCD 
ist, macht die nötige Umrechnerrei den Vorteil evtl. wieder zunichte.

Autor: Peterle Anonym (Firma: keine) (wanderameise)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
die 100 als faktor habe ich mal aus der luft gegriffe, da ich 2 stellen 
nach dem komma für ausreichend halte, wobei das ganze eine frage des 
platzes ist, denn beim faktor 1000 wären es schon 6 stellen die eine 
zahl einnimmt.
Bei der shift-Methode, wären es nur 2!
vll wäre deswegen letzteres eine effizientere methode??


>> die 2. "platzsparendere"- und eigentliche urpsrungsidee wäre gewesen,
>> einfach den wert wieder mal 100 zu nehmen
>
> welchen Wert?
> int oder float?

den float, um ihn wieder als ganzzahl zu behandeln, da man floats nicht 
shiften kann!



>> allerding weiss ich nicht, wie ich
>> hier mit negativen zahlen umzugehen habe!
>
> brauchst du nicht speziell zu behandeln.
> Solange der Empfänger die beiden Bytes wieder zu einer 2-Byte Zahl
> zusammensetzt, kommt bei ihm wieder dasselbe Bitmuster raus. Und da
> heutzutage alle Welt 2-er Komplement benutzt, kriegt er damit auch die
> richtige Zahl.

nicht speziell? ich habe es mal hier simuliert, falls ich eine negative 
zahl aufsplitte in oberes und unteres byte, erhalte ich nur mist:
char buf[3];
float g = -22.44;
int p = (int)(100 * g);
buf[0] = (char)(p >> 8):
buf[1] = (char)(p):
printf("%.2f", ((float)((buf[0] << 8) | buf[1]) / 100));

das klappt mit positiven zahlen ganz gut, aber nicht mit negativen. was 
mache ich falsch?

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das Problem entsteht beim Zusammenbau.
Du musst zuerst wieder auf einen int casten, damit dein 2-Bytekonstrukt 
für den Compiler wieder ein Vorzeichen erhält.

printf("%.2f", ((float)(int)((buf[0] << 8) | buf[1]) / 100));

Autor: Tim Seidel (maxxie)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Karl heinz Buchegger schrieb:
> Das Problem entsteht beim Zusammenbau.
> Du musst zuerst wieder auf einen int casten, damit dein 2-Bytekonstrukt
> für den Compiler wieder ein Vorzeichen erhält.
>
> printf("%.2f", ((float)(int)((buf[0] << 8) | buf[1]) / 100));

Das muss schon eine Stelle früher geschehen.

(buf[0] << 8) ist mit 'char buf[3]' gleich 0
((int)buf[0] << 8) ist erst sinnvoll, da der Speichertyp der geshiftet 
wird ausreichend Stellen besitzt.

Das untere Byte sollte dann nach uint gecastet werden, sonst kann es dir 
ebenfalls wieder (durch den cast von char auf int werden die oberen bits 
sign-extended) Mist reinhauen. (bei Werten &0xFF > 0x7F) sind dann nach 
dem Oder alle höherwertigen Bits 1

int fpval = (int)(((int)buf[0] << 8) | (unsigned int)buf[1]) ;

Mit einem unsigned char buf[3] bräuchte es nur den inneren (int) cast.

Autor: Peterle Anonym (Firma: keine) (wanderameise)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Tim Seidel schrieb:
> Karl heinz Buchegger schrieb:
>> Das Problem entsteht beim Zusammenbau.
>> Du musst zuerst wieder auf einen int casten, damit dein 2-Bytekonstrukt
>> für den Compiler wieder ein Vorzeichen erhält.
>>
>> printf("%.2f", ((float)(int)((buf[0] << 8) | buf[1]) / 100));
>
> Das muss schon eine Stelle früher geschehen.
>
> (buf[0] << 8) ist mit 'char buf[3]' gleich 0
> ((int)buf[0] << 8) ist erst sinnvoll, da der Speichertyp der geshiftet
> wird ausreichend Stellen besitzt.
>
> Das untere Byte sollte dann nach uint gecastet werden, sonst kann es dir
> ebenfalls wieder (durch den cast von char auf int werden die oberen bits
> sign-extended) Mist reinhauen. (bei Werten &0xFF > 0x7F) sind dann nach
> dem Oder alle höherwertigen Bits 1
>
> int fpval = (int)(((int)buf[0] << 8) | (unsigned int)buf[1]) ;
>
> Mit einem unsigned char buf[3] bräuchte es nur den inneren (int) cast.

weiss nicht ob ich das richtig verstanden habe, jedenfalls klappt es 
nicht so recht:
  float g = -49.23;
  int p = (int)(100*g);
  signed char buf[2];
  buf[0] =(char)(p>>8);
  buf[1] =(char)(p);
  p = (int)(((int)buf[0]<<8) | (unsigned int)buf[1]);
  printf("\n%f", (float)p);


buf[1] ist auch negativ bei mir, wieso das denn?

Autor: Tim Seidel (maxxie)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> weiss nicht ob ich das richtig verstanden habe, jedenfalls klappt es
> nicht so recht:
>
>
>   float g = -49.23;
>   int p = (int)(100*g);
>   signed char buf[2];
>   buf[0] =(char)(p>>8);
>   buf[1] =(char)(p);
>   p = (int)(((int)buf[0]<<8) | (unsigned int)buf[1]);
>   printf("\n%f", (float)p);
> 
> 
>
> buf[1] ist auch negativ bei mir, wieso das denn?

Gehen wir mal durch:
(int)(100*g) = -4923.
buf[0] = (char)(p >> 8) = -20 (0xEC)
buf[1] = (char)(p) = -59 (0xC5)
((int)buf[0]<<8) = (int)(char)0xEC << 8 =  0xFFEC << 8 = 0xEC00
(unsigned int)buf[1] = (unsigned int)(char)0xC5 = 0x00C5
0xEC00 | 0x00C5 = 0xECC5
(int)0xECC5 = -4923

Dein printf gibt also das 100fache von g aus.

Beachte:
Bei Wandlungen int<->float gehen Informationen verloren. Den numerischen 
Fehler für -42.23 müsste man jetzt nachrechnen. Liegt die 
float-Annäherung an diese Zahl bei -42.22999999... o.ä. wird das 
Ergebnis entsprechend der Truncate beim integer cast abweichen.

Autor: Peterle Anonym (Firma: keine) (wanderameise)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
mein fehler liegt hier:
(int)buf[0]<<8

der cast des array elements.

danke hat alles geklappt.

das würde aber bedeuten, das ich mit dieser methode 2 arrayelemente 
anstatt von 6 (1. beispiel) benötigen würden, ergo:
letzteres ist effizienter und platzsparender! aber auch sinnvoller?

welche methode würdet ihr wählen?!

Autor: Thilo M. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Zuerst die Frage: was ist gefordert?
Brauchst du Rechenleistung, ist die Anwendung zeitkritisch?

Ich löse das immer nach der Devise 'so schnell wie nötig, so genau wie 
möglich'.

Bei Temperaturen (PT1000) z.B., die sowieso recht träge sind, rechne ich 
alles schön in double. Die Rechenleistung reicht hierfür allemal aus, 
also warum sollte ich mir das Hirn verbiegen? ;)

Wenn der Speicherplatz begrenzt ist oder die Anwendung Geschwindigkeit 
erfordert, dann mache ich mir Gedanken, vorher nicht.

Autor: Peterle Anonym (Firma: keine) (wanderameise)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
guter ansatz: zeitkritische Anwendung.
Ich weiss es gar nicht genau, wo ich enden werde mit der zeit. Im moment 
führe ich berechnungen durch, die durch einen interrupt alle 4ms 
durchgeführt werden. NOCH sind diese Berechnungen im Rahmen. Was aber, 
wenn die Routine länger dauert als 4ms?wie finde ich heraus ob 40 zeilen 
float arithmetik unter x sekunden liegt? Ich denke diesen Aspekt muss 
ich mir nochmal in ruhe anschauen!

Autor: Thilo M. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
4ms sind eine recht lange Zeit für einen µC. Kommt natürlich drauf an, 
was sonst noch läuft (LCD, RS232, ...).
Du kannst die Rechenzeit deiner Funktion im Debugger (AVR-Studio) 
messen, das geht am einfachsten.

Autor: ameise (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
danke werde es dann mal testen!

Autor: Peterle Anonym (Firma: keine) (wanderameise)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
habe nochmal eine frage. ich schaffe es nur positive oder negative 
zahlen zu übertragen, nicht beide zB abwechselnd:

  char answer[64]; 
  int hh, gt;
  (...) //answer wird gefüllt
              
  hh =(int)answer[0];
  hh = hh << 8;
  gt = (answer[1] | hh);
  printf("\n: %f",(float)gt/1000);            




in diesem fall werden negative zahlen korrekt übertragen. positive 
jedoch verkehrt. deklariere ich answer[] als unsigned ist es umgekehrt.
wie löse ich das problem, um mit beide Zahlentypen arbeiten zu können?

danke

Autor: Tim Seidel (maxxie)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das liegt nicht an den negativen Zahlen in der Eingabe. Der Grund warum 
das passiert ist in dem Thread schon genannt.
 gt = (answer[1] | hh);
überschreibt die oberwertigen bits (aka hh) mit 1en, wenn (answer[1] < 
0)
Answer[1] ist immer dann < 0, wenn bit7 gesetzt ist.

Als Zahlenbeispiel: answer[0] = 0x00, answer[1] = 0x80 (Da signed ist 
das -127).
Du willst das (gt) als 128 auslesen, bzw nach dem Teilen als 0.128 es 
passiert aber Folgendes:

hh = 0b0000 0000 0000 0000 ;
gt = (0b1111 1111 1000 0000 | 0b0000 0000 0000 0000)
   =  0b1111 1111 1000 0000 = -127

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Prinzipiell solltest du die etwas zur Gewohnheit machen:

Wenn du irgendwelche Werte über eine Byte-Schnittstelle schleusen musst, 
dann sorge dafür, dass du überall in dieser Tunnelstrecke es immer mit 
Bytes zu tun hast. Das bedeutet keine Vorzeichen mehr, keine 
Spezialbedeutung, nichts. Einfach nur 8 Bit, die zusammen die Einheit 
Byte bilden.

Du schleust vorne in die Tunnelstrecke deine Werte (seien es double, 
seien es float, seien es Strukturen oder was auch immer) ein, dort 
werden diese Werte in einzelne Bytes auseinandergenommen (dazu gibt es 
verschiedene Techniken) und dann hast du nur noch Bytes. Die werden auf 
die Reise geschickt, kommen beim Empfänger an, und der setzt sie in der 
Umkehrung der Auseinanderpflückaktion wieder zu einer Bytesequenz 
zusammen, die dem Abholer wieder als der ursprüngliche Datentyp 
untergjubelt werden.

Aber dazu musst du dir unbedingt etwas angewöhnen:
Der Datentyp 'char' ist für dich tabu!
char benutzt man, wenn man es mit Charactern im Sinne von einzelnen 
Zeichen eines Textes zu tun hat.
Hat man es mit Bytes zu tun, dann IMMER (mit 3 Rufzeichen dahinter) 
'unsigned char' oder 'uint8_t'. Aber NIEMALS einfach nur char.
Ob char als mit oder ohne Vorzeichen aufgefasst wird, hängt von deinem 
Compiler ab und oft sogar davon, mit welchen Commandline Argumenten 
dieser aufgerufen wird. Diese Entscheidung willst du dir aber auf keinen 
Fall aufzwingen lassen. Du willst haben dass ein Byte einfach nur als 
Einheit von 8 Bit gilt. Ohen irgendwelche Sonderfälle, ohne dass beim 
Schieben irgendwelche Vorzeichenbits eine Sonderbehandleung erfahren 
oder sonst irgendetwas Spezielles passiert. Und dazu verlässt du dich 
AUF KEINEN FALL darauf, dass ein char das schon richtig machen wird, 
sondern du erzwingst mit einem 'unsigned char' die Behandlung als Bytes 
so wie der Bitgott sie erfunden hat.

Autor: Peterle Anonym (Firma: keine) (wanderameise)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
im konkreten fall:
device A ssendet ein datenpaket an B
 A füllt einen unsigned char mit daten:
unsigned char message[2];
uint16_t value = 2288;
message[0] = (value >> 8); // hier auf unsigned char casten?
message[1] = value;

dann werden diese daten via bulk send zB via USB an B geschickt:
unsigned char answer[2]
uint16_t hh, gt;
(...) // Bulk wird empfangen -> answer gefüllt 
  
hh = (int)answer[0] << 8;             //??
gt = (answer[1] | hh);               //??
 

was ändere ich beim empfangen nun konkret, um positive sowie negative 
zahlen auswerten zu können? Oder muss eine andere methoder her?

Autor: ameise123 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
keiner ´nen tip für mich?

Autor: Klaus Wachtler (mfgkw)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
auf welche Frage?

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Schreib dir Funktionen für jeden Datentyp, die dir
* den Wert im jeweiligen Datentyp in einem Bytefeld ablegen
* den Wert im jeweiligen Datentyp aus dem Bytefeld holen
void ConvertFromUint16( uint16_t value, uint8_t* buffer )
{
  *(uint16_t*)buffer = value;
}

uint16_t ConvertToUint16( uint8_t* buffer )
{
  return *(uint16_t*)buffer;
}

void ConvertFromInt16( int16_t value, uint8_t* buffer )
{
  *(int16_t*)buffer = value;
}

int16_t ConvertToInt16( uint8_t* buffer )
{
  return *(int16_t*)buffer;
}

void ConvertFromFloat( float value, uint8_t* buffer )
{
  *(float*)buffer = value;
}

float ConvertToFloat( uint8_t* buffer )
{
  return *(float*)buffer;
}

Je nachdem, wie der Rest aussieht, kann es sinnvoll sein oder auch 
nicht, zum buffer die jeweilige Längenangabe mit zu übergeben.

Wenn es wichtig ist, dass die Low/High Byte Reihenfolge eingehalten 
wird, dann müsste man darüber nachdenken, ob man anstelle des wilden 
Pointer-Umcastens nicht eine klassische Zerlegung mittels Shiften macht. 
Aber auch dort wird man um Casten nicht rumkommen.

Edit: Ooops
Sehe gerade, dass du eine USB Übertragung zu einem anderen Rechner 
machst, d.h. die Bytereihenfolge sollte besser explizit definiert 
werden, wobei das bei float/double sowieso so eine Sache ist.
void ConvertFromUint16( uint16_t value, uint8_t* buffer )
{
  buffer[0] = ( value >> 8 ) & 0xFF;
  buffer[1] = value & 0xFF;
}

uint16_t ConvertToUint16( uint8_t* buffer )
{
  return ( ((uint16_t)buffer[0]) << 8 ) | buffer[1];
}

void ConvertFromInt16( int16_t value, uint8_t* buffer )
{
  buffer[0] = ( (uint16_t)value >> 8 ) & 0xFF;
  buffer[1] = (uint16_t)value & 0xFF;
}

int16_t ConvertToInt16( uint8_t* buffer )
{
  return int16_t( ( ((uint16_t)buffer[0]) << 8 ) | buffer[1] ) );
}

void ConvertFromFloat( float value, uint8_t* buffer )
{
  uint16_t* WordPtr = (uint16_t*)value;

  ConvertFromUint16( WordPtr, buffer );
  ConvertFromUint16( WordPtr+1, buffer + 2 );
}

float ConvertToFloat( uint8_t* buffer )
{
  uint16_t WordPtr[2];

  WordPtr[0] = ConvertToUint16( buffer );
  WordPtr[1] = ConvertToUint16( buffer + 2 );

  return *(float*)WordPtr;
}

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.