Toggle Buttons

Toggle buttons are straight forward. This uses a pulldown resistor, marked as R1 in the schematics. Just use 20kΩ. The Arduino code sends a digital message, whenever the value changes. Debouncing is done with a time constant of 50ms.

#define DEBOUNCE_TIME 50

void readDigitalValue(int trigger, int &value, unsigned long &lastChange) {
    int arraySize = 1;
    if (millis() - lastChange < DEBOUNCE_TIME){
        return;
    }
    int tempValue = digitalRead(trigger);
    if (value != tempValue) {
        value = tempValue;
        byte data[arraySize];
        lastChange = millis();
        makeDigitalMessage(trigger, value, data);
        sendMessage(data, arraySize);
    }
}

Variable Resistors

Variable resistors are a little bit more complicated. If these would be potentiometers, then the full range of values from 0-1023 would be available. But force resistive sensors and bend sensors only have two pins, and the value of the resistor is a range between a minimal and a maximum value, where minimal usually is not 0. So R1 must be added to get a voltage divider, and therefore a range of values. The range of values is from \({{R_{min}} \over {R1 + R_{min}}}\cdot 1024\, -\, 1\) to \({{R_{max}} \over {R1 + R_{max}}}\cdot 1024\, -\, 1\).

To get the best possible range of values, you must get closest to the geometric mean of the minimum and maximum value of the variable resistor, \(R1 = \sqrt{R_{max} \cdot R_{min}}\).

An example: If your variable resistor is between 20kΩ and 110kΩ, then you need a value as close as possible to \(\sqrt{20\cdot 110}k\Omega = 46.9k\Omega \), i.e. 47kΩ is the best match using standard resistor values. If this is not available, then use some other resistor closest to the calculated, if you only have other values around, as you can see in the table.

void readAnalogValue(int trigger, int &value) {
    int arraySize = 2;
    int tempValue = analogRead(trigger);
    if (value != tempValue) {
        value = tempValue;
        byte data[arraySize];
        makeAnalogMessage(trigger, value, data);
        sendMessage(data, arraySize);
    }
}

In Puredata, I use an abstraction to calibrate the minimum and maximum values, and scale them to floating point numbers from 0-1.

Rotary Encoder

A rotary encoder consists of 2 switches, that are alternating between on and off on rotation. They have overlapping stages of the on/off position, so that the code can distinguish between clockwise and counter-clockwise rotation. For details see this tutorial.

The encoder pins are directly connected to digital pins, no pullup or pulldown resistors needed, as the switches inside the encoder are connected to +5V and ground respectively on transitioning.

Rotating the encoder clockwise is increasing the value, counter-clockwise decreasing. The value starts at 0 and will wrap around at 1023, so that the data can be sent like a regular analog reading. I am using a value of 7 for the pin number to send out, because that pin number is not available on an Arduino Uno or compatible board.

void readRotary() {
    cwState = digitalRead(ROTARY_CW);
    if (cwState != prevCwState){
        if (cwState == HIGH) {
            if (digitalRead(ROTARY_CCW) == HIGH) {
                rotationSteps--;
            } else {
                rotationSteps++;
            }
        } else {
            if (digitalRead(ROTARY_CCW) == LOW) {
                rotationSteps--;
            } else {
                rotationSteps++;
            }
        }
        int arraySize = 2;
        byte data[arraySize];
        makeAnalogMessage(ROTARY_PORT_NUM, rotationSteps, data);
        sendMessage(data, arraySize);
    }
    prevCwState = cwState;
}

Keypad matrix

NB: This is not used anymore by myself, because it is easier to use a MIDI controller instead of going through all that hassle of calculating resistor values, debouncing, and only being able to press one key at a time. An alternative approach also is using the Keypad library from Arduino, although this uses 5 digital ins instead of just one analog in.

This reads an analog value, similar to Analog keypad library.

The resistor values are selected, such that different keys generate a different voltage division, and in turn a differrent analog value. That value is then sent to the computer.

Debouncing is done in electronics with a 4.7nF capacitor, but also in Pd with a [spigot] and a delay of 300ms, because values are sometimes jittering.

Another idea to minimize sending key presses is to use a threshold for analog values to change before sending it, but this is also not failsafe.

#define ANALOG_ROUGHNESS 10

void readRoughValue(int trigger, int &value) {
    int arraySize = 2;
    int tempValue = analogRead(trigger);
    if (abs(value - tempValue) > ANALOG_ROUGHNESS) {
        value = tempValue;
        byte data[arraySize];
        makeAnalogMessage(trigger, value, data);
        sendMessage(data, arraySize);
    }
}

In Pd the key presses are detected by a chain of [moses] objects. The values of the boundaries were decided by measuring the values reported from the Arduino, because I have used the resistors I had lying around, which were 10% tolerance.