Spin Semiconductor

I've read this but I must admit I'm not at the point where I can translate these diagrams into the proper opcodes.

How would I write a single allpass stage in code?

The FV-1 has special instructions for this to make it quick to do. Make the following assumptions:

"IN" is in the accumulator already, may have come from a filter, delay, ADC, etc.
"DELAY" is the name of the delay block in the all-pass.
"K" = 0.37, why? Because I like that number for examples. Note the LR register is automatically updated every time a value is read from memory so it holds DELAY# when we execute the wrap instruction.

So there you have it, a 2-tick APD.

Can I equate K to a register, or is it like my earlier question where it needs to be a specific coefficient? If I can't, how do I create a varying K value for a phaser?

In this case K is fixed, you need to use mulx to multiply by a register. An all pass can still be done but it will take 6 or 7 instructions to do it, I haven't written code to do this but it should be:

read end of delay (rda),
multiply by reg (mulx),
add input (rdax or rda depending if from register or memory),
write to head of delay (wra),
multiply by reg (mulx),
multiply by -1 (sof),
read end of delay(rda)

I hacked up what I thought a 4-stage phaser might look like using your suggestions. It uses the envelope to vary the phasing.
So far it doesn't work, but it involved a lot of guessing so I didn't really expect it to. I can't remember now why I made the delays 205 samples, and I'm guessing this is one thing that isn't right, but I don't really know how to figure them.

Any suggestions on where I'm going wrong?

A quick look seems OK (will take a closer look Monday when back in the office), try making it just one AP and seeing if it works than add in the LP filter, then the additional stages, etc. We need to isolate where it fails.

frank wrote:In this case K is fixed, you need to use mulx to multiply by a register. An all pass can still be done but it will take 6 or 7 instructions to do it, I haven't written code to do this but it should be:

read end of delay (rda),
multiply by reg (mulx),
add input (rdax or rda depending if from register or memory),
write to head of delay (wra),
multiply by reg (mulx),
multiply by -1 (sof),
read end of delay(rda)

I just had to do a similar thing, where the allpass coefficient was in a register, derived from a pot. Input is in the ACC, so I didn't think you needed to add the input, it is done in the first rda. I came up with this (hopefully it is right):

rda delay#, 1 ; allpass with WRAP replaced to use variable coefficient
mulx coefficient
wra delay, -1 ; store to delay and then negate ACC
mulx coefficient ; apply 'negative' coefficient
rda delay#, 1 ; add in the end entry in the delay

mdroberts1243 wrote:
I just had to do a similar thing, where the allpass coefficient was in a register, derived from a pot. Input is in the ACC, so I didn't think you needed to add the input, it is done in the first rda. I came up with this (hopefully it is right):

rda delay#, 1 ; allpass with WRAP replaced to use variable coefficient
mulx coefficient
wra delay, -1 ; store to delay and then negate ACC
mulx coefficient ; apply 'negative' coefficient
rda delay#, 1 ; add in the end entry in the delay

Not quite correct, input to all-pass is: input + (delayout * K)

If input is in ACC then you are doing: (input + delayout) * K

Not the same result

frank wrote:

mdroberts1243 wrote:
I just had to do a similar thing, where the allpass coefficient was in a register, derived from a pot. Input is in the ACC, so I didn't think you needed to add the input, it is done in the first rda. I came up with this (hopefully it is right):

rda delay#, 1 ; allpass with WRAP replaced to use variable coefficient
mulx coefficient
wra delay, -1 ; store to delay and then negate ACC
mulx coefficient ; apply 'negative' coefficient
rda delay#, 1 ; add in the end entry in the delay

Not quite correct, input to all-pass is: input + (delayout * K)

If input is in ACC then you are doing: (input + delayout) * K

Not the same result

Thanks Frank!

Had to go over it a few times to understand... ended up storing the input to a temp register, clearing the ACC and adding a line:

wrax temp, 0
rda delay#, 1 ; allpass with WRAP replaced to use variable coefficient
mulx coefficient
rdax temp,1 ; add input *NEW*
wra delay, -1 ; store to delay and then negate ACC
mulx coefficient ; apply 'negative' coefficient
rda delay#, 1 ; add in the end entry in the delay

That looks good, think that will work.

frank wrote:That looks good, think that will work.

I think it works, but I went and tried to add chorusing on the delay taps, screwing everything up, which requires me to re-think the flow again.

I don't understand the 'post' processing chorus stuff that is done in a lot of the reverb example programmes... is that explained anywhere? I'm trying to implement the modulated output taps directly in the allpass as shown in a lot of reverb flow-diagrams instead.

Thanks,

Can you post or link directly to an example so I can see the code you are talking about? Lots of reasons to do things in a reverb program.

frank wrote:Can you post or link directly to an example so I can see the code you are talking about? Lots of reasons to do things in a reverb program.

Hi Frank,
Thanks. I've been coding up the Dattorro plate reverb as an exercise (in frustration)
I will start a separate thread... the result might be interesting for others.

frank wrote:Can you post or link directly to an example so I can see the code you are talking about? Lots of reasons to do things in a reverb program.

I think the plate reverb examples on spinsemi use a block of chorus statements at the end of the code to affect each delay. I don't understand that... It seems to just juggle some samples in the interior of the delay. If this is somehow equivalent to modulating the read from the end of the delay/AP then it would be a lot more efficient to implement the Dattorro diagram in the FV-1!

A quick look at the code makes me believe the chorusing of values in the all-pass' is to stop any repetitive noise from happening. With these kind of structures you can get a repetitive sound at a particular frequency, by slightly shifting the sound with a chorus type effect you can stop that from happening.