AVR Freaks

There is an online compiler where you can try out ideas when you don't have access to your own compiler-

https://godbolt.org/

I use it when I quickly want to try something out. Its usually not that important which compiler is chosen as long as its the same family (gcc). I usually just use the x86-64 compiler as you can see the printf output that way by turning on the a.out option.

This would require you to roll your own constexpr version of exp().

I'm not sure why you would need to roll your own. You can use the math.h version of exp(), and also use M_PI from math.h while you're at it. The compiler will certainly let you know when it cannot return a compile time value.

https://godbolt.org/z/9zm91b

Yes, gcc has a large number of builtin functions, so they can all be used in constexpr.

https://gcc.gnu.org/onlinedocs/g...

I found out about this feature some time ago: https://www.avrfreaks.net/forum/...

This is a power far, far beyond what the preprocessor can do.

If you don't have access to AS7, you can still play with the avr compiler at the command line (easy enough to get, unless you are for some reason tied to a work pc that is restricted, I suppose, or maybe you on a beach typing away on an ipad- but then why are you doing any math on a beach).

#include <math.h>

#define FCORNER 0.01
#define XFIL 256*exp(-2 * M_PI * FCORNER)
//or this
//#define XFIL 256*__builtin_exp(-2 * M_PI * FCORNER)

int main(){
    volatile int x = XFIL;
    for(;;){}
}

/*
 ./avr-gcc -Os test.c
 ./avr-size a.out

 text    data     bss     dec     hex filename
   20       0       0      26      14 a.out

 ./avr-objdump -d a.out

 Disassembly of section .text.startup:

00000000 <main>:
   0:   cf 93           push    r28
   2:   df 93           push    r29
   4:   00 d0           rcall   .+0             ; 0x6 <__zero_reg__+0x5>
   6:   cd b7           in      r28, 0x3d       ; 61
   8:   de b7           in      r29, 0x3e       ; 62

   a:   80 ef           ldi     r24, 0xF0       ; 240
   c:   90 e0           ldi     r25, 0x00       ; 0
   e:   9a 83           std     Y+2, r25        ; 0x02
  10:   89 83           std     Y+1, r24        ; 0x01

  12:   ff cf           rjmp    .-2             ; 0x12 <__zero_reg__+0x11>
*/

You can see the value (240) is loaded into the var x (on the stack), so you can use defines/macro in this case without having to pre-compute.

Yes, gcc has a large number of builtin functions

There is probably a lot more of that going on than we realize. The above example also works when using __builtin_exp() (don't even need math.h), so even when using what we think is the library version we get the built in version.