OSCtoCV_LFO.cpp

00001 /*
00002  OSCtoCV_Sequencer.cpp 
00003 */
00004 
00005 #include <math.h>
00006 #include <limits.h>
00007 
00008 #include "OSCtoCV_LFO.h"
00009 #include "OSCtoCV_Random.h"
00010 #include "OSCtoCV.h"
00011 
00012 #define M_PI 3.1415926535897932384626433832795
00013 
00014 //-------------------------------------------------------------
00015 // update LFO
00016 
00017 float UpdateLFO(float freq)
00018 {
00019     static float pos;
00020     
00021     pos += 0.000015259 * freq;
00022 
00023     if (pos > 1.0f)
00024     {
00025         pos = 0;
00026     }
00027     
00028     return pos;
00029 }
00030 
00031 //-------------------------------------------------------------
00032 // triangle wave calc
00033 
00034 float TriWave(float pos)
00035 {
00036     return 1.0f - fabs(pos - 0.5f) * 2.0f;
00037 }
00038 
00039 //-------------------------------------------------------------
00040 // saw(ramp) wave calc
00041 
00042 float SawWave(float pos)
00043 {
00044     return 1.0f - pos;
00045 }
00046 
00047 //-------------------------------------------------------------
00048 // square wave calc
00049 
00050 float SqrWave(float pos)
00051 {
00052     return pos < 0.8f ? 1.0f : 0.0f;
00053 }
00054 
00055 //-------------------------------------------------------------
00056 // sine wave calc
00057 
00058 float SinWave(float pos)
00059 {   
00060     return (sin(pos*2 * M_PI) + 1.0f) * 0.5f;
00061 }
00062 
00063 //-------------------------------------------------------------
00064 // exponential wave calc
00065 
00066 float ExpWave(float pos)
00067 {
00068     return powf((1.0f - fabs(pos - 0.5f) * 2.0f), 2.0);
00069 }
00070 
00071 //-------------------------------------------------------------
00072 // exp wave calc
00073 
00074 float LogWave(float pos)
00075 {
00076     return powf((1.0f - fabs(pos - 0.5f) * 2.0f), 0.5);
00077 }
00078 
00079 //-------------------------------------------------------------
00080 // synthesis wave calc sin
00081 
00082 float SynthWave1(float pos)
00083 {
00084     return (SinWave(pos) + SinWave(3 * pos) - SinWave(2 * pos)) * 0.5;
00085 }
00086 
00087 //-------------------------------------------------------------
00088 // synthesis wave calc sin
00089 
00090 float SynthWave2(float pos)
00091 {
00092     return (SinWave(pos) + SinWave(1 / 3 * pos) - SinWave(2 * pos)) * 0.3;
00093 }
00094 
00095 //-------------------------------------------------------------
00096 // invert float value
00097 
00098 float Invert(float x)
00099 {   
00100     return SCALING_N - x;
00101 }
00102 
00103 //-------------------------------------------------------------
00104 // LFO cv generator
00105 
00106 void SteppedLFO(uint8_t channelOffset, bool quantizeOff)
00107 {
00108     static uint8_t ch = channelOffset;
00109     static uint8_t mcount;
00110     int waveform;
00111     static int _waveform = -1;
00112     static int steps;
00113     uint8_t qmode;
00114     static float lfocv[8], glidecv[8];
00115     unsigned int cv;
00116     static float qcv;
00117     float freq;
00118     static int jitter, jitterCount;
00119 
00120     // select waveform ArdSW1(gArdSW[0])
00121     waveform = CheckSubMode1();
00122     
00123     if (_waveform != waveform) // update LCD
00124     {
00125         switch (waveform)
00126         {
00127             case TRIANGLE_WAVE:
00128 
00129                 UpdateSubModeLCD("Tri:Wave");
00130                 break;
00131 
00132             case SAW_WAVE:
00133 
00134                 UpdateSubModeLCD("Saw:Wave");
00135                 break;
00136                 
00137             case SQUARE_WAVE:
00138 
00139                 UpdateSubModeLCD("Sqr:Wave");
00140                 break;
00141 
00142             case SINE_WAVE:
00143 
00144                 UpdateSubModeLCD("Sin:Wave");
00145                 break;
00146 
00147             case EXP_WAVE:
00148 
00149                 UpdateSubModeLCD("Exp:Wave");
00150                 break;
00151 
00152             case LOG_WAVE:
00153 
00154                 UpdateSubModeLCD("Log:Wave");
00155                 break;
00156 
00157             case SYNTH_WAVE:
00158             
00159                 UpdateSubModeLCD("Syn:Wave");
00160                 break;
00161                 
00162             case NOISE:
00163         
00164                 UpdateSubModeLCD("XorNoise");
00165                 break;
00166 
00167             default:
00168                 break;
00169         }
00170         
00171         _waveform = waveform;
00172     }
00173     
00174     // frequency control ArdPot1(gArdPot[0])
00175     freq = gArdPot[0] * 0.10f + 0.001f;
00176 
00177     switch (waveform)
00178     {
00179         case TRIANGLE_WAVE:
00180 
00181             lfocv[channelOffset] = TriWave(UpdateLFO(freq)) * SCALING_N;
00182             break;
00183 
00184         case SAW_WAVE:
00185 
00186             lfocv[channelOffset] = SawWave(UpdateLFO(freq)) * SCALING_N;
00187             break;
00188 
00189         case SQUARE_WAVE:
00190 
00191             lfocv[channelOffset] = SqrWave(UpdateLFO(freq)) * SCALING_N;
00192             break;
00193 
00194         case SINE_WAVE:
00195 
00196             lfocv[channelOffset] = SinWave(UpdateLFO(freq)) * SCALING_N;
00197             break;
00198 
00199         case EXP_WAVE:
00200 
00201             lfocv[channelOffset] = ExpWave(UpdateLFO(freq)) * SCALING_N;
00202             break;
00203 
00204         case LOG_WAVE:
00205 
00206             lfocv[channelOffset] = LogWave(UpdateLFO(freq)) * SCALING_N;
00207             break;
00208 
00209         case SYNTH_WAVE:
00210 
00211             lfocv[channelOffset] = SynthWave1(UpdateLFO(freq)) * SCALING_N;
00212             break;
00213             
00214         case NOISE:
00215 
00216             lfocv[channelOffset] = fmodf(Xorshift_32(), SCALING_N);
00217             break;
00218 
00219         default:
00220             break;
00221     }
00222 
00223     //lfocv[i + 4] = Invert(lfocv[i]); // ch4 ~ ch8 invert waveform
00224     
00225     if (quantizeOff) // quantize Off
00226     {
00227         qmode = Lin;
00228     
00229     } else {
00230         
00231         qmode = CheckQuantizeMode();
00232     }
00233     
00234     switch (qmode) 
00235     {
00236         case Lin:
00237         
00238             if (gArdPot[1] > 10) 
00239             {
00240                 steps = (unsigned int)gArdPot[1] * 0.1; // check LFO Steps(Quantize Resolustion)ArdPot2gArdPot[1]
00241                 
00242                 lfocv[channelOffset] = quantizedMap[(unsigned int)(MapFloat(lfocv[channelOffset], 0, SCALING_N, 0, steps)) * (1024 / steps)];
00243             }
00244             
00245             glidecv[channelOffset] = glidecv[channelOffset] * gGlide + lfocv[channelOffset] * (1.0f - gGlide);
00246             break;
00247 
00248         case Chr:
00249 
00250             qcv = calibMap1[(unsigned int)MapFloat(lfocv[channelOffset], 0, SCALING_N, 0, (QUAN_RES1 - 1))];
00251 
00252             glidecv[channelOffset] = glidecv[channelOffset] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
00253 
00254             break;
00255 
00256         case Maj:
00257 
00258             qcv = calibMap2[(unsigned int)MapFloat(lfocv[channelOffset], 0, SCALING_N, 0, (QUAN_RES2 - 1))];
00259 
00260             glidecv[channelOffset] = glidecv[channelOffset] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
00261 
00262             break;
00263 
00264         case M7:
00265 
00266             qcv = calibMap3[(unsigned int)MapFloat(lfocv[channelOffset], 0, SCALING_N, 0, (QUAN_RES3 - 1))];
00267 
00268             glidecv[channelOffset] = glidecv[channelOffset] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
00269 
00270             break;
00271 
00272         case Min7:
00273 
00274             qcv = calibMap4[(unsigned int)MapFloat(lfocv[channelOffset], 0, SCALING_N, 0, (QUAN_RES4 - 1))];
00275 
00276             glidecv[channelOffset] = glidecv[channelOffset] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
00277 
00278             break;
00279 
00280         case Dor:
00281 
00282             qcv = calibMap5[(unsigned int)MapFloat(lfocv[channelOffset], 0, SCALING_N, 0, (QUAN_RES5 - 1))];
00283 
00284             glidecv[channelOffset] = glidecv[channelOffset] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
00285 
00286             break;
00287 
00288         case Min:
00289 
00290             qcv = calibMap6[(unsigned int)MapFloat(lfocv[channelOffset], 0, SCALING_N, 0, (QUAN_RES6 - 1))];
00291 
00292             glidecv[channelOffset] = glidecv[channelOffset] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
00293 
00294             break;
00295 
00296         case S5th:
00297 
00298             qcv = calibMap7[(unsigned int)MapFloat(lfocv[channelOffset], 0, SCALING_N, 0, (QUAN_RES7 - 1))];
00299 
00300             glidecv[channelOffset] = glidecv[channelOffset] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
00301 
00302             break;
00303 
00304         case Wht:
00305 
00306             qcv = calibMap8[(unsigned int)MapFloat(lfocv[channelOffset], 0, SCALING_N, 0, (QUAN_RES8 - 1))];
00307 
00308             glidecv[channelOffset] = glidecv[channelOffset] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
00309 
00310             break;
00311     }     
00312 
00313     if (!gCtrlSW[4]) 
00314     { 
00315         jitter = 0;
00316     
00317     } else if (gCtrlSW[4] && jitterCount % 64 == 0) { // ASR Analog Mode
00318         
00319         jitter = ANALOG_JITTER; 
00320     }
00321     
00322     cv = (unsigned int)(glidecv[channelOffset] + jitter);
00323 
00324     UpdateCV(WRITE_UPDATE_N, ch, &cv);
00325     
00326     if (mcount == 0x1F) 
00327     {
00328         UpdateCVMeter(ch, &cv);
00329     }
00330 
00331     ++ch;
00332     
00333     if (ch == 8)
00334     {
00335         ch = channelOffset - 1; //output channelOffset ~ ch8
00336         
00337         ++mcount;
00338         mcount &= 0x3F;
00339     }
00340     
00341     ++jitterCount;
00342     jitterCount &= 0x1FF;
00343 
00344 }
00345