changable logartimic (curve of LFO or ENVELOPE)

Phatline · April 28, 2018, 4:41am

Problems Solution is:

were we have to add this to the lokal makefile:

Quote

first point after adding Math lib, it seems the loading sequence of libraries is wrong. the `__errno’ compilation error.
To resolve it we have to set the loading sequence, just change this line in your Makefile:

LIBS= to LIBS = -lm -lgcc -lc

ORGINAL PROBLEM POST

Hei.

I have made now, a LFO (UP/DOWN Ramp & Triangle), now i need to add a logaritmic ammount to get CURVES/SINEs on the LFO Straight Lines, i want to do this with a Encoder.

My LFO Values going from 0-65535 (16bit, AOUT-Ready)

My Curve CC also goes from 0-65535 (Curve means Logaritmic)

I have to execute this code every milli seconds, to change the AOUT, and every 75ms to update the SCOPE-Display

I tryd around and this is code is working with stdi0 and math.h, outside of mios: (Working)

#include \<stdio.h\> #include \<math.h\> double cc = 32000; double curve = 64000; int endresult; int main (void) { printf("exponential\_input 0-65535: "); scanf("%lf", &curve); endresult = cc \* (log(curve) / log(cc)); printf (" %d \n", endresult ); return 0; }

now in mios my code it is also working when i fill in fixed values: (WORKING)

//calculate Exponential double lfo = 65000; double curve = 32000; double lfo\_result; lfo\_result = lfo \* (log(curve) / log(lfo)); if(lfo\_result \> 65535) { lfo\_result = 65535;} if(lfo\_result \< 1) { lfo\_result = 0;}

but when i use my arrays instead of this fixed values, i become a error (NOT WORKING)

//calculate Exponential double lfo = aout[channel\_strip].lfo[y]; double curve = aout[channel\_strip].v\_cc[26+(y\*8)]; double lfo\_result; lfo\_result = lfo \* (log(curve) / log(lfo));

i also tryed: (NOT WORKING)

double lfo\_result = aout[channel\_strip].lfo[y] \* ( log(aout[channel\_strip].v\_cc[26+(y\*8)]) / log(aout[channel\_strip].lfo[y]) );

error is: (errno)

Quote

make (im Verzeichnis: /home/triggermatrix/c/Filterbox-V1)
rm -f project.hex
Creating object file for app.c
app.c: In function ‘APP_Init’:
app.c:218:5: warning: pointer targets in passing argument 2 of ‘xTaskCreate’ differ in signedness [-Wpointer-sign]
In file included from app.c:11:0:
/home/triggermatrix/mios32/trunk/FreeRTOS/Source/include/task.h:360:13: note: expected ‘const char * const’ but argument is of type ‘signed char *’
/home/triggermatrix/mios32_toolchain/bin/../lib/gcc/arm-none-eabi/4.7.4/../../../../arm-none-eabi/lib/armv7e-m/libm.a(lib_a-w_log.o): In function log': w\_log.c:(.text.log+0xb8): undefined reference to __errno’
w_log.c:(.text.log+0xc2): undefined reference to \_\_errno' w\_log.c:(.text.log+0xcc): undefined reference to __errno’
collect2: error: ld returned 1 exit status
Kompilierung fehlgeschlagen.
make: *** [project_build/project.elf] Fehler 1

dont know how to handle this, i need a cc-controlled logaritmic - any ideas?

here a goodie:

Antichambre · April 28, 2018, 10:03am

It may be better to prepare a log and antilog table then just use multiply, instead of heavy math processing.

Best
Bruno

Phatline · April 28, 2018, 12:37pm

hei.

@ table, na

a life-changeable log? table?

or a table holds all 16bit possibilitys?

[65536][65536] while [lfo_value][curve] - that ram i cant see in a µC (dont say i dont should use 16 bit values, the program doing it well, i have other reasons for that…)

such table could calculate in a a background task - with the give CURVE-Parameter, endlessly, and could be used then live… but in the end i have to ask which value should be which tablecell anyway.

@ least i want to try do the math, - and i will see timing then. if there is a way for log with this compiler(gcc?) gcc and frtos/mios?

what did i wrong. i tryd double floats…

-mike

Phatline · April 28, 2018, 7:06pm

POST NOT WORKING

hmm a workaround, that comes in my mind , while sitting here trinking vodka, set with collected raspberrys in it-

i could (if there is no other solution):

i could set my CURVE-Encoder (log setting encoder) to count from 0-20 ----curve= 0-19 (instead of 0-65525)

then make a switch, not very nice, not very small

switch (curve) { case 0: lfo\_log = lfo\_lin \* log(0.1); break; case 1: lfo\_log = lfo\_lin \* log(0.2); break; case 2: lfo\_log = lfo\_lin \* log(0.3); break; case 3: lfo\_log = lfo\_lin \* log(0.4); break; case 4: lfo\_log = lfo\_lin \* log(0.5); break; case 5: lfo\_log = lfo\_lin \* log(0.6); break; case 6: lfo\_log = lfo\_lin \* log(0.7); break; case 7: lfo\_log = lfo\_lin \* log(0.8); break; case 8: lfo\_log = lfo\_lin \* log(0.9); break; case 9: lfo\_log = lfo\_lin \* log(1.0); break; case 10: lfo\_log = lfo\_lin \* log(1.1); break; case 11: lfo\_log = lfo\_lin \* log(1.2); break; case 12: lfo\_log = lfo\_lin \* log(1.3); break; case 13: lfo\_log = lfo\_lin \* log(1.4); break; case 14: lfo\_log = lfo\_lin \* log(1.5); break; case 15: lfo\_log = lfo\_lin \* log(1.6); break; case 16: lfo\_log = lfo\_lin \* log(1.7); break; case 17: lfo\_log = lfo\_lin \* log(1.8); break; case 18: lfo\_log = lfo\_lin \* log(1.9); break; case 19: lfo\_log = lfo\_lin \* log(2.0); break; }

(not testet yet, cause the lack of hardware here) - maybe there has to be that log(x)/log(y) thing… but somekind like this

so i have this constants what the compiler crying out. for

Antichambre · April 29, 2018, 12:49am

I did the same thing in MIOS32, applied to a 16bit linear function y=x:

Is this what you want?
Will explain tomorrow… have to get some sleep…

Antichambre · April 29, 2018, 10:09am

Good morning,

First thing: the bitmap manipulation

Declaration:

///////////////////////////////////////////////////////////////////////////// // Local variables ///////////////////////////////////////////////////////////////////////////// // You need 128\*64 pixel, for SSD1306 a pixel is one bit // we will declare an u8 array, size is 128\*64/8 = 1024 static u8 bitmap\_array[1024]; // the bitmap mios32\_lcd\_bitmap\_t bitmap; // some other variables for the example u32 line, column; const float a=1.0;

Init:

///////////////////////////////////////////////////////////////////////////// // This hook is called after startup to initialize the application ///////////////////////////////////////////////////////////////////////////// void APP\_Init(void) { MIOS32\_BOARD\_LED\_Init(0xffffffff); // initialize all LEDs // initialize bitmap width=128, height=64, offset=128(!) and depth=1 bit bitmap = MIOS32\_LCD\_BitmapInit(bitmap\_array,128,64,128,1); ... }

Linear function exemple:
I used the SRIO_ServicePrepare as 1ms timer

///////////////////////////////////////////////////////////////////////////// // This hook is called before the shift register chain is scanned ///////////////////////////////////////////////////////////////////////////// void APP\_SRIO\_ServicePrepare(void) { column +=128; //column increment(x axis) if( column \> 0xffff){ // 65535 max column = 0; // this will clear/reset the bitmap ! memset(bitmap\_array, 0, sizeof bitmap\_array); } // this is just a linear function y=ax line = (u32)(a\*column); u8 x= (u8)(column\>\>9); //reducing 16 bit to 128pixels(7bits) u8 y= (u8)(line\>\>10); //reducing 16 bit to 64pixels(6bits) // set the pixel MIOS32\_LCD\_BitmapPixelSet(bitmap, x, 63-y, 1); // 63-y is to invert the y axis }

now we send it:

///////////////////////////////////////////////////////////////////////////// // This task is running endless in background ///////////////////////////////////////////////////////////////////////////// void APP\_Background(void) { column = 0; line = 0; // clear LCD MIOS32\_LCD\_Clear(); // endless loop while( 1 ) { int i; MIOS32\_LCD\_GCursorSet(0, 0); MIOS32\_LCD\_BitmapPrint(bitmap); // done! } }

result:

Antichambre · April 29, 2018, 10:39am

For a partial bitmap(not full screen) e.g. 32x32 centered

change declare

// You need 32\*32 pixel, for SSD1306 a pixel is one bit // we will declare an u8 array, size is 32\*32/8 = 128 //static u8 bitmap\_array[128]; //I don't know why this not work static u8 bitmap\_array[1024]; //this is fine

init:

// initialize bitmap width=32, height=32, offset=128(!) and depth=1 bit bitmap = MIOS32\_LCD\_BitmapInit(bitmap\_array,32,32,128,1);

calc:

 u8 x= (u8)(column\>\>11); //reducing 16 bit to 32pixels(5bits) u8 y= (u8)(line\>\>11); //reducing 16 bit to 32pixels(5bits) // set the pixel MIOS32\_LCD\_BitmapPixelSet(bitmap, x, 31-y, 1); // 31-y is to invert the y axis

positionning:

MIOS32\_LCD\_GCursorSet(48, 16); MIOS32\_LCD\_BitmapPrint(bitmap);

result:

Antichambre · April 29, 2018, 11:45am

Adding curve response Log and Antilog:

first point after adding Math lib, it seems the loading sequence of libraries is wrong. the `__errno’ compilation error.
To resolve it we have to set the loading sequence, just change this line in your Makefile:

LIBS= to LIBS = -lm -lgcc -lc

works for me

Now the curve:
in declaration add the curve variable, I use MIOS Studio to control it

u8 curve = 64;

in MIDI_Notify CC#1 is curve parameter

///////////////////////////////////////////////////////////////////////////// // This hook is called when a MIDI package has been received ///////////////////////////////////////////////////////////////////////////// void APP\_MIDI\_NotifyPackage(mios32\_midi\_port\_t port, mios32\_midi\_package\_t midi\_package) { // store incoming ModWheel values to curve if( midi\_package.type == CC && midi\_package.cc\_number == 1 ) curve = (u8)midi\_package.value; }

Ok now we will change the function to:

///////////////////////////////////////////////////////////////////////////// // This hook is called before the shift register chain is scanned ///////////////////////////////////////////////////////////////////////////// void APP\_SRIO\_ServicePrepare(void) { column +=128; //column increment(x axis) if( column \> 0xffff){ // 65535 max column = 0; // this will clear/reset the bitmap ! memset(bitmap\_array, 0, sizeof bitmap\_array); } // log/antilog function if(curve\<64){ // reducing curve to a float between 0 and 1 float curv\_f=(float)(64-curve)/64.0; // reducing column to a float between 0 and 1 float column\_f = (1.0-((float)(column/65536.0))); // line value is line = (u32)(column + ((log(column\_f)\*curv\_f\*column\_f)\*65536)); }else{ // reducing curve to a float between 0 and 1 float curv\_f=(float)(curve-64)/64.0; // reducing column to a float between 0 and 1 float column\_f = (float)(column/65536.0); // line value is line = (u32)(column - ((log(column\_f)\*curv\_f\*column\_f)\*65536)); } u8 x= (u8)(column\>\>9); //reducing 16 bit to 128pixels(7bits) u8 y= (u8)(line\>\>11); //reducing 16 bit to 64pixels(6bits) // set the pixel MIOS32\_LCD\_BitmapPixelSet(bitmap, x, 63-y, 1); // 63-y is to invert the y axis }

result:

Voilà!
I hope it will help you

have a good sunday!
Bruno

Phatline · April 29, 2018, 12:42pm

cool device** , for programing on the field? yes that curve behavior is what i was looking for..**. thx will try that @ evening — special that library thing

Quote

LIBS= to LIBS = -lm -lgcc -lc

yes also works me thx!!! — i add this to the top of article! this solve allmost everything

in the night i was thinking of a solution, how to DIY a log function special for this task, but it endet up to be exponential… my idea was:

make a linear LFO like bevore, call it LFO_LIN, this is only for calculations
calculate LFO_LOG, this will be mixed with other LFOs and will be sent out to AOUT_Channels

2a: calculate LFO_LOG:

for example:

LFO_length: 500ms, LFO_actual time Position: 250ms, LFO_LIN: 32768, cc_curve: variable from 0-65535 as example below

calculation:

LFO_LOG = LFO_LIN + LFO_LIN_ADD

LFO_LIN_ADD = LFO_LIN * ( %time * %cc_curve) - - - - [0-65535] = [0-65535] * [%] * [%] )

3750 = 15000 * ( ( (1/500ms) * 250ms)) * (1/65536) * 32768)) )

3750 = 15000 * 0,5time * 0,5cc @ cc_curve: 32768

18750 = 15000 + 3750

example calculation of the LFO_LIN_ADD

15000 = 15000 + 0 = 15000 * 0,5time * 0,0cc @ cc_curve: 0

15000,2 = 15000 + 0,22 = 15000 * 0,5time * 0,00003cc @ cc_curve: 2

15000,4 = 15000 + 0,45 = 15000 * 0,5time * 0,00006cc @ cc_curve: 4

…

15234 = 15000 + 234 = 15000 * 0,5time * 0,03125cc @ cc_curve: 2048

15468 = 15000 + 468 = 15000 * 0,5time * 0,06250cc @ cc_curve: 4096

15937 = 15000 + 937 = 15000 * 0,5time * 0,12500cc @ cc_curve: 8192

16875 = 15000 + 1875 = 15000 * 0,5time * 0,25000cc @ cc_curve:16384

18750 = 15000 + 3750 = 15000 * 0,5time * 0,50000cc @ cc_curve:32768

22250 = 15000 + 7500 = 15000 * 0,5time * 1.0000cc @ cc_curve:65536

now try half time and half lfo_lin to proof that this is not linear…:

7968,75 = 7500 + 468 = 7500 * 0,25time * 0,25000cc @ cc_curve:16384

15937,5 = 7968,75 * 2

where we had:

16875 = 15000 + 1875 = 15000 * 0,5time * 0,25000cc @ cc_curve:16384

15937,5 vs 16875 @ 1/4time @ 1/4curve_cc (positive log)

so if that result is not a comma-loos result, then this is now not linear, have to proof if that make sense on the machine

what happens when try a full cc_curve effect @ 65536 :

22250 = 15000 + 7500 = 15000 * 0,5time * 1.0000cc @ cc_curve:65536

vs half time

9375 = 7500 + 1875 = 7500 * 0,25time * 1.0000cc @ cc_curve:65536

18750 = 9375 * 2

18750 vs 22250

what happens @ end of time ( i guis it clips over 65536):

1310720 = 65536+ 65536 = 65536 * 1.0 time * 1.0000cc @ cc_curve:65536

oh that we have to clip

if ( lfo_log > 65536 ) {lfo_log = 65536)

so we have more a exponential then a logarithmic , depending on the cc_curve parameter i have a clipping

expanding cc_curve to -65536 to + 65536 makes it ±(time)exponential, i just cant wait, to try my and brunos codes.

Antichambre · April 29, 2018, 3:13pm

Ahah. Mine is a true log/antilog, this is math!

see the function applied to a triangle LFO
with variable speed and amplitude

Antichambre · April 29, 2018, 3:45pm

On 29/04/2018 at 3:42 PM, Phatline said:

cool device** , for programing on the field?**

This is something I made for a customer, it can convert all serial connection and a lot of protocol, RS232, 422, 485 MIDI LANC and some specials others…
It’s based on 2 SP338 IC around an LPC1769, so I can use it for MIOS32 too.
When I did the boxes I made one for me too and I use it as a tool on field, it ‘saved my life’ 2 times already.

Phatline · April 30, 2018, 12:23am

how get you the tri-angle > sine conversion done,

when i do, i get in the bottum part a arrowhead, and in the top i round (see video first display…3rd encoder sets curve parameter

 // T R I A N G L E if( aout[x].v\_cc[24 + (8\*y)] == 2 ) { if( (counter[x][y] \* 2) \> lfo\_cycle[x][y] ) { lfo\_lin[x][y] = lfo\_lin[x][y] - ( 131072 / lfo\_cycle[x][y] ) ;} else { lfo\_lin[x][y] = lfo\_lin[x][y] + ( 131072 / lfo\_cycle[x][y] ) ;} // Reset - ms - Counter if( lfo\_loop\_step\_pos[x][y] == 0 && flag.step0once[x][y] == 1) { flag.step0once[x][y] = 0; counter[x][y] = 0; lfo\_lin[x][y] = 0; // init lfo internal lfo\_log[x][y] = 1; // init CV Value update\_lfo\_scope[x][y] = 1; // wait for next 16th step of seq to restart LFO Cycle } } // end triangle

i do the lin-log calculation right after the Waveform calculation, and save the result — result will then printed on Screen, and dumped out to AOUT.

for lin-log i used your code - mine have not done that, what i want… did you changed anything? i dont get the sinus you have in your video

// L I N \> L O G / A N T I L O G // lin \> log if (curve \< 32767){ // reducing curve to a float between 0 and 1 curv\_f=(float)(32768-curve)/32768.0; // reducing column to a float between 0 and 1 lfo\_f = (1.0-((float)(lfo\_lin[x][y]/65536.0))); // lin \> log lfo\_log[x][y] = (u32)(lfo\_lin[x][y] + ((log(lfo\_f)\*curv\_f\*lfo\_f)\*65536)); } // lin \> antilog else{ // reducing curve to a float between 0 and 1 curv\_f=(float)(aout[x].v\_cc[26+(y\*8)] - 32768) / 32768.0; // reducing column to a float between 0 and 1 lfo\_f = (float)(lfo\_lin[x][y]/65536.0); // lin \> log lfo\_log[x][y] = (u32)(lfo\_lin[x][y] - ((log(lfo\_f)\*curv\_f\*lfo\_f)\*65536)); } }}// end x y loop

Antichambre · April 30, 2018, 11:19am

Yes I just adapt it to a signed value, normally a lfo is bipolar.

declare 2 new static function

///////////////////////////////////////////////////////////////////////////// // Local variables ///////////////////////////////////////////////////////////////////////////// u16 phase =0; u16 curve =32768; u16 amp\_cc =65535: ///////////////////////////////////////////////////////////////////////////// // Local Prototypes ///////////////////////////////////////////////////////////////////////////// static s16 XXX\_hlp\_log\_signed(u16 curv, s16 signed\_amp); static u16 XXX\_hlp\_log\_unsigned(u16 curv, u16 abs\_amp);

Add the function

///////////////////////////////////////////////////////////////////////////// // help func: return the Log/Antilog of a given signed value ///////////////////////////////////////////////////////////////////////////// static s16 XXX\_hlp\_log\_signed(u16 curv, s16 signed\_amp){ s16 log\_amp; if(signed\_amp\<-32767)signed\_amp=-32767; // limit signed to -32767 to -32767 if(signed\_amp\<0){ u16 abs\_amp = (u16)((0-signed\_amp) \<\< 1); log\_amp = (s16)(0-(XXX\_hlp\_log\_unsigned(curv, abs\_amp)\>\>1)); }else{ log\_amp = (s16)(XXX\_hlp\_log\_unsigned(curv, (u16)(signed\_amp\<\<1))\>\>1); } return log\_amp; } ///////////////////////////////////////////////////////////////////////////// // help func: return the Log/Antilog of a given unsugned value // note: math.h must be included ///////////////////////////////////////////////////////////////////////////// static u16 XXX\_hlp\_log\_unsigned(u16 curv, u16 abs\_amp){ u16 log\_amp; float curv\_f, amp\_f; if (curv \< 32768){ // reducing curve to a float between 0 and 1 curv\_f=(float)(32767-curv)/32767.0; // reducing column to a float between 0 and 1 amp\_f = (1.0-((float)(abs\_amp/65535.0))); // lin \> log log\_amp = (u16)(abs\_amp + ((log(amp\_f)\*curv\_f\*amp\_f)\*65535)); }else{ // reducing curve to a float between 0 and 1 curv\_f=(float)(curv-32767)/32767.0; // reducing column to a float between 0 and 1 amp\_f = (float)(abs\_amp/65535.0); // lin \> log log\_amp = (u16)(abs\_amp - ((log(amp\_f)\*curv\_f\*amp\_f)\*65535)); } return log\_amp; }

now you will be able to use it everywhere with signed or unsigned 16bit value

A TRIANGLE LFO with amplitude, phase and curve parameters:

// calc an unipolar triangle(0 to 65535) depending on x(time) between 0 and 65355 and phase between 0 and 65355 u16 time = (u16)(x + phase + 16384) ; // apply the phase u16 tri = (time \< 32768) ? time \<\< 1 : ((65535 - time) \<\< 1)); // now we shift down the unipolar to get a bipolar one s16 signed\_tri = (s16)(tri - 32768); // call log function, curve is unsigned 16bit value! signed\_tri = XXX\_hlp\_log\_signed(curve, signed\_tri); // apply amplitude parameter, amp\_cc between 0 and 65355 signed\_tri = (s16)(signed\_tri\*amp\_cc/65535); // we shift back the triangle to unsigned 16 bit value, for use with lcd and aout tri = (u16)(signed\_tri + 32768);

Result:

More?

Antichambre · April 30, 2018, 5:06pm

… Always More!

Width modulation added , with it you can achieve ramp down/up, pseudo sine(this is not true sine) and many more from a single triangle waveform:

// calc an unipolar triangle(0 to 65535) depending on x(time) between 0 and 65355 and phase between 0 and 65355 // set the phase u16 time = (u16)(x + phase + (u16)(wide\_mod/2)) ; // apply pos/neg width modulation, wide\_mod is an unsigned 16bit ;) float wide\_pos = 65535.0/wide\_mod; float wide\_neg = 65535.0/(65535-wide\_mod); u16 tri = (time \< wide\_mod) ? ((u16)(time\*wide\_pos)) : ((u16)((65535 - time)\*wide\_neg)); // now we shift down the unipolar to get a bipolar one s16 signed\_tri = (s16)(tri - 32768); // call log function, curve is unsigned 16bit value! signed\_tri = XXX\_hlp\_log\_signed(curve, signed\_tri); // apply amplitude parameter, amp\_cc between 0 and 65355 signed\_tri = (s16)(signed\_tri\*amp\_cc/65535); // we shift back the triangle to unsigned 16 bit value, for use with lcd and aout tri = (u16)(signed\_tri + 32768);

Phatline · May 1, 2018, 11:33pm

thX great inspiration!

special the bithshift to 128 und 64 > genial… or to scale time to u16, and then make more simple any offset possible (automation-assignment of this paremters is now also easy), also the log antilog logic..

i used your code as inspiration source to optimize code… not only because of you, because of RAM, i looked what happens when i let calculate all 4Channel-Strips & all 8 Scopes (8x4 OSCs, 88xVelo-, 88xOSC-,88xMotionSeuencer-Assignments…) had blackscreens, and ram debugger warnings usw, now i am a bit faster here - no problem with + - operation, and like you said, -heavy division and multiplication- the programm then is working ok with one screen, 8 with log and all that stuff just dont have a function… it will take me more time to experience that.

i combine now ENV + LFO und let them share the same controlls, ENV is just a nother OSC/WAVEFORM, with Bendable paremeters.

I addet 0: retrigger und 1: sustain to my RATE CC, the rest are typical LFO cycle rates encreasing… so i can use a envelope as LFO and a typical LFO-Wave as Envelope, so i am also more flexible, not every track needs 4 envelopse

most of them only 2 or even 1, haveing on the other side more LFOs… and so on.

Antichambre · May 2, 2018, 8:01am

You’re welcome!

I already planned to do something like that for the PIXI, then not a waste of time you just pushed me to do it now
But I will come back to this because it needs an accurate frequency too, exponential range something from 0.002Hz to 20Hz.

I’ve already got the math just have to translate it in code:
if note < note_Ref then
freq = Freq_Ref / (2^((note_Ref/note)/12)
else
freq = Freq_Ref * (2^((note/note_Ref)/12)

something like this

#define LFO\_FREQ\_REF 1.0//1Hz #define LFO\_FREQ\_REF\_NOTE 0x45// 69, A3 midi note //7bit #define LFO\_FREQ\_REF\_VALUE (LFO\_FREQ\_REF\_NOTE\<\<9)//16bit #define LFO\_FREQ\_TICK\_RESO 1.0//ms u8 coarse = LFO\_REF\_NOTE;// LFO Coarse Tune (7bit) u8 fine = 64; // LFO Fine Tune +/- 6bit(7bit) float target\_period, last\_period; // in millisecond float accumulator, accum\_step; // in millisecond //with freq\_val = (u16)(coase\<\<9 + (fine-64)\<\<2); if(freq\_val\<LFO\_FREQ\_REF\_VALUE) target\_period = (float)(1000.0 / (REF\_FREQ / (2^(((LFO\_FREQ\_REF\_VALUE-freq\_val)/512.0)/12); else target\_period = (float)(1000.0 / (REF\_FREQ \* (2^(((freq\_val-LFO\_FREQ\_REF\_VALUE)/512.0)/12); accum\_step = target\_period / LFO\_FREQ\_TICK\_RESO;

like a VCO is centered around 440Hz on A3 note, the LFO will be centered around 1Hz on A3 note
which will give 0.01858Hz for the lowest note and 28.50876Hz for the higher one.
ToDo! And I didn’t check in the SVN if something like this was done before

Best
Bruno

Antichambre · May 2, 2018, 8:33am

9 hours ago, Phatline said:

no problem with + - operation, and like you said, -heavy division and multiplication- the programm then is working ok with one screen, 8 with log and all that stuff just dont have a function… it will take me more time to experience that.

For process time, remember, by decreasing the parameters resolution to 7bit (CC resolution) you can prepare some tables at startup(RAM) OR write it in program memory(FLASH) and finally remove some calculation.
e.g. this can be replaced by an array if curve is a 7bit

On 30/04/2018 at 1:19 PM, Antichambre said:

curv_f=(float)(32767-curv)/32767.0;

We can also try to use the FPU of the STM32 for hardware floating point calculation, but I read in the forum people have some troubles to get it.

http://discourse.midibox.org/t/topic/19790

Phatline · May 3, 2018, 3:30am

18 hours ago, Antichambre said:

For process time, remember, by decreasing the parameters resolution to 7bit (CC resolution) you can prepare some tables at startup(RAM) OR write it in program memory(FLASH) and finally remove some calculation.
e.g. this can be replaced by an array if curve is a 7bit

We can also try to use the FPU of the STM32 for hardware floating point calculation, but I read in the forum people have some troubles to get it.

i have tryed, but with the result, that i could use FPU, but not for my program because in order to use FPU i have to turn off optimize and frame pointer (as workaround), but i a am not expirienced enough to rewrite my code good enough to not need optimize and other stuff…

< base_url >/topic/20294-fpu-not-working-on-stm32f4-with-mios32/?do=embed&embedComment=181290&embedDo=findComment

@7bit, i want to automate everything possible (so all except Wave-Form, RATE and Programchange), because they are combined with Clock, resync…)

The Automations are:

MotionSequencer

Velocity from trigger

OSC (LFO)

and they all get summed/combined together on each CC/aout/parameter … i dont want to mix here, its better to leaf it u16, the program is already big, and it would lead to problems and headpain in the future.