Welke PIC te gebruiken voor logaritmische functie?

Of je een log functie hebt hangt van je compiler af. Ik gebruik Mikrobasic, die heeft er een library voor.
Wat betreft type pic, hangt af van wat 'ie nog meer moet doen. In MB gebruikt Log() zo'n 200 bytes programmageheugen, je moet in ieder geval genoeg flash hebben.

Ik denk dat dit soort berekeningen bij eenvoudige PIC's best lastig kunnen zijn. Soms is het stukken praktischer om bijvoorbeeld met een lookup-tabel te werken.

Op 15 september 2014 20:59:16 schreef Franzki:
Soms is het stukken praktischer om bijvoorbeeld met een lookup-tabel te werken.

enlighten me please

Ik beeld mij bij een lookup-tabel een geheugen in waar per getal het natuurlijk logaritme is opgeslagen. Euhm, is dat geen gigantische tabel? Of maak je dan een subset en splits je het getal op om dan de "som" van de logaritmes te nemen etc... ?

Ik denk dat een tabel veel meer als 200 bytes gaat innemen...
Als snelheid geen noodzaak is werkt de log() functie prima.
Qua geheugen kan het allebei. Een beetje PIC heeft 32k flash of meer...

Als algemeen voorbeeld...

Stel je voor dat ik met een PIC een sinusvormige spanning wil genereren, dan kan ik heel veel moeite doen om een sinus-functie te programmeren. Ik kan ook een tabelletje maken met een stuk of 10 waardes van een sinus-functie en dat slim gebruiken (horizontaal en verticaal spiegelen). Scheelt een hoop gedoe.

Voor wat betreft jouw 'probleem'... je wilt beslissen of een ventilator wèl of niet moet draaien op basis van een aantal factoren. Maar misschien kun je de voorwaarden wel versimpelen waardoor je het dauwpunt niet hoeft te berekenen.

Op 15 september 2014 21:16:46 schreef Franzki:
Stel je voor dat ik met een PIC een sinusvormige spanning wil genereren, dan kan ik heel veel moeite doen om een sinus-functie te programmeren. Ik kan ook een tabelletje maken met een stuk of 10 waardes van een sinus-functie en dat slim gebruiken (horizontaal en verticaal spiegelen). Scheelt een hoop gedoe.

Op 10 augustus 2007 10:35:27 schreef rew:
Wil je een circel tekenen, gebruik dan:

short x,y; 

x=0x7ff0;
y=0;
while (1) {
   plot (x>>8,y>>8);
   y += x >> 8;
   x -= y >> 8;
}

Dit is ook te gebruiken om sinus uit te rekenen. Zoals ik het nu heb, doet hij 1 rad per 256 stapjes. Mooi he?

Slecht algemeen voorbeeld dus

Zo ver had ik niet terug gekeken...

Op 15 september 2014 21:16:46 schreef Franzki:
Voor wat betreft jouw 'probleem'... je wilt beslissen of een ventilator wèl of niet moet draaien op basis van een aantal factoren. Maar misschien kun je de voorwaarden wel versimpelen waardoor je het dauwpunt niet hoeft te berekenen.

Tja. Dat is natuurkunde. Kan daar niet veel simpelers voor bedenken dat correct resultaat geeft. Maar ik sta open voor andere ideeën.

De oude rotten hier, kijken met grote argwaan naar "dure" functies als "floating point" en "logarithme".

Een vriendje van m'n pa vertelde dat ze op z'n werk ooit een nieuwe (mainframe!) computer kregen met een ZEE van geheugen: 1k.

Tijden veranderen. In een sot23 kan je een microcontroller krijgen die dat overtreft.

Als je tegenwoordig "niet te klein" begint, heb je een microcontroller die je als je zuinig doet niet voor verder dan 10% gevuld krijgt. Dus: Voor de ontwikkeling: Doe wild! gebruik gewoon de "log" uit de bibliotheek. Vervolgens is het als je eenmaal "klaar" bent instructief om eens te kijken hoeveel die log nu werkelijk gebruikt in programmageheugen en processortijd. Als je het het wilt optimaliseren kan dat dan nog.

(Vroeger had je de luxe van "krijg het eerst werkend met grove verslindende functies" niet. Dan had het gewoon nooit gepast... Dan moest je wel vanaf het begin "zuinig" zijn).

Log op basis van een tabel:

  mylog (float x)
  {
    int exp = 0;

    if (x <= 0) return ERROR;

    while (x > 2) {
      x = x / 2;
      exp ++;
    }
    while (x < 1) {
      x = x * 2;
      exp --;
    }
    return 0.69314718 * (exp + table_log2 (x));
}

De table_log2 hoeft slechts te rekenen op argumenten tussen 1 en 2, dus hoeft helemaal geen grote tabel te hebben. Verder is de "range" zo klein dat een taylor expansie ook vast hoge nauwkeurigheid krijgt.

Ik reken hier eerst de log2 uit. Waarschijnlijk is dat efficiënter, omdat je nu maar 1x met die 0.69 hoeft te vermenigvuldigen. Anders moet dat in de while lussen ook. En een *2 van een floating point getal kan (als de compiler het door heeft) een increment van de exponent zijn. (dat eerste deel is eigenlijk exp=float.exponent ; float.exponent = 0;)

Ik kom zelf ook uit de tijd dat ik een Timex1000 had (de USA-versie van de ZX81) waarin 2kB geheugen zat, het dubbele van de originele ZX81.

Ik ben dus nog steeds een beetje zuinig als het om resources gaat.

Maar natuurlijk kun je op moderne microcontrollers gewoon wiskundige functies gebruiken. Al blijft het de vraag of het ècht nodig is om je doel (het aansturen van een ventilator) te bereiken.