1. //74HC165 start
  2. //--------------------------------------------------------------------------------------------------------------
  4. /* Width of pulse to trigger the shift register to read and latch.
  5. */
  6. #define PULSE_WIDTH_USEC 1
  8. /* Optional delay between shift register reads.
  9. */
  10. #define POLL_DELAY_MSEC 1
  12. /* You will need to change the "int" to "long" If the
  13. * NUMBER_OF_SHIFT_CHIPS is higher than 2.
  14. */
  16. int ploadPin = 5; // Connects to Parallel load pin the 165
  17. int clockEnablePin = 6; // Connects to Clock Enable pin the 165
  18. int dataPin = 7; // Connects to the Q7 pin the 165
  19. int clockPin = 8; // Connects to the Clock pin the 165
  21. /* How many shift register chips are daisy-chained.
  22. */
  23. const byte NUMBER_OF_SHIFT_CHIPS = 6;
  25. /* Width of data (how many ext lines).
  26. */
  27. const byte DATA_WIDTH = NUMBER_OF_SHIFT_CHIPS * 8;
  29. /* This function is essentially a "shift-in" routine reading the
  30. * serial Data from the shift register chips and representing
  31. * the state of those pins in an unsigned integer (or long).
  32. */
  33. //--------------------------------------------------------------------------------------------------------------
  35. const int buttons = 16;
  36. const int encoders = 16;
  37. const int encodernums = encoders * 2;
  38. int pinA[encoders]; // encoder read A
  39. int pinB[encoders]; // encoder read B
  40. int pinALast[encoders];
  41. int aVal[encoders];
  42. int encoderPosCount[encoders]; // encoder start value
  43. int taste[buttons]; // button state
  44. int tasteAlt[buttons]; // button state old
  45. int led[encoders];
  46. int led_state_old[encoders];
  47. int EncoderChannel[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}; // encoder channel
  48. int ButtonChannel[] = {21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40}; // button Channel
  49. int shift[DATA_WIDTH];
  50. int shift_old[DATA_WIDTH];
  51. int count = 0;
  52. int countA = 0;
  53. int countB = 0;
  54. int data = LOW;
  55. unsigned long millisold = 10000;
  56. int noteOn = 176; //note state
  57. byte commandByte; // read note state
  58. byte noteByte; // read Midi Channel
  59. byte velocityByte; // read Midi value
  60. int adjust = 0;
  61. int adjustold = 0;
  62. int adjuststate = 0;
  65. //74HC595 start
  66. //--------------------------------------------------------------------------------------------------------------
  68. #include <ShiftRegister74HC595.h>
  70. // create shift register object (number of shift registers, data pin, clock pin, latch pin)
  71. ShiftRegister74HC595 shifter0 (14, 2, 4, 3);
  72. ShiftRegister74HC595 shifter1 (2, 11, 9, 10);
  74. //time
  75. //--------------------------------------------------------------------------------------------------------------
  76. #include <TimeLib.h>
  77. #include <Wire.h>
  78. #include <DS1307RTC.h>
  80. //start LCD
  81. //--------------------------------------------------------------------------------------------------------------
  82. #include <LiquidCrystal_I2C.h>
  84. // set the LCD address to 0x3F for a 20 chars 4 line display
  85. // Set the pins on the I2C chip used for LCD connections:
  86. // addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
  87. LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
  89. //--------------------------------------------------------------------------------------------------------------
  91. void setup() {
  93. //power LED RG
  94. pinMode(24, OUTPUT);
  95. pinMode(25, OUTPUT);
  97. digitalWrite(25, HIGH);
  99. setSyncProvider(RTC.get);
  101. // start scene
  102. //--------------------------------------------------------------------------------------------------------------
  103. lcd.begin(20, 4);
  104. lcd.clear();
  105. lcd.setCursor(0, 0);
  106. lcd.print("Arduino MIDI");
  107. lcd.setCursor(0, 1);
  108. lcd.print("Controller Load ");
  110. // encoder LED graph start
  111. //--------------------------------------------------------------------------------------------------------------
  112. // for (int i = 0; i < 9; i++) {
  113. // for (int i1 = 0; i1 < encoders; i1++) {
  114. // shifterset(i, i1);
  115. // }
  116. // delay(1);
  117. // }
  118. // for (int i = 8; i > -1; i--) {
  119. // for (int i1 = 0; i1 < encoders; i1++) {
  120. // shifterset(i, i1);
  121. // }
  122. // delay(1);
  123. // }
  124. // delay(100);
  126. for (int i = 0; i < 3; i++) {
  127. shifter0.setAllHigh();
  128. shifter1.setAllHigh();
  129. delay(250);
  130. shifter0.setAllLow();
  131. shifter1.setAllLow();
  132. delay(250);
  133. }
  134. shifter0.setAllHigh();
  135. shifter1.setAllHigh();
  136. delay(1000);
  137. shifter0.setAllLow();
  138. shifter1.setAllLow();
  140. //encoder start
  141. //--------------------------------------------------------------------------------------------------------------
  142. for (int i = 0; i < encoders; i++) {
  143. led[i] = map(encoderPosCount[i], 0, 127, 0, 8);
  144. shifterset(led[i], i);
  145. }
  147. //fine adjust
  148. //--------------------------------------------------------------------------------------------------------------
  149. pinMode(23, OUTPUT);
  150. pinMode(22, INPUT);
  153. //74HC165 setup
  154. //--------------------------------------------------------------------------------------------------------------
  155. /* Initialize our digital pins...
  156. */
  157. pinMode(ploadPin, OUTPUT);
  158. pinMode(clockEnablePin, OUTPUT);
  159. pinMode(clockPin, OUTPUT);
  160. pinMode(dataPin, INPUT);
  162. digitalWrite(clockPin, LOW);
  163. digitalWrite(ploadPin, HIGH);
  165. /* Read in and display the pin states at startup.
  166. */
  167. read_shift_regs();
  168. display_pin_values();
  170. //set display
  171. //--------------------------------------------------------------------------------------------------------------
  172. Serial1.begin(31250);
  173. //Serial.begin(115200);
  174. delay(500);
  175. lcd.clear();
  176. timedate();
  177. lcd.setCursor(2, 2);
  178. lcd.print("OUT: 000 CH: 000");
  179. lcd.setCursor(2, 3);
  180. lcd.print("IN: 000 CH: 000");
  183. digitalWrite(25, LOW);
  184. digitalWrite(24, HIGH);
  185. }
  187. //setup ende
  188. //--------------------------------------------------------------------------------------------------------------
  190. void loop() {
  192. //74HC165 read
  193. read_shift_regs();
  195. /* If there was a chage in state, display which ones changed.
  196. */
  197. for (int i = 0; i < DATA_WIDTH; i++) {
  198. if (shift[i] != shift_old[i])
  199. {
  200. display_pin_values();
  201. shift_old[i] = shift[i];
  202. }
  203. }
  205. readdata(); // Midi data read
  206. encoder(); // read encoder pos and send Midi data
  207. button(); // read button state and send Midi data
  209. if (millis() > millisold) {
  210. timedate();
  211. millisold = millis() + 10000;
  212. }
  214. //fine adjust
  215. adjust = digitalRead(22);
  216. if (adjust == HIGH && adjustold == LOW) {
  217. digitalWrite(23, HIGH);
  218. if (adjuststate == 1) {
  219. adjuststate = 0;
  220. digitalWrite(23, LOW);
  221. } else {
  222. adjuststate = 1;
  223. }
  224. adjustold = adjust;
  225. }
  226. if (adjust == LOW && adjustold == HIGH) {
  227. adjustold = adjust;
  228. }
  230. }
  232. // midi send data
  233. //--------------------------------------------------------------------------------------------------------------
  234. void MIDISEND(int controlChange, int controllerNummer, int controllerWert) {
  235. Serial1.write(controlChange);
  236. Serial1.write(controllerNummer);
  237. Serial1.write(controllerWert);
  238. setout(controllerWert, controllerNummer);
  239. }
  241. // Midi read data
  242. //--------------------------------------------------------------------------------------------------------------
  243. void readdata() {
  244. if (Serial1.available() > 2) {
  245. commandByte = Serial1.read();//read first byte
  246. noteByte = Serial1.read();//read next byte Channel 1-127
  247. velocityByte = Serial1.read();//read final byte value 0-127
  249. setin(velocityByte, noteByte);
  250. if (commandByte == noteOn) { //if note on message
  251. if (noteByte < 20) {
  252. //encoders
  253. for (int i = 0; i < encoders; i++) {
  254. int encodernum = i + 1;
  255. if (noteByte == encodernum) {
  256. encoderPosCount[i] = velocityByte;
  258. led[i] = map(velocityByte, 0, 127, 0, 8);
  259. shifterset(led[i], i);
  260. }
  261. }
  262. } else {
  263. // buttons
  264. for (int i = 0; i < buttons; i++) {
  265. if (noteByte == ButtonChannel[i]) {
  266. if (velocityByte == 127) {
  267. shifter1.set(i, HIGH); //turn on led
  268. } else {
  269. shifter1.set(i, LOW); //turn on led
  270. }
  271. }
  272. }
  273. }
  274. }
  275. }
  276. }
  278. // button config
  279. //--------------------------------------------------------------------------------------------------------------
  280. void button() {
  281. for (int i = 0; i < buttons; i++) {
  284. if (taste[i] == HIGH && tasteAlt[i] == LOW) {
  285. shifter1.set(i, HIGH);
  286. MIDISEND(noteOn, ButtonChannel[i], 127);
  287. tasteAlt[i] = taste[i];
  288. }
  289. if (taste[i] == LOW && tasteAlt[i] == HIGH) {
  290. shifter1.set(i, LOW);
  291. MIDISEND(noteOn, ButtonChannel[i], 0);
  292. tasteAlt[i] = taste[i];
  293. }
  295. }
  296. }
  298. // encoder config
  299. //--------------------------------------------------------------------------------------------------------------
  300. void encoder() {
  301. for (int e_num = 0; e_num < encoders; e_num++) {
  302. aVal[e_num] = pinA[e_num];
  303. if ((pinALast[e_num] == 0) && (aVal[e_num] == 1)) {
  304. if (pinB[e_num] == 0) {
  305. if (encoderPosCount[e_num] != 127) {
  306. if (adjuststate == 0) {
  307. encoderPosCount[e_num] = encoderPosCount[e_num] + 3;
  308. } else {
  309. encoderPosCount[e_num]++;
  310. }
  311. if (encoderPosCount[e_num] > 127) {
  312. encoderPosCount[e_num] = 127;
  313. }
  314. MIDISEND(noteOn, EncoderChannel[e_num], encoderPosCount[e_num]);
  315. led[e_num] = map(encoderPosCount[e_num], 0, 127, 0, 8);
  316. shifterset(led[e_num], e_num);
  317. }
  318. } else {
  319. if (encoderPosCount[e_num] != 0) {
  320. if (adjuststate == 0) {
  321. encoderPosCount[e_num] = encoderPosCount[e_num] - 3;
  322. } else {
  323. encoderPosCount[e_num]--;
  324. }
  325. if (encoderPosCount[e_num] < 0) {
  326. encoderPosCount[e_num] = 0;
  327. }
  328. MIDISEND(noteOn, EncoderChannel[e_num], encoderPosCount[e_num]);
  329. led[e_num] = map(encoderPosCount[e_num], 0, 127, 0, 8);
  330. shifterset(led[e_num], e_num);
  331. }
  332. }
  333. }
  334. pinALast[e_num] = aVal[e_num];
  335. }
  336. }
  338. //time date
  339. //--------------------------------------------------------------------------------------------------------------
  340. void timedate() {
  341. lcd.setCursor(0, 0);
  342. if (day() < 10) {
  343. lcd.print("0");
  344. lcd.print(day());
  345. } else {
  346. lcd.print(day());
  347. }
  348. lcd.print(".");
  349. lcd.setCursor(3, 0);
  350. if (month() < 10) {
  351. lcd.print("0");
  352. lcd.print(month());
  353. } else {
  354. lcd.print(month());
  355. }
  357. lcd.print(".");
  358. if (year() < 10) {
  359. lcd.print("0");
  360. lcd.print(year());
  361. } else {
  362. lcd.print(year());
  363. }
  365. lcd.setCursor(15, 0);
  367. if (hour() < 10) {
  368. lcd.print("0");
  369. lcd.print(hour());
  370. } else {
  371. lcd.print(hour());
  372. }
  374. lcd.print(":");
  376. if (minute() < 10) {
  377. lcd.print("0");
  378. lcd.print(minute());
  379. } else {
  380. lcd.print(minute());
  381. }
  382. }
  384. //display out
  385. //--------------------------------------------------------------------------------------------------------------
  386. void setout (int wert, int chan) {
  387. lcd.setCursor(7, 2);
  388. if (wert < 10) {
  389. lcd.print("00");
  390. lcd.print(wert);
  391. } else if (wert < 100) {
  392. lcd.print("0");
  393. lcd.print(wert);
  394. } else {
  395. lcd.print(wert);
  396. }
  397. lcd.setCursor(15, 2);
  398. if (chan < 10) {
  399. lcd.print("00");
  400. lcd.print(chan);
  401. } else if (chan < 100) {
  402. lcd.print("0");
  403. lcd.print(chan);
  404. } else {
  405. lcd.print(chan);
  406. }
  407. }
  409. //set input display
  410. //--------------------------------------------------------------------------------------------------------------
  411. void setin (int wert, int chan) {
  412. lcd.setCursor(7, 3);
  413. if (wert < 10) {
  414. lcd.print("00");
  415. lcd.print(wert);
  416. } else if (wert < 100) {
  417. lcd.print("0");
  418. lcd.print(wert);
  419. } else {
  420. lcd.print(wert);
  421. }
  422. lcd.setCursor(15, 3);
  423. if (chan < 10) {
  424. lcd.print("00");
  425. lcd.print(chan);
  426. } else if (chan < 100) {
  427. lcd.print("0");
  428. lcd.print(chan);
  429. } else {
  430. lcd.print(chan);
  431. }
  432. }
  434. //set encoder shift
  435. //--------------------------------------------------------------------------------------------------------------
  436. void shifterset(int ledval, int shifternum) {
  437. int ledout = ledval;
  438. int start = shifternum * 8;
  440. for (int i = 0; i < shifternum; i++) {
  441. ledout = ledout + 8;
  442. }
  444. for (int i = start; i < ledout; i++) {
  445. shifter0.set(i, HIGH);
  446. }
  448. if (led_state_old[shifternum] > ledout) {
  449. for (int i = ledout; i < led_state_old[shifternum]; i++) {
  450. shifter0.set(i, LOW);
  451. }
  452. }
  453. led_state_old[shifternum] = ledout;
  454. }
  456. //74HC165 funktion
  457. //--------------------------------------------------------------------------------------------------------------
  458. void read_shift_regs()
  459. {
  460. int bitVal;
  462. /* Trigger a parallel Load to latch the state of the data lines,
  463. */
  464. digitalWrite(clockEnablePin, HIGH);
  465. digitalWrite(ploadPin, LOW);
  466. delayMicroseconds(PULSE_WIDTH_USEC);
  467. digitalWrite(ploadPin, HIGH);
  468. digitalWrite(clockEnablePin, LOW);
  470. /* Loop to read each bit value from the serial out line
  471. * of the SN74HC165N.
  472. */
  473. for (int i = 0; i < DATA_WIDTH; i++)
  474. {
  475. bitVal = digitalRead(dataPin);
  476. /* Set the corresponding bit in bytesVal.
  477. */
  478. shift[DATA_WIDTH - 1 - i] = bitVal;
  479. /* Pulse the Clock (rising edge shifts the next bit).
  480. */
  481. digitalWrite(clockPin, HIGH);
  482. delayMicroseconds(PULSE_WIDTH_USEC);
  483. digitalWrite(clockPin, LOW);
  484. }
  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 (shift[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. }