Finally, after all of the testing, the first Crumar D9U Drawbar Controller application sketch! The sketch below changes the drawbar settings for the Nord Electro 2. The Arduino on board the D9U sends a complete snapshot of all nine drawbar settings to the Electro 2 at start-up and whenever the tactile switch is depressed. Thereafter, it sends a MIDI message to the Electro 2 whenever a slider (drawbar) is changed.

The sketch drives only the Electro 2 upper drawbars. If you need the lower drawbars, too, you can follow Crumar’s example sketch and extend my sketch.

The sketch does not use the Arduino MIDI library because we only need to send simple MIDI continuous control (CC) messages. It’s easy enough to write the necessary code ourselves.

I encountered an Arduino compiler toolchain issue while developing the sketch. I wasn’t able to initialize snapCount in the setup() function. I’ll work around this issue in future sketches and you should back-port the fix. It’s not the first time that I’ve run into an Arduino toolchain bug…

The program logic is quite simple. There are three helper functions: sendNoteOn(), sendNoteOff(), and sendMidiCC(). The sketch uses only the third function which sends a MIDI continuous control message through the Serial1 port, i.e., the Arduino Leonardo TX pin.

The setup() function initializes the digital pins and global variables, and calls sendSnapshot() to scan the analog pins, sending a MIDI CC message for each drawbar. The idea is to sync the Electro 2 with the D9U when the D9U is turned on. You should select an organ voice on the Electro 2 before turning on the D9U in order to take advantage of this feature.

The loop() function goes round and round. If the tactile switch is depressed, the sketch takes a snapshot of the analog pins (sliders) and sends a MIDI CC message for each slider (drawbar). The variable snapCount debounces the tactile switch input, preventing a flood of MIDI CC messages to MIDI OUT and the Electro 2.

After checking the tactile switch, the loop() function delays for a short time and then calls checkSliders(). The function checkSliders() keeps a copy of the most recent slider values. When it detects a change, it saves the new slider value and sends a MIDI CC message with the new value. The Electro 2 accepts drawbar values over the range from 0 to 127.

It’s rather gratifying to attach the Crumar D9U to the Electro 2 and watch the Electro’s drawbar status lights change in sync with the D9U drawbars. Cool. Fun to play, too.

If you have a Nord Electro 2 and a D9U, enjoy the sketch!

Copyright © 2018 Paul J. Drongowski

/*
 * Electro2.ino: Crumar D9U sketch for Nord Electro 2
 */

/*
 * Author:  P.J. Drongowski
 * Address: http://sandsoftwaresound.net/
 * Date:    12 December 2018
 * Version: 1.0
 *
 * A simple sketch to control the Nord Electro 2 with the
 * Crumar D9U Drawbar Controller. This sketch controls
 * the upper drawbars, but could be extended to control
 * the lower drawbars. See the Crumar sketch for
 * inspiration!
 *
 * We assume a direct 5-pin MIDI connection from the
 * D9U to the Electro 2. Since direct MIDI is so simple,
 * the sketch does not use the Arduino MIDI library.
 * MIDI bytes are sent using Serial1.write().
 *
 * Send on MIDI CC messages on MIDI channel 0.
 *
 * Electro 2 MIDI continuous controllers (CC) are:
 *    Parameter       Upper CC#  Lower CC#
 *    --------------  ---------  ---------
 *    16' drawbar         16        70
 *    5 1/3' drawbar      17        71
 *    8' drawbar          18        72
 *    4' drawbar          19        73
 *    2 2/3' drawbar      20        74
 *    2' drawbar          21        75
 *    1 3/5' drawbar      22        76
 *    1 1/3' drawbar      23        77
 *    1' drawbar          24        78

 */

// Pin definitions
#define LED_RED    15
#define LED_GREEN  16
#define BUTTON     5

// Analog pin map
#define NUMBER_OF_SLIDERS 9
int AnalogPinMap[NUMBER_OF_SLIDERS] = {
  A0, A1, A2, A3, A6, A7, A8, A9, A10
} ;

// Drawbar to MIDI CC# map
int MidiCCMap[NUMBER_OF_SLIDERS] = {
  16, 17, 18, 19, 20, 21, 22, 23, 24
} ;

// Global variables
int sliders[NUMBER_OF_SLIDERS] ;
#define SNAP_COUNT  (200)
int snapCount = SNAP_COUNT ;

// MIDI channel
#define CHANNEL 0

// Bias offset for incoming slider values [unused]
#define BIAS 32

void sendNoteOn(byte pitch, byte velocity) {
  Serial1.write(0x90 | CHANNEL) ;
  Serial1.write(pitch) ;
  Serial1.write(velocity) ;
}

void sendNoteOff(byte pitch) {
  Serial1.write(0x80 | CHANNEL) ;
  Serial1.write(pitch) ;
  Serial1.write(0) ;
}

void sendMidiCC(byte cc, byte value) {
  Serial1.write(0xB0 | CHANNEL) ;
  Serial1.write(cc) ;
  Serial1.write(value) ;
}

// Take a snapshot of the current slider state and
// send MIDI CC for all sliders. Electro 2 CC value range
// is 0 to 127.
void sendSnapshot() {
  int newValue = 0 ;
  for (int i = 0 ; i < NUMBER_OF_SLIDERS ; i++) {
    newValue = (analogRead(AnalogPinMap[i]) & 0x3FF) / 8 ;
    sliders[i] = newValue ;
    sendMidiCC(MidiCCMap[i], newValue) ;
  }
}

// Check the sliders for movement (changes). When a change
// is detected, send a MIDI CC message. Nord Electro CC
// values range from 0 to 127.
void checkSliders() {
  int newValue = 0 ;
  for (int i = 0 ; i < NUMBER_OF_SLIDERS ; i++) {
    newValue = (analogRead(AnalogPinMap[i]) & 0x3FF) / 8 ;
    if (sliders[i] != newValue) {
      sliders[i] = newValue ;
      // Send MIDI CC message when the value changes
      sendMidiCC(MidiCCMap[i], newValue) ;
    }
  }
}
 
void setup() {
  // Set up pins
  pinMode(BUTTON, INPUT_PULLUP) ;
  pinMode(LED_RED, OUTPUT) ;
  pinMode(LED_GREEN, OUTPUT) ;

  // Set up Serial1 for MIDI via TX and RX (31,250 baud)
  Serial1.begin(31250) ;

  // Initialize the button debounce count
  // Send an initial snapshot. This operation initializes
  // the current slider values, too.
  sendSnapshot() ;
}

void loop() {
  if ((digitalRead(BUTTON) == LOW) && (snapCount <= 0))
  {
    // Take and send a snapshot of the sliders
    sendSnapshot() ;
    snapCount = SNAP_COUNT ;
  } else {
    snapCount-- ;
  }

  delay(1) ;
  checkSliders() ;
}

Apologies for the delay between posts. It isn’t for lack of enthusiasm for the Crumar D9U Drawbar Controller. It’s preparation for the approaching holidays.

Today’s post is another aspect of unit testing — MIDI. The D9U has a 3.5mm MIDI OUT jack. The MIDI signals conform to the MIDI “Type B” pin-out for 3.5mm jacks. The Type B pin-out is:

    DIN      3.5mm
    -----    --------------------
    Pin 4    Tip (Current Source)
    Pin 5    Ring (Current Sink)
    Pin 2    Sleeve (Shield) 

Type B is used by Arturia, Novation, and 1010Music.

I must note that the MIDI “Type A” pin-out is going to be the standard going forward. Unfortunately, the MIDI Association didn’t get ahead of manufacturers when they began using 3.5mm jacks. For reference, the Type A pin-out is:

    DIN      3.5mm
    -----    --------------------
    Pin 4    Ring (Current Source)
    Pin 5    Tip (Current Sink)
    Pin 2    Sleeve (Shield) 

Type A is used by Akai Pro, IK Multimedia, Korg, Line 6, littleBits, and Make Noise. I found the chart below to be quite helpful in running down an appropriate adapter cable. (Source: MIDI Association 3.5mm stereo TRS to MIDI 5-pin DIN cables)

Thanks to all of the Christmas prep, I didn’t miss a step while waiting for the 1010Music adapter to arrive. (It’s Advent after all.) I detest making cables and the 1010Music adapter is reasonably priced.

I also got down to work on a MIDI test sketch for the D9U. (Code appears at the end of this post.) The sketch does not use the Arduino MIDI library because it simply sends MIDI note ON and note OFF messages through the MIDI port.

If you’re new to Arduino Leonard — the D9U’s Pro Micro is a Leonardo — you may not know that Leonard has two serial ports: Serial and Serial1. The first port, Serial is dedicated to USB communications. The second port, Serial1, is dedicated to the digital RX and TX pins, similar to Arduino UNO, et al. The naming convention sometimes confuses coders who are new to Leonardo. In our case, when we want to send MIDI, we use the Serial1 port, which must be configured for the MIDI baud rate, 31,250Hz.

The sketch repeatedly sends MIDI note ON and OFF messages such that you should hear a steady series of staccato notes when the MIDI message stream is sent to a tone generator. In my case, I connected the D9U to my trusty Yamaha QY70 sequencer and tone module.

Here’s another little twist. Leonardo is equipped with two additional LEDs: TXLED and RXLED. These LEDs flash when there is transmit and receive activity (respectively) on the USB port. The test sketch does not use the USB port (Serial), so the TXLED and RXLED are ours to play with. The four macros:

    TXLED0 ;      RXLED0 ;
    TXLED1 ;      RXLED1 ;

control the LEDs. If you compile the sketch on a regular Arduino (e.g., UNO), these macros will be flagged as undefined symbols.

Extra credit

While wading through the Type A vs. Type B nonsense, I did a few simple experiments with the D9U’s MIDI port. For example, you can check the signal levels using a digital multimeter. DIN pin 2 should read as 0 Volts (ground) while DIN pin 4 should be +5 Volts. DIN pin 5 is the data pin which pulls the MIDI current loop to ground. Please remember that MIDI is a current loop where:

• Logic 1 → High → no current flow → Opto-isolator LED off → MIDI receiver sees High, logic ‘1’ (data bits, stop bit or idle)
• Logic 0 → Low → current loop flow rarr; Opto-isolator LED on → MIDI receiver sees Low, logic ‘0’ (data bits, start bit)

Thanks, Wikipedia.

The sender (MIDI OUT) turns an LED on and off in the receiver (MIDI IN). The LED is part of an opto-isolator which provides electrical isolation between the sender and the receiver.

So, if you want to check out MIDI signals at the pins, all you need is an LED and a current limiting resistor (e.g., 330 ohms) in series in the current loop. The LED lights when connected in the direction of positive current flow. Here are my handwritten notes.

David Battino would be proud. David loves to add flashing LED eyes to Japanese movie monster toys and more. One of these days I’ll put all of those Godzillas in our basement toy chest to work. 🙂

Copyright © 2018 Paul J. Drongowski

/*
 * MidiTest.ino: Crumar D9U MIDI and slider test
 */

/*
 * Author:  P.J. Drongowski
 * Address: http://sandsoftwaresound.net/
 * Date:    11 December 2018
 * Version: 1.0
 *
 * This test reads the current slider values. If there is a
 * change, it prints the current slider values to the Arduino
 * serial port. Watch the values change in the IDE's Serial
 * Monitor. The incoming slider values are biased so that
 * values range reliably from 0 to 8. (Leonarkdo's Serial
 * port is dedicated to USB communications.
 *
 * Additionally, send MIDI note ON and note OFF messages to
 * the Serial1 port. On Leonardo, Serial1 communicates via
 * the TX and RX pins.
 */

// Pin definitions
#define LED_RED    15
#define LED_GREEN  16
#define BUTTON     5

// Analog pin map
#define NUMBER_OF_SLIDERS 9
int AnalogPinMap[NUMBER_OF_SLIDERS] = {
  A0, A1, A2, A3, A6, A7, A8, A9, A10
} ;

// Global variables
int colorMode = 0 ;
int ledMode = 0 ;
int noteState = 0 ;
int sliders[NUMBER_OF_SLIDERS] ;

// Bias offset for incoming slider values
#define BIAS 32

void sendNoteOn() {
  Serial1.write(0x90) ;
  Serial1.write(36) ;
  Serial1.write(100) ;
}

void sendNoteOff() {
  Serial1.write(0x90) ;
  Serial1.write(36) ;
  Serial1.write(0) ;
}

void changeColors() {
  if (colorMode) {
    digitalWrite(LED_RED, LOW) ;
    digitalWrite(LED_GREEN, HIGH) ;
  } else {
    digitalWrite(LED_RED, HIGH) ;
    digitalWrite(LED_GREEN, LOW) ;
  }
}

void printSliders() {
  for (int i = 0 ; i < NUMBER_OF_SLIDERS ; i++) {
    Serial.print(sliders[i]) ;
    Serial.print(" ") ;
  }
  Serial.println("") ;
}

void checkSliders() {
  int changeFlag = 0 ;
  int newValue = 0 ;
  for (int i = 0 ; i < NUMBER_OF_SLIDERS ; i++) {
    newValue = (analogRead(AnalogPinMap[i]) + BIAS ) / 128 ;
    if (sliders[i] != newValue) {
      changeFlag = 1 ; 
      sliders[i] = newValue ;
    }
  }
  if (changeFlag != 0) {
    // If a change was made, print current slider values
    printSliders() ;
  }
}
 
void setup() {
  // Set up pins
  pinMode(BUTTON, INPUT_PULLUP) ;
  pinMode(LED_RED, OUTPUT) ;
  pinMode(LED_GREEN, OUTPUT) ;

  // Set up Serial1 for MIDI via TX and RX (31,250 baud)
  Serial1.begin(31250) ;

  colorMode = 0 ;
  noteState = 0 ;

  for (int i = 0 ; i < NUMBER_OF_SLIDERS ; i++) {
    sliders[i] = -1 ;
  }
}

void loop() {
  if (digitalRead(BUTTON) == LOW) {
    colorMode = 0 ;
  } else {
    colorMode = 1 ;
  }

  // Make the TX and RX LEDs flash in sync with the notes.
  // The TX and RX LEDs are Leonardo only. Remove the code
  // below when compiling for Arduino UNO, etc.
  if (ledMode) {
    ledMode = 0 ;
    TXLED1 ;
    RXLED0 ;    
  } else {
    ledMode = 1 ;
    TXLED0 ;
    RXLED1 ;
  }
  
  if (noteState != 0) {
    sendNoteOn() ;
    noteState = 0 ;
  } else {
    sendNoteOff() ;
    noteState = 1 ;
  }

  delay(100) ;
  changeColors() ;
  checkSliders() ;
}

People who build stuff are optimists. Even just a little.

After slaving over a hot soldering iron (or bit of code), there comes the moment of truth. Of course, we all hope and believe that everything will run just fine when power is turned on.

Thus, I was a little bit bummed when I ran my drawbar test sketch (Arduino program) and saw that the second drawbar was unresponsive.

Hey, PJ, how did you debug and fix this thing?

First and foremost, I want to emphasize the importance of diagnostic tests. My test sketch told me conclusively that the second drawbar was busted. The test not only said, “Houston, we have a problem,” but the test also told me where to look for the problem — the second drawbar. Explicit testing is much better than trying to test and debug hardware with the application sketch itself, i.e., the sample sketch provided by Crumar.

Knowing that the second drawbar was bunged, I whipped out my digital multimeter and did a few simple electrical tests. I usually assume good components, but it was easy to check the second slide pot. Yep, the meter read out the expected resistance. Then I did quick continuity and resistance checks back to the appropriate Arduino analog pin. Thank heavens for the sample sketch because I quickly worked out the pin map (Arduino Pro Micro):

          TX o    o RAW
          RX o    o GND
         GND o    o RST
         GND o    o VCC
         SDA o    o A3    Draw4
         SCL o    o A2    Draw3
  Draw5   A6 o    o A1    Draw2  <---
             o    o A0    Draw1
  Draw6   A7 o    o SCLK
             o    o MISO
  Draw7   A8 o    o MOSI
  Draw8   A9 o    o A10   Draw9

I numbered the drawbars (left to right) starting with one. The Crumar schematics numbers the drawbars from zero. [Oh, well.]

This was a good time to check the batteries in the multimeter. Whoops, 2017. Good, fair or poor, I replaced the batteries with fresh ones.

I didn't find anything out of the ordinary, so I began the usual prayer, "Dear Lord, I hope I didn't blowed up the chip." I did not relish the thought of replacing the Arduino Pro Micro -- all 24 pins of it.

My soldering skills are good, but not perfect. Plus, the large holes and the excessive amount of solder consumed by the slide pot leads immediately made me suspect a bad soldering joint.

In order to test this theory, I tried jumpering the voltage from the first drawbar slider to the Arduino A1 pin while watching the sketch's output in the IDE Serial Monitor. Perhaps an internal pull-up (or something) didn't change the A1 signal or the output from the sketch.

Then it was time to play "which of these isn't like the others" with the multimeter and with the power on. Ah-ha. The voltage at the SIGN #2 pad did not change when sliding the pot to a new position. The rest of the SIGN pads responded correctly. Not conclusive evidence for a bad solder joint, but more hope than a blown up Arduino.

The next step was to fire up the iron and retouch the pot leads for the second drawbar. It takes longer for the iron to heat up than to do the touch up. Damn, these leads suck down solder.

After letting things cool, I plugged the Arduino back in and voila, the second drawbar now responds correctly. Thank you, test sketch.

When testing pot resistance, I noted some variability in resistance across the 9 pots. I hope the variability doesn't affect behavior when I get down to transmitting MIDI values. Maybe everything will act like a well-worn B3? Sometimes higher resistance is due to a marginal solder joint, but I'm not anxious to touch up every pot connection lest I introduce a worse problem. More testing ahead.

If you landed here, check out Day One in this series of blog posts about the Crumar D9U Drawbar Controller kit.

Copyright © 2018 Paul J. Drongowski

Today I completed most of the remaining assembly of the Crumar D9U Drawbar Controller. The work entailed:

1. Combining the Arduino control board and the main PCB.
2. Installing the drawbar slide pots on the bottom of the chassis.
3. Soldering the main PCB to the slide pots and soldering the DIL connections to the Arduino control board.
4. Installing colored plastic caps on the drawbars.

Overall, the work went well. Here’s a few observations and tips.

• When the instructions say make the DIL flat and straight on the control board, they really mean it! The receiving holes on the main PCB are quite small and if that DIL isn’t straight, good luck. Even with a straight DIL, it took some finagling to pass the pins through the holes.
• The control board and main PCB are joined by two long-ish bolts with spacers between the boards. The nuts are really tight. You will not be able to hold the nuts in place with fingers alone. I used needle nose pliers to hold the nuts while turning the bolts. Be careful not to damage the Arduino when using the pliers. I did bend a pin.
• Experience with the main PCB and the slider pins was similar although these holes are larger and more accommodating. Gently straighten any bent pins.
• Speaking of large holes, crimp the pot leads against the main PCB pads to make good electrical contact. These holes eat solder like crazy. You should rely on the solder to maintain electrical contact, not to be the electrical bridge itself.
• The colored caps fit OK, but you will need to use a far bit of force to drive the screws into the caps for a firm result. The white knobs still have a tiny amount of play, but I was afraid to over-tighten the screws and strip the plastic.

The D9U is built like a warship although the tight fit of nuts and screws makes for a slightly stressful assembly job.

I forget to suggest one tip in yesterday’s blog post. If you have a breadboard available, it makes a nice jig for installing DILs and other components that you need to keep straight. Push the DIL into the breadboard, lay the board on top, and then solder away. I usually try to tack one or two corners first and then check for straightness, etc. If the DIL ain’t straight, it’s a lot easier to remove the tack from two pins (using a solder sucker or braided copper tape) than to remove solder from all 16 pins!

See my first blog post about the D9U for pictures of the pieces and parts in the kit.

Slider test sketch

Here is the code for a quick slider test. It prints the slider values to the Arduino IDE’s Serial Monitor. This sketch is already earning its keep — the second drawbar slider is not changing. The other eight sliders are changing just fine. I have some hardware debugging to do!

/*
 * SliderTest.ino: Crumar D9U initial test
 */

/*
 * Author:  P.J. Drongowski
 * Address: http://sandsoftwaresound.net/
 * Date:    7 December 2018
 * Version: 1.0
 *
 * This test reads the current slider values. If there is a
 * change, it prints the current slider values to the Arduino
 * serial port. Watch the values change in the IDE's Serial
 * Monitor.
 */

// Pin definitions
#define LED_RED    15
#define LED_GREEN  16
#define BUTTON     5

// Analog pin map
#define NUMBER_OF_SLIDERS 9
int AnalogPinMap[NUMBER_OF_SLIDERS] = {
  A0, A1, A2, A3, A6, A7, A8, A9, A10
} ;

// Global variables
int colorMode = 0 ;
int sliders[NUMBER_OF_SLIDERS] ;

void changeColors() {
  if (colorMode) {
    digitalWrite(LED_RED, LOW) ;
    digitalWrite(LED_GREEN, HIGH) ;
  } else {
    digitalWrite(LED_RED, HIGH) ;
    digitalWrite(LED_GREEN, LOW) ;
  }
}

void printSliders() {
  for (int i = 0 ; i < NUMBER_OF_SLIDERS ; i++) {
    Serial.print(sliders[i]) ;
    Serial.print(" ") ;
  }
  Serial.println("") ;
}

void checkSliders() {
  int changeFlag = 0 ;
  int newValue = 0 ;
  for (int i = 0 ; i < NUMBER_OF_SLIDERS ; i++) {
    newValue = analogRead(AnalogPinMap[i]) / 128 ;
    if (sliders[i] != newValue) {
      changeFlag = 1 ; 
      sliders[i] = newValue ;
    }
  }
  if (changeFlag != 0) {
    // If a change was made, print current slider values
    printSliders() ;
  }
}
 
void setup() {
  // Set up pins
  pinMode(BUTTON, INPUT_PULLUP) ;
  pinMode(LED_RED, OUTPUT) ;
  pinMode(LED_GREEN, OUTPUT) ;

  colorMode = 0 ;

  for (int i = 0 ; i < NUMBER_OF_SLIDERS ; i++) {
    sliders[i] = -1 ;
  }
}

void loop() {
  if (digitalRead(BUTTON) == LOW)
  {
    colorMode = 0 ;
  } else {
    colorMode = 1 ;
  }

  delay(100) ;
  changeColors() ;
  checkSliders() ;
}

Copyright © 2018 Paul J. Drongowski