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. 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
  36. 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
  37. int pinALast[] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW};
  38. int aVal[] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW};
  39. int EncoderChannel[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}; // encoder channel
  40. 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
  41. int led[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  42. int led_state_old[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  43. int ButtonChannel[] = {21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40}; // button Channel
  44. int taste[] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW}; // button state
  45. 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
  46. int buttons = 16;
  47. int encoders = 16;
  48. int encodernums = 32;
  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 < 5; i++) {
  127. shifter0.setAllHigh();
  128. shifter1.setAllHigh();
  129. delay(250);
  130. shifter0.setAllLow();
  131. shifter1.setAllLow();
  132. delay(250);
  133. }
  135. //encoder start
  136. //--------------------------------------------------------------------------------------------------------------
  137. for (int i = 0; i < encoders; i++) {
  138. led[i] = map(encoderPosCount[i], 0, 127, 0, 8);
  139. shifterset(led[i], i);
  140. }
  142. //fine adjust
  143. //--------------------------------------------------------------------------------------------------------------
  144. pinMode(23, OUTPUT);
  145. pinMode(22, INPUT);
  148. //74HC165 setup
  149. //--------------------------------------------------------------------------------------------------------------
  150. /* Initialize our digital pins...
  151. */
  152. pinMode(ploadPin, OUTPUT);
  153. pinMode(clockEnablePin, OUTPUT);
  154. pinMode(clockPin, OUTPUT);
  155. pinMode(dataPin, INPUT);
  157. digitalWrite(clockPin, LOW);
  158. digitalWrite(ploadPin, HIGH);
  160. /* Read in and display the pin states at startup.
  161. */
  162. read_shift_regs();
  163. display_pin_values();
  165. //set display
  166. //--------------------------------------------------------------------------------------------------------------
  167. Serial1.begin(31250);
  168. Serial.begin(115200);
  169. delay(500);
  170. lcd.clear();
  171. timedate();
  172. lcd.setCursor(2, 2);
  173. lcd.print("OUT: 000 CH: 000");
  174. lcd.setCursor(2, 3);
  175. lcd.print("IN: 000 CH: 000");
  178. digitalWrite(25, LOW);
  179. digitalWrite(24, HIGH);
  180. }
  182. //setup ende
  183. //--------------------------------------------------------------------------------------------------------------
  185. void loop() {
  187. //74HC165 read
  188. read_shift_regs();
  190. /* If there was a chage in state, display which ones changed.
  191. */
  192. for (int i = 0; i < DATA_WIDTH; i++) {
  193. if (shift[i] != shift_old[i])
  194. {
  195. display_pin_values();
  196. shift_old[i] = shift[i];
  197. }
  198. }
  200. readdata(); // Midi data read
  201. encoder(); // read encoder pos and send Midi data
  202. button(); // read button state and send Midi data
  204. if (millis() > millisold) {
  205. timedate();
  206. millisold = millis() + 10000;
  207. }
  209. //fine adjust
  210. adjust = digitalRead(22);
  211. if (adjust == HIGH && adjustold == LOW) {
  212. digitalWrite(23, HIGH);
  213. if (adjuststate == 1) {
  214. adjuststate = 0;
  215. digitalWrite(23, LOW);
  216. } else {
  217. adjuststate = 1;
  218. }
  219. adjustold = adjust;
  220. }
  221. if (adjust == LOW && adjustold == HIGH) {
  222. adjustold = adjust;
  223. }
  225. }
  227. // midi send data
  228. //--------------------------------------------------------------------------------------------------------------
  229. void MIDISEND(int controlChange, int controllerNummer, int controllerWert) {
  230. Serial1.write(controlChange);
  231. Serial1.write(controllerNummer);
  232. Serial1.write(controllerWert);
  233. setout(controllerWert, controllerNummer);
  235. }
  237. // Midi read data
  238. //--------------------------------------------------------------------------------------------------------------
  239. void readdata() {
  240. if (Serial1.available() > 2) {
  241. commandByte = Serial1.read();//read first byte
  242. noteByte = Serial1.read();//read next byte Channel 1-127
  243. velocityByte = Serial1.read();//read final byte value 0-127
  245. setin(velocityByte, noteByte);
  246. if (commandByte == noteOn) { //if note on message
  247. if (noteByte < 20) {
  248. //encoders
  249. for (int i = 0; i < encoders; i++) {
  250. int encodernum = i + 1;
  251. if (noteByte == encodernum) {
  252. encoderPosCount[i] = velocityByte;
  254. led[i] = map(velocityByte, 0, 127, 0, 8);
  255. shifterset(led[i], i);
  256. }
  257. }
  258. } else {
  259. // buttons
  260. for (int i = 0; i < buttons; i++) {
  261. if (noteByte == ButtonChannel[i]) {
  262. if (velocityByte == 127) {
  263. shifter1.set(i, HIGH); //turn on led
  264. } else {
  265. shifter1.set(i, LOW); //turn on led
  266. }
  267. }
  268. }
  269. }
  270. }
  271. }
  272. }
  274. // button config
  275. //--------------------------------------------------------------------------------------------------------------
  276. void button() {
  277. for (int i = 0; i < buttons; i++) {
  280. if (taste[i] == HIGH && tasteAlt[i] == LOW) {
  281. shifter1.set(i, HIGH);
  282. MIDISEND(noteOn, ButtonChannel[i], 127);
  283. tasteAlt[i] = taste[i];
  284. }
  285. if (taste[i] == LOW && tasteAlt[i] == HIGH) {
  286. shifter1.set(i, LOW);
  287. MIDISEND(noteOn, ButtonChannel[i], 0);
  288. tasteAlt[i] = taste[i];
  289. }
  291. }
  292. }
  294. // encoder config
  295. //--------------------------------------------------------------------------------------------------------------
  296. void encoder() {
  297. for (int e_num = 0; e_num < encoders; e_num++) {
  299. aVal[e_num] = pinA[e_num];
  300. if (aVal[e_num] != pinALast[e_num]) { // Means the knob is rotating
  301. // if the knob is rotating, we need to determine direction
  302. // We do that by reading pin B.
  303. if (pinB[e_num] != aVal[e_num]) { // Means pin A Changed first - We're Rotating Clockwise
  304. if (encoderPosCount[e_num] < 127) {
  305. if (adjuststate == 0) {
  306. encoderPosCount[e_num] = encoderPosCount[e_num] + 2;
  307. } else {
  308. encoderPosCount[e_num] = encoderPosCount[e_num] + 1;
  309. }
  310. if ( encoderPosCount[e_num] > 127) {
  311. encoderPosCount[e_num] = 127;
  312. }
  313. MIDISEND(noteOn, EncoderChannel[e_num], encoderPosCount[e_num]);
  314. led[e_num] = map(encoderPosCount[e_num], 0, 127, 0, 8);
  315. shifterset(led[e_num], e_num);
  316. }
  317. } else {// Otherwise B changed first and we're moving CCW
  318. if (encoderPosCount[e_num] > 0) {
  319. if (adjuststate == 0) {
  320. encoderPosCount[e_num] = encoderPosCount[e_num] - 2;
  321. } else {
  322. encoderPosCount[e_num] = encoderPosCount[e_num] - 1;
  323. }
  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];
  336. }
  337. }
  339. //time date
  340. //--------------------------------------------------------------------------------------------------------------
  341. void timedate() {
  342. lcd.setCursor(0, 0);
  343. if (day() < 10) {
  344. lcd.print("0");
  345. lcd.print(day());
  346. } else {
  347. lcd.print(day());
  348. }
  349. lcd.print(".");
  350. lcd.setCursor(3, 0);
  351. if (month() < 10) {
  352. lcd.print("0");
  353. lcd.print(month());
  354. } else {
  355. lcd.print(month());
  356. }
  358. lcd.print(".");
  359. if (year() < 10) {
  360. lcd.print("0");
  361. lcd.print(year());
  362. } else {
  363. lcd.print(year());
  364. }
  366. lcd.setCursor(15, 0);
  368. if (hour() < 10) {
  369. lcd.print("0");
  370. lcd.print(hour());
  371. } else {
  372. lcd.print(hour());
  373. }
  375. lcd.print(":");
  377. if (minute() < 10) {
  378. lcd.print("0");
  379. lcd.print(minute());
  380. } else {
  381. lcd.print(minute());
  382. }
  383. }
  385. //display out
  386. //--------------------------------------------------------------------------------------------------------------
  387. void setout (int wert, int chan) {
  388. lcd.setCursor(7, 2);
  389. if (wert < 10) {
  390. lcd.print("00");
  391. lcd.print(wert);
  392. } else if (wert < 100) {
  393. lcd.print("0");
  394. lcd.print(wert);
  395. } else {
  396. lcd.print(wert);
  397. }
  398. lcd.setCursor(15, 2);
  399. if (chan < 10) {
  400. lcd.print("00");
  401. lcd.print(chan);
  402. } else if (chan < 100) {
  403. lcd.print("0");
  404. lcd.print(chan);
  405. } else {
  406. lcd.print(chan);
  407. }
  408. }
  410. //set input display
  411. //--------------------------------------------------------------------------------------------------------------
  412. void setin (int wert, int chan) {
  413. lcd.setCursor(7, 3);
  414. if (wert < 10) {
  415. lcd.print("00");
  416. lcd.print(wert);
  417. } else if (wert < 100) {
  418. lcd.print("0");
  419. lcd.print(wert);
  420. } else {
  421. lcd.print(wert);
  422. }
  423. lcd.setCursor(15, 3);
  424. if (chan < 10) {
  425. lcd.print("00");
  426. lcd.print(chan);
  427. } else if (chan < 100) {
  428. lcd.print("0");
  429. lcd.print(chan);
  430. } else {
  431. lcd.print(chan);
  432. }
  433. }
  435. //set encoder shift
  436. //--------------------------------------------------------------------------------------------------------------
  437. void shifterset(int ledval, int shifternum) {
  438. int ledout = ledval;
  439. int start = shifternum * 8;
  441. for (int i = 0; i < shifternum; i++) {
  442. ledout = ledout + 8;
  443. }
  445. for (int i = start; i < ledout; i++) {
  446. shifter0.set(i, HIGH);
  447. }
  449. if (led_state_old[shifternum] > ledout) {
  450. for (int i = ledout; i < led_state_old[shifternum]; i++) {
  451. shifter0.set(i, LOW);
  452. }
  453. }
  454. led_state_old[shifternum] = ledout;
  455. }
  457. //74HC165 funktion
  458. //--------------------------------------------------------------------------------------------------------------
  459. void read_shift_regs()
  460. {
  461. int bitVal;
  463. /* Trigger a parallel Load to latch the state of the data lines,
  464. */
  465. digitalWrite(clockEnablePin, HIGH);
  466. digitalWrite(ploadPin, LOW);
  467. delayMicroseconds(PULSE_WIDTH_USEC);
  468. digitalWrite(ploadPin, HIGH);
  469. digitalWrite(clockEnablePin, LOW);
  471. /* Loop to read each bit value from the serial out line
  472. * of the SN74HC165N.
  473. */
  474. for (int i = 0; i < DATA_WIDTH; i++)
  475. {
  476. bitVal = digitalRead(dataPin);
  477. /* Set the corresponding bit in bytesVal.
  478. */
  479. shift[DATA_WIDTH - 1 - i] = bitVal;
  480. /* Pulse the Clock (rising edge shifts the next bit).
  481. */
  482. digitalWrite(clockPin, HIGH);
  483. delayMicroseconds(PULSE_WIDTH_USEC);
  484. digitalWrite(clockPin, LOW);
  485. }
  486. }
  488. //--------------------------------------------------------------------------------------------------------------
  489. /* Dump the list of zones along with their current status.
  490. */
  491. void display_pin_values()
  492. {
  493. countA = 0;
  494. for (int i = 0; i < DATA_WIDTH; i++)
  495. {
  497. if (shift[i] == 1) {
  498. data = HIGH;
  499. } else {
  500. data = LOW;
  501. }
  503. Serial.print("Pin: ");
  504. Serial.print(i);
  505. Serial.print(" ");
  506. Serial.print(data);
  507. Serial.println();
  509. if (i < encodernums) {
  511. if (count == 0) {
  512. pinA[countA / 2] = data;
  513. count = 1;
  514. } else {
  515. pinB[countA / 2] = data;
  516. count = 0;
  517. }
  518. countA++;
  519. } else {
  520. if (i == encodernums) {
  521. countA = 0;
  522. Serial.print("BUTTONS");
  523. Serial.println();
  524. }
  526. if (countA < buttons) {
  527. taste[countA] = data;
  528. countA++;
  529. }
  530. }
  532. }
  535. }