API tools faq
paste
Advertisement
Guest User

LL412

a guest
Sep 29th, 2018
142
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 68.75 KB | None | 0 0
raw download clone embed print report
  1.  
  2. // -----------------------------------------------
  3. // LL412
  4. // -----------------------------------------------
  5. // Historique:
  6. // (Baloran) laurent.lecatelier@free.fr, version 0.1.3 07/05/2012
  7. // (Baloran) laurent.lecatelier@free.fr, version 0.1.4 08/05/2012
  8. // (Baloran) laurent.lecatelier@free.fr, version 0.1.5 10/05/2012 : optimisation du code, ajout du LFO Rand et Alien, Ajout du Midi Thru, Amélioration Dual et Split
  9. // (Baloran) laurent.lecatelier@free.fr, version 0.1.6 11/05/2012 : ajout du stop, continu, start midi
  10. // (Baloran) laurent.lecatelier@free.fr, version 0.1.7 03/06/2012 : ajout de l'accord, ajout d'arpèges divers
  11. // -----------------------------------------------
  12.  
  13.  
  14. #include <LiquidCrystal.h>
  15. #include "MIDI.h"
  16. #include <EEPROM.h>
  17. #include <avr/pgmspace.h>
  18.  
  19.  
  20.  
  21.  
  22. // Forme d'ondes du LFO
  23. const char Sinus[] PROGMEM = {128, 131, 134, 137, 140, 144, 147, 150, 153, 156, 159, 162, 165, 168, 171, 174, 177, 179, 182, 185, 188, 191, 193, 196, 199, 201, 204, 206, 209, 211, 213, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 235, 237, 239, 240, 241, 243, 244, 245, 246, 248, 249, 250, 250, 251, 252, 253, 253, 254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 254, 254, 254, 253, 253, 252, 251, 250, 250, 249, 248, 246, 245, 244, 243, 241, 240, 239, 237, 235, 234, 232, 230, 228, 226, 224, 222, 220, 218, 216, 213, 211, 209, 206, 204, 201, 199, 196, 193, 191, 188, 185, 182, 179, 177, 174, 171, 168, 165, 162, 159, 156, 153, 150, 147, 144, 140, 137, 134, 131, 128, 125, 122, 119, 116, 112, 109, 106, 103, 100, 97, 94, 91, 88, 85, 82, 79, 77, 74, 71, 68, 65, 63, 60, 57, 55, 52, 50, 47, 45, 43, 40, 38, 36, 34, 32, 30, 28, 26, 24, 22, 21, 19, 17, 16, 15, 13, 12, 11, 10, 8, 7, 6, 6, 5, 4, 3, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 5, 6, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 19, 21, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 43, 45, 47, 50, 52, 55, 57, 60, 63, 65, 68, 71, 74, 77, 79, 82, 85, 88, 91, 94, 97, 100, 103, 106, 109, 112, 116, 119, 122, 125};
  24. const char Triangle[] PROGMEM = {128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 255, 253, 251, 249, 247, 245, 243, 241, 239, 237, 235, 233, 231, 229, 227, 225, 223, 221, 219, 217, 215, 213, 211, 209, 207, 205, 203, 201, 199, 197, 195, 193, 191, 189, 187, 185, 183, 181, 179, 177, 175, 173, 171, 169, 167, 165, 163, 161, 159, 157, 155, 153, 151, 149, 147, 145, 143, 141, 139, 137, 135, 133, 131, 129, 127, 125, 123, 121, 119, 117, 115, 113, 111, 109, 107, 105, 103, 101, 99, 97, 95, 93, 91, 89, 87, 85, 83, 81, 79, 77, 75, 73, 71, 69, 67, 65, 63, 61, 59, 57, 55, 53, 51, 49, 47, 45, 43, 41, 39, 37, 35, 33, 31, 29, 27, 25, 23, 21, 19, 17, 15, 13, 11, 9, 7, 5, 3, 1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126 };
  25. const char Rampe[] PROGMEM = {128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127 };
  26. const char Carre[] PROGMEM = {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  27. const char Sinsom[] PROGMEM = {128, 133, 137, 142, 147, 151, 156, 160, 165, 169, 173, 178, 182, 186, 190, 193, 197, 201, 204, 208, 211, 214, 217, 219, 222, 224, 227, 229, 231, 232, 234, 235, 236, 237, 238, 239, 239, 240, 240, 240, 239, 239, 238, 238, 237, 236, 234, 233, 232, 230, 228, 226, 224, 222, 220, 217, 215, 212, 209, 206, 204, 201, 198, 195, 192, 188, 185, 182, 179, 176, 172, 169, 166, 163, 160, 157, 153, 150, 148, 145, 142, 139, 136, 134, 131, 129, 126, 124, 122, 120, 118, 116, 115, 113, 112, 111, 109, 108, 107, 107, 106, 105, 105, 105, 105, 105, 105, 105, 105, 106, 106, 107, 107, 108, 109, 110, 111, 112, 113, 115, 116, 117, 119, 120, 122, 123, 125, 126, 128, 130, 131, 133, 134, 136, 137, 139, 140, 141, 143, 144, 145, 146, 147, 148, 149, 149, 150, 150, 151, 151, 151, 151, 151, 151, 151, 151, 150, 149, 149, 148, 147, 145, 144, 143, 141, 140, 138, 136, 134, 132, 130, 127, 125, 122, 120, 117, 114, 111, 108, 106, 103, 99, 96, 93, 90, 87, 84, 80, 77, 74, 71, 68, 65, 61, 58, 55, 52, 50, 47, 44, 41, 39, 36, 34, 32, 30, 28, 26, 24, 23, 22, 20, 19, 18, 18, 17, 17, 16, 16, 16, 17, 17, 18, 19, 20, 21, 22, 24, 25, 27, 29, 32, 34, 37, 39, 42, 45, 48, 52, 55, 59, 63, 66, 70, 74, 78, 83, 87, 91, 96, 100, 105, 109, 114, 119, 123 };
  28. const char Ransom[] PROGMEM = {128, 130, 131, 133, 134, 136, 137, 139, 140, 142, 143, 145, 146, 148, 149, 151, 152, 154, 155, 157, 158, 160, 161, 163, 164, 166, 167, 169, 170, 172, 173, 175, 176, 178, 179, 181, 182, 184, 185, 187, 188, 190, 191, 193, 194, 196, 197, 199, 200, 202, 203, 205, 206, 208, 209, 211, 212, 214, 215, 217, 218, 220, 221, 223, 96, 98, 99, 101, 102, 104, 105, 107, 108, 110, 111, 113, 114, 116, 117, 119, 120, 122, 123, 125, 126, 128, 129, 131, 132, 134, 135, 137, 138, 140, 141, 143, 144, 146, 147, 149, 150, 152, 153, 155, 156, 158, 159, 161, 162, 164, 165, 167, 168, 170, 171, 173, 174, 176, 177, 179, 180, 182, 183, 185, 186, 188, 189, 191, 64, 66, 67, 69, 70, 72, 73, 75, 76, 78, 79, 81, 82, 84, 85, 87, 88, 90, 91, 93, 94, 96, 97, 99, 100, 102, 103, 105, 106, 108, 109, 111, 112, 114, 115, 117, 118, 120, 121, 123, 124, 126, 127, 129, 130, 132, 133, 135, 136, 138, 139, 141, 142, 144, 145, 147, 148, 150, 151, 153, 154, 156, 157, 159, 32, 34, 35, 37, 38, 40, 41, 43, 44, 46, 47, 49, 50, 52, 53, 55, 56, 58, 59, 61, 62, 64, 65, 67, 68, 70, 71, 73, 74, 76, 77, 79, 80, 82, 83, 85, 86, 88, 89, 91, 92, 94, 95, 97, 98, 100, 101, 103, 104, 106, 107, 109, 110, 112, 113, 115, 116, 118, 119, 121, 122, 124, 125, 127 };
  29.  
  30. // Choix fréquence du LFO
  31. const PROGMEM uint16_t Onde_Hz[] = {100, 102, 105, 107, 110, 112, 115, 117, 120, 122, 125, 127, 130, 132, 135, 137, 140, 142, 145, 147, 150, 152, 155, 157, 160, 162, 165, 168, 170, 173, 175, 178, 181, 183, 186, 188, 191, 194, 196, 199, 202, 204, 207, 209, 212, 215, 217, 220, 223, 226, 228, 231, 234, 236, 239, 242, 245, 247, 250, 253, 256, 258, 261, 264, 267, 269, 272, 275, 278, 281, 283, 286, 289, 292, 295, 298, 301, 303, 306, 309, 312, 315, 318, 321, 324, 327, 329, 332, 335, 338, 341, 344, 347, 350, 353, 356, 359, 362, 365, 368, 371, 374, 377, 380, 383, 386, 389, 393, 396, 399, 402, 405, 408, 411, 414, 417, 421, 424, 427, 430, 433, 436, 440, 443, 446, 449, 453, 456, 459, 462, 466, 469, 472, 475, 479, 482, 485, 489, 492, 495, 499, 502, 505, 509, 512, 516, 519, 522, 526, 529, 533, 536, 540, 543, 546, 550, 553, 557, 561, 564, 568, 571, 575, 578, 582, 585, 589, 593, 596, 600, 604, 607, 611, 615, 618, 622, 626, 629, 633, 637, 641, 644, 648, 652, 656, 660, 663, 667, 671, 675, 679, 683, 687, 690, 694, 698, 702, 706, 710, 714, 718, 722, 726, 730, 734, 738, 742, 746, 751, 755, 759, 763, 767, 771, 775, 780, 784, 788, 792, 797, 801, 805, 809, 814, 818, 822, 827, 831, 835, 840, 844, 849, 853, 858, 862, 867, 871, 876, 880, 885, 889, 894, 899, 903, 908, 912, 917, 922, 927, 931, 936, 941, 946, 950, 955, 960, 965, 970, 975, 980, 985, 990, 995, 1000, 1005, 1010, 1015, 1020, 1025, 1030, 1035, 1040, 1046, 1051, 1056, 1061, 1066, 1072, 1077, 1082, 1088, 1093, 1099, 1104, 1110, 1115, 1121, 1126, 1132, 1137, 1143, 1148, 1154, 1160, 1165, 1171, 1177, 1183, 1189, 1194, 1200, 1206, 1212, 1218, 1224, 1230, 1236, 1242, 1248, 1254, 1261, 1267, 1273, 1279, 1286, 1292, 1298, 1305, 1311, 1317, 1324, 1330, 1337, 1344, 1350, 1357, 1364, 1370, 1377, 1384, 1391, 1398, 1405, 1411, 1418, 1425, 1433, 1440, 1447, 1454, 1461, 1469, 1476, 1483, 1491, 1498, 1506, 1513, 1521, 1528, 1536, 1544, 1551, 1559, 1567, 1575, 1583, 1591, 1599, 1607, 1615, 1624, 1632, 1640, 1649, 1657, 1666, 1674, 1683, 1692, 1700, 1709, 1718, 1727, 1736, 1745, 1754, 1764, 1773, 1782, 1792, 1801, 1811, 1820, 1830, 1840, 1850, 1860, 1870, 1880, 1890, 1900, 1910, 1921, 1931, 1942, 1953, 1964, 1974, 1985, 1997, 2008, 2019, 2030, 2042, 2054, 2065, 2077, 2089, 2101, 2113, 2126, 2138, 2151, 2163, 2176, 2189, 2202, 2215, 2229, 2242, 2256, 2269, 2283, 2298, 2312, 2326, 2341, 2356, 2371, 2386, 2401, 2416, 2432, 2448, 2464, 2480, 2497, 2514, 2531, 2548, 2565, 2583, 2601, 2619, 2638, 2657, 2676, 2695, 2715, 2735, 2755, 2775, 2796, 2818, 2839, 2862, 2884, 2907, 2930, 2954, 2978, 3003, 3028, 3054, 3080, 3107, 3134, 3162, 3191, 3221, 3251, 3281, 3313, 3345, 3379, 3413, 3448, 3484, 3521, 3560, 3600, 3640, 3683, 3727, 3772, 3819, 3868, 3919, 3972, 4027, 4086, 4146, 4210, 4278, 4349, 4425, 4505, 4592, 4684, 4784, 4892, 5011, 5143, 5290, 5456, 5649, 5876, 6155, 6514, 7020, 8000};
  32.  
  33.  
  34. // Initialisation librairie LCD
  35.  
  36. LiquidCrystal lcd(7, 6, 5, 4, 3, 2);
  37.  
  38. // constantes hardware
  39.  
  40. const byte anaIn0 = A4;
  41. const byte anaIn1 = A2;
  42. const byte anaIn2 = A0;
  43.  
  44.  
  45. #define DATAOUT 11//MOSI
  46. #define DATAIN 12//MISO Pa sutilisé pour le moment
  47. #define SPICLOCK 13//sck
  48. #define DAC_0 10//ss
  49. #define DAC_1 9//ss un seul DAC pour le moment
  50.  
  51. #define GATE_0 8
  52. #define GATE_1 9
  53.  
  54.  
  55.  
  56.  
  57. // Allocation
  58.  
  59. #define MIDI_LENBUF 32
  60. #define MIDI_LENARP 8
  61. #define MIDI_LENSEQ 32
  62. #define MIDI_MOTIF 96
  63.  
  64.  
  65. // Gestion du temps
  66.  
  67.  
  68. int REF_1V = 895; // coorespondance DAC 1v/Oct
  69.  
  70. #define REF_CTRL 32
  71. #define REF_CMD_DELAY 200
  72.  
  73. unsigned long refTime;
  74. unsigned long deltaTime;
  75. unsigned long nextTime;
  76. unsigned long nextGate;
  77. unsigned long refCmd;
  78. unsigned long depTime;
  79.  
  80.  
  81.  
  82. // Gestion des modes
  83.  
  84. char buf[16];
  85. char p_buffer[20];
  86. #define P(str) (strcpy_P(p_buffer, PSTR(str)), p_buffer)
  87.  
  88.  
  89.  
  90. #define MODE_MODE 0
  91. #define MODE_REGLAGE 1
  92.  
  93.  
  94. byte mode_reglage = MODE_MODE;
  95.  
  96. #define NB_MENU_REGLAGE 10
  97.  
  98. const char m_Reglage_0[] PROGMEM = "ACCORD";
  99. const char m_Reglage_1[] PROGMEM = "+-SEMI";
  100. const char m_Reglage_2[] PROGMEM = "+-BEND";
  101. const char m_Reglage_3[] PROGMEM = "KEYTRA";
  102. const char m_Reglage_4[] PROGMEM = "1 VOLT";
  103. const char m_Reglage_5[] PROGMEM = "GATE/X";
  104. const char m_Reglage_6[] PROGMEM = "CHNL";
  105. const char m_Reglage_7[] PROGMEM = "CLK";
  106. const char m_Reglage_8[] PROGMEM = "MUTVEL";
  107. const char m_Reglage_9[] PROGMEM = "EEPROM";
  108.  
  109. const char * const menu_Reglage[] PROGMEM = {
  110. m_Reglage_0,
  111. m_Reglage_1,
  112. m_Reglage_2,
  113. m_Reglage_3,
  114. m_Reglage_4,
  115. m_Reglage_5,
  116. m_Reglage_6,
  117. m_Reglage_7,
  118. m_Reglage_8,
  119. m_Reglage_9 };
  120.  
  121. /*
  122. char *Menu_Reglage[] = { "+-SEMI",
  123. "+-OCTA",
  124. "+-BEND",
  125. "KEYTRA",
  126. "1 VOLT",
  127. "GATE/X",
  128. "MIDCHA",
  129. "MIDCLK",
  130. "MUTVEL",
  131. "EEPROM"};
  132. */
  133.  
  134. #define REGLE_ACCORD 0
  135. #define REGLE_DEMIT 1
  136. #define REGLE_BEND 2
  137. #define REGLE_DECAL 3
  138. #define REGLE_REF1V 4
  139. #define REGLE_GATECLK 5
  140. #define REGLE_MIDI 6
  141. #define REGLE_CLOCK 7
  142. #define REGLE_VELMUT 8
  143. #define REGLE_EEPROM 9
  144.  
  145. #define NB_MENU_MODE 8
  146.  
  147. const char m_Mode_0[] PROGMEM = "SIMPLE";
  148. const char m_Mode_1[] PROGMEM = "LEGATO";
  149. const char m_Mode_2[] PROGMEM = "DUAL";
  150. const char m_Mode_3[] PROGMEM = "SPLIT";
  151. const char m_Mode_4[] PROGMEM = "ARP";
  152. const char m_Mode_5[] PROGMEM = "ARP/SU";
  153. const char m_Mode_6[] PROGMEM = "ARP/TR";
  154. const char m_Mode_7[] PROGMEM = "SEQUEN";
  155.  
  156. const char * const menu_Mode[] PROGMEM = {
  157. m_Mode_0,
  158. m_Mode_1,
  159. m_Mode_2,
  160. m_Mode_3,
  161. m_Mode_4,
  162. m_Mode_5,
  163. m_Mode_6,
  164. m_Mode_7 };
  165. /*
  166. char *Menu_Mode[] = { "SIMPLE",
  167. "REGATE",
  168. "DUAL",
  169. "SPLIT",
  170. "ARP",
  171. "SUS",
  172. "TRANS",
  173. "SEQ" };
  174. */
  175. byte gen_Reglage = REGLE_DEMIT;
  176. byte old_Reglage = REGLE_DEMIT;
  177.  
  178. #define MODE_MONO 0
  179. #define MODE_RETRIG 1
  180. #define MODE_DUO 2
  181. #define MODE_SPLIT 3
  182. #define MODE_ARPEGE 4
  183. #define MODE_ARPEGE_SUST 5
  184. #define MODE_ARPEGE_TRANS 6
  185. #define MODE_SEQUENCER 7
  186.  
  187. byte gen_Mode = MODE_MONO;
  188. byte old_Mode = MODE_MONO;
  189.  
  190.  
  191. // Gestion des controleur
  192.  
  193. #define NB_MENU_CTRL 6
  194. #define NB_MENU_CTRL_RED 2
  195. #define NB_MENU_VELMUT 5
  196.  
  197. const char m_Ctrl_0[] PROGMEM = "VEL";
  198. const char m_Ctrl_1[] PROGMEM = "EXP";
  199. const char m_Ctrl_2[] PROGMEM = "EXPxVEL";
  200. const char m_Ctrl_3[] PROGMEM = "LFO";
  201. const char m_Ctrl_4[] PROGMEM = "LFOxVEL";
  202. const char m_Ctrl_5[] PROGMEM = "LFOxEXP";
  203. const char m_Ctrl_6[] PROGMEM = "OFF";
  204. const char m_Ctrl_7[] PROGMEM = "MUTE";
  205. const char m_Ctrl_8[] PROGMEM = "MUTEXP";
  206.  
  207. const char * const menu_Ctrl[] PROGMEM = {
  208. m_Ctrl_0,
  209. m_Ctrl_1,
  210. m_Ctrl_2,
  211. m_Ctrl_3,
  212. m_Ctrl_4,
  213. m_Ctrl_5};
  214.  
  215. const char * const menu_Ctrl_Red[] PROGMEM = {
  216. m_Ctrl_6,
  217. m_Ctrl_1 };
  218.  
  219. const char * const menu_Velmut[] PROGMEM = {
  220. m_Ctrl_6,
  221. m_Ctrl_0,
  222. m_Ctrl_1,
  223. m_Ctrl_7,
  224. m_Ctrl_8};
  225.  
  226. /*
  227. char *Menu_Ctrl[] = { "VEL",
  228. "EXP",
  229. "EXPxVEL",
  230. "LFO",
  231. "LFOxVEL",
  232. "LFOxEXP" };
  233. */
  234. #define MODE_CTRL_VEL 0
  235. #define MODE_CTRL_EXP 1
  236. #define MODE_CTRL_EXPVEL 2
  237. #define MODE_CTRL_LFO 3
  238. #define MODE_CTRL_LFOVEL 4
  239. #define MODE_CTRL_LFOEXP 5
  240.  
  241.  
  242. byte gen_Ctrl = MODE_CTRL_VEL;
  243. int gen_CtrlPc = 100; // 0-100
  244. int old_CtrlPc = 100; // 0-100
  245. byte gen_Last_Ctrl = 0;
  246. byte gen_Last_Velo = 0;
  247. // Gestion du LFO
  248.  
  249. #define NB_ONDE 8
  250.  
  251. byte gen_Onde = 0;
  252. int gen_Rand = 128;
  253. int cycle_Rand = 300;
  254. char inc_Rand = 0;
  255. int gen_OndeHz = 998;
  256. int old_OndeHz = 998;
  257. const char m_Onde_0[] PROGMEM = "SIN";
  258. const char m_Onde_1[] PROGMEM = "TRI";
  259. const char m_Onde_2[] PROGMEM = "SAW";
  260. const char m_Onde_3[] PROGMEM = "SQR";
  261. const char m_Onde_4[] PROGMEM = "2SIN";
  262. const char m_Onde_5[] PROGMEM = "2SAW";
  263. const char m_Onde_6[] PROGMEM = "RAND";
  264. const char m_Onde_7[] PROGMEM = "ALIEN";
  265.  
  266. const char * const menu_Onde[] PROGMEM = {
  267. m_Onde_0,
  268. m_Onde_1,
  269. m_Onde_2,
  270. m_Onde_3,
  271. m_Onde_4,
  272. m_Onde_5,
  273. m_Onde_6,
  274. m_Onde_7};
  275.  
  276. /*
  277. char *Menu_Onde[] = { "SIN",
  278. "TRI",
  279. "SAW",
  280. "SQR",
  281. "2SIN",
  282. "2SAW"};
  283. */
  284.  
  285.  
  286. // Gestion du Bend
  287.  
  288. char gen_Pitch = 2;
  289. int midi_Pitch_Value = 0;
  290.  
  291.  
  292.  
  293. // Gestion midi
  294.  
  295. char gen_Midi=0;
  296. char gen_Clock=0;
  297. char gen_Clock_State=0;
  298. char gen_Cpt_Clock=0;
  299. char gen_Midi_Gate=0;
  300. char gen_VelMute=0;
  301. char ref_VelMute=48;
  302. char gen_GateClk=4;
  303. char cpt_gate=0;
  304.  
  305. // Gestion de la transposition générale
  306.  
  307. char gen_Transpose = 0 ;
  308. char gen_Accord = 0;
  309. char gen_Decalage = 24 ;
  310.  
  311. // Gestion du tempo
  312.  
  313. int gen_Tempo = 120 ;
  314. int old_Tempo = 120 ;
  315. int cycle = 60000 / 120;
  316.  
  317. // Gestion des notes
  318.  
  319. char *Note[] = { "C","C#","D","D#","E","F","F#","G","G#","A","A#","B" };
  320. byte gen_Split = 48;
  321. boolean init_Dual=false;
  322.  
  323.  
  324. // Gestion du Buffer Midi
  325.  
  326.  
  327. typedef struct {
  328. byte Etat;
  329. byte Note;
  330. byte Expr;
  331. unsigned long rTime;
  332. } BufMidi;
  333.  
  334. BufMidi bMidi[MIDI_LENBUF];
  335.  
  336. int gen_Midi_Max = 0;
  337.  
  338.  
  339. // Gestion des motif / Arpège / Sequence
  340.  
  341. typedef struct {
  342. char *nom;
  343. byte octave;
  344. byte sens;
  345. } Sch_Motif;
  346.  
  347. #define NB_MOTIF 23
  348. Sch_Motif lMotif[]={
  349. {"Up1",1,0},
  350. {"Up2",2,0},
  351. {"Up3",3,0},
  352. {"Dw1",1,1},
  353. {"Dw2",2,1},
  354. {"Dw3",3,1},
  355. {"UD1",1,2},
  356. {"UD2",2,2},
  357. {"UD3",3,2},
  358. {"Ran1",1,4},
  359. {"Ran2",2,4},
  360. {"Ran3",3,4},
  361. {"Rnb1",1,5},
  362. {"Rnb2",2,5},
  363. {"Rnb3",3,5},
  364. {"Pro1",1,3},
  365. {"Pro2",2,3},
  366. {"Cov1",1,6},
  367. {"Cov2",2,6},
  368. {"Low1",1,7},
  369. {"Low2",2,7},
  370. {"Hig1",1,8},
  371. {"Hig2",2,8}};
  372.  
  373. byte ord_Motif[MIDI_LENARP];
  374. byte Motif[MIDI_MOTIF];
  375. byte temp_Motif[MIDI_MOTIF];
  376. char gen_Motif = 0;
  377. char old_Motif = 0;
  378. char pos_Motif = 0;
  379. char max_Motif = 0;
  380. char max_Order_Motif = 0;
  381. boolean doit_Reconstruit_Motif;
  382.  
  383. boolean is_Recorder=true;
  384. char pos_Recorder=0;
  385. char ref_Arpege_Trans=0;
  386.  
  387.  
  388. // Gestion LCD
  389.  
  390. char tmpCh[30];
  391.  
  392. #define Z0 0
  393. #define Z1 1
  394. #define Z2 2
  395. #define Z3 3
  396. #define Z4 4
  397. #define Z5 5
  398.  
  399. char *zVide = "";
  400.  
  401. byte ZL[]= {7, 7, 6, 7, 7, 6};
  402. byte ZPOS[]= {1, 8, 14, 1, 8, 14};
  403. byte ZLIN[]= {0, 0, 0, 1, 1, 1};
  404.  
  405. void str_LCD(int Zn, char *value)
  406. {
  407. char buf[16];
  408. byte cpt=0;
  409. while ( value[cpt] && cpt < ZL[Zn] ) {
  410. buf[cpt]=value[cpt];
  411. cpt++;
  412. }
  413. while ( cpt < ZL[Zn] ) buf[cpt++]=32;
  414. buf[cpt++]=0;
  415. lcd.setCursor(ZPOS[Zn],ZLIN[Zn]);
  416. lcd.print(buf);
  417. }
  418.  
  419. void progmem_LCD(int Zn, char *Adress)
  420. {
  421. strcpy_P(tmpCh, Adress);
  422. str_LCD(Zn, tmpCh);
  423. }
  424.  
  425. void int_LCD(int Zn, int value)
  426. {
  427. sprintf(tmpCh,"%d",value);
  428. str_LCD(Zn, tmpCh);
  429. }
  430.  
  431. void sign_LCD(int Zn, int value)
  432. {
  433. if (value>0)
  434. sprintf(tmpCh,"+%d",value);
  435. else
  436. sprintf(tmpCh,"%d",value);
  437. str_LCD(Zn, tmpCh);
  438. }
  439.  
  440. void trans_LCD(int Zn, int value)
  441. {
  442. if (value>0)
  443. sprintf(tmpCh,"TR=+%d",value);
  444. else
  445. sprintf(tmpCh,"TR=%d",value);
  446. str_LCD(Zn, tmpCh);
  447. }
  448.  
  449. void pc_LCD(int Zn, int value)
  450. {
  451. sprintf(tmpCh,"%d%%",value);
  452. str_LCD(Zn, tmpCh);
  453. }
  454.  
  455. void hz_LCD(int Zn, int value)
  456. {
  457. float temp = 1000.0 / value;
  458. int temp1 = (temp - (int)temp) * 100;
  459. sprintf(tmpCh,"%d.%d Hz", (int)temp, temp1 );
  460. str_LCD(Zn, tmpCh);
  461.  
  462. }
  463.  
  464. void tempo_LCD(int Zn, int value)
  465. {
  466. if (gen_Clock==0)
  467. sprintf(tmpCh,"%d BPM", value );
  468. else
  469. strcpy(tmpCh,P("EXT."));
  470. str_LCD(Zn, tmpCh);
  471. }
  472.  
  473. void note_LCD(int Zn, byte value)
  474. {
  475. sprintf(tmpCh,"%s%d", Note[ (value % 12 ) ], (value/12) + 1 );
  476. str_LCD(Zn, tmpCh);
  477. }
  478.  
  479.  
  480. void midi_LCD(int Zn, int value)
  481. {
  482. switch(value)
  483. {
  484. case 0:
  485. str_LCD(Zn, P("OMNI"));break;
  486. case 17:
  487. str_LCD(Zn, P("OFF"));break;
  488. default:
  489. int_LCD(Zn, value);break;
  490. }
  491. }
  492.  
  493. byte clock_Div[]={0, 6 , 8 , 12 , 24};
  494.  
  495. void clock_LCD(int Zn, int value)
  496. {
  497. switch(value)
  498. {
  499. case 0:
  500. str_LCD(Zn, P("INT"));break;
  501. case 1:
  502. str_LCD(Zn, P("EXT/6"));break;
  503. case 2:
  504. str_LCD(Zn, P("EXT/8"));break;
  505. case 3:
  506. str_LCD(Zn, P("EXT/12"));break;
  507. case 4:
  508. str_LCD(Zn, P("EXT/24"));break;
  509. }
  510. }
  511.  
  512. void onoff_LCD(int Zn, int value)
  513. {
  514. switch(value)
  515. {
  516. case 0:
  517. str_LCD(Zn, P("OFF") );break;
  518. default:
  519. int_LCD(Zn, value);break;
  520. }
  521. }
  522.  
  523. void div_LCD(int Zn, int value)
  524. {
  525. sprintf(tmpCh,"1/%d", value);
  526. str_LCD(Zn, tmpCh);
  527. }
  528.  
  529. void pos_LCD(int Zn, int value)
  530. {
  531. sprintf(tmpCh,"%d/%d", value + 1, MIDI_LENSEQ );
  532. str_LCD(Zn, tmpCh);
  533. }
  534.  
  535. // Gestion des boutons
  536.  
  537. #define REF_BTN_ON 800
  538.  
  539. typedef struct {
  540. byte Port;
  541. byte Etat;
  542. byte Autorepet;
  543. } Sch_Btn;
  544.  
  545. Sch_Btn btn[] = {
  546. {A5,0,0},
  547. {A3,0,0},
  548. {A1,0,0}
  549. };
  550.  
  551. void ScanBtn()
  552. {
  553.  
  554.  
  555. for (int numBtn=0;numBtn<3;numBtn++)
  556. {
  557. int bVal = analogRead( btn[numBtn].Port );
  558. if (bVal > REF_BTN_ON)
  559. {
  560. if ( btn[numBtn].Etat == 0 )
  561. btn[numBtn].Etat = 1;
  562.  
  563. }
  564. else
  565. {
  566. if ( btn[numBtn].Etat > 0 )
  567. btn[numBtn].Etat = 0;
  568. }
  569. }
  570. }
  571.  
  572. boolean BtnTest(int numBtn, boolean autoRepet)
  573. {
  574. if (autoRepet && btn[numBtn].Etat == 2)
  575. {
  576. btn[numBtn].Autorepet--;
  577. if (btn[numBtn].Autorepet==0) btn[numBtn].Etat = 1;
  578. }
  579. boolean ret = (btn[numBtn].Etat == 1 );
  580. if ( ret )
  581. {
  582. btn[numBtn].Autorepet=2;
  583. btn[numBtn].Etat=2;
  584. }
  585. return ret;
  586. }
  587.  
  588.  
  589. // Fonctions EEPROM
  590.  
  591. void EEPROM_writeInt(int ee, int value)
  592. {
  593. byte* p = (byte*)(void*)&value;
  594. for (int i = 0; i < sizeof(value); i++)
  595. EEPROM.write(ee++, *p++);
  596. }
  597.  
  598. int EEPROM_readInt(int ee, int ref)
  599. {
  600. int value = 0;
  601. byte* p = (byte*)(void*)&value;
  602. if ( (byte)EEPROM.read(ee+1) == (byte)255 ) return ref;
  603. for (int i = 0; i < sizeof(value); i++)
  604. *p++ = EEPROM.read(ee++);
  605. return value;
  606. }
  607.  
  608.  
  609. // Fonction TRI
  610. void irsort(byte *a, int n)
  611. {
  612. for (int i = 1; i < n; ++i)
  613. {
  614. int j = a[i];
  615. int k;
  616. for (k = i - 1; (k >= 0) && (j > a[k]); k--)
  617. {
  618. a[k + 1] = a[k];
  619. }
  620. a[k + 1] = j;
  621. }
  622. }
  623.  
  624. void isort(byte *a, int n)
  625. {
  626. for (int i = 1; i < n; ++i)
  627. {
  628. int j = a[i];
  629. int k;
  630. for (k = i - 1; (k >= 0) && (j < a[k]); k--)
  631. {
  632. a[k + 1] = a[k];
  633. }
  634. a[k + 1] = j;
  635. }
  636. }
  637.  
  638. // Fonction de construction du motif
  639.  
  640. void Reconstruit_Motif(byte reord)
  641. {
  642. int tmp_max_Motif;
  643.  
  644. if ( reord == 1 )
  645. {
  646. max_Order_Motif=0;
  647. for ( int ct = 0; ct < gen_Midi_Max;ct++ )
  648. {
  649. if ( bMidi[ct].Etat >= 1 )
  650. {
  651. ord_Motif[max_Order_Motif++] = bMidi[ct].Note;
  652. }
  653. }
  654. isort(ord_Motif,max_Order_Motif);
  655. doit_Reconstruit_Motif = false;
  656. }
  657. max_Motif=0;
  658. tmp_max_Motif=0;
  659.  
  660. switch( lMotif[gen_Motif].sens )
  661. {
  662. case 0:
  663. for (int oct=0 ; oct < lMotif[gen_Motif].octave ; oct++)
  664. {
  665. for (int note=0 ; note<max_Order_Motif ; note++)
  666. {
  667. Motif[max_Motif++]= ord_Motif[note] + oct * 12;
  668. if ( max_Motif >= MIDI_MOTIF ) break;
  669. }
  670. }
  671. break;
  672.  
  673. case 1:
  674. for (int oct=0 ; oct < lMotif[gen_Motif].octave ; oct++)
  675. {
  676. for (int note=0 ; note<max_Order_Motif ; note++)
  677. {
  678. Motif[max_Motif++]= ord_Motif[max_Order_Motif - note - 1] + ( lMotif[gen_Motif].octave - oct - 1) * 12;
  679. if ( max_Motif >= MIDI_MOTIF ) break;
  680. }
  681. }
  682. break;
  683.  
  684.  
  685. case 2:
  686. for (int oct=0 ; oct < lMotif[gen_Motif].octave ; oct++)
  687. {
  688. for (int note=0 ; note<max_Order_Motif ; note++)
  689. {
  690. Motif[max_Motif++]=ord_Motif[note] + oct * 12;
  691. if ( max_Motif >= MIDI_MOTIF ) break;
  692. }
  693. }
  694. max_Motif--; // pour éviter la redondance;
  695. for (int oct=0 ; oct < lMotif[gen_Motif].octave ; oct++)
  696. {
  697. for (int note=0 ; note < max_Order_Motif ; note++)
  698. {
  699. Motif[max_Motif++]=ord_Motif[max_Order_Motif - note - 1] + ( lMotif[gen_Motif].octave - oct - 1) * 12;
  700. if ( max_Motif >= MIDI_MOTIF ) break;
  701. }
  702. }
  703. max_Motif--; // pour éviter la redondance;
  704. break;
  705.  
  706. case 12:
  707. for (int oct=0 ; oct < lMotif[gen_Motif].octave ; oct++)
  708. {
  709. for (int note=0 ; note<max_Order_Motif ; note++)
  710. {
  711. Motif[max_Motif++]=ord_Motif[max_Order_Motif - note - 1] + ( lMotif[gen_Motif].octave - oct - 1) * 12;
  712. if ( max_Motif >= MIDI_MOTIF ) break;
  713. }
  714. }
  715. max_Motif--; // pour éviter la redondance;
  716. for (int oct=0 ; oct < lMotif[gen_Motif].octave ; oct++)
  717. {
  718. for (int note=0 ; note < max_Order_Motif ; note++)
  719. {
  720. Motif[max_Motif++]=ord_Motif[note] + oct * 12;
  721. if ( max_Motif >= MIDI_MOTIF ) break;
  722. }
  723. }
  724. max_Motif--; // pour éviter la redondance;
  725. break;
  726.  
  727.  
  728. case 3:
  729. for (int oct=0 ; oct < lMotif[gen_Motif].octave ; oct++)
  730. {
  731. for (int note=0 ; note<max_Order_Motif ; note++)
  732. {
  733. temp_Motif[tmp_max_Motif++]=ord_Motif[note] + oct * 12;
  734. if ( tmp_max_Motif >= MIDI_MOTIF ) break;
  735. }
  736. }
  737. // AJoute la premiere note un octave plus haut
  738. if ( tmp_max_Motif < MIDI_MOTIF )
  739. temp_Motif[tmp_max_Motif++] = ord_Motif[0] + lMotif[gen_Motif].octave * 12;
  740.  
  741. for (int bar = 0 ; bar < tmp_max_Motif - max_Order_Motif + 1 ; bar++)
  742. {
  743. for (int bar1 = 0 ; bar1 < max_Order_Motif ; bar1++)
  744. {
  745. Motif[max_Motif++] = temp_Motif[bar+bar1];
  746. if ( max_Motif >= MIDI_MOTIF ) break;
  747. }
  748. if ( max_Motif >= MIDI_MOTIF ) break;
  749. }
  750.  
  751. break;
  752.  
  753. case 4:
  754. case 5:
  755. for (int oct=0 ; oct < lMotif[gen_Motif].octave ; oct++)
  756. {
  757. for (int note=0 ; note<max_Order_Motif ; note++)
  758. {
  759. Motif[max_Motif++]=ord_Motif[note] + oct * 12;
  760. if ( max_Motif >= MIDI_MOTIF ) break;
  761. }
  762. }
  763.  
  764. for (int bar = 0 ; bar < max_Motif ; bar++)
  765. {
  766. int pos = random(bar,max_Motif);
  767. tmp_max_Motif = Motif[bar];
  768. Motif[bar]=Motif[pos];
  769. Motif[pos]=tmp_max_Motif;
  770. }
  771.  
  772. break;
  773.  
  774. case 6:
  775. for (int oct=0 ; oct < lMotif[gen_Motif].octave ; oct++)
  776. {
  777. for (int note=0 ; note<max_Order_Motif ; note++)
  778. {
  779. temp_Motif[tmp_max_Motif++]=ord_Motif[note] + oct * 12;
  780. if ( tmp_max_Motif >= MIDI_MOTIF ) break;
  781. }
  782. }
  783. {
  784. int bar=0; int bar1=tmp_max_Motif-1;
  785. while (bar <= bar1)
  786. {
  787. Motif[max_Motif++] = temp_Motif[bar];
  788. Motif[max_Motif++] = temp_Motif[bar1];
  789. bar++;
  790. bar1--;
  791. if ( max_Motif >= MIDI_MOTIF ) break;
  792. }
  793. }
  794. break;
  795.  
  796. case 7:
  797. for (int oct=0 ; oct < lMotif[gen_Motif].octave ; oct++)
  798. {
  799. for (int note=0 ; note<max_Order_Motif ; note++)
  800. {
  801. temp_Motif[tmp_max_Motif++]=ord_Motif[note] + oct * 12;
  802. if ( tmp_max_Motif >= MIDI_MOTIF ) break;
  803. }
  804. }
  805. {
  806. int bar=0; int bar1=1;
  807. while (bar1 < tmp_max_Motif)
  808. {
  809. Motif[max_Motif++] = temp_Motif[bar];
  810. Motif[max_Motif++] = temp_Motif[bar1];
  811. bar1++;
  812. if ( max_Motif >= MIDI_MOTIF ) break;
  813. }
  814. }
  815. break;
  816.  
  817. case 8:
  818. for (int oct=0 ; oct < lMotif[gen_Motif].octave ; oct++)
  819. {
  820. for (int note=0 ; note<max_Order_Motif ; note++)
  821. {
  822. temp_Motif[tmp_max_Motif++]=ord_Motif[note] + oct * 12;
  823. if ( tmp_max_Motif >= MIDI_MOTIF ) break;
  824. }
  825. }
  826. {
  827. int bar=tmp_max_Motif-1; int bar1=tmp_max_Motif-2;
  828. while (bar1 >= 0)
  829. {
  830. Motif[max_Motif++] = temp_Motif[bar];
  831. Motif[max_Motif++] = temp_Motif[bar1];
  832. bar1--;
  833. if ( max_Motif >= MIDI_MOTIF ) break;
  834. }
  835. }
  836. break;
  837.  
  838. }
  839.  
  840. if ( pos_Motif >= max_Motif) pos_Motif=0;
  841. }
  842.  
  843.  
  844. // ------------------
  845. // Conversion Note tension
  846. // ------------------
  847.  
  848. void p_CV(byte port, int pitch)
  849. {
  850. if (pitch < gen_Decalage ) return;
  851.  
  852. if ( gen_Pitch > 0 && mode_reglage == MODE_MODE )
  853. {
  854. dac_Out(port, (long)REF_1V * ( pitch - gen_Decalage + gen_Transpose ) / 12 + midi_Pitch_Value + gen_Accord) ;
  855. }
  856. else
  857. dac_Out(port, (long)REF_1V * ( pitch - gen_Decalage + gen_Transpose ) / 12 + gen_Accord);
  858. }
  859.  
  860.  
  861. // ------------------
  862. // Ecriture d'un Gate sur Out
  863. // ------------------
  864.  
  865. void p_GATE(byte port, byte Etat)
  866. {
  867.  
  868. switch(port)
  869. {
  870. case 0:
  871. digitalWrite(GATE_0, Etat);
  872. break;
  873. case 1:
  874. digitalWrite(GATE_1, Etat);
  875. break;
  876. }
  877. }
  878.  
  879. // ------------------
  880. // Initialisation Mode MIDI et nettoyage buffer
  881. // ------------------
  882.  
  883. void maj_Ecran()
  884. {
  885. if ( mode_reglage == MODE_MODE )
  886. {
  887. trans_LCD( Z0, gen_Transpose);
  888. progmem_LCD( Z3, (char*)pgm_read_word(&(menu_Mode[gen_Mode])));
  889. switch(gen_Mode)
  890. {
  891. case MODE_MONO:
  892. case MODE_RETRIG:
  893. progmem_LCD( Z1, (char*)pgm_read_word(&(menu_Onde[gen_Onde])));
  894. progmem_LCD( Z2, (char*)pgm_read_word(&(menu_Ctrl[gen_Ctrl])));
  895. hz_LCD( Z4, gen_OndeHz );
  896. pc_LCD( Z5, gen_CtrlPc );
  897. old_OndeHz = map( analogRead(anaIn1) ,0 , 1023 , 511 , 0);
  898. old_OndeHz = pgm_read_word_near(Onde_Hz + old_OndeHz);
  899. old_CtrlPc = map( analogRead(anaIn2) ,0 , 1023 , 0 , 100);
  900. break;
  901. case MODE_DUO:
  902. str_LCD( Z1, zVide );
  903. str_LCD( Z2, zVide );
  904. str_LCD( Z4, zVide );
  905. str_LCD( Z5, zVide );
  906. break;
  907. case MODE_SPLIT:
  908. note_LCD( Z1, gen_Split );
  909. str_LCD( Z2, zVide );
  910. str_LCD( Z4, zVide );
  911. str_LCD( Z5, zVide );
  912. break;
  913. case MODE_ARPEGE:
  914. str_LCD( Z1, zVide );
  915. progmem_LCD( Z2, (char*)pgm_read_word(&(menu_Ctrl_Red[gen_Ctrl])));
  916. str_LCD( Z4, lMotif[gen_Motif].nom );
  917. tempo_LCD( Z5, gen_Tempo );
  918. old_Tempo = map( analogRead(anaIn2) ,0 , 1023 , 20 , 1000);
  919. old_Motif = map( analogRead(anaIn1) ,0 , 1023 , 0 , NB_MOTIF -1 );
  920. break;
  921. case MODE_ARPEGE_SUST:
  922. str_LCD( Z1, P("CLEAR") );
  923. progmem_LCD( Z2, (char*)pgm_read_word(&(menu_Ctrl_Red[gen_Ctrl])));
  924. str_LCD( Z4, lMotif[gen_Motif].nom );
  925. tempo_LCD( Z5, gen_Tempo );
  926. old_Tempo = map( analogRead(anaIn2) ,0 , 1023 , 20 , 1000);
  927. old_Motif = map( analogRead(anaIn1) ,0 , 1023 , 0 , NB_MOTIF -1 );
  928. break;
  929. case MODE_ARPEGE_TRANS:
  930. if (is_Recorder)
  931. {
  932. str_LCD( Z1, P("REC") );
  933. }
  934. else
  935. {
  936. str_LCD( Z1, P("PLAY") );
  937. }
  938. progmem_LCD( Z2, (char*)pgm_read_word(&(menu_Ctrl_Red[gen_Ctrl])));
  939. str_LCD( Z4, lMotif[gen_Motif].nom );
  940. tempo_LCD( Z5, gen_Tempo );
  941. old_Tempo = map( analogRead(anaIn2) ,0 , 1023 , 20 , 1000);
  942. old_Motif = map( analogRead(anaIn1) ,0 , 1023 , 0 , NB_MOTIF -1 );
  943. break;
  944. case MODE_SEQUENCER:
  945. if (is_Recorder)
  946. {
  947. str_LCD( Z1, P("REC") );
  948. pos_LCD( Z2, pos_Recorder );
  949. }
  950. else
  951. {
  952. str_LCD( Z1, P("PLAY") );
  953. progmem_LCD( Z2, (char*)pgm_read_word(&(menu_Velmut[gen_VelMute])));
  954. }
  955. str_LCD( Z4, lMotif[gen_Motif].nom );
  956. tempo_LCD( Z5, gen_Tempo );
  957. break;
  958. }
  959. }
  960. else
  961. {
  962.  
  963. if ( gen_Reglage != REGLE_EEPROM )
  964. {
  965. str_LCD( Z0, P("ESC") );
  966. str_LCD( Z1, P("-") );
  967. str_LCD( Z2, P("+") );
  968. progmem_LCD( Z3, (char*)pgm_read_word(&(menu_Reglage[gen_Reglage])));
  969. str_LCD( Z4, zVide );
  970. }
  971. switch(gen_Reglage)
  972. {
  973. case REGLE_DEMIT:
  974. sign_LCD( Z5, gen_Transpose );
  975. break;
  976. case REGLE_ACCORD:
  977. sign_LCD( Z5, gen_Accord );
  978. break;
  979. case REGLE_BEND:
  980. onoff_LCD( Z5, gen_Pitch );
  981. break;
  982. case REGLE_DECAL:
  983. int_LCD( Z5, gen_Decalage );
  984. break;
  985. case REGLE_REF1V:
  986. int_LCD( Z5, REF_1V );
  987. break;
  988. case REGLE_MIDI:
  989. midi_LCD( Z5, gen_Midi );
  990. break;
  991. case REGLE_GATECLK:
  992. div_LCD( Z5, gen_GateClk );
  993. break;
  994. case REGLE_CLOCK:
  995. clock_LCD( Z5, gen_Clock );
  996. break;
  997. case REGLE_VELMUT:
  998. int_LCD( Z5, ref_VelMute );
  999. break;
  1000. case REGLE_EEPROM:
  1001. str_LCD( Z0, P("ESC") );
  1002. str_LCD( Z1, P("READ") );
  1003. str_LCD( Z2, P("WRITE") );
  1004. progmem_LCD( Z3, (char*)pgm_read_word(&(menu_Reglage[gen_Reglage])));
  1005. str_LCD( Z5, zVide );
  1006. str_LCD( Z4, zVide );
  1007. break;
  1008. }
  1009. }
  1010. }
  1011.  
  1012.  
  1013. void clear_Buf()
  1014. {
  1015. for (int ct=0;ct<MIDI_LENBUF;ct++)
  1016. {
  1017. bMidi[ct].Etat=0;
  1018. bMidi[ct].Note=0;
  1019. }
  1020. p_GATE(0,LOW);
  1021. p_GATE(1,LOW);
  1022. dac_Out(1,0);
  1023.  
  1024. randomSeed(millis());
  1025. pos_Recorder = 0;
  1026. pos_Motif=0;
  1027. Reconstruit_Motif(1);
  1028.  
  1029.  
  1030. if ( mode_reglage == MODE_MODE )
  1031. {
  1032. switch(gen_Mode)
  1033. {
  1034. case MODE_MONO:
  1035. gen_Midi_Max=1;
  1036. break;
  1037.  
  1038. case MODE_RETRIG:
  1039. gen_Midi_Max=1;
  1040. break;
  1041. case MODE_DUO:
  1042. gen_Midi_Max=2;
  1043. break;
  1044. case MODE_SPLIT:
  1045. gen_Midi_Max=2;
  1046. break;
  1047. case MODE_ARPEGE:
  1048. gen_Midi_Max=MIDI_LENARP;
  1049. if (gen_Ctrl>=NB_MENU_CTRL_RED) gen_Ctrl=0;
  1050. break;
  1051. case MODE_ARPEGE_SUST:
  1052. gen_Midi_Max=MIDI_LENARP;
  1053. if (gen_Ctrl>=NB_MENU_CTRL_RED) gen_Ctrl=0;
  1054. break;
  1055. case MODE_ARPEGE_TRANS:
  1056. is_Recorder=true;
  1057. gen_Midi_Max=MIDI_LENARP;
  1058. if (gen_Ctrl>=NB_MENU_CTRL_RED) gen_Ctrl=0;
  1059. break;
  1060. case MODE_SEQUENCER:
  1061. is_Recorder=true;
  1062. gen_Midi_Max=MIDI_LENARP;
  1063. break;
  1064. }
  1065. }
  1066.  
  1067. maj_Ecran();
  1068.  
  1069. }
  1070.  
  1071.  
  1072.  
  1073. // ------------------
  1074. // Callback Midi PitchBend
  1075. // ------------------
  1076.  
  1077. void HandlePitchBend(byte channel, int bend)
  1078. {
  1079. if (gen_Pitch>0) {
  1080. midi_Pitch_Value = ( (long)bend * REF_1V * gen_Pitch / 12 ) / 8192;
  1081. if ( gen_Mode < MODE_ARPEGE )
  1082. for (int ct=0 ; ct<gen_Midi_Max ; ct++ ) p_CV(ct , bMidi[ct].Note);
  1083. }
  1084. }
  1085.  
  1086. // ------------------
  1087. // Callback Midi NOte On
  1088. // ------------------
  1089.  
  1090. void HandleNoteOn(byte channel, byte pitch, byte velocity)
  1091. {
  1092. char posIndex;
  1093. char ct;
  1094. if (velocity == 0)
  1095. {
  1096. HandleNoteOff(channel, pitch, velocity);
  1097. return;
  1098. }
  1099. else
  1100. {
  1101. gen_Last_Velo = velocity;
  1102. }
  1103. switch(gen_Mode)
  1104. {
  1105. case MODE_MONO:
  1106. if ( bMidi[0].Etat == 0 )
  1107. {
  1108. bMidi[0].Etat = 1 ;
  1109. bMidi[0].Note = pitch ;
  1110. bMidi[0].rTime = millis() ;
  1111. if ( gen_Ctrl == MODE_CTRL_VEL ) dac_Out(1, (long)velocity * REF_CTRL * gen_CtrlPc / 100 );
  1112. if ( gen_Ctrl == MODE_CTRL_EXPVEL ) dac_Out(1, ( (long)velocity * REF_CTRL * gen_CtrlPc / 100 ) * gen_Last_Ctrl / 127 );
  1113. p_CV(0,pitch);
  1114. p_GATE(0,HIGH);
  1115. }
  1116. else
  1117. {
  1118. bMidi[0].rTime = millis() ;
  1119. bMidi[0].Note = pitch ;
  1120. p_CV(0,pitch);
  1121. }
  1122. break;
  1123. case MODE_RETRIG:
  1124. if ( bMidi[0].Etat == 0 )
  1125. {
  1126. bMidi[0].Etat = 1 ;
  1127. bMidi[0].Note = pitch ;
  1128. if ( gen_Ctrl == MODE_CTRL_VEL ) dac_Out(1, (long)velocity * REF_CTRL * gen_CtrlPc / 100 );
  1129. if ( gen_Ctrl == MODE_CTRL_EXPVEL ) dac_Out(1, ( (long)velocity * REF_CTRL * gen_CtrlPc / 100 ) * gen_Last_Ctrl / 127 );
  1130. bMidi[0].rTime = millis() ;
  1131. p_CV(0,pitch);
  1132. p_GATE(0,HIGH);
  1133. }
  1134. else
  1135. {
  1136. p_GATE(0,LOW);
  1137. bMidi[0].Note = pitch ;
  1138. if ( gen_Ctrl == MODE_CTRL_VEL ) dac_Out(1, (long)velocity * REF_CTRL * gen_CtrlPc / 100 );
  1139. if ( gen_Ctrl == MODE_CTRL_EXPVEL ) dac_Out(1, ( (long)velocity * REF_CTRL * gen_CtrlPc / 100 ) * gen_Last_Ctrl / 127 );
  1140. bMidi[0].rTime = millis() ;
  1141. p_CV(0,pitch);
  1142. p_GATE(0,HIGH);
  1143. }
  1144. break;
  1145. case MODE_DUO:
  1146. posIndex=0;
  1147. for (ct = 0; ct < gen_Midi_Max; ct++ )
  1148. {
  1149. if ( bMidi[ct].Etat == 0 )
  1150. {
  1151. bMidi[ct].rTime = millis() ;
  1152. bMidi[ct].Etat = 1 ;
  1153. bMidi[ct].Note = pitch ;
  1154. p_CV(ct,pitch);
  1155. p_GATE(ct,HIGH);
  1156. break;
  1157. }
  1158. else
  1159. {
  1160. if ( bMidi[ct].rTime > bMidi[posIndex].rTime ) posIndex = ct;
  1161. }
  1162. }
  1163. if (ct>=gen_Midi_Max)
  1164. {
  1165. p_GATE(posIndex,LOW);
  1166. bMidi[posIndex].rTime = millis() ;
  1167. bMidi[posIndex].Etat = 1 ;
  1168. bMidi[posIndex].Note = pitch ;
  1169. p_CV(posIndex,pitch);
  1170. p_GATE(posIndex,HIGH);
  1171. }
  1172. break;
  1173.  
  1174. case MODE_SPLIT:
  1175. if (init_Dual)
  1176. {
  1177. gen_Split = pitch;
  1178. note_LCD( Z1, gen_Split );
  1179. }
  1180. else
  1181. {
  1182. int port = pitch < gen_Split ? 0 : 1;
  1183. if ( bMidi[port].Etat == 0 )
  1184. {
  1185. bMidi[port].Etat = 1 ;
  1186. bMidi[port].Note = pitch ;
  1187. bMidi[port].rTime = millis() ;
  1188. p_CV(port,pitch);
  1189. p_GATE(port,HIGH);
  1190. }
  1191. else
  1192. {
  1193. p_GATE(port,LOW);
  1194. bMidi[port].Note = pitch ;
  1195. bMidi[port].rTime = millis() ;
  1196. p_CV(port,pitch);
  1197. p_GATE(port,HIGH);
  1198. }
  1199.  
  1200. }
  1201. break;
  1202.  
  1203.  
  1204. case MODE_ARPEGE:
  1205. posIndex=0;
  1206. for (ct = 0; ct < gen_Midi_Max; ct++ )
  1207. {
  1208. if ( bMidi[ct].Etat == 0 )
  1209. {
  1210. bMidi[ct].rTime = millis() ;
  1211. bMidi[ct].Etat = 1 ;
  1212. bMidi[ct].Note = pitch ;
  1213. doit_Reconstruit_Motif=true;
  1214. break;
  1215. }
  1216. else
  1217. {
  1218. if ( bMidi[ct].rTime < bMidi[posIndex].rTime ) posIndex = ct;
  1219. }
  1220. }
  1221. if (ct>=gen_Midi_Max)
  1222. {
  1223. bMidi[posIndex].rTime = millis() ;
  1224. bMidi[posIndex].Etat = 1 ;
  1225. bMidi[posIndex].Note = pitch ;
  1226. doit_Reconstruit_Motif=true;
  1227. }
  1228. break;
  1229.  
  1230. case MODE_ARPEGE_SUST:
  1231.  
  1232. for (ct = 0; ct < gen_Midi_Max; ct++ )
  1233. {
  1234. if ( bMidi[ct].Etat == 1 ) break;
  1235. }
  1236. if ( ct >= gen_Midi_Max ) // toutes les notes ont été relachées
  1237. {
  1238. for (ct = 0; ct < gen_Midi_Max; ct++ )
  1239. {
  1240. bMidi[ct].Etat = 0 ;
  1241. }
  1242. }
  1243. for (ct = 0; ct < gen_Midi_Max; ct++ )
  1244. {
  1245. if ( bMidi[ct].Etat == 0 )
  1246. {
  1247. bMidi[ct].Etat = 1 ;
  1248. bMidi[ct].Note = pitch ;
  1249. doit_Reconstruit_Motif=true;
  1250. break;
  1251. }
  1252. if ( bMidi[ct].Etat >= 0 && pitch == bMidi[ct].Note )
  1253. {
  1254. bMidi[ct].Etat = 0 ;
  1255. doit_Reconstruit_Motif=true;
  1256. break;
  1257. }
  1258. }
  1259. break;
  1260.  
  1261. case MODE_ARPEGE_TRANS:
  1262. if (is_Recorder)
  1263. {
  1264. for (ct = 0; ct < gen_Midi_Max; ct++ )
  1265. {
  1266. if ( bMidi[ct].Etat == 0 )
  1267. {
  1268. bMidi[ct].Etat = 1 ;
  1269. bMidi[ct].Note = pitch ;
  1270. doit_Reconstruit_Motif=true;
  1271. break;
  1272. }
  1273. if ( bMidi[ct].Etat == 1 && pitch == bMidi[ct].Note )
  1274. {
  1275. bMidi[ct].Etat = 0 ;
  1276. doit_Reconstruit_Motif=true;
  1277. break;
  1278. }
  1279. }
  1280. }
  1281. else
  1282. {
  1283. ref_Arpege_Trans = (int)pitch - (int)ord_Motif[0];
  1284. }
  1285. break;
  1286.  
  1287. case MODE_SEQUENCER:
  1288. if ( is_Recorder )
  1289. {
  1290. bMidi[pos_Recorder].Etat=1;
  1291. bMidi[pos_Recorder].Note = pitch ;
  1292. bMidi[pos_Recorder].rTime = millis() ;
  1293. bMidi[pos_Recorder].Expr = velocity;
  1294. if ( gen_VelMute == 1)
  1295. dac_Out(1, (int)bMidi[pos_Recorder].Expr * REF_CTRL );
  1296. p_CV(0,pitch);
  1297. p_GATE(0,HIGH);
  1298. if (pos_Recorder < MIDI_LENSEQ ) pos_Recorder++;
  1299. pos_LCD(Z2, pos_Recorder);
  1300. }
  1301. else
  1302. {
  1303. ref_Arpege_Trans = (int)pitch - (int)bMidi[0].Note;
  1304. }
  1305. break;
  1306. }
  1307.  
  1308. }
  1309.  
  1310. // ------------------
  1311. // Callback Midi NOte Off
  1312. // ------------------
  1313.  
  1314. void HandleNoteOff(byte channel, byte pitch, byte velocity)
  1315. {
  1316. switch(gen_Mode)
  1317. {
  1318. case MODE_MONO:
  1319. case MODE_RETRIG:
  1320. // case MODE_REGLAGE_VO:
  1321. if ( bMidi[0].Etat == 1 && pitch == bMidi[0].Note )
  1322. {
  1323. p_GATE(0,LOW);
  1324. bMidi[0].Etat = 0 ;
  1325. // if ( Mode_Ctrl == MODE_CTRL_VEL ) dac_Out(1, (int)0 );
  1326. }
  1327. break;
  1328. case MODE_DUO:
  1329. for (int ct = 0; ct < gen_Midi_Max; ct++ )
  1330. {
  1331. if ( bMidi[ct].Etat == 1 && pitch == bMidi[ct].Note )
  1332. {
  1333. p_GATE(ct,LOW);
  1334. bMidi[ct].Etat = 0 ;
  1335. }
  1336. }
  1337. break;
  1338.  
  1339. case MODE_SPLIT:
  1340. if (!init_Dual)
  1341. {
  1342. int port = pitch < gen_Split ? 0 : 1;
  1343. if ( bMidi[port].Etat == 1 && pitch == bMidi[port].Note )
  1344. {
  1345. p_GATE(port,LOW);
  1346. bMidi[port].Etat = 0 ;
  1347. }
  1348. }
  1349. break;
  1350.  
  1351. case MODE_ARPEGE:
  1352. for (int ct = 0; ct < gen_Midi_Max; ct++ )
  1353. {
  1354. if ( bMidi[ct].Etat == 1 && pitch == bMidi[ct].Note )
  1355. {
  1356. bMidi[ct].Etat = 0 ;
  1357. doit_Reconstruit_Motif=true;
  1358. break;
  1359. }
  1360. }
  1361. break;
  1362.  
  1363. case MODE_ARPEGE_SUST:
  1364. for (int ct = 0; ct < gen_Midi_Max; ct++ )
  1365. {
  1366. if ( bMidi[ct].Etat == 1 && pitch == bMidi[ct].Note )
  1367. {
  1368. bMidi[ct].Etat = 2 ;
  1369. break;
  1370. }
  1371. }
  1372. break;
  1373.  
  1374.  
  1375. case MODE_ARPEGE_TRANS:
  1376. break;
  1377.  
  1378. case MODE_SEQUENCER:
  1379. if (is_Recorder)
  1380. {
  1381. p_GATE(0,LOW);
  1382. }
  1383. break;
  1384. }
  1385.  
  1386. }
  1387.  
  1388.  
  1389. // ------------------
  1390. // Callback Clock Midi
  1391. // ------------------
  1392.  
  1393. void HandleClock()
  1394. {
  1395. if (gen_Clock==0) return;
  1396. gen_Cpt_Clock++;
  1397. if (gen_Cpt_Clock >= clock_Div[gen_Clock])
  1398. {
  1399. nextTime = millis()-1;
  1400. if (gen_Clock_State>0) gen_Clock_State=2;
  1401. gen_Cpt_Clock=0;
  1402. }
  1403. if (gen_Cpt_Clock >= clock_Div[gen_Clock] / 2 && nextGate > 0)
  1404. {
  1405. nextGate = millis()-1;
  1406. }
  1407. }
  1408.  
  1409. void HandleStart()
  1410. {
  1411. if (gen_Clock==0) return;
  1412. pos_Motif=0;
  1413. gen_Clock_State=2;
  1414. gen_Cpt_Clock=0;
  1415. midi_Pitch_Value=0;
  1416. nextTime = millis()-1;
  1417. }
  1418.  
  1419. void HandleContinue()
  1420. {
  1421. if (gen_Clock==0) return;
  1422. gen_Clock_State=2;
  1423. gen_Cpt_Clock=0;
  1424. nextTime = millis()-1;
  1425. }
  1426.  
  1427. void HandleStop()
  1428. {
  1429. if (gen_Clock==0) return;
  1430. gen_Clock_State=0;
  1431. }
  1432.  
  1433.  
  1434. // ------------------
  1435. // Callback Midi Control Change
  1436. // ------------------
  1437.  
  1438. void HandleControlChange(byte channel, byte number, byte value)
  1439. {
  1440. switch (number)
  1441. {
  1442. case 0x01: //Modulation Wheel or Lever
  1443. case 0x02: //Breath Controller
  1444. case 0x0B: //Expression Controller
  1445. gen_Last_Ctrl = value;
  1446. switch(gen_Mode)
  1447. {
  1448. case MODE_MONO:
  1449. case MODE_RETRIG:
  1450. if ( gen_Ctrl == MODE_CTRL_EXP ) dac_Out(1, (long)value * REF_CTRL * gen_CtrlPc / 100);
  1451. break;
  1452. case MODE_ARPEGE:
  1453. case MODE_ARPEGE_SUST:
  1454. case MODE_ARPEGE_TRANS:
  1455. if ( gen_Ctrl == MODE_CTRL_EXP ) dac_Out(1, (long)value * REF_CTRL );
  1456. break;
  1457. case MODE_SEQUENCER:
  1458. if ( gen_VelMute == 2 || gen_VelMute == 4 ) dac_Out(1, (long)value * REF_CTRL );
  1459. break;
  1460. }
  1461. break;
  1462.  
  1463. }
  1464. }
  1465.  
  1466.  
  1467. // ------------------
  1468. // Ecriture tension sur DAC
  1469. // ------------------
  1470.  
  1471. void dac_Out(int port, uint16_t sample)
  1472. {
  1473.  
  1474. uint8_t dacSPI0 = 0;
  1475. uint8_t dacSPI1 = 0;
  1476. byte selector;
  1477.  
  1478. switch (port)
  1479. {
  1480. case 0:
  1481. selector = DAC_0;
  1482. sample = sample | 0b0111000000000000;
  1483. break;
  1484. case 1:
  1485. selector = DAC_0;
  1486. sample = sample | 0b1111000000000000;
  1487. break;
  1488. }
  1489. dacSPI0 = (sample >> 8) & 0x00FF;
  1490. dacSPI1 = sample & 0x00FF;
  1491.  
  1492. digitalWrite(selector,LOW);
  1493. SPDR = dacSPI0; // Start the transmission
  1494. while (!(SPSR & (1<<SPIF))) // Wait the end of the transmission
  1495. {
  1496. };
  1497.  
  1498. SPDR = dacSPI1;
  1499. while (!(SPSR & (1<<SPIF))) // Wait the end of the transmission
  1500. {
  1501. };
  1502. digitalWrite(selector,HIGH);
  1503.  
  1504. }
  1505.  
  1506.  
  1507. // ------------------
  1508. // Setup Arduino
  1509. // ------------------
  1510.  
  1511.  
  1512. void setup()
  1513. {
  1514. byte clr;
  1515.  
  1516. lcd.begin(24, 2);
  1517. lcd.clear();
  1518.  
  1519. // Initialisation DAC(s) et SPI
  1520. pinMode(DATAOUT, OUTPUT);
  1521. pinMode(DATAIN, INPUT);
  1522. pinMode(SPICLOCK,OUTPUT);
  1523. pinMode(DAC_0,OUTPUT);
  1524. digitalWrite(DAC_0,LOW);
  1525.  
  1526. SPCR = (1<<SPE)|(1<<MSTR);
  1527. clr=SPSR;
  1528. clr=SPDR;
  1529. delay(10);
  1530.  
  1531.  
  1532. // Initialisation Buffer
  1533.  
  1534. mode_reglage = MODE_MODE;
  1535.  
  1536.  
  1537. gen_Transpose = EEPROM_readInt(10,gen_Transpose);
  1538. gen_Accord = EEPROM_readInt(12,gen_Accord);
  1539. gen_Decalage = EEPROM_readInt(14,gen_Decalage);
  1540. REF_1V = EEPROM_readInt(16,REF_1V);
  1541. if (REF_1V < 800) REF_1V=895;
  1542. gen_Midi = EEPROM_readInt(18,gen_Midi);
  1543. gen_Clock = EEPROM_readInt(20,gen_Clock);
  1544. ref_VelMute = EEPROM_readInt(22,ref_VelMute);
  1545. gen_VelMute = EEPROM_readInt(24,gen_VelMute);
  1546. gen_Onde = EEPROM_readInt(26,gen_Onde);
  1547. gen_Ctrl = EEPROM_readInt(28,gen_Ctrl);
  1548. gen_CtrlPc = EEPROM_readInt(30,gen_CtrlPc);
  1549. gen_Pitch = EEPROM_readInt(32,gen_Pitch);
  1550. gen_GateClk = EEPROM_readInt(34,gen_GateClk);
  1551. gen_Tempo = EEPROM_readInt(36,gen_Tempo);
  1552. gen_Motif = EEPROM_readInt(38,gen_Motif);
  1553. gen_OndeHz = EEPROM_readInt(40,gen_OndeHz);
  1554. gen_Split = EEPROM_readInt(42,gen_Split);
  1555.  
  1556.  
  1557. clear_Buf();
  1558.  
  1559. // Initialisation Midi
  1560. MIDI.begin(gen_Midi);
  1561. MIDI.turnThruOn();
  1562. MIDI.setHandleNoteOn(HandleNoteOn);
  1563. MIDI.setHandleNoteOff(HandleNoteOff );
  1564. MIDI.setHandleControlChange(HandleControlChange);
  1565. MIDI.setHandlePitchBend(HandlePitchBend);
  1566. MIDI.setHandleClock(HandleClock);
  1567. MIDI.setHandleStart(HandleStart);
  1568. MIDI.setHandleStop(HandleStop);
  1569. MIDI.setHandleContinue(HandleContinue);
  1570.  
  1571. pinMode(GATE_0,OUTPUT);
  1572. pinMode(GATE_1,OUTPUT);
  1573. digitalWrite(GATE_0,LOW);
  1574. digitalWrite(GATE_1,LOW);
  1575.  
  1576. // Gestion du temps
  1577. depTime = refCmd = nextTime = millis();
  1578. nextGate = 0;
  1579.  
  1580.  
  1581. }
  1582.  
  1583. void GateClock()
  1584. {
  1585. if ( cpt_gate == 0 ) p_GATE(1,HIGH);
  1586. if ( cpt_gate == 1 ) p_GATE(1,LOW);
  1587. cpt_gate++;
  1588. if ( cpt_gate >= gen_GateClk ) cpt_gate=0;
  1589. }
  1590.  
  1591. void incRand()
  1592. {
  1593. gen_Rand+=inc_Rand;
  1594. if (gen_Rand<0) { gen_Rand=0;inc_Rand=-inc_Rand;}
  1595. if (gen_Rand>4000) { gen_Rand=4000;inc_Rand=-inc_Rand;}
  1596. cycle_Rand++;
  1597. if (cycle_Rand>gen_OndeHz)
  1598. {
  1599. cycle_Rand=0;
  1600. inc_Rand=random(0,3)-1;
  1601. }
  1602. }
  1603.  
  1604. void loop()
  1605. {
  1606. int v0, v1, v2, v3;
  1607.  
  1608. refTime = millis();
  1609.  
  1610.  
  1611. // Pour éviter le bouclage si refTime passe à zéro...
  1612.  
  1613. /*
  1614. if ( refTime < depTime ) {
  1615. depTime = refCmd = nextTime = refTime;
  1616. }
  1617. */
  1618. MIDI.read();
  1619.  
  1620.  
  1621. if ( mode_reglage == MODE_MODE && ( gen_Mode == MODE_MONO || gen_Mode == MODE_RETRIG ))
  1622. {
  1623. if ( gen_Ctrl == MODE_CTRL_LFO )
  1624. {
  1625. int pos_onde = ( (long)( refTime - depTime ) * 256 / gen_OndeHz ) % 256;
  1626.  
  1627.  
  1628. // 6 = ...t(1, (long)pgm_read_byte_near(Triangle + pos_onde) * 16 * gen_CtrlPc / 100 )...
  1629. switch( gen_Onde )
  1630. {
  1631. case 0:
  1632. dac_Out(1, (long)pgm_read_byte_near(Sinus + pos_onde) * gen_CtrlPc * 16 / 100); break;
  1633. case 1:
  1634. dac_Out(1, (long)pgm_read_byte_near(Triangle + pos_onde) * gen_CtrlPc * 16 / 100); break;
  1635. case 2:
  1636. dac_Out(1, (long)pgm_read_byte_near(Rampe + pos_onde) * gen_CtrlPc * 16 / 100); break;
  1637. case 3:
  1638. dac_Out(1, (long)pgm_read_byte_near(Carre + pos_onde) * gen_CtrlPc * 16 / 100); break;
  1639. case 4:
  1640. dac_Out(1, (long)pgm_read_byte_near(Sinsom + pos_onde) * gen_CtrlPc * 16 / 100); break;
  1641. case 5:
  1642. dac_Out(1, (long)pgm_read_byte_near(Ransom + pos_onde) * gen_CtrlPc * 16 / 100); break;
  1643. case 6:
  1644. dac_Out(1, (long)gen_Rand * gen_CtrlPc / 100);
  1645. incRand();
  1646. break;
  1647. case 7:
  1648. dac_Out(1, (long)gen_Rand * gen_CtrlPc / 10);
  1649. incRand();
  1650. break;
  1651. }
  1652. }
  1653.  
  1654. // 800 = ...+ pos_onde) * 16 * gen_CtrlPc ) / 100 ) * gen_Last_Ctrl / 128...
  1655. if ( gen_Ctrl == MODE_CTRL_LFOEXP )
  1656. {
  1657.  
  1658. int pos_onde = ( (long)( refTime - depTime ) * 256 / gen_OndeHz ) % 256;
  1659.  
  1660. switch( gen_Onde )
  1661. {
  1662. case 0:
  1663. // dac_Out(1, ((long)pgm_read_byte_near(Sinus + pos_onde) * 16 * gen_CtrlPc / 100 ) * gen_Last_Ctrl / 128 ); break;
  1664. dac_Out(1, (long)pgm_read_byte_near(Sinus + pos_onde) * gen_CtrlPc * gen_Last_Ctrl / 800 ); break;
  1665. case 1:
  1666. dac_Out(1, (long)pgm_read_byte_near(Triangle + pos_onde) * gen_CtrlPc * gen_Last_Ctrl / 800 ); break;
  1667. case 2:
  1668. dac_Out(1, (long)pgm_read_byte_near(Rampe + pos_onde) * gen_CtrlPc * gen_Last_Ctrl / 800 ); break;
  1669. case 3:
  1670. dac_Out(1, (long)pgm_read_byte_near(Carre + pos_onde) * gen_CtrlPc * gen_Last_Ctrl / 800 ); break;
  1671. case 4:
  1672. dac_Out(1, (long)pgm_read_byte_near(Sinsom + pos_onde) * gen_CtrlPc * gen_Last_Ctrl / 800 ); break;
  1673. case 5:
  1674. dac_Out(1, (long)pgm_read_byte_near(Ransom + pos_onde) * gen_CtrlPc * gen_Last_Ctrl / 800 ); break;
  1675. case 6:
  1676. dac_Out(1, (long)gen_Rand * gen_CtrlPc * gen_Last_Ctrl / 12800 );
  1677. incRand();
  1678. break;
  1679. case 7:
  1680. dac_Out(1, (long)gen_Rand * gen_CtrlPc * gen_Last_Ctrl / 1280 );
  1681. incRand();
  1682. break;
  1683. }
  1684. }
  1685. if ( gen_Ctrl == MODE_CTRL_LFOVEL )
  1686. {
  1687. int pos_onde = ( (long)( refTime - depTime ) * 256 / gen_OndeHz ) % 256;
  1688.  
  1689. switch( gen_Onde )
  1690. {
  1691. case 0:
  1692. dac_Out(1, (long)pgm_read_byte_near(Sinus + pos_onde) * gen_CtrlPc * gen_Last_Velo / 800 ); break;
  1693. case 1:
  1694. dac_Out(1, (long)pgm_read_byte_near(Triangle + pos_onde) * gen_CtrlPc * gen_Last_Velo / 800 ); break;
  1695. case 2:
  1696. dac_Out(1, (long)pgm_read_byte_near(Rampe + pos_onde) * gen_CtrlPc * gen_Last_Velo / 800 ); break;
  1697. case 3:
  1698. dac_Out(1, (long)pgm_read_byte_near(Carre + pos_onde) * gen_CtrlPc * gen_Last_Velo / 800 ); break;
  1699. case 4:
  1700. dac_Out(1, (long)pgm_read_byte_near(Sinsom + pos_onde) * gen_CtrlPc * gen_Last_Velo / 800 ); break;
  1701. case 5:
  1702. dac_Out(1, (long)pgm_read_byte_near(Ransom + pos_onde) * gen_CtrlPc * gen_Last_Velo / 800 ); break;
  1703. case 6:
  1704. dac_Out(1, (long)gen_Rand * gen_CtrlPc * gen_Last_Ctrl / 12800 );
  1705. incRand();
  1706. break;
  1707. case 7:
  1708. dac_Out(1, (long)gen_Rand * gen_CtrlPc * gen_Last_Ctrl / 1280 );
  1709. incRand();
  1710. break;
  1711. }
  1712. }
  1713. }
  1714.  
  1715. if ( refTime > refCmd )
  1716. {
  1717.  
  1718. ScanBtn();
  1719.  
  1720. if ( BtnTest(0, false) )
  1721. {
  1722. if ( mode_reglage == MODE_MODE )
  1723. {
  1724. mode_reglage = MODE_REGLAGE;
  1725. old_Reglage = map( analogRead(anaIn0) ,0 , 1023 , 0 , NB_MENU_REGLAGE - 1);
  1726. }
  1727. else
  1728. {
  1729.  
  1730. mode_reglage = MODE_MODE;
  1731. old_Mode = map( analogRead(anaIn0) ,0 , 1023 , 0 , NB_MENU_MODE - 1);
  1732. }
  1733. maj_Ecran();
  1734. }
  1735.  
  1736. if ( mode_reglage == MODE_REGLAGE )
  1737. {
  1738. v0 = map( analogRead(anaIn0) ,0 , 1023 , 0 , NB_MENU_REGLAGE - 1);
  1739. if ( v0 != old_Reglage )
  1740. {
  1741.  
  1742. gen_Reglage = old_Reglage = v0;
  1743. maj_Ecran();
  1744. }
  1745. if ( BtnTest(1, true) )
  1746. {
  1747.  
  1748. switch (gen_Reglage)
  1749. {
  1750. case REGLE_DEMIT:
  1751. gen_Transpose--;
  1752. if (gen_Transpose<-12) gen_Transpose=-12;
  1753. sign_LCD( Z5, gen_Transpose );
  1754. break;
  1755. case REGLE_ACCORD:
  1756. gen_Accord--;
  1757. if (gen_Accord<-100) gen_Accord=-100;
  1758. sign_LCD( Z5, gen_Accord);
  1759. break;
  1760. case REGLE_BEND:
  1761. gen_Pitch--;
  1762. if (gen_Pitch<0) {
  1763. gen_Pitch=0; midi_Pitch_Value = 0;
  1764. }
  1765. onoff_LCD( Z5, gen_Pitch );
  1766. break;
  1767. case REGLE_DECAL:
  1768. gen_Decalage-=12;
  1769. if (gen_Decalage<0) gen_Decalage=0;
  1770. int_LCD( Z5, gen_Decalage );
  1771. break;
  1772. case REGLE_REF1V:
  1773. REF_1V--;
  1774. if (REF_1V < 850) REF_1V=850;
  1775. int_LCD( Z5, REF_1V );
  1776. break;
  1777. case REGLE_GATECLK:
  1778. gen_GateClk--;
  1779. if (gen_GateClk < 2) gen_GateClk=2;
  1780. div_LCD( Z5, gen_GateClk);
  1781. break;
  1782. case REGLE_MIDI:
  1783. gen_Midi--;
  1784. if (gen_Midi < 0) gen_Midi=0;
  1785. midi_LCD( Z5, gen_Midi);
  1786. MIDI.setInputChannel(gen_Midi);
  1787. break;
  1788. case REGLE_CLOCK:
  1789. gen_Clock--;
  1790. if (gen_Clock < 0) gen_Clock=0;
  1791. clock_LCD( Z5, gen_Clock);
  1792. break;
  1793. case REGLE_VELMUT:
  1794. ref_VelMute--;
  1795. if (ref_VelMute < 0) ref_VelMute=0;
  1796. int_LCD( Z5, ref_VelMute);
  1797. break;
  1798. case REGLE_EEPROM:
  1799. gen_Transpose = EEPROM_readInt(10,gen_Transpose);
  1800. gen_Accord = EEPROM_readInt(12,gen_Accord);
  1801. gen_Decalage = EEPROM_readInt(14,gen_Decalage);
  1802. REF_1V = EEPROM_readInt(16,REF_1V);
  1803. if (REF_1V < 800) REF_1V=890;
  1804. gen_Midi = EEPROM_readInt(18,gen_Midi);
  1805. gen_Clock = EEPROM_readInt(20,gen_Clock);
  1806. ref_VelMute = EEPROM_readInt(22,ref_VelMute);
  1807. gen_VelMute = EEPROM_readInt(24,gen_VelMute);
  1808. gen_Onde = EEPROM_readInt(26,gen_Onde);
  1809. gen_Ctrl = EEPROM_readInt(28,gen_Ctrl);
  1810. gen_CtrlPc = EEPROM_readInt(30,gen_CtrlPc);
  1811. gen_Pitch = EEPROM_readInt(32,gen_Pitch);
  1812. gen_GateClk = EEPROM_readInt(34,gen_GateClk);
  1813. gen_Tempo = EEPROM_readInt(36,gen_Tempo);
  1814. gen_Motif = EEPROM_readInt(38,gen_Motif);
  1815. gen_OndeHz = EEPROM_readInt(40,gen_OndeHz);
  1816. gen_Split = EEPROM_readInt(42,gen_Split);
  1817. break;
  1818. }
  1819. p_CV(0, bMidi[0].Note );
  1820. }
  1821. if ( BtnTest(2, true) )
  1822. {
  1823. switch (gen_Reglage)
  1824. {
  1825. case REGLE_DEMIT:
  1826. gen_Transpose++;
  1827. if (gen_Transpose>12) gen_Transpose=12;
  1828. sign_LCD( Z5, gen_Transpose );
  1829. break;
  1830. case REGLE_ACCORD:
  1831. gen_Accord++;
  1832. if (gen_Accord>100) gen_Accord=100;
  1833. sign_LCD( Z5, gen_Accord );
  1834. break;
  1835. case REGLE_BEND:
  1836. gen_Pitch++;
  1837. if (gen_Pitch>12) gen_Pitch=12;
  1838. onoff_LCD( Z5, gen_Pitch );
  1839. break;
  1840. case REGLE_DECAL:
  1841. gen_Decalage+=12;
  1842. if (gen_Decalage>64) gen_Decalage=64;
  1843. int_LCD( Z5, gen_Decalage );
  1844. break;
  1845. case REGLE_REF1V:
  1846. REF_1V++;
  1847. if (REF_1V > 950) REF_1V=950;
  1848. int_LCD( Z5, REF_1V );
  1849. break;
  1850. case REGLE_GATECLK:
  1851. gen_GateClk++;
  1852. if (gen_GateClk > 16) gen_GateClk=16;
  1853. div_LCD( Z5, gen_GateClk);
  1854. break;
  1855. case REGLE_MIDI:
  1856. gen_Midi++;
  1857. if (gen_Midi > 17) gen_Midi=17;
  1858. midi_LCD( Z5, gen_Midi);
  1859. MIDI.setInputChannel(gen_Midi);
  1860. break;
  1861. case REGLE_CLOCK:
  1862. gen_Clock++;
  1863. if (gen_Clock > 4) gen_Clock=4;
  1864. clock_LCD( Z5, gen_Clock);
  1865. break;
  1866. case REGLE_VELMUT:
  1867. ref_VelMute++;
  1868. if (ref_VelMute > 127) ref_VelMute=127;
  1869. int_LCD( Z5, ref_VelMute);
  1870. break;
  1871. case REGLE_EEPROM:
  1872. EEPROM_writeInt(10,gen_Transpose);
  1873. EEPROM_writeInt(12,gen_Accord);
  1874. EEPROM_writeInt(14,gen_Decalage);
  1875. EEPROM_writeInt(16,REF_1V);
  1876. EEPROM_writeInt(18,gen_Midi);
  1877. EEPROM_writeInt(20,gen_Clock);
  1878. EEPROM_writeInt(22,ref_VelMute);
  1879. EEPROM_writeInt(24,gen_VelMute);
  1880. EEPROM_writeInt(26,gen_Onde);
  1881. EEPROM_writeInt(28,gen_Ctrl);
  1882. EEPROM_writeInt(30,gen_CtrlPc);
  1883. EEPROM_writeInt(32,gen_Pitch);
  1884. EEPROM_writeInt(34,gen_GateClk);
  1885. EEPROM_writeInt(36,gen_Tempo);
  1886. EEPROM_writeInt(38,gen_Motif);
  1887. EEPROM_writeInt(40,gen_OndeHz);
  1888. EEPROM_writeInt(42,gen_Split);
  1889. break;
  1890. }
  1891. p_CV(0, bMidi[0].Note );
  1892. }
  1893. }
  1894. else
  1895. {
  1896. v0 = map( analogRead(anaIn0) ,0 , 1023 - 100, 0 , NB_MENU_MODE - 1);
  1897. if ( v0 != old_Mode )
  1898. {
  1899. nextTime = refTime;
  1900. gen_Mode=old_Mode=v0;
  1901. clear_Buf();
  1902. maj_Ecran();
  1903. }
  1904. switch ( gen_Mode )
  1905. {
  1906. case MODE_MONO:
  1907. case MODE_RETRIG:
  1908. if ( BtnTest(1, true) )
  1909. {
  1910. gen_Onde++;
  1911. if (gen_Onde>=NB_ONDE) gen_Onde=0;
  1912. progmem_LCD( Z1, (char*)pgm_read_word(&(menu_Onde[gen_Onde])));
  1913. }
  1914. if ( BtnTest(2, true) )
  1915. {
  1916. gen_Ctrl++;
  1917. if (gen_Ctrl>=NB_MENU_CTRL) gen_Ctrl=0;
  1918. progmem_LCD( Z2, (char*)pgm_read_word(&(menu_Ctrl[gen_Ctrl])));
  1919. dac_Out(1,0);
  1920.  
  1921. }
  1922.  
  1923. v1 = map( analogRead(anaIn1) ,0 , 1023 , 511 , 0);
  1924. v1 = pgm_read_word_near(Onde_Hz + v1);
  1925. if ( v1 != old_OndeHz )
  1926. {
  1927. gen_OndeHz = old_OndeHz = v1;
  1928. hz_LCD(Z4, gen_OndeHz );
  1929. depTime = millis();
  1930. }
  1931. v2 = map( analogRead(anaIn2) ,0 , 1023 , 0 , 100);
  1932. if ( v2 != old_CtrlPc )
  1933. {
  1934. gen_CtrlPc = old_CtrlPc =v2;
  1935. pc_LCD(Z5,gen_CtrlPc);
  1936. }
  1937. break;
  1938.  
  1939. case MODE_SPLIT:
  1940. init_Dual = ( BtnTest(1, true) );
  1941. break;
  1942.  
  1943. case MODE_ARPEGE:
  1944. case MODE_ARPEGE_SUST:
  1945. case MODE_ARPEGE_TRANS:
  1946.  
  1947. if ( BtnTest(2, true) )
  1948. {
  1949. gen_Ctrl++;
  1950. if (gen_Ctrl>=NB_MENU_CTRL_RED) gen_Ctrl=0;
  1951. progmem_LCD( Z2, (char*)pgm_read_word(&(menu_Ctrl_Red[gen_Ctrl])));
  1952. }
  1953.  
  1954. v2 = map( analogRead(anaIn2) ,0 , 1023 , 20 , 1000);
  1955. if ( v2 != old_Tempo )
  1956. {
  1957. gen_Tempo=old_Tempo=v2;
  1958. cycle = 60000/gen_Tempo;
  1959. tempo_LCD(Z5,gen_Tempo);
  1960. }
  1961. v1 = map( analogRead(anaIn1) ,0 , 1023 , 0 , NB_MOTIF -1 );
  1962. if (v1 != old_Motif )
  1963. {
  1964. gen_Motif = old_Motif = v1;
  1965. doit_Reconstruit_Motif = true;
  1966. str_LCD( Z4, lMotif[gen_Motif].nom );
  1967. }
  1968. break;
  1969.  
  1970. case MODE_SEQUENCER:
  1971. if ( !is_Recorder && BtnTest(2, false) )
  1972. {
  1973. gen_VelMute++;
  1974. if (gen_VelMute >= NB_MENU_VELMUT) gen_VelMute=0;
  1975. progmem_LCD( Z2, (char*)pgm_read_word(&(menu_Velmut[gen_VelMute])));
  1976. }
  1977.  
  1978. v2 = map( analogRead(anaIn2) ,0 , 1023 , 20 , 1000);
  1979. if ( v2 != old_Tempo )
  1980. {
  1981. gen_Tempo=old_Tempo=v2;
  1982. cycle = 60000/gen_Tempo;
  1983. tempo_LCD(Z5,gen_Tempo);
  1984. }
  1985. break;
  1986.  
  1987. }
  1988. }
  1989. refCmd = refTime + REF_CMD_DELAY ;
  1990.  
  1991. }
  1992.  
  1993.  
  1994. if (gen_Mode >= MODE_ARPEGE )
  1995. {
  1996.  
  1997. if ( refTime > nextGate && nextGate > 0 )
  1998. {
  1999. p_GATE(0,LOW);
  2000. nextGate = 0;
  2001. }
  2002.  
  2003. if ( refTime > nextTime && mode_reglage == MODE_MODE )
  2004. {
  2005.  
  2006.  
  2007. switch(gen_Mode)
  2008. {
  2009. case MODE_ARPEGE:
  2010. case MODE_ARPEGE_SUST:
  2011.  
  2012. if ( BtnTest(1, false) )
  2013. {
  2014. clear_Buf();
  2015. cpt_gate=0;
  2016. }
  2017. if (doit_Reconstruit_Motif) Reconstruit_Motif(1);
  2018.  
  2019. if (max_Motif>0)
  2020. {
  2021. if ( gen_Clock == 0 || gen_Clock_State == 2)
  2022. {
  2023. gen_Clock_State = 1;
  2024. p_CV(0, Motif[pos_Motif]);
  2025. p_GATE(0,HIGH);
  2026. nextGate = refTime + cycle / 2;
  2027. GateClock();
  2028. pos_Motif++;
  2029. if (pos_Motif>=max_Motif)
  2030. {
  2031. pos_Motif=0;
  2032. if (lMotif[gen_Motif].sens == 4 ) Reconstruit_Motif(0);
  2033. }
  2034. }
  2035. }
  2036. break;
  2037.  
  2038. case MODE_ARPEGE_TRANS:
  2039. if ( BtnTest(1, false) )
  2040. {
  2041. if ( is_Recorder )
  2042. {
  2043. is_Recorder=false;
  2044. pos_Motif=0;
  2045. ref_Arpege_Trans=0;
  2046. maj_Ecran();
  2047. cpt_gate=0;
  2048. }
  2049. else
  2050. {
  2051. clear_Buf();
  2052. }
  2053. }
  2054.  
  2055. if (doit_Reconstruit_Motif) Reconstruit_Motif(1);
  2056.  
  2057. if (max_Motif>0)
  2058. {
  2059. if ( gen_Clock == 0 || gen_Clock_State == 2)
  2060. {
  2061. gen_Clock_State = 1;
  2062. p_CV(0, Motif[pos_Motif] + (!is_Recorder?ref_Arpege_Trans:0) );
  2063. p_GATE(0,HIGH);
  2064. GateClock();
  2065. nextGate = refTime + cycle / 2;
  2066. pos_Motif++;
  2067. if (pos_Motif>=max_Motif)
  2068. {
  2069. pos_Motif=0;
  2070. if (lMotif[gen_Motif].sens == 4 ) Reconstruit_Motif(0);
  2071. }
  2072. }
  2073. }
  2074.  
  2075. break;
  2076.  
  2077.  
  2078. case MODE_SEQUENCER:
  2079.  
  2080. if ( BtnTest(1, false) )
  2081. {
  2082. if ( is_Recorder )
  2083. {
  2084. is_Recorder=false;
  2085. pos_Motif=0;
  2086. ref_Arpege_Trans=0;
  2087. dac_Out(1,0);
  2088. maj_Ecran();
  2089. cpt_gate=0;
  2090. }
  2091. else
  2092. {
  2093. clear_Buf();
  2094. }
  2095. }
  2096.  
  2097. if ( !is_Recorder && pos_Recorder >0 )
  2098. {
  2099. if ( gen_Clock == 0 || gen_Clock_State == 2)
  2100. {
  2101. gen_Clock_State = 1;
  2102. if (gen_VelMute < 3 || bMidi[pos_Motif].Expr > ref_VelMute)
  2103. {
  2104. if (gen_VelMute == 1 )
  2105. dac_Out(1, (int)bMidi[pos_Motif].Expr * REF_CTRL );
  2106. p_CV(0, bMidi[pos_Motif].Note + ref_Arpege_Trans);
  2107. p_GATE(0,HIGH);
  2108. nextGate = refTime + cycle / 2;
  2109. }
  2110. GateClock();
  2111. pos_Motif++;
  2112. if (pos_Motif>=pos_Recorder) pos_Motif=0;
  2113. }
  2114. }
  2115. break;
  2116.  
  2117. }
  2118.  
  2119.  
  2120. // while ( nextTime <= refTime ) nextTime += cycle;
  2121. if ( gen_Clock==0 )
  2122. nextTime += cycle;
  2123. else
  2124. nextTime += 200;
  2125. }
  2126. }
  2127. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!