1. //74HC165 start
  2. //--------------------------------------------------------------------------------------------------------------
  3. /* How many shift register chips are daisy-chained.
  4. */
  5. #define NUMBER_OF_SHIFT_CHIPS 2
  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 2
  15. /* Optional delay between shift register reads.
  16. */
  17. #define POLL_DELAY_MSEC 0
  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 unsigned int
  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 = 10;
  50. int encoders = 3;
  51. int encodernums = 6;
  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
  63. //74HC595 start
  64. //--------------------------------------------------------------------------------------------------------------
  66. #define SER_Pin 2 //Serial data input
  67. #define RCLK_Pin 3 //Register clock
  68. #define SRCLK_Pin 4 //Shift register clock
  69. #define NumOf 4 //Shift register clock
  71. #include <ShiftRegister74HC595.h>
  73. // create shift register object (number of shift registers, data pin, clock pin, latch pin)
  74. ShiftRegister74HC595 shifter0 (3, 2, 4, 3);
  75. ShiftRegister74HC595 shifter1 (2, 11, 9, 10);
  77. //time
  78. //--------------------------------------------------------------------------------------------------------------
  79. #include <TimeLib.h>
  80. #include <Wire.h>
  81. #include <DS1307RTC.h>
  83. //start LCD
  84. //--------------------------------------------------------------------------------------------------------------
  85. #include <LiquidCrystal_I2C.h>
  87. // set the LCD address to 0x3F for a 20 chars 4 line display
  88. // Set the pins on the I2C chip used for LCD connections:
  89. // addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
  90. LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
  92. //--------------------------------------------------------------------------------------------------------------
  94. void setup() {
  96. setSyncProvider(RTC.get);
  98. // start scene
  99. //--------------------------------------------------------------------------------------------------------------
  100. lcd.begin(20, 4);
  101. lcd.clear();
  102. lcd.setCursor(0, 0);
  103. lcd.print("Arduino MIDI");
  104. lcd.setCursor(0, 1);
  105. lcd.print("Controller Load ");
  107. // encoder LED graph start
  108. //--------------------------------------------------------------------------------------------------------------
  109. for (int i = 0; i < 9; i++) {
  110. for (int i1 = 0; i1 < encoders; i1++){
  111. shifterset(i, i1);
  112. }
  113. delay(40);
  114. }
  115. for (int i = 9; i > -1; i--) {
  116. for (int i1 = 0; i1 < encoders; i1++){
  117. shifterset(i, i1);
  118. }
  119. delay(40);
  120. }
  121. shifter0.setAllHigh();
  122. shifter1.setAllHigh();
  123. delay(500);
  124. shifter0.setAllLow();
  125. shifter1.setAllLow();
  127. //set display
  128. //--------------------------------------------------------------------------------------------------------------
  129. Serial1.begin(31250);
  130. delay(500);
  131. lcd.clear();
  132. lcd.setCursor(2, 2);
  133. lcd.print("OUT: 000 CH: 000");
  134. lcd.setCursor(2, 3);
  135. lcd.print("IN: 000 CH: 000");
  137. //--------------------------------------------------------------------------------------------------------------
  139. timedate(); // read time
  141. //encoder start
  142. //--------------------------------------------------------------------------------------------------------------
  143. for (int i = 0; i < encoders; i++){
  144. led[i] = map(encoderPosCount[i], 0, 127, 0, 8);
  145. shifterset(led[i],i);
  146. }
  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. pinValues = read_shift_regs();
  163. display_pin_values();
  164. oldPinValues = pinValues;
  165. }
  167. //setup ende
  168. //--------------------------------------------------------------------------------------------------------------
  170. void loop() {
  172. //74HC165 read
  173. pinValues = read_shift_regs();
  175. /* If there was a chage in state, display which ones changed.
  176. */
  177. if(pinValues != oldPinValues)
  178. {
  179. display_pin_values();
  180. oldPinValues = pinValues;
  181. }
  183. readdata(); // Midi data read
  184. encoder(); // read encoder pos and send Midi data
  185. button(); // read button state and send Midi data
  187. if (millis() > millisold) {
  188. timedate();
  189. millisold = millis() + 10000;
  190. }
  192. }
  194. // midi send data
  195. //--------------------------------------------------------------------------------------------------------------
  196. void MIDISEND(int controlChange, int controllerNummer, int controllerWert) {
  197. Serial1.write(controlChange);
  198. Serial1.write(controllerNummer);
  199. Serial1.write(controllerWert);
  201. setout(controllerWert, controllerNummer);
  203. }
  205. // Midi read data
  206. //--------------------------------------------------------------------------------------------------------------
  207. void readdata() {
  208. if (Serial1.available() > 2) {
  209. commandByte = Serial1.read();//read first byte
  210. noteByte = Serial1.read();//read next byte Channel 1-127
  211. velocityByte = Serial1.read();//read final byte value 0-127
  213. setin(velocityByte, noteByte);
  214. if (commandByte == noteOn) { //if note on message
  215. if (noteByte < 20) {
  216. //encoders
  217. for (int i = 0; i < encoders; i++) {
  218. int encodernum = i + 1;
  219. if (noteByte == encodernum) {
  220. encoderPosCount[i] = velocityByte;
  222. led[i] = map(velocityByte, 0, 127, 0, 8);
  223. shifterset(led[i],i);
  224. }
  225. }
  226. } else {
  227. // buttons
  228. for (int i = 0; i < buttons; i++) {
  229. if (noteByte == ButtonChannel[i]) {
  230. if (velocityByte == 127) {
  231. shifter1.set(i, HIGH); //turn on led
  232. } else {
  233. shifter1.set(i, LOW); //turn on led
  234. }
  235. }
  236. }
  237. }
  238. }
  239. }
  240. }
  242. // button config
  243. //--------------------------------------------------------------------------------------------------------------
  244. void button() {
  245. for (int i = 0; i < buttons; i++) {
  248. if (taste[i] == HIGH && tasteAlt[i] == LOW) {
  249. shifter1.set(i, HIGH);
  250. MIDISEND(noteOn, ButtonChannel[i], 127);
  251. tasteAlt[i] = taste[i];
  252. }
  253. if (taste[i] == LOW && tasteAlt[i] == HIGH) {
  254. shifter1.set(i, LOW);
  255. MIDISEND(noteOn, ButtonChannel[i], 0);
  256. tasteAlt[i] = taste[i];
  257. }
  259. }
  260. }
  262. // encoder config
  263. //--------------------------------------------------------------------------------------------------------------
  264. void encoder() {
  265. for (int e_num = 0; e_num < encoders; e_num++) {
  267. aVal[e_num] = pinA[e_num];
  268. if (aVal[e_num] != pinALast[e_num]) { // Means the knob is rotating
  269. // if the knob is rotating, we need to determine direction
  270. // We do that by reading pin B.
  271. if (pinB[e_num] != aVal[e_num]) { // Means pin A Changed first - We're Rotating Clockwise
  272. if (encoderPosCount[e_num] < 127) {
  273. encoderPosCount[e_num]++;
  274. MIDISEND(noteOn, EncoderChannel[e_num], encoderPosCount[e_num]);
  275. }
  276. } else {// Otherwise B changed first and we're moving CCW
  277. if (encoderPosCount[e_num] > 0) {
  278. encoderPosCount[e_num]--;
  279. MIDISEND(noteOn, EncoderChannel[e_num], encoderPosCount[e_num]);
  280. }
  281. }
  282. led[e_num] = map(encoderPosCount[e_num], 0, 127, 0, 8);
  283. shifterset(led[e_num],e_num);
  284. }
  285. pinALast[e_num] = aVal[e_num];
  286. }
  287. }
  289. //time date
  290. //--------------------------------------------------------------------------------------------------------------
  291. void timedate() {
  292. lcd.setCursor(0, 0);
  293. if (day() < 10) {
  294. lcd.print("0");
  295. lcd.print(day());
  296. } else {
  297. lcd.print(day());
  298. }
  299. lcd.print(".");
  300. lcd.setCursor(3, 0);
  301. if (month() < 10) {
  302. lcd.print("0");
  303. lcd.print(month());
  304. } else {
  305. lcd.print(month());
  306. }
  308. lcd.print(".");
  309. if (year() < 10) {
  310. lcd.print("0");
  311. lcd.print(year());
  312. } else {
  313. lcd.print(year());
  314. }
  316. lcd.setCursor(15, 0);
  318. if (hour() < 10) {
  319. lcd.print("0");
  320. lcd.print(hour());
  321. } else {
  322. lcd.print(hour());
  323. }
  325. lcd.print(":");
  327. if (minute() < 10) {
  328. lcd.print("0");
  329. lcd.print(minute());
  330. } else {
  331. lcd.print(minute());
  332. }
  333. }
  335. //display out
  336. //--------------------------------------------------------------------------------------------------------------
  337. void setout (int wert, int chan) {
  338. lcd.setCursor(7, 2);
  339. if (wert < 10) {
  340. lcd.print("00");
  341. lcd.print(wert);
  342. } else if (wert < 100) {
  343. lcd.print("0");
  344. lcd.print(wert);
  345. } else {
  346. lcd.print(wert);
  347. }
  348. lcd.setCursor(15, 2);
  349. if (chan < 10) {
  350. lcd.print("00");
  351. lcd.print(chan);
  352. } else if (chan < 100) {
  353. lcd.print("0");
  354. lcd.print(chan);
  355. } else {
  356. lcd.print(chan);
  357. }
  358. }
  360. //set input display
  361. //--------------------------------------------------------------------------------------------------------------
  362. void setin (int wert, int chan) {
  363. lcd.setCursor(7, 3);
  364. if (wert < 10) {
  365. lcd.print("00");
  366. lcd.print(wert);
  367. } else if (wert < 100) {
  368. lcd.print("0");
  369. lcd.print(wert);
  370. } else {
  371. lcd.print(wert);
  372. }
  373. lcd.setCursor(15, 3);
  374. if (chan < 10) {
  375. lcd.print("00");
  376. lcd.print(chan);
  377. } else if (chan < 100) {
  378. lcd.print("0");
  379. lcd.print(chan);
  380. } else {
  381. lcd.print(chan);
  382. }
  383. }
  385. //set encoder shift
  386. //--------------------------------------------------------------------------------------------------------------
  387. void shifterset(int ledval, int shifternum) {
  388. int ledout = ledval;
  389. int start = shifternum * 8;
  391. for (int i = 0; i < shifternum; i++){
  392. ledout = ledout + 8;
  393. }
  395. for (int i = start; i < ledout; i++){
  396. shifter0.set(i, HIGH);
  397. }
  399. if (led_state_old[shifternum] > ledout) {
  400. for (int i = ledout; i < led_state_old[shifternum]; i++) {
  401. shifter0.set(i, LOW);
  402. }
  403. }
  404. led_state_old[shifternum] = ledout;
  405. }
  407. //74HC165 funktion
  408. //--------------------------------------------------------------------------------------------------------------
  409. BYTES_VAL_T read_shift_regs()
  410. {
  411. long bitVal;
  412. BYTES_VAL_T bytesVal = 0;
  414. /* Trigger a parallel Load to latch the state of the data lines,
  415. */
  416. digitalWrite(clockEnablePin, HIGH);
  417. digitalWrite(ploadPin, LOW);
  418. delayMicroseconds(PULSE_WIDTH_USEC);
  419. digitalWrite(ploadPin, HIGH);
  420. digitalWrite(clockEnablePin, LOW);
  422. /* Loop to read each bit value from the serial out line
  423. * of the SN74HC165N.
  424. */
  425. for(int i = 0; i < DATA_WIDTH; i++)
  426. {
  427. bitVal = digitalRead(dataPin);
  429. /* Set the corresponding bit in bytesVal.
  430. */
  431. bytesVal |= (bitVal << ((DATA_WIDTH-1) - i));
  433. /* Pulse the Clock (rising edge shifts the next bit).
  434. */
  435. digitalWrite(clockPin, HIGH);
  436. delayMicroseconds(PULSE_WIDTH_USEC);
  437. digitalWrite(clockPin, LOW);
  438. }
  440. return(bytesVal);
  441. }
  443. //--------------------------------------------------------------------------------------------------------------
  444. /* Dump the list of zones along with their current status.
  445. */
  446. void display_pin_values()
  447. {
  448. countA = 0;
  449. for(int i = 0; i < DATA_WIDTH; i++)
  450. {
  452. if((pinValues >> i) & 1){
  453. data = HIGH;
  454. } else {
  455. data = LOW;
  456. }
  457. if (i < encodernums){
  458. if (count == 0){
  459. pinA[countA / 2] = data;
  460. count = 1;
  461. } else {
  462. pinB[countA / 2] = data;
  463. count = 0;
  464. }
  466. countA++;
  467. } else {
  468. if (i == encodernums) {
  469. countA = 0;
  470. }
  472. if (countA < buttons){
  473. taste[countA] = data;
  474. countA++;
  475. }
  476. }
  477. }
  479. }