Sinus in ASM Realisieren

ja dürfte sich ausgehen, beim Cordic Algo muss ich soweit ichs bis jetzt 
verstanden hab einen atan Lookup Table bauen, denk nicht das ich soviel 
platz hab.

kannst du das in einem Pseudo C erklären? ( hab 8 Bit eingang und 8 Bit 
ausgang )

meinte nicht Radius sondern Winkel ...

Brauche Winkel & Radius :)

diese ganzen erklärungen beruhen alle auf Floating Points, und da sind 
meistens, die Lookuptable für den atan is auch schon zu gross ...

moin moin,

anbei mal was in cordic...

  *   *   *   *  
..ca. 40 Zeilen an Code frei ..

das bedarf einer Erklärung, den Rest kann man googeln.

mfg
Pieter

danke für die Info,

nunja ich vermute zurzeit eher das die Skalierung meiner zahlen das 
problem ist, meine Eingangswerte für X und Y sind 0 bis 255 und als 
ausgang hätte ich einen Radius von 0 bis 255 und einen Winkel von 0 bis 
8

der Mittelpunkt meines kreises ist x=127 y=127

ich glaub ich schaff es sogar 50 Zeilen rauszuboxen, problem ist mein 
Ram hat nur 16Bytes, wie genau die atan Lookup Table sein muss hab ich 
auch noch nicht abgecheckt ...

Also anstatt eines sinus hab ich ein "quasi Rechteck geschaffen, das is 
jetzt eine 255x255er Anzeige

code dazu:

uchar sinus( int z )
{
        int x = 255;
        int y = 0;

        int dx = 0;
        int dy = 0;

        int i = 0;

//        Form1->Memo1->Clear();

        for ( i = 0; i < 8 ; i++ )
        {
                        dx = x >> i;
                        dy = y >> i;

                if( z > 127 )
                {
                        x = x - dy;
                        y = y + dx;
                        z = z - atan(128>>i)*64;
                }
                else
                {
                        x = x + dy;
                        y = y - dx;
                        z = z + atan(128>>i)*64;
                }

//                Form1->Memo1->Lines->Add( 
AnsiString().sprintf("x:%dy:%dz:%d",x,y,z) );

        }

        return y;
}

jein, 0 bis 7 und 0 bis 8 sollte möglich sein, 0 bis 248 für Winkel zb 
wäre wieder perfekt.

Eigentlich suche ich sowas:

Angle[0~248] = aTan(y/x);

das aTan mit y/x zu realisieren mit Cordic erstellt sich als etwas 
schwierig, zumals ich nur 8 Bit Rechenbreite zur verfügung habe und alle 
mit 16 Bit und mehr rechnen. Koordinatenvergleich is keine Ausreichend 
genaue Methode.

lg

so mit dem Ding schafft man einen Sauberen 8 Bit Sinus


Mittelpunkt ist 127




int i = 0;
for ( i = 0; i < 8 ; i++ )
{
      y -= (x >> i);
      x += (y >> i);
}

return y;

so, problem bei der Berechnung ist das er aus irgend einem Grund 2x den 
Winkel durchrechnet, hat eigentlich einer von denen die CORDIC hier 
gepostet haben auch wirklich mal versucht in einem uController 
nachzubauen?

uchar phi( int x , int y )
{
        int z = 128;
        int i = 0;
        int X = x;
        int Y = z;

        for (i = 1; i <= 10; ++i)
        {
                x >>= 1;
                z >>= 1;

                if( Z < 0 )
                {
                    Y += x;
                    Z -= z;
                }
                else
                {
                    Y -= x;
                    Z += z;
                }
        }

        return Z;
}

Also Winkel ist vorrangig, wenn der Radius "kann" egal sein, schöner 
wärs natürlich wenn ich ihn noch reinklopfen könnte, zurzeit überlege 
ich mithilfe eines Integrators eine Sinusähnliche Kennlinie nachzubauen 
...

irgendwie komm ich einfach nicht auf den Winkel von 255*atan(y/x)...

ich hab 2 Eingangssignale als X und Y Positions und will die Richtung 
anzeigen in die die 2 Werte Zeigen, problem dabei, das system in das ich 
anzeigen will ist Radial ...

Ja Karthesische Eingangskoordinaten von 0 bis 255 auf X und Y, ausgang 
ist dann eine Polare sagen wir mal "anzeige" ...

kann ich leider nicht ( patent pending ), wie wäre denn letzteres 
möglich?

*x = 1;
        float dx;
        *y = 0;
        int i = 0;

        *x = 0.6073*(*x);


        for( i = 0; i < 8 ; i++ )
        {
                dx = (*x);
                if( z>=0 )
                {
                        (*x) -= (*y)  * (1.0/pow(2,i)) ;
                        (*y) += dx * (1.0/pow(2,i)) ;
                        z -= atan((double)(1/pow(2,i)))*(180/M_PI);
                }
                else
                {
                        (*x) += (*y)  * (1.0/pow(2,i)) ;
                        (*y) -= dx * (1.0/pow(2,i)) ;
                        z += atan((double)(1/pow(2,i)))*(180/M_PI);
                }
        }


So hab jetzt diese Funktion hier mehr oder weniger aus dem Web Adaptiert 
und etwas modifiziert. als Input hat sie denk Winkel, als output X & Y, 
die funktion müsste man eigentlich nur umdrehen ... so irgendwie ...

eigentlich eine gute Idee, nur das man /255*127 auch als /2 schreiben 
kann ..und wenn du dann auflößt kommt

Qx = (Px>>1 - 127)+127
Qy = (Py>>1 - 127)+127

Qx = Px>>1
Qy = Py>>1

daran erkennt man aber einen echten denker :) er beschäftigt sich mit 
leidenschaft.

Das mit Patenten ist so: Wenn man irgendwo vor Veröffentlichung des 
Patents etwas darüber öffentlich gestellt hat is es sinnlos & nicht 
schützbar.

Es ist klar, dass das resultat von atan() in radianten sind...

Als Potenzreihe?

             x     1y     1y^3    2y^5
cot (y/x) = --- - ---- - ----- - ----- - ...
             y     3x    45x^3   945x^5

Vielleicht reicht es ja, bis ^3 zu rechnen, müsste man testen...?

==>


256cot(y/x) ~= 256(y/x)^-1  -  85(y/x)  -  6(y/x)^3

Taylor Reihe is glaub ich zu gross ...


void cordic2( int *x , int *y , int *z )
{
        int dx;
        int i = 0;
        int ATAN[8]= { 128 , 64 , 32 , 16 , 8 , 4 , 2 , 1 };


        for( i = 0; i < 8 ; i++ )
        {
                dx = (*x);

//                if( *z>=0 )
                if( -(*y)>=0 )
                {
                        (*x) -= (*y)>>i  ;
                        (*y) += dx>>i ;
                        (*z) -= ATAN[i];
                }
                else
                {
                        (*x) += (*y)>>i;
                        (*y) -= dx>>i;
                        (*z) += ATAN[i];
                }
        }
}


ich glaub die richtung stimmt ...

also der Algorithmus funktioniert jetzt ... zwar immer nur auf 1/4tel 
vom Kreis aber mit 4 If Abfragen bin ich ja wieder dort.

Also nach langem hin und her, auf signed integer funktioniert es richtig 
gut, aber auf unsigned char ( 8 bit unsigned ) funktioniert es einfach 
nicht weils eigentlich in den Negativen bereich gehen müsste ..