OSC-CV Converter

Dependencies:   Bonjour OSCReceiver TextLCD mbed mbed-rpc BurstSPI DebouncedInterrupt FastIO MIDI OSC OSCtoCV ClockControl

OSC to CV Converter

http://gtbts.tumblr.com/post/125663817741/osc-to-cv-converter-ver2-mbed-osctocv

/media/uploads/casiotone401/tumblr_nsg7y4pkfg1qlle9fo1_540.png

Files at this revision

API Documentation at this revision

Comitter:
casiotone401
Date:
Sun Mar 09 04:52:52 2014 +0000
Parent:
12:33c8f06c2e03
Child:
14:977f3c5a4b4e
Commit message:
minor update

Changed in this revision

example.h Show annotated file Show diff for this revision Revisions of this file
main.cpp Show annotated file Show diff for this revision Revisions of this file
mbed-rpc.lib Show annotated file Show diff for this revision Revisions of this file
mbed.bld Show annotated file Show diff for this revision Revisions of this file
--- a/example.h	Sun Apr 14 00:54:10 2013 +0000
+++ b/example.h	Sun Mar 09 04:52:52 2014 +0000
@@ -35,54 +35,39 @@
 //-------------------------------------------------------------
 // Define
 
-#define MODE_Calb           0        // Calibration (for VCO Tuning)
-#define MODE_LIN            1        // Linear LinearCV
-#define MODE_QChr           2        // Chromatic   Quantize Mode
-#define MODE_QMaj           3        // Major
-#define MODE_QDor           4        // Dorian
-#define MODE_Q5th           5        // 5th
-#define MODE_QWht           6        // Wholetone
-#define MODE_SEQ            7        // Sequencer & Shift Register
-#define MODE_SHIF           8        // Mode Shift
-
-#define MODE_NUM            9        // Modes
+#define MODE_LIN            0       // Linear       ~LinearCV Mode
+#define MODE_QChr           1       // Chromatic    ~Quantize Mode 
+#define MODE_QMaj           2       // Major
+#define MODE_QDor           3       // Dorian
+#define MODE_Q5th           4       // 5th
+#define MODE_QWht           5       // Wholetone
+#define MODE_Calb           6       // Calibration
 
-#define Lin                 0        // Linear LinearCV
-#define Chr                 1        // Chromatic
-#define Maj                 2        // Major
-#define M7                  3        // Major7
-#define Min7                4        // Minor7
-#define Dor                 5        // Dorian
-#define Min                 6        // Minor
-#define S5th                7        // 5th
-#define Wht                 8        // Wholetone
+#define QUAN_RES1           116     // Quantize voltage Steps
+#define QUAN_RES2           69
+#define QUAN_RES3           68  
+#define QUAN_RES4           17
+#define QUAN_RES5           58
 
-#define QUAN_RES1           115      // Quantize voltage Steps
-#define QUAN_RES2           67
-#define QUAN_RES3           39
-#define QUAN_RES4           48
-#define QUAN_RES5           67
-#define QUAN_RES6           67  
-#define QUAN_RES7           17
-#define QUAN_RES8           57
+#define MODE_NUM            7        // Modes
 
-#define SPI_RATE            48000000 // 40Mbps SPI Clock
+#define SPI_RATE            40000000 // 40Mbps SPI Clock
 #define SCALING_N           38400.0
 #define INPUT_PORT          12345    // Input Port Number
 
 #define POLLING_INTERVAL    20       // Polling Interval (us)
 
 //-------------------------------------------------------------
-// DAC8568 Control Bits (See datasheet)
+// DAC8568 Control Bits
 
 #define WRITE               0x00
 #define UPDATE              0x01
-#define WRITE_UPDATE_ALL    0x02     // LDAC Write to Selected Update All
-#define WRITE_UPDATE_N      0x03     // LDAC Write to Selected Update Respective
+#define WRITE_UPDATE_ALL    0x02       // LDAC Write to Selected Update All
+#define WRITE_UPDATE_N      0x03       // LDAC Write to Selected Update Respective
 #define POWER               0x04
-#define CLR                 0x05     // Clear Code Register
+#define CLR                 0x05       // Clear Code Register
 #define WRITE_LDAC_REG      0x06
-#define RESET               0x07     // Software Reset DAC8568
+#define RESET               0x07       // Software Reset DAC8568
 #define SETUP_INTERNAL_REF  0x08
 
 //------------------------------------------------------------- 
@@ -90,53 +75,18 @@
 #define _DISABLE            0
 #define _ENABLE             1
 
-#define GATE1               0
-#define GATE2               1
-#define GATE3               2
-#define GATE4               3
-#define GATEALL             4
-
-//------------------------------------------------------------- 
-// Beats (Note values)
-
-#define N1ST                1   // whole
-#define N2ND                2   // harf
-#define N4TH                4   // quarter
-#define N8TH                8
-#define N16TH               16
-#define N32TH               32
-#define N64TH               64
-#define NDOT2               3   // dotted
-#define NDOT4               7
-#define NDOT8               9
-#define NDOT16              11
-#define NDOT32              13
-#define TRIP2               15  // triplets
-#define TRIP4               17
-#define TRIP8               19
-#define TRIP16              21
-#define TRIP32              23
-#define NRESET              0   // Gate Reset
-
 //-------------------------------------------------------------
 // Functions
 
 inline void NetPoll(void);
 void InitOSCCV(void);
-inline void Seq(void);
 inline void UpdateCV(int, int, const unsigned int*);
-inline int UpdateTrigger(volatile bool);
-inline int UpdateGate(int, int, int, int, bool);
-inline void SetCV(void);
-inline void SetSCV(void);
-inline void ShiftCV(int);
-inline void SeqCV(int);
-void CheckModeSW(void);
-inline void CVMeter(int, const unsigned int*);
-void LCD();
+void SetCV(void);
+void CheckSW(void);
+void CVMeter(int, const unsigned int*);
 void WriteCustomChar(unsigned char, unsigned char*);
 int  SetupEthNetIf(void);
-inline void onUDPSocketEvent(UDPSocketEvent);
+void onUDPSocketEvent(UDPSocketEvent);
 
 //-------------------------------------------------------------
 // Silentway Calibration Data Mapping
@@ -144,164 +94,117 @@
 
 //  Chromatic Scale
 const float calibMap1[QUAN_RES1] = {
-0.00559238,   0.01324014,   0.02088790,   0.02853566,   0.03618342, 
-0.04383118,   0.05147894,   0.05912671,   0.06677447,   0.07442223, 
-0.08206999,   0.08971775,   0.09736551,   0.10501327,   0.11266103, 
-0.12030879,   0.12775089,   0.13486665,   0.14198242,   0.14909819, 
-0.15621395,   0.16332972,   0.17044549,   0.17756125,   0.18467702, 
-0.19179279,   0.19890857,   0.20602433,   0.21314010,   0.22025587, 
-0.22737163,   0.23448740,   0.24160317,   0.24871893,   0.25587305, 
-0.26303557,   0.27019811,   0.27736065,   0.28452319,   0.29168573, 
-0.29884824,   0.30601078,   0.31317332,   0.32033587,   0.32749838, 
-0.33466092,   0.34182346,   0.34898600,   0.35614854,   0.36331105, 
-0.37047359,   0.37764084,   0.38481620,   0.39199156,   0.39916691, 
-0.40634227,   0.41351759,   0.42069295,   0.42786831,   0.43504366, 
-0.44221902,   0.44939438,   0.45656973,   0.46374506,   0.47092041, 
-0.47809577,   0.48527113,   0.49244648,   0.49962184,   0.50685716, 
-0.51409578,   0.52133441,   0.52857304,   0.53581166,   0.54305035, 
-0.55028898,   0.55752760,   0.56476623,   0.57200485,   0.57924354, 
-0.58648217,   0.59372079,   0.60095942,   0.60819805,   0.61543667, 
-0.62267536,   0.62996829,   0.63728690,   0.64460552,   0.65192413, 
-0.65924275,   0.66656137,   0.67387998,   0.68119860,   0.68851727, 
-0.69583589,   0.70315450,   0.71047312,   0.71779174,   0.72511035, 
-0.73242897,   0.73974758,   0.74706620,   0.75810421,   0.77163076, 
-0.78515732,   0.79868382,   0.81221038,   0.82573694,   0.83926344, 
-0.85279000,   0.86631656,   0.88188213,   0.90110368,   0.92032516
+0.00663080,   0.01433030,   0.02202980,   0.02972930,   0.03742880,
+0.04512830,   0.05282781,   0.06052731,   0.06822681,   0.07592630,
+0.08362581,   0.09132531,   0.09902481,   0.10672431,   0.11442380,
+0.12212331,   0.12951356,   0.13671936,   0.14392516,   0.15113096,
+0.15833676,   0.16554256,   0.17274836,   0.17995416,   0.18715996,
+0.19436575,   0.20157155,   0.20877735,   0.21598317,   0.22318897,
+0.23039477,   0.23760056,   0.24480636,   0.25202271,   0.25926629,
+0.26650983,   0.27375340,   0.28099698,   0.28824055,   0.29548413,
+0.30272770,   0.30997124,   0.31721482,   0.32445839,   0.33170196,
+0.33894554,   0.34618911,   0.35343266,   0.36067623,   0.36791980,
+0.37516347,   0.38241133,   0.38965923,   0.39690709,   0.40415496,
+0.41140282,   0.41865072,   0.42589858,   0.43314645,   0.44039431,
+0.44764221,   0.45489007,   0.46213794,   0.46938580,   0.47663370,
+0.48388156,   0.49112943,   0.49837729,   0.50566339,   0.51296055,
+0.52025765,   0.52755481,   0.53485191,   0.54214907,   0.54944617,
+0.55674326,   0.56404042,   0.57133752,   0.57863468,   0.58593178,
+0.59322894,   0.60052603,   0.60782319,   0.61512029,   0.62241745,
+0.62976688,   0.63714498,   0.64452308,   0.65190119,   0.65927929,
+0.66665739,   0.67403549,   0.68141359,   0.68879169,   0.69616979,
+0.70354789,   0.71092600,   0.71830410,   0.72568226,   0.73306036,
+0.74043846,   0.74781656,   0.75820577,   0.76986063,   0.78151548,
+0.79317033,   0.80482519,   0.81648004,   0.82813489,   0.83978975,
+0.85144460,   0.86309946,   0.87475431,   0.90686423,   0.93941462,
+0.97196496
 };
 
 //  Major Scale
 const float calibMap2[QUAN_RES2] = {
-0.01324014,   0.02853566,   0.03618342,   0.05147894,   0.06677447,
-0.08206999,   0.08971775,   0.10501327,   0.12030879,   0.12775089,
-0.14198242,   0.15621395,   0.17044549,   0.17756125,   0.19179279,
-0.20602433,   0.21314010,   0.22737163,   0.24160317,   0.25587305,
-0.26303557,   0.27736065,   0.29168573,   0.29884824,   0.31317332,
-0.32749838,   0.34182346,   0.34898600,   0.36331105,   0.37764084,
-0.38481620,   0.39916691,   0.41351759,   0.42786831,   0.43504366,
-0.44939438,   0.46374506,   0.47092041,   0.48527113,   0.49962184,
-0.51409578,   0.52133441,   0.53581166,   0.55028898,   0.55752760,
-0.57200485,   0.58648217,   0.60095942,   0.60819805,   0.62267536,
-0.63728690,   0.64460552,   0.65924275,   0.67387998,   0.68851727,
-0.69583589,   0.71047312,   0.72511035,   0.73242897,   0.74706620,
-0.77163076,   0.79868382,   0.81221038,   0.83926344,   0.86631656,
-0.88188213,   0.92032516
-};
-
-//  M7(9)
-const float calibMap3[QUAN_RES3] = {
-0.02853566,   0.05147894,   0.08206999,   0.08971775,   0.12030879,
-0.14198242,   0.17044549,   0.17756125,   0.20602433,   0.22737163,
-0.25587305,   0.26303557,   0.29168573,   0.31317332,   0.34182346,
-0.34898600,   0.37764084,   0.39916691,   0.42786831,   0.43504366,
-0.44939438,   0.46374506,   0.48527113,   0.51409578,   0.52133441,
-0.55028898,   0.57200485,   0.60095942,   0.60819805,   0.62267536,
-0.63728690,   0.65924275,   0.68851727,   0.69583589,   0.72511035,
-0.74706620,   0.79868382,   0.86631656,   0.92032516
-};
-
-//  m7(9)
-const float calibMap4[QUAN_RES4] = {
-0.01324014,   0.02088790,   0.03618342,   0.05147894,   0.07442223,
-0.08971775,   0.11266103,   0.14198242,   0.16332972,   0.17756125,
-0.19890857,   0.22737163,   0.24160317,   0.24871893,   0.26303557,
-0.29168573,   0.31317332,   0.33466092,   0.34898600,   0.36331105,
-0.37047359,   0.38481620,   0.39916691,   0.41351759,   0.42069295,
-0.43504366,   0.45656973,   0.48527113,   0.50685716,   0.52133441,
-0.53581166,   0.55752760,   0.57200485,   0.59372079,   0.62267536,
-0.62996829,   0.64460552,   0.65924275,   0.68119860,   0.69583589,
-0.71779174,   0.74706620,   0.77163076,   0.78515732,   0.81221038,
-0.83926344,   0.85279000,   0.92032516
+0.00663080,   0.01433030,   0.02972930,   0.04512830,   0.05282781,
+0.06822681,   0.08362581,   0.09902481,   0.10672431,   0.12212331,
+0.13671936,   0.14392516,   0.15833676,   0.17274836,   0.18715996,
+0.19436575,   0.20877735,   0.22318897,   0.23039477,   0.24480636,
+0.25926629,   0.27375340,   0.28099698,   0.29548413,   0.30997124,
+0.31721482,   0.33170196,   0.34618911,   0.36067623,   0.36791980,
+0.38241133,   0.39690709,   0.40415496,   0.41865072,   0.43314645,
+0.44764221,   0.45489007,   0.46938580,   0.48388156,   0.49112943,
+0.50566339,   0.52025765,   0.53485191,   0.54214907,   0.55674326,
+0.57133752,   0.57863468,   0.59322894,   0.60782319,   0.62241745,
+0.62976688,   0.64452308,   0.65927929,   0.66665739,   0.68141359,
+0.69616979,   0.71092600,   0.71830410,   0.73306036,   0.74781656,
+0.75820577,   0.78151548,   0.80482519,   0.82813489,   0.83978975,
+0.86309946,   0.90686423,   0.93941462
 };
 
 //  Dorian Scale
-const float calibMap5[QUAN_RES5] = {
-0.01324014,   0.02853566,   0.04383118,    0.05147894,   0.06677447,
-0.08206999,   0.08971775,   0.10501327,    0.12030879,   0.13486665,
-0.14198242,   0.15621395,   0.17044549,    0.17756125,   0.19179279,
-0.20602433,   0.22025587,   0.22737163,    0.24160317,   0.25587305,
-0.26303557,   0.27736065,   0.29168573,    0.30601078,   0.31317332,
-0.32749838,   0.34182346,   0.34898600,    0.36331105,   0.37764084,
-0.39199156,   0.39916691,   0.41351759,    0.42786831,   0.43504366,
-0.44939438,   0.46374506,   0.47809577,    0.48527113,   0.49962184,
-0.51409578,   0.52133441,   0.53581166,    0.55028898,   0.56476623,
-0.57200485,   0.58648217,   0.60095942,    0.60819805,   0.62267536,
-0.63728690,   0.65192413,   0.65924275,    0.67387998,   0.68851727,
-0.69583589,   0.71047312,   0.72511035,    0.73974758,   0.74706620,
-0.77163076,   0.79868382,   0.81221038,    0.83926344,   0.86631656,
-0.90110368,   0.92032516
-};
-
-//  Minor Scale
-const float calibMap6[QUAN_RES6] = {
-0.01324014,   0.02088790,   0.03618342,   0.05147894,   0.05912671,
-0.07442223,   0.08971775,   0.10501327,   0.11266103,   0.12775089,
-0.14198242,   0.14909819,   0.16332972,   0.17756125,   0.19179279,
-0.19890857,   0.21314010,   0.22737163,   0.23448740,   0.24871893,
-0.26303557,   0.27736065,   0.28452319,   0.29884824,   0.31317332,
-0.32033587,   0.33466092,   0.34898600,   0.36331105,   0.37047359,
-0.38481620,   0.39916691,   0.40634227,   0.42069295,   0.43504366,
-0.44939438,   0.45656973,   0.47092041,   0.48527113,   0.49244648,
-0.50685716,   0.52133441,   0.53581166,   0.54305035,   0.55752760,
-0.57200485,   0.57924354,   0.59372079,   0.60819805,   0.62267536,
-0.62996829,   0.64460552,   0.65924275,   0.66656137,   0.68119860,
-0.69583589,   0.71047312,   0.71779174,   0.73242897,   0.74706620,
-0.75810421,   0.78515732,   0.81221038,   0.83926344,   0.85279000,
-0.88188213,   0.92032516
+const float calibMap3[QUAN_RES3] = {
+0.00663080,   0.01433030,   0.02972930,   0.04512830,   0.06052731,
+0.06822681,   0.08362581,   0.09902481,   0.10672431,   0.12212331,
+0.13671936,   0.15113096,   0.15833676,   0.17274836,   0.18715996,
+0.19436575,   0.20877735,   0.22318897,   0.23760056,   0.24480636,
+0.25926629,   0.27375340,   0.28099698,   0.29548413,   0.30997124,
+0.32445839,   0.33170196,   0.34618911,   0.36067623,   0.36791980,
+0.38241133,   0.39690709,   0.41140282,   0.41865072,   0.43314645,
+0.44764221,   0.45489007,   0.46938580,   0.48388156,   0.49837729,
+0.50566339,   0.52025765,   0.53485191,   0.54214907,   0.55674326,
+0.57133752,   0.58593178,   0.59322894,   0.60782319,   0.62241745,
+0.62976688,   0.64452308,   0.65927929,   0.67403549,   0.68141359,
+0.69616979,   0.71092600,   0.71830410,   0.73306036,   0.74781656,
+0.76986063,   0.78151548,   0.80482519,   0.82813489,   0.83978975,
+0.86309946,   0.90686423,   0.97196496
 };
 
 //  5th
-const float calibMap7[QUAN_RES7] = {
-0.01324014,  0.06677447,   0.12030879,    0.17044549,    0.22025587,
-0.27019811,  0.32033587,   0.37047359,    0.42069295,    0.47092041,
-0.52133441,  0.57200485,   0.62267536,    0.67387998,    0.72511035,
-0.79868382,  0.90110368
+const float calibMap4[QUAN_RES4] = {
+0.00663080,   0.06052731,    0.11442380,   0.16554256,   0.21598317,
+0.26650983,   0.31721482,    0.36791980,   0.41865072,   0.46938580,
+0.52025765,   0.57133752,    0.62241745,   0.67403549,   0.72568226,
+0.79317033,   0.87475431
+
 };
 
 //  Whole tone
-const float calibMap8[QUAN_RES8] = {
-0.01324014,   0.02853566,   0.04383118,   0.05912671,    0.07442223,
-0.08971775,   0.10501327,   0.12030879,   0.13486665,    0.14909819,
-0.16332972,   0.17756125,   0.19179279,   0.20602433,    0.22025587,
-0.23448740,   0.24871893,   0.26303557,   0.27736065,    0.29168573,
-0.30601078,   0.32033587,   0.33466092,   0.34898600,    0.36331105,
-0.37764084,   0.39199156,   0.40634227,   0.42069295,    0.43504366,
-0.44939438,   0.46374506,   0.47809577,   0.49244648,    0.50685716,
-0.52133441,   0.53581166,   0.55028898,   0.56476623,    0.57924354,
-0.59372079,   0.60819805,   0.62267536,   0.63728690,    0.65192413,
-0.66656137,   0.68119860,   0.69583589,   0.71047312,    0.72511035,
-0.73974758,   0.75810421,   0.78515732,   0.81221038,    0.83926344,
-0.86631656,   0.90110368
+const float calibMap5[QUAN_RES5] = {
+0.00663080,    0.02202980,    0.03742880,    0.05282781,    0.06822681,
+0.08362581,    0.09902481,    0.11442380,    0.12951356,    0.14392516,
+0.15833676,    0.17274836,    0.18715996,    0.20157155,    0.21598317,
+0.23039477,    0.24480636,    0.25926629,    0.27375340,    0.28824055,
+0.30272770,    0.31721482,    0.33170196,    0.34618911,    0.36067623,
+0.37516347,    0.38965923,    0.40415496,    0.41865072,    0.43314645,
+0.44764221,    0.46213794,    0.47663370,    0.49112943,    0.50566339,
+0.52025765,    0.53485191,    0.54944617,    0.56404042,    0.57863468,
+0.59322894,    0.60782319,    0.62241745,    0.63714498,    0.65190119,
+0.66665739,    0.68141359,    0.69616979,    0.71092600,    0.72568226,
+0.74043846,    0.75820577,    0.78151548,    0.80482519,    0.82813489,
+0.85144460,    0.87475431,    0.93941462
+    
 };
 
 //-------------------------------------------------------------
 // CV Meter Custom Character
 
-unsigned char str1[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1F};
-unsigned char str2[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0x1F};
-unsigned char str3[8] = {0x00,0x00,0x00,0x00,0x00,0x1F,0x1F,0x1F};
-unsigned char str4[8] = {0x00,0x00,0x00,0x00,0x1F,0x1F,0x1F,0x1F};
-unsigned char str5[8] = {0x00,0x00,0x00,0x1F,0x1F,0x1F,0x1F,0x1F};
-unsigned char str6[8] = {0x00,0x00,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F};
-unsigned char str7[8] = {0x00,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F};
-unsigned char str8[8] = {0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F};
+const unsigned char str1[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1F};
+const unsigned char str2[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0x1F};
+const unsigned char str3[8] = {0x00,0x00,0x00,0x00,0x00,0x1F,0x1F,0x1F};
+const unsigned char str4[8] = {0x00,0x00,0x00,0x00,0x1F,0x1F,0x1F,0x1F};
+const unsigned char str5[8] = {0x00,0x00,0x00,0x1F,0x1F,0x1F,0x1F,0x1F};
+const unsigned char str6[8] = {0x00,0x00,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F};
+const unsigned char str7[8] = {0x00,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F};
+const unsigned char str8[8] = {0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F};
 
 //-------------------------------------------------------------
 // Global Variables
 
-float   gOSC_cv[8];
-float   gSeq_cv1[8], gSeq_cv2[8];
-float   gGlide;
-volatile int gMode;
-
-// Variables for Control
-
-float         gCtrl[3];
-volatile bool gCtrlSW[4] = {false};
+static float    gOSC_cv[8];
+static float    gGlide;
+unsigned int    gMode;
 
 //-------------------------------------------------------------
 // mbed Functions
 
-TextLCD     gLCD(p9, p10, p11, p12, p13, p14); // rs, e, d4-d7
+TextLCD gLCD(p9, p10, p11, p12, p13, p14); // rs, e, d4-d7
 
 SPI         gSPI(p5,p6,p7);     // SPI (p6 unconnected)
 DigitalOut  gSYNCMODE(p15);     // SYNC DAC8568
@@ -309,12 +212,12 @@
 
 DigitalOut  gGATES[4] = {p21, p22, p23, p24};   // GateOut
 DigitalOut  gLEDS[4] = {p18, p19, p20, p28};    // LED
-DigitalOut  gCLOCKOUT(p25);                     // ClockOut
+DigitalOut  gCLOCKOUT(p25);             // ClockOut
 
 AnalogIn    gAIN(p17);  // Glide Potentiometer
 InterruptIn gSW(p30);   // Mode SW
 
-Timer       gTimer;     // Timer
+Ticker      gSetter;    // Ticker SetCV
 Ticker      gPoller;    // Ticker Polling
 
 // Ethernet
@@ -326,44 +229,20 @@
  
 int main() 
 { 
+    int i;
     float pot, _pot;
     
-//http://mbed.org/forum/mbed/topic/229/?page=2#comment-13047    
-//Clock Up 100Mhz -------------------------------------------------------------
-    LPC_SC->PLL0CON   = 0x00;             /* PLL0 Disable                    */
-    LPC_SC->PLL0FEED  = 0xAA;
-    LPC_SC->PLL0FEED  = 0x55;
- 
-    LPC_SC->CCLKCFG   = 0x00000003;       /* Select Clock Divisor = 4        */
-    LPC_SC->PLL0CFG   = 0x00020031;       /* configure PLL0                  */
-    LPC_SC->PLL0FEED  = 0xAA;             /* divide by 3 then multiply by 50 */
-    LPC_SC->PLL0FEED  = 0x55;             /* PLL0 frequency = 400,000,000    */
- 
-    LPC_SC->PLL0CON   = 0x01;             /* PLL0 Enable                     */
-    LPC_SC->PLL0FEED  = 0xAA;
-    LPC_SC->PLL0FEED  = 0x55;
-    while (!(LPC_SC->PLL0STAT & (1<<26)));/* Wait for PLOCK0                 */
- 
-    LPC_SC->PLL0CON   = 0x03;             /* PLL0 Enable & Connect           */
-    LPC_SC->PLL0FEED  = 0xAA;
-    LPC_SC->PLL0FEED  = 0x55;
-    while (!(LPC_SC->PLL0STAT & ((1<<25) | (1<<24))));/* Wait for PLLC0_STAT & PLLE0_STAT */
-    
-    SystemCoreClockUpdate();
-//-----------------------------------------------------------------------------
-    
     if(SetupEthNetIf() == -1)
     {
-        for(int i = 0; i < 4; i++) 
+        for(i = 0; i < 4; i++) 
         {
             gLEDS[i] = 1;
             wait(0.25);
         }
-        
         return -1;
     }
     
-// mdns (Bonjour)
+    // mdns (Bonjour)
     HTTPServer svr;
     mDNSResponder mdns;
     
@@ -377,14 +256,15 @@
     pot = _pot = 0;
     gGlide = gMode = 0;
         
-    LCD();
+    gLCD.locate( 9, 0 );
+    gLCD.printf("OSC-CV");
     gLCD.locate( 0, 1 );
     gLCD.printf("12345678 G>>%3.2f", gGlide);
     
-// loop
+    // loop
     while(1) 
     {
-        gGlide = pot = gAIN.read();  // Glide Value
+        gGlide = pot = gAIN.read();
         
         if(abs(pot - _pot) > 0.01f) 
         {
@@ -394,63 +274,11 @@
             _pot = gAIN.read();
         }
         
-        switch(gMode)
-        {               
-            case MODE_SEQ:
-                
-                Seq();
-                break;
-                                
-            case MODE_SHIF:
-            
-                ShiftCV((UpdateTrigger(gGATES[0])));
-                break;
-                    
-            case MODE_LIN:
-            
-                SetSCV();
-                break;
-            
-            default:
-            
-                SetCV();
-                break;
-        }
+        SetCV();
     }
 }
 
 //-------------------------------------------------------------
-// Initialize OSC-CV
-
-void InitOSCCV()
-{
-// write custom char LCD CGRAM
-    WriteCustomChar(0x00, str1);
-    WriteCustomChar(0x01, str2);
-    WriteCustomChar(0x02, str3);
-    WriteCustomChar(0x03, str4);
-    WriteCustomChar(0x04, str5);
-    WriteCustomChar(0x05, str6);
-    WriteCustomChar(0x06, str7);
-    WriteCustomChar(0x07, str8);
-    
-// Init. SPI
-    gLDAC = _ENABLE;
-    gSPI.format(8,1);           // Data word length 8bit, Mode=1
-    gSPI.frequency(SPI_RATE);
-    
-    UpdateCV(CLR, 0, 0);        // Ignore CLR Pin
-    
-    gSW.mode(PullUp);           // Use internal pullup for ModeSW
-    wait(.001);
-    
-    gSW.rise(&CheckModeSW);     // InterruptIn rising edge(ModeSW)
-    gPoller.attach_us(&NetPoll, POLLING_INTERVAL);  // Ticker Polling
-    
-    wait(0.2);
-}
-
-//-------------------------------------------------------------
 // Ethernet Polling
 
 inline void NetPoll()
@@ -459,44 +287,34 @@
 }
 
 //-------------------------------------------------------------
-// Sequencer Mode
-inline void Seq()
+// Initialize OSC-CV
+
+void InitOSCCV()
 {
-    static int bpm, _bpm;
+    // write custom char LCD CGRAM
+    WriteCustomChar(0x00, str1);
+    WriteCustomChar(0x01, str2);
+    WriteCustomChar(0x02, str3);
+    WriteCustomChar(0x03, str4);
+    WriteCustomChar(0x04, str5);
+    WriteCustomChar(0x05, str6);
+    WriteCustomChar(0x06, str7);
+    WriteCustomChar(0x07, str8);
     
-    bpm = (gCtrl[0] * 300 + 10);                    // Set BPM (gCtrl[0])
-            
-    if(abs(bpm - _bpm) > 1)
-    {
-        UpdateGate(bpm, NRESET, GATEALL, 3, false);         // Reset (if bpm change)
-        _bpm = bpm;
-                    
-    } else if (gCtrlSW[0]) {                        // Stop (gCtrlSW[0])
-                        
-        bpm = 0;
-    }
-            
-    if(!gCtrlSW[2] && !gCtrlSW[3])              // Sequencer Mode1
-    {
-        SeqCV((UpdateGate(bpm, N16TH, GATE1, 3, false)));   // Shift Timming 16th note
-        UpdateGate(bpm, N8TH, GATE2, 3, 0);
-        UpdateGate(bpm, NDOT8, GATE3, 3, 0);
-        UpdateGate(bpm, TRIP4, GATE4, 3, 0);
-                
-    } else if (gCtrlSW[2] && !gCtrlSW[3]) { // Sequencer Mode2 (if gCtrlSW[2] ON)
-                
-        SeqCV((UpdateGate(bpm, N16TH, GATE1, 3, false)));  // Do shift ch 1~5
-        SeqCV((UpdateGate(bpm, N4TH, GATE2, 3, false)));   // Do shift  ch 6
-        SeqCV((UpdateGate(bpm, NDOT4, GATE3, 3, false)));  // Do shift  ch 7
-        SeqCV((UpdateGate(bpm, TRIP8, GATE4, 3, false)));  // Do shift ch 8
-                
-    } else if (gCtrlSW[3]) {                        // Sequencer Mode3 (if gCtrlSW[3] ON)
-                                                        // (ch6,7,8, short loop)
-        SeqCV((UpdateGate(bpm, N16TH, GATE1, 3, false)));  // Do shift ch 1~5
-        SeqCV((UpdateGate(bpm, N8TH, GATE2, 3, false)));   // Do shift  ch 6
-        SeqCV((UpdateGate(bpm, NDOT8, GATE3, 3, false)));  // Do shift  ch 7
-        SeqCV((UpdateGate(bpm, TRIP4, GATE4, 3, false)));  // Do shift ch 8
-    }
+    // Init. SPI
+    gLDAC = _ENABLE;
+    gSPI.format(8,1);       // Data word length 8bit, Mode=1
+    gSPI.frequency(SPI_RATE);
+    
+    UpdateCV(CLR, 0, 0);    // Ignore CLR Pin
+    
+    gSW.mode(PullUp);       // Use internal pullup for ModeSW
+    wait(.001);
+    
+    gSW.rise(&CheckSW);     // InterruptIn rising edge(ModeSW)
+    gPoller.attach_us(&NetPoll, POLLING_INTERVAL);  // Ticker Polling
+    
+    wait(0.2);
 }
 
 //-------------------------------------------------------------
@@ -505,11 +323,12 @@
 
 inline void UpdateCV(int control, int address, const unsigned int *data)
 {
-
+    __disable_irq();
+    
     switch(control)
     {
         case WRITE_UPDATE_N:
-
+        {   
             gSYNCMODE = _DISABLE;
             gSPI.write(00000000|control);            // padding at beginning of byte and control bits
             gSPI.write(address << 4 | *data >> 12);  // address(ch) bits
@@ -519,9 +338,9 @@
             gLDAC = _DISABLE;
             gLDAC = _ENABLE;
             break;
-
+        }
         case RESET:
-
+        {   
             gSYNCMODE = _DISABLE;
             gSPI.write(00000111);   // Software RESET
             gSPI.write(00000000);
@@ -529,9 +348,9 @@
             gSPI.write(00000000);
             gSYNCMODE = _ENABLE;
             break;
-
+        }
         case CLR:
-        
+        {            
             gSYNCMODE = _DISABLE;
             gSPI.write(00000101);   // CLR Register
             gSPI.write(00000000);
@@ -539,188 +358,30 @@
             gSPI.write(00000011);   // Ignore CLR Pin
             gSYNCMODE = _ENABLE;
             break;
+        }
     }
-}
-
-//-------------------------------------------------------------
-// UpdateTrigger
-
-inline int UpdateTrigger(bool gate)
-{
-    static bool clkstate;
-    static int gatetime, oldgatetime;
-    static int oldshift;
-    
-    int time = gTimer.read_ms();
-    
-    if(gate && !clkstate)
-    {
-        oldgatetime = time;
-        clkstate = 1;
-        
-    } else if (!gate && clkstate) {
-            
-        gatetime = time - oldgatetime + 2;
-        clkstate = 0;
-        
-    } else if (gCtrlSW[0]) {
-        
-        gTimer.reset();
-        oldshift = clkstate = 0;
-    }
-        
-    if(time >= oldshift + gatetime)
-    {
-        oldshift = time;
-        return 1;
-        
-    } else {
-            
-        return 0;   
-    }
-}
-
-//-------------------------------------------------------------
-// GateOutSequence  beat(Note values) length(Gate time) invert(invert Gate)
-
-inline int UpdateGate(int bpm, int beat, int ch, int length, bool invert)
-{
-    int i;
-    static int gatetime[4], oldgatetime[4];
-    static int bar, sync24, oldsynctime;
-    
-    int time = gTimer.read_us();
-    
-    bar = (60.0f / bpm) * 4000000;
-    sync24 = (bar / 4) / 24; // sync24 not tested
     
-    switch(beat)                                // Calculate Note values 
-        {
-            case NDOT2:
-                
-                gatetime[ch] = (bar / 4) * 3;
-                break;
-                    
-            case NDOT4:
-            
-                gatetime[ch] = (bar / 8) * 3;
-                break;
-                
-            case NDOT8:
-                
-                gatetime[ch] = (bar / 16) * 3;
-                break;
-                    
-            case NDOT16:
-                
-                gatetime[ch] = (bar / 32) * 3;
-                break;
-        
-            case NDOT32:
-                
-                gatetime[ch] = (bar / 64) * 3;
-                break;
-                
-            case TRIP2:
-                
-                gatetime[ch] = bar / 3;
-                break;
-                
-            case TRIP4:
-                
-                gatetime[ch] = (bar / 2) / 3;
-                break;
-                
-            case TRIP8:
-                        
-                gatetime[ch] = (bar / 4) / 3;
-                break;
-            
-            case TRIP16:
-                
-                gatetime[ch] = (bar / 8) / 3;
-                break;
-            
-            case TRIP32:
-                
-                gatetime[ch] = (bar / 16) / 3;
-                break;
-                
-            case NRESET:
-                
-                for(i = 0; i < GATEALL; ++i)    // Reset
-                {
-                    gTimer.reset();
-                    oldsynctime = oldgatetime[i] = gatetime[i] = NRESET;
-                }
-                break;
-                
-            default:
-                
-                gatetime[ch] = bar / beat;
-        }
-        
-        if(time > oldsynctime + sync24)  // sync24 not tested
-        {
-            oldsynctime = time;
-            gCLOCKOUT = 1;
-            
-        } else if (time > sync24 - (sync24 - 2)) {
-        
-            gCLOCKOUT = 0;
-        }
-    
-    if (ch == GATEALL) 
-    {
-        return -1;
-        
-    } else if (time > oldgatetime[ch] + gatetime[ch] && !invert) {
-        
-        oldgatetime[ch] = time;
-        gLEDS[ch] = gGATES[ch] = 1;
-        
-        return ch + 1;
-    
-    } else if (time > oldgatetime[ch] + gatetime[ch] && invert) {
-        
-        oldgatetime[ch] = time;
-        gLEDS[ch] = gGATES[ch] = 0;
-        
-        return 0;
-        
-    } else if (time > oldgatetime[ch] + (gatetime[ch] - gatetime[ch] / length) && !invert) {
-        
-        gLEDS[ch] = gGATES[ch] = 0;
-        
-        return 0;
-        
-    } else if (time > oldgatetime[ch] + (gatetime[ch] - gatetime[ch] / length) && invert) {
-        
-        gLEDS[ch] = gGATES[ch] = 1;
-        
-        return ch + 1;
-        
-    } else {
-        
-        return -1;          
-    }
+    __enable_irq();
 }
 
 //-------------------------------------------------------------
 // Calculate CV
 
-inline void SetCV()
+void SetCV()
 {
-    static int ch, quan;
-    static float glidecv[8], oldcv[8];
+    static int ch;
+    float glidecv[8];
     unsigned int cv[8];
+    static float oldcv[8];
+    static unsigned int quan;
     float qcv;
 
     switch(gMode) 
         {
             case MODE_LIN:
                 
-                oldcv[ch] = glidecv[ch] = oldcv[ch] * gGlide + gOSC_cv[ch] * (1.0f - gGlide);
+                glidecv[ch] = oldcv[ch] * gGlide + gOSC_cv[ch] * (1.0f - gGlide);
+                oldcv[ch] = glidecv[ch];
                 cv[ch] = (unsigned int)glidecv[ch];
                     
                 UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
@@ -731,7 +392,8 @@
                 quan = 40616 / QUAN_RES1;
                 qcv = calibMap1[(unsigned int)(gOSC_cv[ch] / quan)];
                     
-                oldcv[ch] = glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
+                glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
+                oldcv[ch] = glidecv[ch];
                 cv[ch] = (unsigned int)glidecv[ch];
                         
                 UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
@@ -742,7 +404,8 @@
                 quan = 40616 / QUAN_RES2;
                 qcv = calibMap2[(unsigned int)(gOSC_cv[ch] / quan)];
                     
-                oldcv[ch] = glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
+                glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
+                oldcv[ch] = glidecv[ch];
                 cv[ch] = (unsigned int)glidecv[ch];
                         
                 UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
@@ -750,10 +413,11 @@
                     
             case MODE_QDor:
                 
-                quan = 40616 / QUAN_RES5;
-                qcv = calibMap5[(unsigned int)(gOSC_cv[ch] / quan)];
+                quan = 40616 / QUAN_RES3;
+                qcv = calibMap3[(unsigned int)(gOSC_cv[ch] / quan)];
                     
-                oldcv[ch] = glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
+                glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
+                oldcv[ch] = glidecv[ch];
                 cv[ch] = (unsigned int)glidecv[ch];
                         
                 UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
@@ -761,10 +425,11 @@
                 
             case MODE_Q5th:
                 
-                quan = 40616 / QUAN_RES7;
-                qcv = calibMap7[(unsigned int)(gOSC_cv[ch] / quan)];
+                quan = 40616 / QUAN_RES4;
+                qcv = calibMap4[(unsigned int)(gOSC_cv[ch] / quan)];
                     
-                oldcv[ch] = glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
+                glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
+                oldcv[ch] = glidecv[ch];
                 cv[ch] = (unsigned int)glidecv[ch];
                         
                 UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
@@ -772,10 +437,11 @@
                 
             case MODE_QWht:
                 
-                quan = 40616 / QUAN_RES8;
-                qcv = calibMap8[(unsigned int)(gOSC_cv[ch] / quan)];
+                quan = 40616 / QUAN_RES5;
+                qcv = calibMap5[(unsigned int)(gOSC_cv[ch] / quan)];
                     
-                oldcv[ch] = glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
+                glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
+                oldcv[ch] = glidecv[ch];
                 cv[ch] = (unsigned int)glidecv[ch];
                         
                 UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
@@ -783,531 +449,22 @@
                 
             case MODE_Calb:
                 
-                cv[ch] = 19212;     // A880.0Hz
-                
-                gGATES[0] = gGATES[1] = gGATES[2] = gGATES[3] = 1;
-                gLEDS[0] = gLEDS[1] = gLEDS[2] = gLEDS[3] = 1;
-                
-                UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
-                break;
-        }
-
-        CVMeter(ch, &cv[ch]);
-        
-        ch++;
-        ch &= 0x07;
-}
-
-//-------------------------------------------------------------
-// Calculate CV
-
-inline void SetSCV()
-{
-    static int ch, quan, mode;
-    static float glidecv[8], oldcv[8];
-    unsigned int cv[8];
-    float qcv;
-
-    mode = (gCtrl[1] * 8);
-
-    gCLOCKOUT = gGATES[0];
-    
-    switch(mode) 
-        {
-            case Lin:
-                
-                oldcv[ch] = glidecv[ch] = oldcv[ch] * gGlide + gOSC_cv[ch] * (1.0f - gGlide);
-                cv[ch] = (unsigned int)glidecv[ch];
-                    
-                UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
-                break;
-                    
-            case Chr:
-            
-                quan = 40616 / QUAN_RES1;
-                qcv = calibMap1[(unsigned int)(gOSC_cv[ch] / quan)];
-                    
-                oldcv[ch] = glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[ch] = (unsigned int)glidecv[ch];
-                        
-                UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
-                break;
-                
-            case Maj:
-                
-                quan = 40616 / QUAN_RES2;
-                qcv = calibMap2[(unsigned int)(gOSC_cv[ch] / quan)];
-                    
-                oldcv[ch] = glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[ch] = (unsigned int)glidecv[ch];
-                        
-                UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
-                break;
-            
-            case M7:
-            
-                quan = 40616 / QUAN_RES3;
-                qcv = calibMap3[(unsigned int)(gOSC_cv[ch] / quan)];
-                    
-                oldcv[ch] = glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[ch] = (unsigned int)glidecv[ch];
-                        
-                UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
-                break;
-                
-            case Min7:
-                
-                quan = 40616 / QUAN_RES4;
-                qcv = calibMap4[(unsigned int)(gOSC_cv[ch] / quan)];
-                    
-                oldcv[ch] = glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[ch] = (unsigned int)glidecv[ch];
-                        
-                UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
-                break;
-                    
-            case Dor:
-                
-                quan = 40616 / QUAN_RES5;
-                qcv = calibMap5[(unsigned int)(gOSC_cv[ch] / quan)];
-                    
-                oldcv[ch] = glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[ch] = (unsigned int)glidecv[ch];
-                        
-                UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
-                break;
-        
-            case Min:
-                
-                quan = 40616 / QUAN_RES6;
-                qcv = calibMap6[(unsigned int)(gOSC_cv[ch] / quan)];
-                    
-                oldcv[ch] = glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[ch] = (unsigned int)glidecv[ch];
-                        
-                UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
-                break;
-                
-            case S5th:
-                
-                quan = 40616 / QUAN_RES7;
-                qcv = calibMap7[(unsigned int)(gOSC_cv[ch] / quan)];
-                    
-                oldcv[ch] = glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[ch] = (unsigned int)glidecv[ch];
-                        
-                UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
-                break;
-                
-            case Wht:
-                
-                quan = 40616 / QUAN_RES8;
-                qcv = calibMap8[(unsigned int)(gOSC_cv[ch] / quan)];
-                    
-                oldcv[ch] = glidecv[ch] = oldcv[ch] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[ch] = (unsigned int)glidecv[ch];
+                cv[ch] = 19212;     // A440.0Hz
                         
                 UpdateCV(WRITE_UPDATE_N, ch, &cv[ch]);
                 break;
         }
 
         CVMeter(ch, &cv[ch]);
-        
         ch++;
         ch &= 0x07;
 }
 
 //-------------------------------------------------------------
-// Sequence & Shift Out CV
-
-inline void SeqCV(int shift)
-{
-    int i, j, k;
-    static int ch, quan, mode;
-    static int cnt1, cnt2, cnt3;
-    static int cntloop1, cntloop2, cntloop3;
-    static float glidecv[8], shiftcv[8];
-    static float buffercv[9], loopcv[3];
-    unsigned int cv[8];
-    float qcv;
-        
-    mode = (gCtrl[1] * 8);  // Sequencer Quantize Mode (gCtrl[1])
-    
-    switch(mode) 
-        {
-            case Lin:
-            
-                if(ch < 8)
-                {
-                    glidecv[0] = glidecv[0] * gGlide + gSeq_cv1[ch] * (1.0f - gGlide);
-                            
-                } else {
-                        
-                    glidecv[0] = glidecv[0] * gGlide + gSeq_cv2[ch-8] * (1.0f - gGlide);
-                }
-                
-                cv[0] = (unsigned int)glidecv[0];
-                
-                UpdateCV(WRITE_UPDATE_N, 0, &cv[0]);
-                break;
-                    
-            case Chr:
-            
-                quan = 40616 / QUAN_RES1;
-                
-                if(ch < 8)
-                {
-                    qcv = calibMap1[(unsigned int)(gSeq_cv1[ch] / quan)];
-                            
-                } else {
-                        
-                    qcv = calibMap1[(unsigned int)(gSeq_cv2[ch-8] / quan)];
-                }
-                    
-                glidecv[0] = glidecv[0] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[0] = (unsigned int)glidecv[0];
-                
-                UpdateCV(WRITE_UPDATE_N, 0, &cv[0]);
-                break;
-                
-            case Maj:
-                
-                quan = 40616 / QUAN_RES2;
-                
-                if(ch < 8)
-                {
-                    qcv = calibMap2[(unsigned int)(gSeq_cv1[ch] / quan)];
-                            
-                } else {
-                        
-                    qcv = calibMap2[(unsigned int)(gSeq_cv2[ch-8] / quan)];
-                }
-                    
-                glidecv[0] = glidecv[0] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[0] = (unsigned int)glidecv[0];
-                
-                UpdateCV(WRITE_UPDATE_N, 0, &cv[0]);
-                break;
-            
-            case M7:
-                
-                quan = 40616 / QUAN_RES3;
-                
-                if(ch < 8)
-                {
-                    qcv = calibMap3[(unsigned int)(gSeq_cv1[ch] / quan)];
-                            
-                } else {
-                        
-                    qcv = calibMap3[(unsigned int)(gSeq_cv2[ch-8] / quan)];
-                }
-                    
-                glidecv[0] = glidecv[0] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[0] = (unsigned int)glidecv[0];
-                
-                UpdateCV(WRITE_UPDATE_N, 0, &cv[0]);
-                break;
-                    
-            case Min7:
-                
-                quan = 40616 / QUAN_RES4;
-                
-                if(ch < 8)
-                {
-                    qcv = calibMap4[(unsigned int)(gSeq_cv1[ch] / quan)];
-                            
-                } else {
-                        
-                    qcv = calibMap4[(unsigned int)(gSeq_cv2[ch-8] / quan)];
-                }
-                
-                glidecv[0] = glidecv[0] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[0] = (unsigned int)glidecv[0];
-                
-                UpdateCV(WRITE_UPDATE_N, 0, &cv[0]);
-                break;
-                            
-            case Dor:
-                
-                quan = 40616 / QUAN_RES5;
-                
-                if(ch < 8)
-                {
-                    qcv = calibMap5[(unsigned int)(gSeq_cv1[ch] / quan)];
-                            
-                } else {
-                        
-                    qcv = calibMap5[(unsigned int)(gSeq_cv2[ch-8] / quan)];
-                }
-                
-                glidecv[0] = glidecv[0] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[0] = (unsigned int)glidecv[0];
-                
-                UpdateCV(WRITE_UPDATE_N, 0, &cv[0]);
-                break;
-                
-            case Min:
-                
-                quan = 40616 / QUAN_RES6;
-                
-                if(ch < 8)
-                {
-                    qcv = calibMap6[(unsigned int)(gSeq_cv1[ch] / quan)];
-                            
-                } else {
-                        
-                    qcv = calibMap6[(unsigned int)(gSeq_cv2[ch-8] / quan)];
-                }
-                
-                glidecv[0] = glidecv[0] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[0] = (unsigned int)glidecv[0];
-                
-                UpdateCV(WRITE_UPDATE_N, 0, &cv[0]);
-                break;
-            
-            case S5th:
-                
-                quan = 40616 / QUAN_RES7;
-                
-                if(ch < 8)
-                {
-                    qcv = calibMap7[(unsigned int)(gSeq_cv1[ch] / quan)];
-                            
-                } else {
-                        
-                    qcv = calibMap7[(unsigned int)(gSeq_cv2[ch-8] / quan)];
-                }
-                
-                glidecv[0] = glidecv[0] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[0] = (unsigned int)glidecv[0];
-                
-                UpdateCV(WRITE_UPDATE_N, 0, &cv[0]);
-                break;
-                
-            case Wht:
-                
-                quan = 40616 / QUAN_RES8;
-                
-                if(ch < 8)
-                {
-                    qcv = calibMap8[(unsigned int)(gSeq_cv1[ch] / quan)];
-                            
-                } else {
-                        
-                    qcv = calibMap8[(unsigned int)(gSeq_cv2[ch-8] / quan)];
-                }
-                    
-                glidecv[0] = glidecv[0] * gGlide + (qcv * SCALING_N) * (1.0f - gGlide);
-                cv[0] = (unsigned int)glidecv[0];
-                
-                UpdateCV(WRITE_UPDATE_N, 0, &cv[0]);
-                break;
-        }
-            
-        if(!gCtrlSW[2] && !gCtrlSW[3])              // Sequencer Mode1
-        {
-            for(i = 1; i < 8; ++i)
-            {
-                glidecv[i] = glidecv[i] * gGlide + shiftcv[i] * (1.0f - gGlide);
-                cv[i] = (unsigned int)glidecv[i];
-                    
-                UpdateCV(WRITE_UPDATE_N, i, &cv[i]);
-            }
-            
-            if(shift == 1)                  // GATE1
-            {
-                for(j = 1; j < 8; ++j)      // Shift ch2~8
-                {
-                    shiftcv[j] = glidecv[j-1];
-                }
-            
-                ch++;
-                ch &= 0x0F;
-            }
-            
-            cnt1 = cnt2 = cnt3 = 0;
-                    
-        } else if (gCtrlSW[2] && !gCtrlSW[3]) { // Sequencer Mode2
-                
-            for(i = 1; i < 8; ++i)
-            {
-                glidecv[i] = glidecv[i] * gGlide + shiftcv[i] * (1.0f - gGlide);
-                cv[i] = (unsigned int)glidecv[i];
-                    
-                UpdateCV(WRITE_UPDATE_N, i, &cv[i]);
-            }
-            
-            if(shift == 1)                      // GATE1
-            {
-                for(j = 1; j < 5; ++j)
-                {
-                    shiftcv[j] = glidecv[j-1];  // Shift ch2~5
-                }
-            
-                ch++;
-                ch &= 0x0F;
-                
-            } else if (shift == 2) {            // GATE2
-                
-                shiftcv[5] = glidecv[1];        // Shift ch6
-                
-            } else if (shift == 3) {            // GATE3
-                
-                shiftcv[6] = glidecv[2];        // Shift ch7
-                
-            } else if (shift == 4) {            // GATE4
-                
-                shiftcv[7] = glidecv[3];        // Shift ch8
-            }
-            
-            cnt1 = cnt2 = cnt3 = 0;
-                
-        } else if (gCtrlSW[3]) {                        // Sequencer Mode3
-                
-            for(i = 1; i < 5; ++i)
-            {
-                glidecv[i] = glidecv[i] * gGlide + shiftcv[i] * (1.0f - gGlide);
-                cv[i] = (unsigned int)glidecv[i];
-                    
-                UpdateCV(WRITE_UPDATE_N, i, &cv[i]);            
-            }
-            
-            for(j = 5; j < 8; ++j)
-            {
-                glidecv[j] = glidecv[j] * gGlide + loopcv[j - 5] * (1.0f - gGlide);
-                cv[j] = (unsigned int)glidecv[j];
-                    
-                UpdateCV(WRITE_UPDATE_N, j, &cv[j]);            
-            }
-            
-            if(shift == 1)                      // GATE1
-            {
-                for(k = 1; k < 8; ++k)
-                {
-                    shiftcv[k] = glidecv[k-1];  // Shift ch2~5
-                }
-            
-                ch++;
-                ch &= 0x0F;
-                
-            } else if (shift == 2) {            // GATE2
-                
-                if(cnt1 < 4) 
-                {
-                    loopcv[0] = buffercv[cnt1] = shiftcv[4];
-                    
-                    cnt1++;
-                    
-                } else if (cnt1 >= 4) {
-                    
-                    loopcv[0] = buffercv[cntloop1];
-                    
-                    cntloop1++;
-                    cntloop1 &= 0x03;
-                }
-                        
-            } else if (shift == 3) {            // GATE3
-                
-                if(cnt2 < 3) 
-                {
-                    loopcv[1] = buffercv[(cnt2 + 4)] = shiftcv[5];
-                    
-                    cnt2++;
-                    
-                } else if (cnt2 >= 3) {
-                    
-                    loopcv[1] = buffercv[(cntloop2 + 4)];
-                    
-                    cntloop2++;
-                    cntloop2 &= 0x03;   
-                }
-                
-            } else if (shift == 4) {            // GATE4
-                
-                if(cnt3 < 2) 
-                {
-                    loopcv[2] = buffercv[(cnt3 + 7)] = shiftcv[6];
-                    
-                    cnt3++;
-                    
-                } else if (cnt3 >= 2) {
-                    
-                    loopcv[2] = buffercv[(cntloop3 + 7)];
-                    
-                    cntloop3++;
-                    cntloop3 &= 0x01;   
-                }
-            }
-            
-            if(gCtrlSW[1])                  // Update loop buffer (if gCtrlSW[1] ON)
-            {
-                cnt1 = cnt2 = cnt3 = 0;
-            } 
-        }
-        
-        if(ch < 8)
-        {
-            CVMeter(ch, &cv[0]);
-                            
-        } else {
-                        
-            CVMeter((ch-8), &cv[0]);
-        }
-}
-
-//-------------------------------------------------------------
-// Shift CV
-
-inline void ShiftCV(int shift)
-{
-    int i;
-    static int ch;
-    static float glidecv[8], shiftcv[8], oldcv;
-    unsigned int cv[8];
-    
-    gLEDS[1] = gGATES[1] = gGATES[0];
-    
-    oldcv = glidecv[0] = glidecv[0] * gGlide + gOSC_cv[0] * (1.0f - gGlide);
-    
-    cv[0] = (unsigned int)glidecv[0];
-                
-    UpdateCV(WRITE_UPDATE_N, 0, &cv[0]);
-    
-    glidecv[ch+1] = glidecv[ch+1] * gGlide + shiftcv[ch+1] * (1.0f - gGlide);
-    cv[ch+1] = (unsigned int)glidecv[ch+1];
-                    
-    UpdateCV(WRITE_UPDATE_N, ch+1, &cv[ch+1]);
-                
-    if(shift == 1)              // GATE1
-    {   
-        shiftcv[0] = oldcv;
-        
-        for(i = 7; i > 0; --i)
-        {
-            shiftcv[i] = shiftcv[i-1];
-        }
-    }
-        
-    if(ch < 8)
-    {
-        CVMeter(ch, &cv[0]);
-                            
-    } else {
-                        
-        CVMeter((ch-8), &cv[0]);
-    }
-    
-    ch++;
-    ch &= 0x07;
-}
-
-//-------------------------------------------------------------
 // Check SW
 
-void CheckModeSW()
+void CheckSW()
 {   
-    wait(0.05);
-    
     if(gMode < MODE_NUM - 1) 
     {   
         gMode++;
@@ -1317,46 +474,8 @@
         gMode = 0;
     }
     
-    gCLOCKOUT = gGATES[0] = gGATES[1] = gGATES[2] = gGATES[3] = 0;
-    gLEDS[0] = gLEDS[1] = gLEDS[2] = gLEDS[3] = 0;
-    
-    if((gMode == MODE_SEQ) || (gMode == MODE_SHIF))
-    {
-        gTimer.start();     // Sequencer Timer Start
-        
-    } else {
-            
-        gTimer.stop();      // Sequencer Timer Stop
-    }
-    
-    LCD();
-}
-
-//-------------------------------------------------------------
-// CV meter
-
-inline void CVMeter(int ch, const unsigned int *level)
-{
-    int cvmeter;
-    
-    cvmeter = *level / (SCALING_N / 7.9f);
-        
-    gLCD.locate ( ch, 0 );
-    gLCD.putc(cvmeter);     // put custom char
-}
-
-//-------------------------------------------------------------
-// Print LCD Mode Status
-
-void LCD()
-{
     switch(gMode) 
         {
-            case MODE_Calb: 
-                gLCD.locate( 9, 0 );
-                gLCD.printf("Calibr "); 
-                break;
-                
             case MODE_LIN:
                 gLCD.locate( 9, 0 );
                 gLCD.printf("OSC-CV ");
@@ -1387,19 +506,28 @@
                 gLCD.printf("QUAN_W "); 
                 break;
                 
-            case MODE_SEQ:  
+            case MODE_Calb: 
                 gLCD.locate( 9, 0 );
-                gLCD.printf("ASRSEQ ");
-                break;
-                
-            case MODE_SHIF: 
-                gLCD.locate( 9, 0 );
-                gLCD.printf("ASHSEQ ");
+                gLCD.printf("Calibr "); 
                 break;
         }
 }
 
 //-------------------------------------------------------------
+// CV meter
+
+void CVMeter(int ch, const unsigned int *level)
+{
+    unsigned int cvmeter;
+    
+    cvmeter = *level / 4860;
+    // cvmeter = *level / (SCALING_N / 7.9);
+        
+    gLCD.locate ( ch, 0 );
+    gLCD.putc(cvmeter);     // put custom char
+}
+
+//-------------------------------------------------------------
 // Write command Custom Char LCD CGRAM(CV Meter) 
 
 void WriteCustomChar(unsigned char addr, unsigned char *c)
@@ -1411,7 +539,6 @@
     {
         gLCD.writeCommand(addr | cnt);
         gLCD.writeData(*c);
-        
         cnt++;
         c++;
     }
@@ -1432,6 +559,7 @@
         gLCD.locate( 0, 1 );
         gLCD.printf("Error in setup.");
 //  printf("Error %d in setup.\r\n", ethErr);
+        
         return -1;
     }
 //  printf("Setup OK\r\n");
@@ -1443,7 +571,7 @@
     
     gLCD.locate( 0, 1 );
     gLCD.printf("%03d.%03d.%03d.%03d", gEth.getIp()[0], gEth.getIp()[1], gEth.getIp()[2], gEth.getIp()[3]);
-    wait(1.0);
+    wait(2.0);
     
     return 0;
 }
@@ -1451,147 +579,97 @@
 //-------------------------------------------------------------
 // Handller receive UDP Packet
 
-inline void onUDPSocketEvent(UDPSocketEvent e)
+void onUDPSocketEvent(UDPSocketEvent e)
 {
     union OSCarg msg[10];
-    char buf[768] = {0};
-    int num, recvlen, len;
-    unsigned int absv;
-    int messagepos = 0;
-    bool bundleflag = false;
-    
-    Host host;
+    static int num;
     
     switch(e)
     {
         case UDPSOCKET_READABLE: // The only event for now
-        
-        recvlen = gUdp.recvfrom(buf, 768, &host);  // packet length    
-        
-        if(recvlen <= 0)  break;
-        
-        if(buf[0] == '#') // #bundle
-        {
-            messagepos += 16;     // skip #bundle & timetag
-            recvlen -= 16;
+        char buf[256] = {0};
+        Host host;
             
-            bundleflag = true;  
-        }
-        
-        do {
-                if(bundleflag)
-                {
-                    messagepos += 4;
-                    recvlen -= 4;
-                    
-                    if(recvlen <= 0)
-                    {
-                        bundleflag = false;
-                        break;
-                    }
-                }
-                
-                if(getOSCmsg(buf + messagepos, msg) == -1)  continue;
+        while( int len = gUdp.recvfrom( buf, 256, &host ))
+        {
+            if(len <= 0)  break;
+            //  printf("\r\nFrom %d.%d.%d.%d:\r\n", 
+            //  host.getIp()[0], host.getIp()[1], host.getIp()[2], host.getIp()[3]);
             
-                len = strlen(msg[0].address);
-        
-                if(isdigit(msg[0].address[len-1])) 
-                {       
-                    num = msg[0].address[len-1] - '0' - 1;
+            getOSCmsg(buf,msg);
+            //  printf("OSCmsg: %s %s %f %i\r\n", 
+            //  msg[0].address, msg[1].typeTag, msg[2].f, msg[2].i);
+                
+            len = strlen(msg[0].address);
+            if(isdigit(msg[0].address[len-1])) num = msg[0].address[len-1] - '0' - 1;
+            else num = -1;
             
-                } else {
+            unsigned int absv = msg[2].f + 0; //convert -0 to 0
             
-                    num = -1;
-                }
-        
-                absv = msg[2].f + 0; //convert -0 to 0
-        
             // address pattern SYNC & GATE (Type Tag int, float)
-                if(!strncmp(msg[0].address+(len-1)-4, "sync", 4)) 
-                { 
-                    if(absv >= 1 || msg[2].i >= 1) gCLOCKOUT = 1;
-                    else                           gCLOCKOUT = 0;
-                    continue;
-
-                } else if (!strncmp(msg[0].address+(len-1)-4, "gate", 4) && (num != -1)) {
-                    if(num > 4) continue;
-                    if(absv >= 1 || msg[2].i >= 1) gLEDS[num] = gGATES[num] = 1;
-                    else                           gLEDS[num] = gGATES[num] = 0;
-                    continue;
-            // (touchOSC Control push, toggle)
-                } else if (!strncmp(msg[0].address+(len-1)-4, "push", 4) && (num != -1)) {     
-                    if(num > 4) continue;
-                    if(absv >= 1 || msg[2].i >= 1) gLEDS[num] = gGATES[num] = 1;
-                    else                           gLEDS[num] = gGATES[num] = 0;
-                    continue;
-                
-                } else if (!strncmp(msg[0].address+(len-1)-6, "toggle", 6) && (num != -1)) {
-                    if(num > 4) continue;
+            if((strncmp(msg[0].address+(len-1)-4, "sync", 4)==0) && (num == -1)) { 
+                if(num > 1) break;
+                if(absv >= 1 || msg[2].i >= 1) gCLOCKOUT = 1;
+                else                           gCLOCKOUT = 0;
+                break;
+    
+                } else if ((strncmp(msg[0].address+(len-1)-4, "gate", 4)==0) && (num != -1)) {
+                    if(num > 3) break;
                     if(absv >= 1 || msg[2].i >= 1) gLEDS[num] = gGATES[num] = 1;
                     else                           gLEDS[num] = gGATES[num] = 0;
-                    continue;
-                        
-                } else if (!strncmp(msg[0].address,"/1/multipush",12) && (num != -1)) {
-                    if(num > 4) continue;
-                    if(absv >= 1 || msg[2].i >= 1) gLEDS[num] = gGATES[num] = 1;
-                    else                           gLEDS[num] = gGATES[num] = 0;
-                    continue;
-            // address pattern CV (Type Tag float)  
-                } else if(!strncmp(msg[0].address+(len-1)-2, "cv", 2) && (num != -1)) {
-                    if(num > 7) continue;
-                    if(msg[1].typeTag[1] == 'f') gOSC_cv[num] = msg[2].f * (SCALING_N);
-                    continue;
-            // (touchOSC Control fader, rotary, xy, multixy, multifader)        
-                } else if (!strncmp(msg[0].address+(len-1)-5, "fader", 5) && (num != -1)) {
-                    if(num > 7) continue;                                              
-                    if(msg[1].typeTag[1] == 'f') gOSC_cv[num] = msg[2].f * (SCALING_N);
-                    continue;
+                    break;
+                    // (touchOSC Control push, toggle)
+                    } else if ((strncmp(msg[0].address+(len-1)-4, "push", 4)==0) && (num != -1)) {     
+                        if(num > 3) break;
+                        if(absv >= 1 || msg[2].i >= 1) gLEDS[num] = gGATES[num] = 1;
+                        else                           gLEDS[num] = gGATES[num] = 0;
+                        break;
+                    
+                        } else if ((strncmp(msg[0].address+(len-1)-6, "toggle", 6)==0) && (num != -1)) {
+                            if(num > 3) break;
+                            if(absv >= 1 || msg[2].i >= 1) gLEDS[num] = gGATES[num] = 1;
+                            else                           gLEDS[num] = gGATES[num] = 0;
+                            break;
+                            
+                            } else if ((strncmp(msg[0].address,"/1/multipush",12)==0) && (num != -1)) {
+                                if(num > 3) break;
+                                if(absv >= 1 || msg[2].i >= 1) gLEDS[num] = gGATES[num] = 1;
+                                else                           gLEDS[num] = gGATES[num] = 0;
+                                break;
+                            }
 
-                } else if (!strncmp(msg[0].address+(len-1)-6, "rotary", 6) && (num != -1)) { 
-                    if(num > 7) continue;
-                    if(msg[1].typeTag[1] == 'f') gOSC_cv[num] = msg[2].f * (SCALING_N);
-                    continue;
-                
-                } else if (!strncmp(msg[0].address+(len-1)-2, "xy", 2) && (num != -1)) {
-                    if(num > 7) continue;
-                    if(msg[1].typeTag[1] == 'f') gOSC_cv[num] = msg[2].f * (SCALING_N);
-                    if(msg[1].typeTag[1] == 'f') gOSC_cv[++num] = msg[3].f * (SCALING_N);
-                    continue;
-                        
-                } else if (!strncmp(msg[0].address+(len-1)-9, "multixy1/", 9) && (num != -1)) {
-                    if(num > 7) continue;
-                    if(msg[1].typeTag[1] == 'f') gOSC_cv[num] = msg[2].f * (SCALING_N);
-                    if(msg[1].typeTag[1] == 'f') gOSC_cv[++num] = msg[3].f * (SCALING_N);
-                    continue;
-    
-                } else if (!strncmp(msg[0].address+(len-1)-12, "multifader1/", 12) && (num != -1)) {
-                    if(num > 7) continue;
-                    if(msg[1].typeTag[1] == 'f') gOSC_cv[num] = msg[2].f * (SCALING_N);
-                    continue;
-            // (touchOSC multifader for Sequencer Mode)
-                } else if (!strncmp(msg[0].address+(len-1)-11, "sequencer1/", 11) && (num != -1)) {
-                    if(num > 7) continue;
-                    if(msg[1].typeTag[1] == 'f') gSeq_cv1[num] = msg[2].f * (SCALING_N);
-                    continue;
+                        // address pattern CV (Type Tag float)
+                            if((strncmp(msg[0].address+(len-1)-2, "cv", 2)==0) && (num != -1)) {
+                                if(num > 7) break;
+                                if(msg[1].typeTag[1] == 'f') gOSC_cv[num] = msg[2].f * (SCALING_N);
+                                break;
+                            // (touchOSC Control fader, rotary, xy, multixy, multifader)
+                                } else if ((strncmp(msg[0].address+(len-1)-5, "fader", 5)==0) && (num != -1)) {
+                                    if(num > 7) break;                                                     
+                                    if(msg[1].typeTag[1] == 'f') gOSC_cv[num] = msg[2].f * (SCALING_N);
+                                    break;
+
+                                    } else if ((strncmp(msg[0].address+(len-1)-6, "rotary", 6)==0) && (num != -1)) { 
+                                        if(num > 7) break;
+                                        if(msg[1].typeTag[1] == 'f') gOSC_cv[num] = msg[2].f * (SCALING_N);
+                                        break;
+                    
+                                        } else if ((strncmp(msg[0].address+(len-1)-2, "xy", 2)==0) && (num != -1)) {
+                                            if(num > 7) break;
+                                            if(msg[1].typeTag[1] == 'f') gOSC_cv[num] = msg[2].f * (SCALING_N);
+                                            if(msg[1].typeTag[1] == 'f') gOSC_cv[++num] = msg[3].f * (SCALING_N);
+                                            break;
                             
-                } else if (!strncmp(msg[0].address+(len-1)-11, "sequencer2/", 11) && (num != -1)) {
-                    if(num > 7) continue;
-                    if(msg[1].typeTag[1] == 'f') gSeq_cv2[num] = msg[2].f * (SCALING_N);
-                    continue;
-            // address pattern for control
-                } else if (!strncmp(msg[0].address+(len-1)-6, "ctrlsw", 6) && (num != -1)) {
-                    if(num > 4) continue;
-                    if(absv >= 1 || msg[2].i >= 1) gCtrlSW[num] = true;
-                    else                           gCtrlSW[num] = false;
-                    continue;
-                                                
-                } else if (!strncmp(msg[0].address+(len-1)-4, "ctrl", 4) && (num != -1)) {
-                    if(num > 3) continue;                                             
-                    if(msg[1].typeTag[1] == 'f') gCtrl[num] = msg[2].f;
-                    continue;
-                }
-                
-            } while(bundleflag);
-                    
-    }
-}
+                                            } else if ((strncmp(msg[0].address+(len-1)-9, "multixy1/", 9)==0) && (num != -1)) {
+                                                if(num > 7) break;
+                                                if(msg[1].typeTag[1] == 'f') gOSC_cv[num] = msg[2].f * (SCALING_N);
+                                                if(msg[1].typeTag[1] == 'f') gOSC_cv[++num] = msg[3].f * (SCALING_N);
+                                                break;
+                                
+                                                } else if ((strncmp(msg[0].address+(len-1)-12, "multifader1/", 12)==0) && (num != -1)) {
+                                                    if(num > 7) break;
+                                                    if(msg[1].typeTag[1] == 'f') gOSC_cv[num] = msg[2].f * (SCALING_N);
+                                                }
+                                            }
+                                        }                           
+                                    }
--- a/main.cpp	Sun Apr 14 00:54:10 2013 +0000
+++ b/main.cpp	Sun Mar 09 04:52:52 2014 +0000
@@ -124,7 +124,7 @@
 // Silentway Calibration Data Mapping
 // http://www.expert-sleepers.co.uk/silentway.html
 
-//  Chromatic Scale
+// Chromatic Scale
 const float calibMap1[QUAN_RES1] = {
 0.00559238,   0.01324014,   0.02088790,   0.02853566,   0.03618342, 
 0.04383118,   0.05147894,   0.05912671,   0.06677447,   0.07442223, 
@@ -151,7 +151,7 @@
 0.85279000,   0.86631656,   0.88188213,   0.90110368,   0.92032516
 };
 
-//  Major Scale
+// Major Scale
 const float calibMap2[QUAN_RES2] = {
 0.01324014,   0.02853566,   0.03618342,   0.05147894,   0.06677447,
 0.08206999,   0.08971775,   0.10501327,   0.12030879,   0.12775089,
@@ -169,7 +169,7 @@
 0.88188213,   0.92032516
 };
 
-//  Dorian Scale
+// Dorian Scale
 const float calibMap3[QUAN_RES3] = {
 0.01324014,   0.02853566,   0.04383118,    0.05147894,   0.06677447,
 0.08206999,   0.08971775,   0.10501327,    0.12030879,   0.13486665,
@@ -187,7 +187,7 @@
 0.90110368,   0.92032516
 };
 
-//  5th
+// 5th
 const float calibMap4[QUAN_RES4] = {
 0.01324014,  0.06677447,   0.12030879,    0.17044549,    0.22025587,
 0.27019811,  0.32033587,   0.37047359,    0.42069295,    0.47092041,
@@ -195,7 +195,7 @@
 0.79868382,  0.90110368
 };
 
-//  Whole tone
+// Whole tone
 const float calibMap5[QUAN_RES5] = {
 0.01324014,   0.02853566,   0.04383118,   0.05912671,    0.07442223,
 0.08971775,   0.10501327,   0.12030879,   0.13486665,    0.14909819,
@@ -234,7 +234,7 @@
 
 // Variables for Control
 
-float gCtrl[2];
+volatile float gCtrl[2];
 volatile bool gCtrlSW[4] = {false};
 
 //-------------------------------------------------------------
@@ -315,19 +315,19 @@
         {
             case MODE_SEQ:
                 
-                bpm = (gCtrl[0] * 300 + 10);                    // Set BPM (gCtrl[0])
+                bpm = (gCtrl[0] * 300 + 10);                        // Set BPM (gCtrl[0])
             
                 if(abs(bpm - _bpm) > 1)
                 {
                     UpdateGate(bpm, NRESET, GATEALL, 3, 0);         // Reset (if bpm change)
                     _bpm = bpm;
                     
-                } else if (gCtrlSW[0]) {                        // Stop (gCtrlSW[0])
+                } else if (gCtrlSW[0]) {                            // Stop (gCtrlSW[0])
                         
                     bpm = 0;
                 }
             
-                if(!gCtrlSW[2] && !gCtrlSW[3])              // Sequencer Mode1
+                if(!gCtrlSW[2] && !gCtrlSW[3])                      // Sequencer Mode1
                 {
                     SeqCV((UpdateGate(bpm, N16TH, GATE1, 3, 0)));   // Shift Timming 16th note
                     UpdateGate(bpm, N8TH, GATE2, 3, 0);
@@ -336,7 +336,7 @@
 
                     break;
                 
-                } else if (gCtrlSW[2] && !gCtrlSW[3]) { // Sequencer Mode2 (if gCtrlSW[2] ON)
+                } else if (gCtrlSW[2] && !gCtrlSW[3]) {            // Sequencer Mode2 (if gCtrlSW[2] ON)
                 
                     SeqCV((UpdateGate(bpm, N16TH, GATE1, 3, 0)));  // Do shift ch 1~5
                     SeqCV((UpdateGate(bpm, N4TH, GATE2, 3, 0)));   // Do shift  ch 6
@@ -345,8 +345,8 @@
                     
                     break;
                 
-                } else if (gCtrlSW[3]) {                        // Sequencer Mode3 (if gCtrlSW[3] ON)
-                                                                    // (ch6,7,8, short loop)
+                } else if (gCtrlSW[3]) {                           // Sequencer Mode3 (if gCtrlSW[3] ON)
+                                                                   // (ch6,7,8, short loop)
                     SeqCV((UpdateGate(bpm, N16TH, GATE1, 3, 0)));  // Do shift ch 1~5
                     SeqCV((UpdateGate(bpm, N8TH, GATE2, 3, 0)));   // Do shift  ch 6
                     SeqCV((UpdateGate(bpm, NDOT8, GATE3, 3, 0)));  // Do shift  ch 7
@@ -460,9 +460,9 @@
     int time = gTimer.read_us();
     
     bar = (60.0f / bpm) * 4000000;
-    sync24 = (bar / 4) / 24; // sync24 not tested
+    sync24 = (bar / 4) / 24;            // sync24 not tested
     
-    switch(beat)                                // Calculate Note values 
+    switch(beat)                        // Calculate Note values 
         {
             case NDOT2:
                 
@@ -802,7 +802,7 @@
                 break;
         }
         
-        if(!gCtrlSW[2] && !gCtrlSW[3])              // Sequencer Mode1
+        if(!gCtrlSW[2] && !gCtrlSW[3])      // Sequencer Mode1
         {
             for(i = 1; i < 8; ++i)
             {
@@ -860,7 +860,7 @@
             
             cnt1 = cnt2 = cnt3 = 0;
                 
-        } else if (gCtrlSW[3]) {                        // Sequencer Mode3
+        } else if (gCtrlSW[3]) {                // Sequencer Mode3
                 
             for(i = 1; i < 5; ++i)
             {
@@ -937,7 +937,7 @@
                 }
             }
             
-            if(gCtrlSW[1])                  // Update loop buffer (if gCtrlSW[1] ON)
+            if(gCtrlSW[1])                      // Update loop buffer (if gCtrlSW[1] ON)
             {
                 cnt1 = cnt2 = cnt3 = 0;
             } 
@@ -1098,17 +1098,15 @@
 //-------------------------------------------------------------
 // Handller receive UDP Packet
 
-//-------------------------------------------------------------
-// Handller receive UDP Packet
-
 inline void onUDPSocketEvent(UDPSocketEvent e)
 {
     union OSCarg msg[10];
     char buf[768] = {0};
-    int num, recvlen, len;
-    unsigned int absv;
-    int messagepos = 0;
-    bool bundleflag = false;
+    int num, len;
+    volatile int recvlen;
+    volatile unsigned int absv;
+    volatile int messagepos = 0;
+    volatile bool bundleflag = false;
     
     Host host;
     
--- a/mbed-rpc.lib	Sun Apr 14 00:54:10 2013 +0000
+++ b/mbed-rpc.lib	Sun Mar 09 04:52:52 2014 +0000
@@ -1,1 +1,1 @@
-http://mbed.org/users/mbed_official/code/mbed-rpc/#efe8172b4113
+http://mbed.org/teams/mbed-official/code/mbed-rpc/#4490a0d9cb2a
--- a/mbed.bld	Sun Apr 14 00:54:10 2013 +0000
+++ b/mbed.bld	Sun Mar 09 04:52:52 2014 +0000
@@ -1,1 +1,1 @@
-http://mbed.org/users/mbed_official/code/mbed/builds/5e5da4a5990b
\ No newline at end of file
+http://mbed.org/users/mbed_official/code/mbed/builds/8e73be2a2ac1
\ No newline at end of file