Teletype : LFOs

xeric · 2016-10-05T01:34:25.697Z

I originally posted something about this in the teletype : code exchange but I thought I’d start a separate thread to make things easier to follow.

The general idea here is that I’m trying to develop a quad (possibly octo! via Ansible/expanders) pingable LFO generator on Teletype.

I succeeded at creating very basic pingable Triangle waves with the following script, modified slightly for scripts 1-4 to change outputs and variable names.
Y AVG Y SUB TIME X
X TIME
CV.SLEW 1 DIV Y 2
CV.1 PARAM
DEL DIV Y 2 : CV 1 0
DEL DIV Y 2 : TR.PULSE 1

PARAM controls the LFO amount, but now I’m trying to get PARAM to control the LFO shape. Essentially I just want to morph the triangle into a sawtooth as I turn either direction past 12 o clock.

I can’t for the life of me figure out how to get this simple concept into few enough characters that it will fit in a single script.

Y AVG Y SUB TIME X
X TIME
Z SCALE 0 V 10 0 Y PARAM
CV.SLEW 1 Z
CV.1 PARAM
DEL Z : CV.SLEW 1 SUB Y Z
DEL Z : CV 1 0

Even while removing the (very useful) trigger when the LFO is high, I’m still stuck with 7 lines of code… can anyone help me get this down to 6 lines? Looks like this would solve my problem – but I feel like I should be able to accomplish this with some clever arithmetic

trickyflemming · 2016-10-05T03:12:41.608Z

This is the function I’m porting to Ansible’s Cycles in a week or two after our next plug-in is released:

github.com

LancePutnam/Gamma/blob/master/Gamma/Oscillator.h#L1215


	freq(f);
}


template<class Tv, class Td> inline Tv AccumPhase<Tv, Td>::freq() const { return mInc/mFreqToInc; }
template<class Tv, class Td> inline Tv AccumPhase<Tv, Td>::freqUnit() const { return freq()*this->ups(); }
template<class Tv, class Td> inline Tv AccumPhase<Tv, Td>::period() const { return Tv(1)/freq(); }
template<class Tv, class Td> inline Tv AccumPhase<Tv, Td>::phase() const { return mPhase/(Tv(2)*mRadius); }
template<class Tv, class Td> inline Tv AccumPhase<Tv, Td>::radius() const { return mRadius; }


template<class Tv, class Td> void AccumPhase<Tv, Td>::onDomainChange(double /*r*/){
	Tv f=freq();
	recache();
	freq(f);
}
template<class Tv, class Td> void AccumPhase<Tv, Td>::recache(){
	mFreqToInc = Tv(Td::ups() * Tv(2)*mRadius);
}


template<class Tv, class Td> void AccumPhase<Tv, Td>::print(FILE * fp, const char * append){
	fprintf(fp, "%f %f %f%s", freq(), phase(), mInc, append);
}

It takes one phasor and can smoothly transition between ramp, triangle, and sawtooth. I don’t know how feasible it is with regular TT code.

However, in the TT 2.0 thread, LFOs have been discussed as a potential future feature. I think this variable-shape LFO code would be an excellent operator in a future firmware.

lloydcole · 2016-11-13T22:21:45.979Z

trickyflemming:

This is the function I’m porting to Ansible’s Cycles in a week or two

Any update on this? And any chance you could explain to non-coder what this will make possible with Cycles?

trickyflemming · 2016-11-13T22:30:56.035Z

No updates yet, sorry. I’m defending my dissertation on December 9th, so everything is on hold until then.

lloydcole · 2016-11-13T22:41:07.196Z

Thanks for letting me know.

bobbcorr · 2016-11-13T23:41:59.717Z

Good luck with your defense!

trickyflemming · 2016-11-14T00:20:40.830Z

Thank you! Really appreciate it.

midilifestyle · 2016-11-20T04:41:20.807Z

From one phd to another: congratulations!!
(I play with synths instead of writing my diss; if I wouldn’t have picked your field I could do both at once!)

rdfm · 2017-09-24T00:26:25.575Z

Any chance this will ever see the light of day? Sounds like a lot of fun to be had

sliderule · 2017-09-26T07:00:59.109Z

I have some thoughts about implementing function generators within teletype, but I fear that their usefulness is going to be limited at the moment by the CV update rate. The stepping is notable to my ears, especially when patched into something like the Rossum Morpheus, where alias jumps on the modulation inputs can produce clicks.

emenel · 2017-09-27T02:01:10.755Z

The Telex expanders add this type of functionality… as does Ansible via Arc. I’m not sure TT is the right place for full on function generators, it feels like it’s starting to stray too far from what TT is all about. It feels more right to use TT to trigger something like a Function or Pip Slope in an interesting or generative way.