API tools faq
paste
Advertisement
Guest User

Auduino RGB LCD

a guest
Nov 16th, 2012
161
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 33.67 KB | None | 0 0
raw download clone embed print report
  1. // Auduino, the Lo-Fi granular synthesiser
  2. //
  3. // by Peter Knight, Tinker.it http://tinker.it
  4. // PROGMEM additions by Duane B http://rcarduino.blogspot.com
  5. // Additional scales, customizations, and tweaks by Patrick Enright
  6. //
  7. // Help: http://code.google.com/p/tinkerit/wiki/Auduino
  8. // More help: http://groups.google.com/group/auduino
  9. //
  10. // Analog in 0: Grain 1 pitch
  11. // Analog in 1: Grain 2 decay
  12. // Analog in 2: Grain 1 decay
  13. // Analog in 3: Grain 2 pitch
  14. // Analog in 4: Grain repetition frequency
  15. //
  16. // Digital 3: Audio out (Digital 11 on ATmega8)
  17. //
  18. // Changelog:
  19. // 19 Nov 2008: Added support for ATmega8 boards
  20. // 21 Mar 2009: Added support for ATmega328 boards
  21. // 7 Apr 2009: Fixed interrupt vector for ATmega328 boards
  22. // 8 Apr 2009: Added support for ATmega1280 boards (Arduino Mega)
  23.  
  24. #include <avr/io.h>
  25. #include <avr/interrupt.h>
  26. #include <LiquidCrystal.h>
  27. #include <Wire.h>
  28.  
  29. #define REDLITE 9
  30. #define GREENLITE 10
  31. #define BLUELITE 11
  32.  
  33. // initialize the library with the numbers of the interface pins
  34. LiquidCrystal lcd(0, 1, 6, 7, 8, 12);
  35.  
  36. // you can change the overall brightness by range 0 -> 255
  37. int brightness = 255;
  38.  
  39. int scalePin =5;
  40. int keyPin = 2; // This is shared with grain 1's decay pot. A board with more serial ports will be necessary for the final product
  41.  
  42. uint16_t syncPhaseAcc;
  43. volatile uint16_t syncPhaseInc;
  44. uint16_t grainPhaseAcc;
  45. volatile uint16_t grainPhaseInc;
  46. uint16_t grainAmp;
  47. volatile uint8_t grainDecay;
  48. uint16_t grain2PhaseAcc;
  49. volatile uint16_t grain2PhaseInc;
  50. uint16_t grain2Amp;
  51. volatile uint8_t grain2Decay;
  52.  
  53. // Map Analogue channels
  54. #define SYNC_CONTROL (4)
  55. #define GRAIN_FREQ_CONTROL (0)
  56. #define GRAIN_DECAY_CONTROL (2)
  57. #define GRAIN2_FREQ_CONTROL (3)
  58. #define GRAIN2_DECAY_CONTROL (1)
  59.  
  60.  
  61. // Changing these will also requires rewriting audioOn()
  62.  
  63. #if defined(__AVR_ATmega8__)
  64. //
  65. // On old ATmega8 boards.
  66. // Output is on pin 11
  67. //
  68. #define LED_PIN 13
  69. #define LED_PORT PORTB
  70. #define LED_BIT 5
  71. #define PWM_PIN 11
  72. #define PWM_VALUE OCR2
  73. #define PWM_INTERRUPT TIMER2_OVF_vect
  74. #elif defined(__AVR_ATmega1280__)
  75. //
  76. // On the Arduino Mega
  77. // Output is on pin 3
  78. //
  79. #define LED_PIN 13
  80. #define LED_PORT PORTB
  81. #define LED_BIT 7
  82. #define PWM_PIN 3
  83. #define PWM_VALUE OCR3C
  84. #define PWM_INTERRUPT TIMER3_OVF_vect
  85. #else
  86. //
  87. // For modern ATmega168 and ATmega328 boards
  88. // Output is on pin 3
  89. //
  90. #define PWM_PIN 3
  91. #define PWM_VALUE OCR2B
  92. #define LED_PIN 13
  93. #define LED_PORT PORTB
  94. #define LED_BIT 5
  95. #define PWM_INTERRUPT TIMER2_OVF_vect
  96. #endif
  97.  
  98. #ifndef _NOTETABLES_
  99. #define _NOTETABLES_
  100.  
  101. #include "avr/pgmspace.h"
  102.  
  103. #define MIDI_NOTES 128
  104. // used to convert midi note numbers into the increments required to generate the note in the ISR
  105. PROGMEM unsigned int midiNoteToWavePhaseIncrement[MIDI_NOTES] =
  106. {
  107. 66 // C 0, 8.18,66.98,66 C
  108. ,70 // C# 1, 8.66,70.96,70
  109. ,75 // D 2, 9.18,75.18,75
  110. ,79 // D# 3, 9.72,79.65,79
  111. ,84 // E 4, 10.30,84.38,84
  112. ,89 // F 5, 10.91,89.40,89
  113. ,94 // F# 6, 11.56,94.72,94
  114. ,100 // G 7, 12.25,100.35,100
  115. ,106 // G# 8, 12.98,106.32,106
  116. ,112 // A 9, 13.75,112.64,112
  117. ,119 // A# 10, 14.57,119.34,119
  118. ,126 // B 11, 15.43,126.43,126
  119. ,133 // C0 12, 16.35,133.95,133 C0
  120. ,141 // C#0 13, 17.32,141.92,141
  121. ,150 // D0 14, 18.35,150.35,150
  122. ,159 // D#0 15, 19.45,159.29,159
  123. ,168 // E0 16, 20.60,168.77,168
  124. ,178 // F0 17, 21.83,178.80,178
  125. ,189 // F#0 18, 23.12,189.43,189
  126. ,200 // G0 19, 24.50,200.70,200
  127. ,212 // G#0 20, 25.96,212.63,212
  128. ,225 // A0 21, 27.50,225.28,225
  129. ,238 // A#0 22, 29.14,238.67,238
  130. ,252 // B0 23, 30.87,252.86,252
  131. ,267 // C1 24, 32.70,267.90,267 C1
  132. ,283 // C#1 25, 34.65,283.83,283
  133. ,300 // D1 26, 36.71,300.71,300
  134. ,318 // D#1 27, 38.89,318.59,318
  135. ,337 // E1 28, 41.20,337.53,337
  136. ,357 // F1 29, 43.65,357.60,357
  137. ,378 // F#1 30, 46.25,378.87,378
  138. ,401 // G1 31, 49.00,401.40,401
  139. ,425 // G#1 32, 51.91,425.27,425
  140. ,450 // A1 33, 55.00,450.55,450
  141. ,477 // A#1 34, 58.27,477.34,477
  142. ,505 // B1 35, 61.74,505.73,505
  143. ,535 // C2 36, 65.41,535.80,535 C2
  144. ,567 // C#2 37, 69.30,567.66,567
  145. ,601 // D2 38, 73.42,601.42,601
  146. ,637 // D#2 39, 77.78,637.18,637
  147. ,675 // E2 40, 82.41,675.07,675
  148. ,715 // F2 41, 87.31,715.21,715
  149. ,757 // F#2 42, 92.50,757.74,757
  150. ,802 // G2 43, 98.00,802.79,802
  151. ,850 // G#2 44, 103.83,850.53,850
  152. ,901 // A2 45, 110.00,901.11,901
  153. ,954 // A#2 46, 116.54,954.69,954
  154. ,1011 // B2 47, 123.47,1011.46,1011
  155. ,1071 // C3 48, 130.81,1071.60,1071 C3
  156. ,1135 // C#3 49, 138.59,1135.32,1135
  157. ,1202 // D3 50, 146.83,1202.83,1202
  158. ,1274 // D#3 51, 155.56,1274.36,1274
  159. ,1350 // E3 52, 164.81,1350.13,1350
  160. ,1430 // F3 53, 174.61,1430.42,1430
  161. ,1515 // F#3 54, 185.00,1515.47,1515
  162. ,1605 // G3 55, 196.00,1605.59,1605
  163. ,1701 // G#3 56, 207.65,1701.06,1701
  164. ,1802 // A3 57, 220.00,1802.21,1802
  165. ,1909 // A#3 58, 233.08,1909.38,1909
  166. ,2022 // B3 59, 246.94,2022.92,2022
  167. ,2143 // C4 60, 261.63,2143.20,2143 C4
  168. ,2270 // C#4 61, 277.18,2270.64,2270
  169. ,2405 // D4 62, 293.66,2405.66,2405
  170. ,2548 // D#4 63, 311.13,2548.71,2548
  171. ,2700 // E4 64, 329.63,2700.27,2700
  172. ,2860 // F4 65, 349.23,2860.83,2860
  173. ,3030 // F#4 66, 369.99,3030.95,3030
  174. ,3211 // G4 67, 392.00,3211.18,3211
  175. ,3402 // G#4 68, 415.30,3402.12,3402
  176. ,3604 // A4 69, 440.00,3604.42,3604
  177. ,3818 // A#4 70, 466.16,3818.75,3818
  178. ,4045 // B4 71, 493.88,4045.83,4045
  179. ,4286 // C5 72, 523.25,4286.41,4286 C5
  180. ,4541 // C#5 73, 554.37,4541.29,4541
  181. ,4811 // D5 74, 587.33,4811.33,4811
  182. ,5097 // D#5 75, 622.25,5097.42,5097
  183. ,5400 // E5 76, 659.26,5400.53,5400
  184. ,5721 // F5 77, 698.46,5721.67,5721
  185. ,6061 // F#5 78, 739.99,6061.89,6061
  186. ,6422 // G5 79, 783.99,6422.36,6422
  187. ,6804 // G#5 80, 830.61,6804.25,6804
  188. ,7208 // A5 81, 880.00,7208.85,7208
  189. ,7637 // A#5 82, 932.33,7637.51,7637
  190. ,8091 // B5 83, 987.77,8091.66,8091
  191. ,8572 // C6 84, 1046.50,8572.82,8572 C6
  192. ,9082 // C#6 85, 1108.73,9082.58,9082
  193. ,9622 // D6 86, 1174.66,9622.66,9622
  194. ,10194 // D#6 87, 1244.51,10194.85,10194
  195. ,10801 // E6 88, 1318.51,10801.07,10801
  196. ,11443 // F6 89, 1396.91,11443.33,11443
  197. ,12123 // F#6 90, 1479.98,12123.79,12123
  198. ,12844 // G6 91, 1567.98,12844.71,12844
  199. ,13608 // G#6 92, 1661.22,13608.50,13608
  200. ,14417 // A6 93, 1760.00,14417.70,14417
  201. ,15275 // A#6 94, 1864.65,15275.02,15275
  202. ,16183 // B6 95, 1975.53,16183.31,16183
  203. ,17145 // C7 96, 2093.00,17145.63,17145 C7
  204. ,18165 // C#7 97, 2217.46,18165.16,18165
  205. ,19245 // D7 98, 2349.32,19245.31,19245
  206. ,20389 // D#7 99, 2489.01,20389.70,20389
  207. ,21602 // E7 100, 2637.02,21602.14,21602
  208. ,22886 // F7 101, 2793.83,22886.67,22886
  209. ,24247 // F#7 102, 2959.95,24247.58,24247
  210. ,25689 // G7 103, 3135.96,25689.42,25689
  211. ,27216 // G#7 104, 3322.44,27216.99,27216
  212. ,28835 // A7 105, 3520.00,28835.39,28835
  213. ,30550 // A#7 106, 3729.31,30550.04,30550
  214. ,32366 // B7 107, 3951.06,32366.63,32366
  215. ,34291 // C8 108, 4186.01,34291.26,34291 C8
  216. ,36330 // C#8 109, 4434.92,36330.32,36330
  217. ,38490 // D8 110, 4698.64,38490.65,38490
  218. ,40779 // D#8 111, 4978.03,40779.41,40779
  219. ,43204 // E8 112, 5274.04,43204.25,43204
  220. ,45773 // F8 113, 5587.65,45773.32,45773
  221. ,48495 // F#8 114, 5919.91,48495.14,48495
  222. ,51378 // G8 115, 6271.92,51378.79,51378
  223. ,54433 // G#8 116, 6644.87,54433.96,54433
  224. ,57670 // A8 117, 7040.00,57670.76,57670
  225. ,61100 // A#8 118, 7458.62,61100.07,61100
  226. ,64733 // B8 119, 7902.13,64733.26,64733
  227. ,3046 // C9 120, 8372.02,68582.53,3046 C9
  228. ,7124 // C#9 121, 8869.84,72660.64,7124
  229. ,11445 // D9 122, 9397.27,76981.30,11445
  230. ,16022 // D#9 123, 9956.06,81558.77,16022
  231. ,20872 // E9 124, 10548.07,86408.50,20872
  232. ,26010 // F9 125, 11175.30,91546.65,26010
  233. ,31454 // F#9 126, 11839.81,96990.28,31454
  234. ,31454 // G9 127, 11839.81,96990.28,31454 // possibly incorrect, however no scale will access notes this high
  235. };
  236.  
  237. unsigned int getMidiNotePhaseIncrement(unsigned char sNote)
  238. {
  239. return pgm_read_word(midiNoteToWavePhaseIncrement + (sNote));
  240. }
  241.  
  242. // Major keys
  243. // Key of C ........C D E F G A B
  244. PROGMEM unsigned char majorC[29] = {
  245. 48, 50, 52, 53, 55, 57, 59,
  246. 60, 62, 64, 65, 67, 69, 71,
  247. 72, 74, 76, 77, 79, 81, 83,
  248. 84, 86, 88, 89, 91, 93, 95, 96
  249. };
  250.  
  251. unsigned int getMajorC(unsigned int nAnalogInput)
  252. {
  253. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,29);
  254. uint8_t sMidiIndex = pgm_read_byte(majorC + sPentatonicNote);
  255. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  256. }
  257.  
  258. // Key of G ........G A B C D E F#
  259. PROGMEM unsigned char majorG[29] = {
  260. 55, 57, 59, 48, 50, 52, 54,
  261. 67, 69, 71, 72, 74, 76, 78,
  262. 79, 81, 83, 84, 86, 88, 90,
  263. 91, 93, 95, 96, 98, 100, 102, 103,
  264. };
  265.  
  266. unsigned int getMajorG(unsigned int nAnalogInput)
  267. {
  268. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,29);
  269. uint8_t sMidiIndex = pgm_read_byte(majorG + sPentatonicNote);
  270. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  271. }
  272.  
  273. // Key of D ........D E F# G A B C#
  274. PROGMEM unsigned char majorD[29] = {
  275. 50, 52, 54, 55, 57, 59, 61,
  276. 62, 64, 66, 67, 69, 71, 73,
  277. 74, 76, 78, 79, 81, 83, 85,
  278. 86, 88, 90, 91, 93, 95, 97, 98,
  279. };
  280.  
  281. unsigned int getMajorD(unsigned int nAnalogInput)
  282. {
  283. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,29);
  284. uint8_t sMidiIndex = pgm_read_byte(majorD + sPentatonicNote);
  285. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  286. }
  287.  
  288. // Key of A ........A B C# D E F# G#
  289. PROGMEM unsigned char majorA[29] = {
  290. 57, 59, 61, 62, 64, 66, 68,
  291. 69, 71, 73, 74, 76, 78, 80,
  292. 81, 83, 85, 86, 88, 90, 92,
  293. 93, 95, 97, 98, 100, 102, 104, 105,
  294. };
  295.  
  296. unsigned int getMajorA(unsigned int nAnalogInput)
  297. {
  298. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,29);
  299. uint8_t sMidiIndex = pgm_read_byte(majorA + sPentatonicNote);
  300. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  301. }
  302.  
  303. // Key of E ........E F# G# A B C# D#
  304. PROGMEM unsigned char majorE[29] = {
  305. 52, 54, 56, 57, 59, 61, 63,
  306. 64, 66, 68, 69, 71, 73, 75,
  307. 76, 78, 80, 81, 83, 85, 87,
  308. 88, 90, 92, 93, 95, 97, 99, 100
  309. };
  310.  
  311. unsigned int getMajorE(unsigned int nAnalogInput)
  312. {
  313. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,29);
  314. uint8_t sMidiIndex = pgm_read_byte(majorE + sPentatonicNote);
  315. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  316. }
  317.  
  318. // Key of B ........B C# D# E F# G# A#
  319. PROGMEM unsigned char majorB[29] = {
  320. 59, 61, 63, 64, 66, 68, 70,
  321. 71, 73, 75, 76, 78, 80, 82,
  322. 83, 85, 87, 88, 90, 92, 94,
  323. 95, 97, 99, 100, 102, 104, 106, 107
  324. };
  325.  
  326. unsigned int getMajorB(unsigned int nAnalogInput)
  327. {
  328. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,29);
  329. uint8_t sMidiIndex = pgm_read_byte(majorB + sPentatonicNote);
  330. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  331. }
  332.  
  333. // Key of F# ........F# G# A# B C# D# E#
  334. PROGMEM unsigned char majorFs[29] = {
  335. 54, 56, 58, 59, 61, 63, 65,
  336. 66, 68, 70, 71, 73, 75, 77,
  337. 78, 80, 82, 83, 85, 87, 89,
  338. 90, 92, 94, 95, 97, 99, 101, 102,
  339. };
  340.  
  341. unsigned int getMajorFs(unsigned int nAnalogInput)
  342. {
  343. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,29);
  344. uint8_t sMidiIndex = pgm_read_byte(majorFs + sPentatonicNote);
  345. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  346. }
  347.  
  348. // Key of Db ........C# D# F F# G# A# C
  349. PROGMEM unsigned char majorDb[29] = {
  350. 49, 51, 53, 54, 56, 58, 48,
  351. 61, 63, 65, 66, 68, 70, 60,
  352. 73, 75, 77, 78, 80, 82, 72,
  353. 85, 87, 89, 90, 92, 94, 84, 97
  354. };
  355.  
  356. unsigned int getMajorDb(unsigned int nAnalogInput)
  357. {
  358. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,29);
  359. uint8_t sMidiIndex = pgm_read_byte(majorDb + sPentatonicNote);
  360. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  361. }
  362.  
  363. // Key of Ab ........G# A# C C# D# F G
  364. PROGMEM unsigned char majorAb[29] = {
  365. 56, 58, 48, 61, 63, 65, 67,
  366. 68, 70, 60, 73, 75, 77, 79,
  367. 80, 82, 72, 85, 87, 89, 91,
  368. 92, 94, 84, 97, 99, 101, 103, 104
  369. };
  370.  
  371. unsigned int getMajorAb(unsigned int nAnalogInput)
  372. {
  373. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,29);
  374. uint8_t sMidiIndex = pgm_read_byte(majorAb + sPentatonicNote);
  375. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  376. }
  377.  
  378. // Key of Eb ........D# F G G# A# C D
  379. PROGMEM unsigned char majorEb[29] = {
  380. 51, 53, 55, 56, 58, 48, 62,
  381. 63, 65, 67, 68, 70, 60, 74,
  382. 75, 77, 79, 80, 82, 72, 86,
  383. 87, 89, 91, 92, 94, 84, 98, 99
  384. };
  385.  
  386. unsigned int getMajorEb(unsigned int nAnalogInput)
  387. {
  388. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,29);
  389. uint8_t sMidiIndex = pgm_read_byte(majorEb + sPentatonicNote);
  390. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  391. }
  392.  
  393. // Key of Bb ........A# C D D# F G A
  394. PROGMEM unsigned char majorBb[29] = {
  395. 58, 48, 62, 63, 65, 67, 69,
  396. 70, 60, 74, 75, 77, 79, 81,
  397. 82, 72, 86, 87, 89, 91, 93,
  398. 94, 84, 98, 99, 101, 103, 105, 106
  399. };
  400.  
  401. unsigned int getMajorBb(unsigned int nAnalogInput)
  402. {
  403. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,29);
  404. uint8_t sMidiIndex = pgm_read_byte(majorBb + sPentatonicNote);
  405. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  406. }
  407.  
  408. // Key of F ........F G A A# C D E
  409. PROGMEM unsigned char majorF[29] = {
  410. 53, 55, 57, 58, 48, 62, 64,
  411. 65, 67, 69, 70, 60, 74, 76,
  412. 77, 79, 81, 82, 72, 86, 88,
  413. 89, 91, 93, 94, 84, 98, 100, 101
  414. };
  415.  
  416. unsigned int getMajorF(unsigned int nAnalogInput)
  417. {
  418. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,29);
  419. uint8_t sMidiIndex = pgm_read_byte(majorF + sPentatonicNote);
  420. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  421. }
  422.  
  423. // Half Whole Diminished keys
  424. // Key of C ........C,C#,Eb,E,F#,G,A,A#
  425. PROGMEM unsigned char dimC[25] = {
  426. 48, 49, 51, 52, 54, 55, 57, 58,
  427. 60, 61, 63, 64, 66, 67, 69, 70,
  428. 72, 73, 75, 76, 78, 79, 81, 82, 84,
  429. };
  430.  
  431. unsigned int getDimC(unsigned int nAnalogInput)
  432. {
  433. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,25);
  434. uint8_t sMidiIndex = pgm_read_byte(dimC + sPentatonicNote);
  435. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  436. }
  437.  
  438. // Key of G ........G,G#,A#,B,C#,D,E,F
  439. PROGMEM unsigned char dimG[25] = {
  440. 55, 56, 58, 59, 61, 62, 64, 65,
  441. 67, 68, 70, 71, 73, 74, 76, 77,
  442. 79, 80, 82, 83, 85, 86, 88, 89, 91,
  443. };
  444.  
  445. unsigned int getDimG(unsigned int nAnalogInput)
  446. {
  447. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,25);
  448. uint8_t sMidiIndex = pgm_read_byte(dimG + sPentatonicNote);
  449. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  450. }
  451.  
  452. // Key of D ........D,Eb,F,F#,G#,A,B,C
  453. PROGMEM unsigned char dimD[25] = {
  454. 50, 51, 53, 54, 56, 57, 59, 60,
  455. 62, 63, 65, 66, 68, 69, 71, 72,
  456. 74, 75, 77, 78, 80, 81, 83, 84, 86,
  457. };
  458.  
  459. unsigned int getDimD(unsigned int nAnalogInput)
  460. {
  461. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,25);
  462. uint8_t sMidiIndex = pgm_read_byte(dimD + sPentatonicNote);
  463. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  464. }
  465.  
  466. // Key of A ........A,A#,C,C#,Eb,E,F#,G
  467. PROGMEM unsigned char dimA[25] = {
  468. 57, 58, 60, 61, 63, 64, 66, 67,
  469. 69, 70, 72, 73, 75, 76, 78, 79,
  470. 81, 82, 84, 85, 87, 88, 90, 91, 93,
  471. };
  472.  
  473. unsigned int getDimA(unsigned int nAnalogInput)
  474. {
  475. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,25);
  476. uint8_t sMidiIndex = pgm_read_byte(dimA + sPentatonicNote);
  477. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  478. }
  479.  
  480. // Key of E ........E,F,G,G#,A#,B,C#,D
  481. PROGMEM unsigned char dimE[25] = {
  482. 52, 53, 55, 56, 58, 59, 61, 62,
  483. 64, 65, 67, 68, 70, 71, 73, 74,
  484. 76, 77, 79, 80, 82, 83, 85, 86, 88,
  485. };
  486.  
  487. unsigned int getDimE(unsigned int nAnalogInput)
  488. {
  489. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,25);
  490. uint8_t sMidiIndex = pgm_read_byte(dimE + sPentatonicNote);
  491. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  492. }
  493.  
  494. // Key of B ........B,C,D,Eb,F,F#,G#,A
  495. PROGMEM unsigned char dimB[25] = {
  496. 59, 60, 62, 63, 65, 66, 68, 69,
  497. 71, 72, 74, 75, 77, 78, 80, 81,
  498. 83, 84, 86, 87, 89, 90, 92, 93, 93,
  499. };
  500.  
  501. unsigned int getDimB(unsigned int nAnalogInput)
  502. {
  503. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,25);
  504. uint8_t sMidiIndex = pgm_read_byte(dimB + sPentatonicNote);
  505. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  506. }
  507.  
  508. // Key of F# ........F#,G,A,A#,C,C#,Eb,E
  509. PROGMEM unsigned char dimFs[25] = {
  510. 54, 55, 57, 58, 60, 61, 63, 64,
  511. 66, 67, 69, 70, 72, 73, 75, 76,
  512. 78, 79, 81, 82, 84, 85, 87, 88, 90,
  513. };
  514.  
  515. unsigned int getDimFs(unsigned int nAnalogInput)
  516. {
  517. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,25);
  518. uint8_t sMidiIndex = pgm_read_byte(dimFs + sPentatonicNote);
  519. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  520. }
  521.  
  522. // Key of Db ........C#,D,E,F,G,G#,A#,B
  523. PROGMEM unsigned char dimDb[25] = {
  524. 49, 50, 52, 53, 55, 56, 58, 59,
  525. 61, 62, 64, 65, 67, 68, 70, 71,
  526. 73, 74, 76, 77, 79, 80, 82, 83, 85,
  527. };
  528.  
  529. unsigned int getDimDb(unsigned int nAnalogInput)
  530. {
  531. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,25);
  532. uint8_t sMidiIndex = pgm_read_byte(dimDb + sPentatonicNote);
  533. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  534. }
  535.  
  536. // Key of Ab ........G#,A,B,C,D,Eb,F,F#
  537. PROGMEM unsigned char dimAb[25] = {
  538. 56, 57, 59, 60, 62, 63, 65, 66,
  539. 68, 69, 71, 72, 74, 75, 77, 78,
  540. 80, 81, 83, 84, 86, 87, 89, 90, 92,
  541. };
  542.  
  543. unsigned int getDimAb(unsigned int nAnalogInput)
  544. {
  545. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,25);
  546. uint8_t sMidiIndex = pgm_read_byte(dimAb + sPentatonicNote);
  547. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  548. }
  549.  
  550. // Key of Eb ........Eb,E,F#,G,A,A#,C,C#
  551. PROGMEM unsigned char dimEb[25] = {
  552. 51, 52, 54, 55, 57, 58, 60, 61,
  553. 63, 64, 66, 67, 69, 70, 72, 73,
  554. 75, 76, 78, 79, 81, 82, 84, 85, 87,
  555. };
  556.  
  557. unsigned int getDimEb(unsigned int nAnalogInput)
  558. {
  559. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,25);
  560. uint8_t sMidiIndex = pgm_read_byte(dimEb + sPentatonicNote);
  561. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  562. }
  563.  
  564. // Key of Bb ........A#,B,C#,D,E,F,G,G#
  565. PROGMEM unsigned char dimBb[25] = {
  566. 58, 59, 61, 62, 64, 65, 67, 68,
  567. 70, 71, 73, 74, 76, 77, 79, 80,
  568. 82, 83, 85, 86, 88, 89, 91, 92, 94
  569. };
  570.  
  571. unsigned int getDimBb(unsigned int nAnalogInput)
  572. {
  573. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,25);
  574. uint8_t sMidiIndex = pgm_read_byte(dimBb + sPentatonicNote);
  575. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  576. }
  577.  
  578. // Key of F ........F,F#,G#,A,B,C,D,Eb
  579. PROGMEM unsigned char dimF[25] = {
  580. 53, 54, 56, 57, 59, 60, 62, 63,
  581. 65, 66, 68, 69, 71, 72, 74, 75,
  582. 77, 78, 80, 81, 83, 84, 86, 87, 89,
  583. };
  584.  
  585. unsigned int getDimF(unsigned int nAnalogInput)
  586. {
  587. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,25);
  588. uint8_t sMidiIndex = pgm_read_byte(dimF + sPentatonicNote);
  589. return pgm_read_word(midiNoteToWavePhaseIncrement + sMidiIndex);
  590. }
  591. // Minor Pentatonic Keys
  592. // Key of C ........C,Eb,F,G,A#,C
  593. PROGMEM unsigned char pentC[26] = {
  594. 36, 39, 41, 43, 46,
  595. 48, 51, 53, 55, 58,
  596. 60, 63, 65, 67, 70,
  597. 72, 75, 77, 79, 82,
  598. 84, 87, 89, 91, 94, 96,
  599. };
  600.  
  601. unsigned int getPentC(unsigned int nAnalogInput)
  602. {
  603. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,26);
  604. uint8_t sMidiIndex = pgm_read_byte(pentC + sPentatonicNote);
  605. return pgm_read_word(midiNoteToWavePhaseIncrement +
  606.  
  607. sMidiIndex);
  608. }
  609.  
  610. // Key of G ........G,A#,C,D,F,G
  611. PROGMEM unsigned char pentG[26] = {
  612. 43, 46, 48, 50, 53,
  613. 55, 58, 60, 62, 65,
  614. 67, 70, 72, 74, 77,
  615. 79, 82, 84, 86, 89,
  616. 91, 94, 96, 98, 101, 103,
  617. };
  618.  
  619. unsigned int getPentG(unsigned int nAnalogInput)
  620. {
  621. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,26);
  622. uint8_t sMidiIndex = pgm_read_byte(pentG + sPentatonicNote);
  623. return pgm_read_word(midiNoteToWavePhaseIncrement +
  624.  
  625. sMidiIndex);
  626. }
  627.  
  628. // Key of D ........D,F,G,A,C,D
  629. PROGMEM unsigned char pentD[26] = {
  630. 38, 41, 43, 45, 48,
  631. 50, 53, 55, 57, 60,
  632. 62, 65, 67, 69, 72,
  633. 74, 77, 79, 81, 84,
  634. 86, 89, 91, 93, 96, 98,
  635. };
  636.  
  637. unsigned int getPentD(unsigned int nAnalogInput)
  638. {
  639. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,26);
  640. uint8_t sMidiIndex = pgm_read_byte(pentD + sPentatonicNote);
  641. return pgm_read_word(midiNoteToWavePhaseIncrement +
  642.  
  643. sMidiIndex);
  644. }
  645.  
  646. // Key of A ........A,C,D,E,G,A
  647. PROGMEM unsigned char pentA[26] = {
  648. 45, 48, 50, 52, 55,
  649. 57, 60, 62, 64, 67,
  650. 69, 72, 74, 76, 79,
  651. 81, 84, 86, 88, 91,
  652. 93, 96, 98, 100, 103, 105,
  653. };
  654.  
  655. unsigned int getPentA(unsigned int nAnalogInput)
  656. {
  657. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,26);
  658. uint8_t sMidiIndex = pgm_read_byte(pentA + sPentatonicNote);
  659. return pgm_read_word(midiNoteToWavePhaseIncrement +
  660.  
  661. sMidiIndex);
  662. }
  663.  
  664. // Key of E ........E,G,A,B,D,E
  665. PROGMEM unsigned char pentE[26] = {
  666. 40, 43, 45, 47, 50,
  667. 52, 55, 57, 59, 62,
  668. 64, 67, 69, 71, 74,
  669. 76, 79, 81, 83, 86,
  670. 88, 91, 93, 95, 98, 100,
  671. };
  672.  
  673. unsigned int getPentE(unsigned int nAnalogInput)
  674. {
  675. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,26);
  676. uint8_t sMidiIndex = pgm_read_byte(pentE + sPentatonicNote);
  677. return pgm_read_word(midiNoteToWavePhaseIncrement +
  678.  
  679. sMidiIndex);
  680. }
  681.  
  682. // Key of B ........B,D,E,F#,A,
  683. PROGMEM unsigned char pentB[26] = {
  684. 47, 50, 52, 54, 57,
  685. 59, 62, 64, 66, 69,
  686. 71, 74, 76, 78, 81,
  687. 83, 86, 88, 90, 93,
  688. 95, 98, 100, 102, 105, 107,
  689. };
  690.  
  691. unsigned int getPentB(unsigned int nAnalogInput)
  692. {
  693. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,26);
  694. uint8_t sMidiIndex = pgm_read_byte(pentB + sPentatonicNote);
  695. return pgm_read_word(midiNoteToWavePhaseIncrement +
  696.  
  697. sMidiIndex);
  698. }
  699.  
  700. // Key of F# ........F#,A,B,C#,E,F#
  701. PROGMEM unsigned char pentFs[26] = {
  702. 42, 45, 47, 49, 52,
  703. 54, 57, 59, 61, 64,
  704. 66, 69, 71, 73, 76,
  705. 78, 81, 83, 85, 88,
  706. 90, 93, 95, 97, 100, 102,
  707. };
  708.  
  709. unsigned int getPentFs(unsigned int nAnalogInput)
  710. {
  711. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,26);
  712. uint8_t sMidiIndex = pgm_read_byte(pentFs + sPentatonicNote);
  713. return pgm_read_word(midiNoteToWavePhaseIncrement +
  714.  
  715. sMidiIndex);
  716. }
  717.  
  718. // Key of Db ........C#,E,F#,G#,B,C#
  719. PROGMEM unsigned char pentDb[26] = {
  720. 37, 40, 42, 44, 47,
  721. 49, 52, 54, 56, 59,
  722. 61, 64, 66, 68, 71,
  723. 73, 76, 78, 80, 83,
  724. 85, 88, 90, 92, 95, 97,
  725. };
  726.  
  727. unsigned int getPentDb(unsigned int nAnalogInput)
  728. {
  729. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,26);
  730. uint8_t sMidiIndex = pgm_read_byte(pentDb + sPentatonicNote);
  731. return pgm_read_word(midiNoteToWavePhaseIncrement +
  732.  
  733. sMidiIndex);
  734. }
  735.  
  736. // Key of Ab ........G#,B,C#,Eb,F#,G#
  737. PROGMEM unsigned char pentAb[26] = {
  738. 44, 47, 49, 51, 54,
  739. 56, 59, 61, 63, 66,
  740. 68, 71, 73, 75, 78,
  741. 80, 83, 85, 87, 90,
  742. 92, 95, 97, 99, 102, 104,
  743. };
  744.  
  745. unsigned int getPentAb(unsigned int nAnalogInput)
  746. {
  747. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,26);
  748. uint8_t sMidiIndex = pgm_read_byte(pentAb + sPentatonicNote);
  749. return pgm_read_word(midiNoteToWavePhaseIncrement +
  750.  
  751. sMidiIndex);
  752. }
  753.  
  754. // Key of Eb ........Eb,F#,G#,A#,C#,Eb
  755. PROGMEM unsigned char pentEb[26] = {
  756. 39, 42, 44, 46, 49,
  757. 51, 66, 68, 70, 61,
  758. 63, 78, 80, 82, 73,
  759. 75, 78, 92, 94, 85,
  760. 87, 90, 104, 106, 97, 99,
  761. };
  762.  
  763. unsigned int getPentEb(unsigned int nAnalogInput)
  764. {
  765. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,26);
  766. uint8_t sMidiIndex = pgm_read_byte(pentEb + sPentatonicNote);
  767. return pgm_read_word(midiNoteToWavePhaseIncrement +
  768.  
  769. sMidiIndex);
  770. }
  771.  
  772. // Key of Bb ........A#,C#,Eb,F,G#,A#
  773. PROGMEM unsigned char pentBb[26] = {
  774. 46, 49, 51, 53, 56,
  775. 58, 61, 63, 65, 68,
  776. 70, 73, 75, 77, 80,
  777. 82, 85, 87, 89, 92,
  778. 94, 97, 99, 101, 104, 106,
  779. };
  780.  
  781. unsigned int getPentBb(unsigned int nAnalogInput)
  782. {
  783. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,26);
  784. uint8_t sMidiIndex = pgm_read_byte(pentBb + sPentatonicNote);
  785. return pgm_read_word(midiNoteToWavePhaseIncrement +
  786.  
  787. sMidiIndex);
  788. }
  789.  
  790. // Key of F ........F,G#,A#,C,Eb,F
  791. PROGMEM unsigned char pentF[26] = {
  792. 41, 44, 46, 48, 51,
  793. 53, 56, 58, 60, 63,
  794. 65, 68, 70, 72, 75,
  795. 77, 80, 82, 84, 87,
  796. 89, 92, 94, 96, 99, 101,
  797. };
  798.  
  799. unsigned int getPentF(unsigned int nAnalogInput)
  800. {
  801. uint8_t sPentatonicNote = map(nAnalogInput,0,1024,0,26);
  802. uint8_t sMidiIndex = pgm_read_byte(pentF + sPentatonicNote);
  803. return pgm_read_word(midiNoteToWavePhaseIncrement +
  804.  
  805. sMidiIndex);
  806. }
  807. #endif
  808.  
  809. // Smooth logarithmic mapping
  810. //
  811. uint16_t antilogTable[] = {
  812. 64830,64132,63441,62757,62081,61413,60751,60097,59449,58809,58176,57549,56929,56316,55709,55109,
  813. 54515,53928,53347,52773,52204,51642,51085,50535,49991,49452,48920,48393,47871,47356,46846,46341,
  814. 45842,45348,44859,44376,43898,43425,42958,42495,42037,41584,41136,40693,40255,39821,39392,38968,
  815. 38548,38133,37722,37316,36914,36516,36123,35734,35349,34968,34591,34219,33850,33486,33125,32768
  816. };
  817. uint16_t mapPhaseInc(uint16_t input) {
  818. return (antilogTable[input & 0x3f]) >> (input >> 6);
  819. }
  820.  
  821. void audioOn() {
  822. #if defined(__AVR_ATmega8__)
  823. // ATmega8 has different registers
  824. TCCR2 = _BV(WGM20) | _BV(COM21) | _BV(CS20);
  825. TIMSK = _BV(TOIE2);
  826. #elif defined(__AVR_ATmega1280__)
  827. TCCR3A = _BV(COM3C1) | _BV(WGM30);
  828. TCCR3B = _BV(CS30);
  829. TIMSK3 = _BV(TOIE3);
  830. #else
  831. // Set up PWM to 31.25kHz, phase accurate
  832. TCCR2A = _BV(COM2B1) | _BV(WGM20);
  833. TCCR2B = _BV(CS20);
  834. TIMSK2 = _BV(TOIE2);
  835. #endif
  836. }
  837.  
  838.  
  839. void setup() {
  840. pinMode(PWM_PIN,OUTPUT);
  841. audioOn();
  842. pinMode(LED_PIN,OUTPUT);
  843.  
  844. // set up the LCD's number of rows and columns:
  845. lcd.begin(16, 2);
  846. // Print a message to the LCD.
  847. lcd.print("RGB 16x2 Display ");
  848. lcd.setCursor(0,1);
  849. lcd.print(" Multicolor LCD ");
  850.  
  851. pinMode(REDLITE, OUTPUT);
  852. pinMode(GREENLITE, OUTPUT);
  853. pinMode(BLUELITE, OUTPUT);
  854.  
  855. brightness = 100;
  856.  
  857. }
  858.  
  859. void loop() {
  860. // The loop is pretty simple - it just updates the parameters for the oscillators.
  861. //
  862. // Avoid using any functions that make extensive use of interrupts, or turn interrupts off.
  863. // They will cause clicks and poops in the audio.
  864.  
  865. // Smooth frequency mapping
  866. //syncPhaseInc = mapPhaseInc(analogRead(SYNC_CONTROL)) / 4;
  867.  
  868. // Stepped mapping to MIDI notes: C, Db, D, Eb, E, F...
  869. //syncPhaseInc = mapMidi(analogRead(SYNC_CONTROL));
  870.  
  871. // Stepped pentatonic mapping: D, E, G, A, B
  872. //syncPhaseInc = getPentatonicPhaseIncrement(analogRead(SYNC_CONTROL));
  873.  
  874. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  875. // Reads the scale select pin, converts input to 3 choices.+
  876. // Reads the converted input to select a scale from the +
  877. // corresponding case. This then reads from the key pin +
  878. // and selects from a choice of 12 keys from a nested case.+
  879. // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  880.  
  881. int scale = analogRead(scalePin);
  882. scale = constrain(scale, 0, 1023);
  883. int scaleSelect = map(scale, 0, 1024, 0, 3);
  884.  
  885. int key = analogRead(keyPin);
  886. key = constrain(key, 0, 1023);
  887. int keySelect = map(key, 0, 1024, 0, 11);
  888.  
  889. switch (scaleSelect) {
  890. case 0:
  891. switch (keySelect) {
  892. case 0:
  893. syncPhaseInc = getMajorC(analogRead(SYNC_CONTROL));
  894. break;
  895. case 1:
  896. syncPhaseInc = getMajorG(analogRead(SYNC_CONTROL));
  897. break;
  898. case 2:
  899. syncPhaseInc = getMajorD(analogRead(SYNC_CONTROL));
  900. break;
  901. case 3:
  902. syncPhaseInc = getMajorA(analogRead(SYNC_CONTROL));
  903. break;
  904. case 4:
  905. syncPhaseInc = getMajorE(analogRead(SYNC_CONTROL));
  906. break;
  907. case 5:
  908. syncPhaseInc = getMajorB(analogRead(SYNC_CONTROL));
  909. break;
  910. case 6:
  911. syncPhaseInc = getMajorFs(analogRead(SYNC_CONTROL));
  912. break;
  913. case 7:
  914. syncPhaseInc = getMajorDb(analogRead(SYNC_CONTROL));
  915. break;
  916. case 8:
  917. syncPhaseInc = getMajorAb(analogRead(SYNC_CONTROL));
  918. break;
  919. case 9:
  920. syncPhaseInc = getMajorEb(analogRead(SYNC_CONTROL));
  921. break;
  922. case 10:
  923. syncPhaseInc = getMajorBb(analogRead(SYNC_CONTROL));
  924. break;
  925. case 11:
  926. syncPhaseInc = getMajorF(analogRead(SYNC_CONTROL));
  927. break;
  928. }
  929. case 1:
  930. switch (keySelect) {
  931. case 0:
  932. syncPhaseInc = getDimC(analogRead(SYNC_CONTROL));
  933. break;
  934. case 1:
  935. syncPhaseInc = getDimG(analogRead(SYNC_CONTROL));
  936. break;
  937. case 2:
  938. syncPhaseInc = getDimD(analogRead(SYNC_CONTROL));
  939. break;
  940. case 3:
  941. syncPhaseInc = getDimA(analogRead(SYNC_CONTROL));
  942. break;
  943. case 4:
  944. syncPhaseInc = getDimE(analogRead(SYNC_CONTROL));
  945. break;
  946. case 5:
  947. syncPhaseInc = getDimB(analogRead(SYNC_CONTROL));
  948. break;
  949. case 6:
  950. syncPhaseInc = getDimFs(analogRead(SYNC_CONTROL));
  951. break;
  952. case 7:
  953. syncPhaseInc = getDimDb(analogRead(SYNC_CONTROL));
  954. break;
  955. case 8:
  956. syncPhaseInc = getDimAb(analogRead(SYNC_CONTROL));
  957. break;
  958. case 9:
  959. syncPhaseInc = getDimEb(analogRead(SYNC_CONTROL));
  960. break;
  961. case 10:
  962. syncPhaseInc = getDimBb(analogRead(SYNC_CONTROL));
  963. break;
  964. case 11:
  965. syncPhaseInc = getDimF(analogRead(SYNC_CONTROL));
  966. break;
  967. }
  968. case 2:
  969. switch (keySelect) {
  970. case 0:
  971. syncPhaseInc = getPentC(analogRead(SYNC_CONTROL));
  972. break;
  973. case 1:
  974. syncPhaseInc = getPentG(analogRead(SYNC_CONTROL));
  975. break;
  976. case 2:
  977. syncPhaseInc = getPentD(analogRead(SYNC_CONTROL));
  978. break;
  979. case 3:
  980. syncPhaseInc = getPentA(analogRead(SYNC_CONTROL));
  981. break;
  982. case 4:
  983. syncPhaseInc = getPentE(analogRead(SYNC_CONTROL));
  984. break;
  985. case 5:
  986. syncPhaseInc = getPentB(analogRead(SYNC_CONTROL));
  987. break;
  988. case 6:
  989. syncPhaseInc = getPentFs(analogRead(SYNC_CONTROL));
  990. break;
  991. case 7:
  992. syncPhaseInc = getPentDb(analogRead(SYNC_CONTROL));
  993. break;
  994. case 8:
  995. syncPhaseInc = getPentAb(analogRead(SYNC_CONTROL));
  996. break;
  997. case 9:
  998. syncPhaseInc = getPentEb(analogRead(SYNC_CONTROL));
  999. break;
  1000. case 10:
  1001. syncPhaseInc = getPentBb(analogRead(SYNC_CONTROL));
  1002. break;
  1003. case 11:
  1004. syncPhaseInc = getPentF(analogRead(SYNC_CONTROL));
  1005. break;
  1006. }
  1007. }
  1008.  
  1009. grainPhaseInc = mapPhaseInc(analogRead(GRAIN_FREQ_CONTROL)) / 2;
  1010. grainDecay = analogRead(GRAIN_DECAY_CONTROL) / 8;
  1011. grain2PhaseInc = mapPhaseInc(analogRead(GRAIN2_FREQ_CONTROL)) / 2;
  1012. grain2Decay = analogRead(GRAIN2_DECAY_CONTROL) / 4;
  1013.  
  1014. for (int i = 0; i < 255; i++) {
  1015. setBacklight(i, 0, 255-i);
  1016. delay(1);
  1017. }
  1018. for (int i = 0; i < 255; i++) {
  1019. setBacklight(255-i, i, 0);
  1020. delay(1);
  1021. }
  1022. for (int i = 0; i < 255; i++) {
  1023. setBacklight(0, 255-i, i);
  1024. delay(1);
  1025. }
  1026. }
  1027.  
  1028. SIGNAL(PWM_INTERRUPT)
  1029. {
  1030. uint8_t value;
  1031. uint16_t output;
  1032.  
  1033. syncPhaseAcc += syncPhaseInc;
  1034. if (syncPhaseAcc < syncPhaseInc) {
  1035. // Time to start the next grain
  1036. grainPhaseAcc = 0;
  1037. grainAmp = 0x7fff;
  1038. grain2PhaseAcc = 0;
  1039. grain2Amp = 0x7fff;
  1040. LED_PORT ^= 1 << LED_BIT; // Faster than using digitalWrite
  1041. }
  1042.  
  1043. // Increment the phase of the grain oscillators
  1044. grainPhaseAcc += grainPhaseInc;
  1045. grain2PhaseAcc += grain2PhaseInc;
  1046.  
  1047. // Convert phase into a triangle wave
  1048. value = (grainPhaseAcc >> 7) & 0xff;
  1049. if (grainPhaseAcc & 0x8000) value = ~value;
  1050. // Multiply by current grain amplitude to get sample
  1051. output = value * (grainAmp >> 8);
  1052.  
  1053. // Repeat for second grain
  1054. value = (grain2PhaseAcc >> 7) & 0xff;
  1055. if (grain2PhaseAcc & 0x8000) value = ~value;
  1056. output += value * (grain2Amp >> 8);
  1057.  
  1058. // Make the grain amplitudes decay by a factor every sample (exponential decay)
  1059. grainAmp -= (grainAmp >> 8) * grainDecay;
  1060. grain2Amp -= (grain2Amp >> 8) * grain2Decay;
  1061.  
  1062. // Scale output to the available range, clipping if necessary
  1063. output >>= 9;
  1064. if (output > 255) output = 255;
  1065.  
  1066. // Output to PWM (this is faster than using analogWrite)
  1067. PWM_VALUE = output;
  1068. }
  1069.  
  1070. void setBacklight(uint8_t red, uint8_t green , uint8_t blue) {
  1071. // normalize the red LED - its brighter than the rest!
  1072. red = map(red, 0, 255, 0, 100);
  1073. green = map(green, 0, 255, 0, 150);
  1074.  
  1075. red = map(red, 0, 255, 0, brightness);
  1076. green = map(green, 0, 255, 0, brightness);
  1077. blue = map(blue, 0, 255, 0, brightness);
  1078.  
  1079. // common anode so invert!
  1080. red = map(red, 0, 255, 255, 0);
  1081. green = map(green, 0, 255, 255, 0);
  1082. blue = map(blue, 0, 255, 255, 0);
  1083. Serial.print("R = "); Serial.print(red, DEC);
  1084. Serial.print(" G = "); Serial.print(green, DEC);
  1085. Serial.print(" B = "); Serial.println(blue, DEC);
  1086. analogWrite(REDLITE, red);
  1087. analogWrite(GREENLITE, green);
  1088. analogWrite(BLUELITE, blue);
  1089. }
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!