File content as of revision 1:f3350a372732:

#include "mbed.h"

AnalogOut DAC0(PA_4);//Not labeled in the docs for the f401, but seems to be for all
AnalogOut DAC1(PA_5);

AnalogIn ADC0(PA_0);
AnalogIn ADC1(PA_1);
//AnalogIn ADC2(PA_2);//not labeled as such in MBED's docs for f401, yes 446
//AnalogIn ADC3(PA_3);//not labeled as such in MBED's docs for f401, yes 446
//AnalogIn ADC4(PA_4);//we're using these for output
//AnalogIn ADC5(PA_5);//we're using these for output
AnalogIn ADC6(PA_6);
AnalogIn ADC7(PA_7);
//AnalogIn ADC8(PB_0);//lets leave the 2 we aren't using in a single port
//AnalogIn ADC9(PB_1);//that way we know there's not ADCs on one of them
AnalogIn ADC10(PC_0);
AnalogIn ADC11(PC_1);
AnalogIn ADC12(PC_2);
AnalogIn ADC13(PC_3);
AnalogIn ADC14(PC_4);
AnalogIn ADC15(PC_5);

//Renaming ports
#define inVol ADC0
#define inModAmt ADC1
#define inCarA ADC6
#define inCarD ADC7
#define inCarS ADC10
#define inCarR ADC11
#define inModA ADC12
#define inModD ADC13
#define inModS ADC14
#define inModR ADC15
#define outMono DAC0

#define numKeys 88
#define PI M_PI

//possible constants
int carrierIncrements[numKeys];
const int attackLimit = (0x1 << 16) - 1;
const int fixed2Pi = (int) ((2.0 * PI) * (0x1 << 16));


//non-constants
//Most of these will be recalculated or reset on every input cycle of the main
//  loop, as appropriate
int FMmult;
int Volume;
int modVol;
int modAmpI;
int carAmpS;
bool keysPressed[numKeys];
int carrierPhases[numKeys];
int modulatorPhases[numKeys];
short envelopeStatesC[numKeys];
short envelopeStatesM[numKeys];
int envelopeAmpsC[numKeys];
int envelopeAmpsM[numKeys];

int modA;
int modD;
int modS;
int modR;
int carA;
int carD;
int carS;
int carR;

int fastSin(const int phase){
    return 0;
}

void synthesize(){
    carAmpS = 0;
    for(int i = 0; i < numKeys; ++i){
        if(keysPressed[i]){
            if(envelopeStatesC[i] < 2)
                envelopeStatesC[i] = 4;
            if(envelopeStatesM[i] < 2)
                envelopeStatesM[i] = 4;
            
            if(envelopeStatesC[i] == 4){
                envelopeAmpsC[i] += carA;
                if(envelopeAmpsC[i] >= attackLimit){
                    envelopeAmpsC[i] = attackLimit;
                    envelopeStatesC[i] = 3;
                }
            }
            
            if(envelopeStatesM[i] == 4){
                envelopeAmpsM[i] += modA;
                if(envelopeAmpsM[i] >= attackLimit){
                    envelopeAmpsM[i] = attackLimit;
                    envelopeStatesM[i] = 3;
                }
            }
            
            if(envelopeStatesC[i] == 3){
                envelopeAmpsC[i] += carD;
                if(envelopeAmpsC[i] <= carS){
                    envelopeAmpsC[i] = carS;
                    envelopeStatesC[i] = 2;
                }
            }

            if(envelopeStatesM[i] == 3){
                envelopeAmpsM[i] += modD;
                if(envelopeAmpsM[i] <= modS){
                    envelopeAmpsM[i] = modS;
                    envelopeStatesM[i] = 2;
                }
            }
        }else{
            if(envelopeStatesC[i] > 1)
                envelopeStatesC[i] = 1;
            if(envelopeStatesM[i] > 1)
                envelopeStatesM[i] = 1;
                
            if(envelopeStatesC[i] == 1){
                if(envelopeAmpsC[i] <= 0){
                    envelopeStatesC[i] = 0;
                    envelopeAmpsC[i] = 0;
                }else{
                    envelopeAmpsC[i] -= carR;
                }
            }
            if(envelopeStatesM[i] == 1){
                if(envelopeAmpsM[i] <= 0){
                    envelopeStatesM[i] = 0;
                    envelopeAmpsM[i] = 0;
                }else{
                    envelopeAmpsM[i] -= modR;
                }
            }            
        }
        
        if(envelopeAmpsC[i] > 0){
            modulatorPhases[i] += (Fmult * carrierIncrements[i]) >> 16;
            modAmpI = fastSin((((modulatorPhases[i] * envelopeAmpsM[i]) >> 16)
                * modVol) >> 16);
            carrierPhases[i] += ((carrierIncrements[i] + modAmpI) * fixed2pi) >> 16;
            carAmps += (fastSin(carrierPhases[i]) * envelopeAmpsC[i]) >> 16;
        }
    }
    outMono.write_u16(((carAmps / numKeys) * Volume) >> 16);
}


int main() {
}