Flyttalslib till 16F887 ?

[Marta]

Är här någon som har ett fungerande flyttalslig till 16F887? Det jag önskar i första hand är en binärblob och en lista på relevanta entry points.

Först som sist, det är 16F887 som gäller, inte någon 32-bit GHz-processor av någon slag. 16F887 alltså...

Har hittat detta:
https://github.com/magore/picfloat

Gjorde git clone, installerade gputils från Debian's repository och körde make all som instruktionerna säger. Ganska väntat som det dessvärre brukar bli med denna typ av material så sprutade det ut errors i mängder. Bifogar en fil med dessa errors.

Det verkar som att detta är allt som finns. Om alternativ saknas, är här någon med bätre vana vid sådant här som kan hjälpa mig att få det hela att fungera? Jag bryr mig inte om alla testgrejor o.dyl., bara en binärblob med det egentliga libbet.

[Marta]

Hittade det jag tror är huvudfilen och försökte assemblera med gpasm. Den plöjer igenom, men det blir en del errors.
Kommandot jag testar är: gpasm -c picfp.asm

Antar problemet beror på saknade filer eller saknade/trasiga #define. Dokumentationen är dessvärre helkass, eller så är jag för dum och för gammal för att begripa den. Är här någon med vana från sådant här som vill hjälpa lite?

Exempel på error, alla är samma [151], 34 stycken sådana:

009E 00127 _INIT_IO: ; Set default I/O functions
00128 CLR8 _IO_FLAGS
00129 SET_PUTC _DEBUG_PUTC
Error[151] : Operand contains unresolvable labels or is too complex.
Error[151] : Operand contains unresolvable labels or is too complex.
00130 SET_GETC _IO_DUMMY
Error[151] : Operand contains unresolvable labels or is too complex.
Error[151] : Operand contains unresolvable labels or is too complex.
00131 ENDSUB
00132

TILLÄGG: Har kommit lite vidare. Med -C istället för -c i kommandoraden så assembleras det hela utan errors. Däremot en varning där någonting verkar egendomligt. Vad har ett fplib med portconfig o.dyl. att göra? Det ju något användaren måste få hantera och libbet skall ge f*n i rent ut sagt.
Massor är oklart. Måste hitta begripliga exempel där detta lib används.
00126 ; Setup PIC registers and I/O functions
06D0 00127 _PIC_INIT:
00128 ; Set option to NO weak B-pull-ups and RTCC with prescale of 64
06D0 30C1 00129 movlw 0xC1 ; Week B Pull Up Off, Prescale == 0x64, + INT
00130 ; option
06D1 1683 1303 00131 banksel OPTION_REG
Message[302]: Register in operand not in bank 0. Ensure that bank bits are correct. Bank_bits = 0x80, register{0x1}.
06D3 0081 00132 movwf OPTION_REG
00133
00134 ; bank0
06D4 1283 00135 bcf STATUS,RP0
06D5 1303 00136 bcf STATUS,RP1

[agehall]

Jag kan ha fel, men jag tror inte du får ut ett bibliotek du bara kan länka mot. Filen du kompilerar är testkoden, så den är avsedd att skapa något du kan programmera och köra direkt.

Jag skulle tippa på att du får inkludera de bitar du behöver i ditt egna program.

[ghu]

https://www.microchip.com/en-us/application-notes/an660
https://ww1.microchip.com/downloads/en/ ... /00660.pdf

Om det fungerar för 16F887 har jag ingen aning om.

Enklare alternativ: MPLAB XC8

[Marta]

Tackar för länkarna. Materialet från Microchip håller antagligen bättre klass än det från Sourceforge.

[Marta]

Jag måste ha missat något, men hittar inte atan i Microchip's lib. Även asin/acos saknas. Känns helt osannolikt att det skulle saknas möjlighet att beräkna en vinkel.

Tillägg: atan2 är inte längre aktuell. Hittade en annan algoritm där denna inte förekommer.

Hade börjat på att få till något med det andra alternativet, där atan finns, så valde att fortsätta på detta. Det lilla jag testat ser ut att vara ok. Tyvärr saknas atan2, vilken behövs. Det kan ju lösas, men vilket sätt är att föredra?

[guckrum]

Arcusfunktioner, och flera andra trigonometriska funktioner implementerar man annars enkelt med CORDIC-algoritmen, utan att behöva använda flyttal.

[guckrum]

Fick ett kodryck och skrev ett enkelt exempel som bara använder heltal för att beräkna atan(x).

Kod: Markera allt

from math import atan, pi

iterations = 16

# table of angles in 0.001 degrees
deg = [round(1000*180*atan(2**(-x))/pi) for x in range(0, iterations)]


def cordic_atan(x, y, N=iterations):
    angle = 0
    for e in range(0, N):
        sign = 1 if y > 0 else -1
        x0, y0 = x, y
        x = x0 + sign * (y0 >> e)
        y = y0 - sign * (x0 >> e)
        angle += sign * deg[e]
    return angle

x = 10000
y = 17320
print("atan(%f) = %d/1000" % (y/x, cordic_atan(x, y)))
x = 10000
y = 10000
print("atan(%f) = %d/1000" % (y/x, cordic_atan(x, y)))

och så här blir det:

Kod: Markera allt

atan(1.732000) = 59999/1000
atan(1.000000) = 44995/1000

Fritt ur huvudet, jag har säkert missat någon detalj.

Notera att inga multiplikationer behövs, bara skift och add.

[Marta]

Har sett namnet CORDIC, men kan inga detaljer. Varför gjorde Du exemplet i detta vedervärdiga språk? Vad gör deg[e], är det ett funktionsanrop till den översta långa raden?. Men där är ju ingen ingående parameter i denna rad. Är för gammal att begripa så jag kan porta exemplet till C.

[H.O]

Den "översta långa raden" skapar väl en array vid namn deg innehållande iterations antal värden (16 i det här fallet). deg[e] hämtar värde nummer [e] ur arrayen.

[guckrum]

Har sett namnet CORDIC, men kan inga detaljer. Varför gjorde Du exemplet i detta vedervärdiga språk? Vad gör deg[e], är det ett funktionsanrop till den översta långa raden?. Men där är ju ingen ingående parameter i denna rad. Är för gammal att begripa så jag kan porta exemplet till C.

Jag tror att du fixar portningen vid behov. Vad algoritmen gör är att rotera ingående "vektor" (x,y) i ett antal fixa steg. Stegens storlek är lagrade i "deg"-arrayen, och i detta fallet innehåller den

Kod: Markera allt

[45000, 26565, 14036, 7125, 3576, 1790, 895, 448, 224, 112, 56, 28, 14, 7, 3, 2, 1, 0, 0, 0]

dvs vinkeln 45 grader x 1000, vinkeln 26.565 grader x 1000 osv... Varje vinkel är atan(1/(1<<e)) för e=0,1,2... om du vill göra en egen tabell. Jag har multiplicerat med 180/pi för att få värdena i grader, och med 1000 för att få lite noggranhet för att kunna jobba med heltal. Ju fler iterationer desto högre noggrannhet, men som du ser så är det menlöst att köra mer än 17 iterationer om man bara multiplicerar med 1000. (Jag tyckte det var bättre att inkudera kod för arrayskapande än att bara stoppa i en array med magiska tal.)

Stegen blir alltså mindre för varje iteration, och rotationsriktningen är antingen positiv eller negativ, beroende på tecknet på y. Algoritmen försöker rotera ner invektorn (x,y) så att den ligger parallel med x-axeln (dvs där y=0), därför ackumulerar den alla vinklar längs vägen så att man får ut den totala vinkeln som roterats. Detta är returvärdet.

Funkar naturligvis lika bra eller bättre om du har flyttals addition och skift, men det häftiga är att det också går utmärkt med bara heltal.

Det behövs en liten initial justering om x är negativt. Som den ser ut nu funkar den nog bara för vinklar mellan +-90 grader. Men det är ju bara att kolla om x<0 och i så fall ändra tecken på x och göra något i stil med returvärdet = 180 - returvärdet, typ. Jag kan fixa det om du är intresserad.

Python må va läskigt, men oj vad mycket snabbare jag kodar i det språket jämfört med valfritt annat språk. Sorry.

[Marta]

Visst är det tydligare såhär? Det måste ju alla C...

Kod: Markera allt

#include <stdio.h>
#include <math.h>

const int iterations = 16;
const float pi=3.141592654;
int* d;


int cordic_atan(int x, int y){
  int angle, e, sign, x0, y0;

  angle = 0;
  for (e=0; e<iterations; e++){
      if (y>0)
        sign = 1;
      else
        sign=-1;
      x0=x; y0=y;
      x = x0 + sign * (y0 >> e);
      y = y0 - sign * (x0 >> e);
      angle += sign * d[e];
  };
  return angle;
};


void main(void){
int i, x, y;

// table of angles in 0.001 degrees
int deg_[iterations];

  for (i=0; i<iterations; i++)
    deg_[i] = round(1000*180*atan(pow(2,-i))/pi);
   d=deg_;


  x = 10000;
  y = 17320;
  printf("%i\n", cordic_atan(x, y));
  x = 10000;
  y = 10000;
  printf("%i\n", cordic_atan(x, y));

};

[guckrum]

Ja, det är bättre, snyggt! (Jag hade kanske slagit till på en frågeteckensoperator för att komprimera lite, men då blir det å andra sidan mera svårläst.) Att jag valde 1000 som uppskalningsfaktor var helt godtyckligt. I en implementation bör man ju sätta den så att man styr ut signalen så mycket som möjligt (men inte mer). Och just det, specialfallet x==y==0 måste specialbehandlas om man skall vara korrekt. Nollvektorn har ingen riktning.

[Marta]

Tack för Din beskrivning av CORDIC. Det är ju en enkel algoritm, en typ av succesiv approximation. Det blir stora tabeller, men enkelhet och snabbhet vinner. Har tyvärr inte hittat något sådant lib, av någon anledning tycks polynom-metoden föredras. Kanske storleken, blir antagligen betydligt mindre kodvolym för ett fullt set med funktioner.

[guckrum]

Tabellen växer linjärt med antalet iterationer, men värdena avtar exponentiellt så den är helt klart begränsad.

Numeriska metoder brukar annars baseras på någon iterativ approximation som har kvadratisk konvergens, dvs antalet giltiga utbitar dubblas i varje steg. Å andra sidan kräver dessa metoder ofta en multiplikator, med allt vad det innebär i energi, kiselarea, och tidsfördröjning. Dessutom är de klurigare att testa.