Mathebibliothek für STM8S

[Max M. (maxmicr)]

Guten Abend,

ich suche nach einer Mathe-Bibliothek (mit Cos/Sin/e) für den 
STM8S(003F3), kann ich da jede beliebige C-Bibliothek nehmen? Welche 
würdet ihr empfehlen?

Grüße

[S. R. (svenska)]

Ich vermute mal, dass SDCC passende Routinen enthält, aber ziemlich 
sicher nur mit einfacher Genauigkeit.

[pegel (Gast)]

sdcc/include/math.h bietet:

/* Trigonometric functions */
float sinf(float x) _FLOAT_FUNC_REENTRANT;
float cosf(float x) _FLOAT_FUNC_REENTRANT;
float tanf(float x) _FLOAT_FUNC_REENTRANT;
float cotf(float x) _FLOAT_FUNC_REENTRANT;
float asinf(float x) _FLOAT_FUNC_REENTRANT;
float acosf(float x) _FLOAT_FUNC_REENTRANT;
float atanf(float x) _FLOAT_FUNC_REENTRANT;
float atan2f(float x, float y);

/* Hyperbolic functions */
float sinhf(float x) _FLOAT_FUNC_REENTRANT;
float coshf(float x) _FLOAT_FUNC_REENTRANT;
float tanhf(float x) _FLOAT_FUNC_REENTRANT;

/* Exponential, logarithmic and power functions */
float expf(float x) _FLOAT_FUNC_REENTRANT;
float logf(float x) _FLOAT_FUNC_REENTRANT;
float log10f(float x) _FLOAT_FUNC_REENTRANT;
float powf(float x, float y);
float sqrtf(float a) _FLOAT_FUNC_REENTRANT;

/* Nearest integer, absolute value, and remainder functions */
float fabsf(float x) _FLOAT_FUNC_REENTRANT;
float frexpf(float x, int *pw2);
float ldexpf(float x, int pw2);
float ceilf(float x) _FLOAT_FUNC_REENTRANT;
float floorf(float x) _FLOAT_FUNC_REENTRANT;
float modff(float x, float * y);

[Max M. (maxmicr)]

Danke für eure Hilfe,

kann man die Bibliothek vom SDCC mit dem IAR-Compiler auch benutzen?

[S. R. (svenska)]

Warum nimmst du nicht einfach die Bibliothek vom IAR, wenn du den 
sowieso schon nutzt?

[Max M. (maxmicr)]

Ich wusste nicht, dass es eine IAR C-Bibliothek gibt? Wo finde ich die?

[S. R. (svenska)]

Wenn du einen C-Compiler hast, dann hast du auch eine 
C-Standardbibliothek. Ohne die funktionieren nämlich viele Funktionen, 
die der C-Standard vorschreibt, nicht.

[(º°)·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.· (Gast)]

> Wo finde ich die?

stm8/lib

Eigentlich sollte hier mal was stehen.
Aber wer zu faul ist, die Doku* mal selber zu lesen...
Dem schreib ich das hier nicht nochmal ab.



*) doc/EWstm8_DevelopmentGuide.pdf

[Sebastian K. (sek)]

Durch Verwendung der IAR eigenen Bibliothek hast du über die Linker 
Options zudem den Vorteil zwischen diversen Implementierungsvarianten 
(auf Größe optimiert, auf Speed optimiert...) der Funktionen wählen zu 
können.

[Ralph S. (jjflash)]

... wenn du die math - library nicht einbinden magst, vielleicht hilft 
dir das ?!?

Sinus / Cosinus über Taylorreihenentwicklung. Ich hatte es hier vor 
geraumer Zeit auch davon (allerdings primär für einen STM32F030). Ein 
Forumsmitglied hatte hier eine geniale Festkommabibliothek gepostet 
(nicht von ihm), die ich allerdings noch nicht auf einen STM8 portiert 
habe (gibt Schwierigkeiten bzgl. int32 Variablen).

Die folgenden Funktionen funktionieren auf STM8 und MCS51:

/* --------------------------------------------------------
     wenn stdarg.h NICHT eingebunden ist, dann ist die
     Auskommentierung fuer abs aufzuheben !
   -------------------------------------------------------- */
/*
float abs(float value)
{
  if (value< 0.0f) return (value * -(1.0f));
           else return value;
}
*/

#define MY_PI     3.14159265359f

/* --------------------------------------------------------
   tiny_pow

   bestimmt den Wert fuer value hoch n ( value ^ n)
   Der Exponent n muss (leider) eine Ganzzahl (integer)
   sein
   -------------------------------------------------------- */
float tiny_pow(int n, float value)
{
  float tmp;
  int   i;

  tmp= value;
  for (i= 0; i < n-1; i++)
  {
    tmp= tmp*value;
  }
  return tmp;
}

/* --------------------------------------------------------
   tiny_sin

   bestimmt den Sinus von value im Bogenmass. Die Be-
   rechnung erfolgt mittels Taylorreihe
   Eine Umrechnung in Grad kann mittels:
      sin(wert * (MY_PI / 180.0f) erfolgen
   -------------------------------------------------------- */
float tiny_sin(float value)
{
  float degree;
  float p3;
  float p5;
  float p7;
  float sinx;

  int   mflag= 0;

  while (value > (2*MY_PI)) value -= (2*MY_PI);
  if (value > MY_PI)
  {
    mflag= - 1;
    value -= MY_PI;
  }

  if (value > (MY_PI /2)) value = MY_PI - value;

  degree= value;

  p3 = tiny_pow(3, degree);
  p5  = tiny_pow(5, degree);
  p7  = tiny_pow(7, degree);

  // Taylor-Reihenentwicklung
  // 6 = fak(3); 120 = fak(5); 5040= fak(7)
  sinx= (degree - (p3/6.0f) + (p5/120.0f) - (p7/5040.0f));

  if (mflag) sinx = sinx * (-1);

  return sinx;
}

/* --------------------------------------------------------
   tiny_cos

   Bestimmt den Cosinus von Value im Bogenmass
   -------------------------------------------------------- */
float tiny_cos(float value)
{
  return tiny_sin(value - (MY_PI / 2.0f)) * -1.0f;
}

[A. B. (Gast)]

Na, das mit dem "tiny_pow" ist aber so ziemlich die ärgste 
Resoucenverschwendung, Stichwort Horner-Schema. Spart VIELE 
Multiplikationen gegenüber der Trivial-Variante bei der 
Polynomauswertung:
a_n*x^n+a_{n-1}*x^{n-1}+...+a_1*x+a_0
=(...(a_n*x+a_{n-1})*x+a_{n-2})*x+a_{n-3})...)*x+a_0
Da wird also nur fortwährend mit x multipliziert und der 
nächstniedrigere Koeffizient dazu addiert.
Wenn man weiß, dass nur ungerade (oder nur gerade) Potenzen auftauchen, 
modifiert man das natürlich, dass man laufend mit x^2 multipliziert.
Die Zahl der Multiplikationen ist bei der Trivial-Variante von der 
Größenordnung n^2, beim Horner-Schema nur n.

Außerdem: Taylor-Entwicklung ist nicht so das Gelbe vom Ei, wenn man ein 
relativ großes Intervall betrachtet. In der Nähe des Entwicklungspunktes 
(hier: 0) zwar nicht schlecht, aber die Qualität sinkt mit zunehmendem 
Abstand rapide ... Und [0,pi] ist schon ziemlich groß.
(Übrigens ist das oben nicht "mit Taylor-Reihe", sondern "mit 
Taylor-Polynom".)

Besser: Entwicklung nach Legendre- oder Tschebyschow-Polynomen, damit 
erzielt man eine halbwegs gleichmäßige Approximationsgüte auch bei einem 
längeren Intervall. Und es kommt trotzdem wieder ein Polynom (auch 
ungerade bzw. beim Kosinus gerade) heraus, der Rechenaufwand ist also 
derselbe.

Die Implementierung oben liefert übrigens bei negativen Winkeln ... ?!
Und wenn schon Taylor, sollte man ein möglichst kleines Intervall 
nehmen, es böte sich also an, auch noch die Symmetrie von [0,pi/2] zu 
[pi/2,pi] zu nutzen.

[Ralph S. (jjflash)]

... absolut alles richtig was du sagst.

Allerdings hatten diese Funktionen schlicht funktioniert und es war noch 
ausreichend Platz.

Grundsätzlich war das etwas schnelles und bei anderen Controllern hatte 
ich die math hinzugelinkt.

Dann, wenn der Platz gering wird, verwende ich die Festkomma-Software 
die hier ein Forumsmitglied gepostet hat.

Bei der Taylorreihenentwicklung sieht man allerdings auch sehr schön, 
wie das aufgebaut ist... und (ich weiß das ist nicht wirklich ein 
Argument) die Quelldateien bleiben schön klein und übersichtlich !

(Allerdings - wie du absolut richtig angemerkt hast: ungenau und 
resourcenverschwendend)