1. //74HC165 start
  2. //--------------------------------------------------------------------------------------------------------------
  3. /* How many shift register chips are daisy-chained.
  4. */
  5. #define NUMBER_OF_SHIFT_CHIPS 6
  7. /* Width of data (how many ext lines).
  8. */
  9. #define DATA_WIDTH NUMBER_OF_SHIFT_CHIPS * 8
  11. /* Width of pulse to trigger the shift register to read and latch.
  12. */
  13. #define PULSE_WIDTH_USEC 5
  15. /* Optional delay between shift register reads.
  16. */
  17. #define POLL_DELAY_MSEC 5
  19. /* You will need to change the "int" to "long" If the
  20. * NUMBER_OF_SHIFT_CHIPS is higher than 2.
  21. */
  22. #define BYTES_VAL_T long
  24. int ploadPin = 5; // Connects to Parallel load pin the 165
  25. int clockEnablePin = 6; // Connects to Clock Enable pin the 165
  26. int dataPin = 7; // Connects to the Q7 pin the 165
  27. int clockPin = 8; // Connects to the Clock pin the 165
  29. BYTES_VAL_T pinValues;
  30. BYTES_VAL_T oldPinValues;
  32. /* This function is essentially a "shift-in" routine reading the
  33. * serial Data from the shift register chips and representing
  34. * the state of those pins in an unsigned integer (or long).
  35. */
  36. //--------------------------------------------------------------------------------------------------------------
  38. int pinA[] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW}; // encoder read A
  39. int pinB[] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW}; // encoder read B
  40. int pinALast[] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW};
  41. int aVal[] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW};
  42. int EncoderChannel[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}; // encoder channel
  43. int encoderPosCount[] = {65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65}; // encoder start value
  44. int led[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  45. int led_state_old[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  46. int ButtonChannel[] = {21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40}; // button Channel
  47. int taste[] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW}; // button state
  48. int tasteAlt[] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW}; // button state old
  49. int buttons = 16;
  50. int encoders = 16;
  51. int encodernums = 32;
  52. int count = 0;
  53. int countA = 0;
  54. int countB = 0;
  55. int data = LOW;
  56. unsigned long millisold = 10000;
  57. int noteOn = 176; //note state
  58. byte commandByte; // read note state
  59. byte noteByte; // read Midi Channel
  60. byte velocityByte; // read Midi value
  61. int adjust = 0;
  62. int adjustold = 0;
  63. int adjuststate = 0;
  66. //74HC595 start
  67. //--------------------------------------------------------------------------------------------------------------
  69. #include <ShiftRegister74HC595.h>
  71. // create shift register object (number of shift registers, data pin, clock pin, latch pin)
  72. ShiftRegister74HC595 shifter0 (14, 2, 4, 3);
  73. ShiftRegister74HC595 shifter1 (2, 11, 9, 10);
  75. //time
  76. //--------------------------------------------------------------------------------------------------------------
  77. #include <TimeLib.h>
  78. #include <Wire.h>
  79. #include <DS1307RTC.h>
  81. //start LCD
  82. //--------------------------------------------------------------------------------------------------------------
  83. #include <LiquidCrystal_I2C.h>
  85. // set the LCD address to 0x3F for a 20 chars 4 line display
  86. // Set the pins on the I2C chip used for LCD connections:
  87. // addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
  88. LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
  90. //--------------------------------------------------------------------------------------------------------------
  92. void setup() {
  94. //power LED RG
  95. pinMode(24, OUTPUT);
  96. pinMode(25, OUTPUT);
  98. digitalWrite(25, HIGH);
  100. setSyncProvider(RTC.get);
  102. // start scene
  103. //--------------------------------------------------------------------------------------------------------------
  104. lcd.begin(20, 4);
  105. lcd.clear();
  106. lcd.setCursor(0, 0);
  107. lcd.print("Arduino MIDI");
  108. lcd.setCursor(0, 1);
  109. lcd.print("Controller Load ");
  111. // encoder LED graph start
  112. //--------------------------------------------------------------------------------------------------------------
  113. for (int i = 0; i < 9; i++) {
  114. for (int i1 = 0; i1 < encoders; i1++) {
  115. shifterset(i, i1);
  116. }
  117. delay(5);
  118. }
  119. for (int i = 8; i > -1; i--) {
  120. for (int i1 = 0; i1 < encoders; i1++) {
  121. shifterset(i, i1);
  122. }
  123. delay(5);
  124. }
  125. delay(100);
  126. shifter0.setAllHigh();
  127. shifter1.setAllHigh();
  128. delay(500);
  129. shifter0.setAllLow();
  130. shifter1.setAllLow();
  132. //encoder start
  133. //--------------------------------------------------------------------------------------------------------------
  134. for (int i = 0; i < encoders; i++) {
  135. led[i] = map(encoderPosCount[i], 0, 127, 0, 8);
  136. shifterset(led[i], i);
  137. }
  139. //fine adjust
  140. //--------------------------------------------------------------------------------------------------------------
  141. pinMode(23, OUTPUT);
  142. pinMode(22, INPUT);
  145. //74HC165 setup
  146. //--------------------------------------------------------------------------------------------------------------
  147. /* Initialize our digital pins...
  148. */
  149. pinMode(ploadPin, OUTPUT);
  150. pinMode(clockEnablePin, OUTPUT);
  151. pinMode(clockPin, OUTPUT);
  152. pinMode(dataPin, INPUT);
  154. digitalWrite(clockPin, LOW);
  155. digitalWrite(ploadPin, HIGH);
  157. /* Read in and display the pin states at startup.
  158. */
  159. pinValues = read_shift_regs();
  160. display_pin_values();
  161. oldPinValues = pinValues;
  163. //set display
  164. //--------------------------------------------------------------------------------------------------------------
  165. Serial1.begin(31250);
  166. Serial.begin(115200);
  167. delay(500);
  168. lcd.clear();
  169. timedate();
  170. lcd.setCursor(2, 2);
  171. lcd.print("OUT: 000 CH: 000");
  172. lcd.setCursor(2, 3);
  173. lcd.print("IN: 000 CH: 000");
  176. digitalWrite(25, LOW);
  177. digitalWrite(24, HIGH);
  178. }
  180. //setup ende
  181. //--------------------------------------------------------------------------------------------------------------
  183. void loop() {
  185. //74HC165 read
  186. pinValues = read_shift_regs();
  188. /* If there was a chage in state, display which ones changed.
  189. */
  190. if (pinValues != oldPinValues)
  191. {
  192. display_pin_values();
  193. oldPinValues = pinValues;
  194. }
  196. readdata(); // Midi data read
  197. encoder(); // read encoder pos and send Midi data
  198. button(); // read button state and send Midi data
  200. if (millis() > millisold) {
  201. timedate();
  202. millisold = millis() + 10000;
  203. }
  205. //fine adjust
  206. adjust = digitalRead(22);
  207. if (adjust == HIGH && adjustold == LOW) {
  208. digitalWrite(23, HIGH);
  209. if (adjuststate == 1) {
  210. adjuststate = 0;
  211. digitalWrite(23, LOW);
  212. } else {
  213. adjuststate = 1;
  214. }
  215. adjustold = adjust;
  216. }
  217. if (adjust == LOW && adjustold == HIGH) {
  218. adjustold = adjust;
  219. }
  221. }
  223. // midi send data
  224. //--------------------------------------------------------------------------------------------------------------
  225. void MIDISEND(int controlChange, int controllerNummer, int controllerWert) {
  226. Serial1.write(controlChange);
  227. Serial1.write(controllerNummer);
  228. Serial1.write(controllerWert);
  229. setout(controllerWert, controllerNummer);
  231. }
  233. // Midi read data
  234. //--------------------------------------------------------------------------------------------------------------
  235. void readdata() {
  236. if (Serial1.available() > 2) {
  237. commandByte = Serial1.read();//read first byte
  238. noteByte = Serial1.read();//read next byte Channel 1-127
  239. velocityByte = Serial1.read();//read final byte value 0-127
  241. setin(velocityByte, noteByte);
  242. if (commandByte == noteOn) { //if note on message
  243. if (noteByte < 20) {
  244. //encoders
  245. for (int i = 0; i < encoders; i++) {
  246. int encodernum = i + 1;
  247. if (noteByte == encodernum) {
  248. encoderPosCount[i] = velocityByte;
  250. led[i] = map(velocityByte, 0, 127, 0, 8);
  251. shifterset(led[i], i);
  252. }
  253. }
  254. } else {
  255. // buttons
  256. for (int i = 0; i < buttons; i++) {
  257. if (noteByte == ButtonChannel[i]) {
  258. if (velocityByte == 127) {
  259. shifter1.set(i, HIGH); //turn on led
  260. } else {
  261. shifter1.set(i, LOW); //turn on led
  262. }
  263. }
  264. }
  265. }
  266. }
  267. }
  268. }
  270. // button config
  271. //--------------------------------------------------------------------------------------------------------------
  272. void button() {
  273. for (int i = 0; i < buttons; i++) {
  276. if (taste[i] == HIGH && tasteAlt[i] == LOW) {
  277. shifter1.set(i, HIGH);
  278. MIDISEND(noteOn, ButtonChannel[i], 127);
  279. tasteAlt[i] = taste[i];
  280. }
  281. if (taste[i] == LOW && tasteAlt[i] == HIGH) {
  282. shifter1.set(i, LOW);
  283. MIDISEND(noteOn, ButtonChannel[i], 0);
  284. tasteAlt[i] = taste[i];
  285. }
  287. }
  288. }
  290. // encoder config
  291. //--------------------------------------------------------------------------------------------------------------
  292. void encoder() {
  293. for (int e_num = 0; e_num < encoders; e_num++) {
  295. aVal[e_num] = pinA[e_num];
  296. if (aVal[e_num] != pinALast[e_num]) { // Means the knob is rotating
  297. // if the knob is rotating, we need to determine direction
  298. // We do that by reading pin B.
  299. if (pinB[e_num] != aVal[e_num]) { // Means pin A Changed first - We're Rotating Clockwise
  300. if (encoderPosCount[e_num] < 127) {
  301. if (adjuststate == 0) {
  302. encoderPosCount[e_num] = encoderPosCount[e_num] + 2;
  303. } else {
  304. encoderPosCount[e_num] = encoderPosCount[e_num] + 1;
  305. }
  306. if ( encoderPosCount[e_num] > 127) {
  307. encoderPosCount[e_num] = 127;
  308. }
  309. MIDISEND(noteOn, EncoderChannel[e_num], encoderPosCount[e_num]);
  310. led[e_num] = map(encoderPosCount[e_num], 0, 127, 0, 8);
  311. shifterset(led[e_num], e_num);
  312. }
  313. } else {// Otherwise B changed first and we're moving CCW
  314. if (encoderPosCount[e_num] > 0) {
  315. if (adjuststate == 0) {
  316. encoderPosCount[e_num] = encoderPosCount[e_num] - 2;
  317. } else {
  318. encoderPosCount[e_num] = encoderPosCount[e_num] - 1;
  319. }
  321. if ( encoderPosCount[e_num] < 0) {
  322. encoderPosCount[e_num] = 0;
  323. }
  324. MIDISEND(noteOn, EncoderChannel[e_num], encoderPosCount[e_num]);
  325. led[e_num] = map(encoderPosCount[e_num], 0, 127, 0, 8);
  326. shifterset(led[e_num], e_num);
  327. }
  328. }
  329. }
  330. pinALast[e_num] = aVal[e_num];
  332. }
  333. }
  335. //time date
  336. //--------------------------------------------------------------------------------------------------------------
  337. void timedate() {
  338. lcd.setCursor(0, 0);
  339. if (day() < 10) {
  340. lcd.print("0");
  341. lcd.print(day());
  342. } else {
  343. lcd.print(day());
  344. }
  345. lcd.print(".");
  346. lcd.setCursor(3, 0);
  347. if (month() < 10) {
  348. lcd.print("0");
  349. lcd.print(month());
  350. } else {
  351. lcd.print(month());
  352. }
  354. lcd.print(".");
  355. if (year() < 10) {
  356. lcd.print("0");
  357. lcd.print(year());
  358. } else {
  359. lcd.print(year());
  360. }
  362. lcd.setCursor(15, 0);
  364. if (hour() < 10) {
  365. lcd.print("0");
  366. lcd.print(hour());
  367. } else {
  368. lcd.print(hour());
  369. }
  371. lcd.print(":");
  373. if (minute() < 10) {
  374. lcd.print("0");
  375. lcd.print(minute());
  376. } else {
  377. lcd.print(minute());
  378. }
  379. }
  381. //display out
  382. //--------------------------------------------------------------------------------------------------------------
  383. void setout (int wert, int chan) {
  384. lcd.setCursor(7, 2);
  385. if (wert < 10) {
  386. lcd.print("00");
  387. lcd.print(wert);
  388. } else if (wert < 100) {
  389. lcd.print("0");
  390. lcd.print(wert);
  391. } else {
  392. lcd.print(wert);
  393. }
  394. lcd.setCursor(15, 2);
  395. if (chan < 10) {
  396. lcd.print("00");
  397. lcd.print(chan);
  398. } else if (chan < 100) {
  399. lcd.print("0");
  400. lcd.print(chan);
  401. } else {
  402. lcd.print(chan);
  403. }
  404. }
  406. //set input display
  407. //--------------------------------------------------------------------------------------------------------------
  408. void setin (int wert, int chan) {
  409. lcd.setCursor(7, 3);
  410. if (wert < 10) {
  411. lcd.print("00");
  412. lcd.print(wert);
  413. } else if (wert < 100) {
  414. lcd.print("0");
  415. lcd.print(wert);
  416. } else {
  417. lcd.print(wert);
  418. }
  419. lcd.setCursor(15, 3);
  420. if (chan < 10) {
  421. lcd.print("00");
  422. lcd.print(chan);
  423. } else if (chan < 100) {
  424. lcd.print("0");
  425. lcd.print(chan);
  426. } else {
  427. lcd.print(chan);
  428. }
  429. }
  431. //set encoder shift
  432. //--------------------------------------------------------------------------------------------------------------
  433. void shifterset(int ledval, int shifternum) {
  434. int ledout = ledval;
  435. int start = shifternum * 8;
  437. for (int i = 0; i < shifternum; i++) {
  438. ledout = ledout + 8;
  439. }
  441. for (int i = start; i < ledout; i++) {
  442. shifter0.set(i, HIGH);
  443. }
  445. if (led_state_old[shifternum] > ledout) {
  446. for (int i = ledout; i < led_state_old[shifternum]; i++) {
  447. shifter0.set(i, LOW);
  448. }
  449. }
  450. led_state_old[shifternum] = ledout;
  451. }
  453. //74HC165 funktion
  454. //--------------------------------------------------------------------------------------------------------------
  455. BYTES_VAL_T read_shift_regs()
  456. {
  457. long bitVal;
  458. BYTES_VAL_T bytesVal = 0;
  460. /* Trigger a parallel Load to latch the state of the data lines,
  461. */
  462. digitalWrite(clockEnablePin, HIGH);
  463. digitalWrite(ploadPin, LOW);
  464. delayMicroseconds(PULSE_WIDTH_USEC);
  465. digitalWrite(ploadPin, HIGH);
  466. digitalWrite(clockEnablePin, LOW);
  468. /* Loop to read each bit value from the serial out line
  469. * of the SN74HC165N.
  470. */
  471. for (int i = 0; i < DATA_WIDTH; i++)
  472. {
  473. bitVal = digitalRead(dataPin);
  474. /* Set the corresponding bit in bytesVal.
  475. */
  476. bytesVal |= (bitVal << ((DATA_WIDTH - 1) - i));
  478. /* Pulse the Clock (rising edge shifts the next bit).
  479. */
  480. digitalWrite(clockPin, HIGH);
  481. delayMicroseconds(PULSE_WIDTH_USEC);
  482. digitalWrite(clockPin, LOW);
  483. }
  484. return (bytesVal);
  485. }
  487. //--------------------------------------------------------------------------------------------------------------
  488. /* Dump the list of zones along with their current status.
  489. */
  490. void display_pin_values()
  491. {
  492. countA = 0;
  493. for (int i = 0; i < DATA_WIDTH; i++)
  494. {
  496. if ((pinValues >> i) & 1) {
  497. data = HIGH;
  498. } else {
  499. data = LOW;
  500. }
  502. if (i < encodernums) {
  504. if (count == 0) {
  505. pinA[countA / 2] = data;
  506. count = 1;
  507. } else {
  508. pinB[countA / 2] = data;
  509. count = 0;
  510. }
  511. countA++;
  512. } else {
  513. if (i == encodernums) {
  514. countA = 0;
  515. }
  517. if (countA < buttons) {
  518. taste[countA] = data;
  519. countA++;
  520. }
  521. }
  523. }
  526. }