Creative Projects to Build with MIDIHUM

Getting Started with MIDIHUM — A Beginner’s GuideMIDIHUM is an emerging technology that blends simple hardware, accessible software, and musical creativity to let anyone interact with MIDI-enabled instruments and devices using subtle, physical gestures and environmental inputs. Whether you’re a musician, a hobbyist, an educator, or a developer, this guide will walk you through what MIDIHUM is, why it matters, what you need to get started, step‑by‑step setup instructions, creative project ideas, troubleshooting tips, and next steps to grow your skills.

What is MIDIHUM?

MIDIHUM is a compact hardware interface and firmware/software ecosystem designed to translate small analog signals — like breath, touch, proximity, or vibrations — into standard MIDI messages. It’s often used to connect expressive controllers (breath sensors, contact mics, capacitive touch pads) to synthesizers, DAWs, or MIDI-capable software. Unlike traditional MIDI controllers that rely on keys, pads, or extensive electronics, MIDIHUM focuses on minimal, low-cost sensors and intuitive mappings to unlock expressive control.

Key features typically include:

• Analog input mapping to MIDI CCs, notes, and velocity.
• Low-latency USB-MIDI or DIN-MIDI output.
• Configurable thresholds and scaling for expressive control.
• Compact form factor suitable for DIY projects.

Why MIDIHUM matters

• Accessibility: Allows people with limited mobility or nontraditional playing styles to control music instruments.
• Affordability: Uses inexpensive sensors and simple circuits.
• Expressiveness: Captures subtle gestures (breath pressure, finger proximity, hum/vibration) and converts them to continuous MIDI data like pitch bend, modulation, or CCs.
• Creativity: Encourages unconventional controllers and new performance techniques.

What you’ll need

Hardware:

• A MIDIHUM device (or compatible microcontroller configured for MIDI over USB).
• Sensors (examples): piezo/contact microphone, electret microphone, force-sensitive resistor (FSR), potentiometer, capacitive touch sensor, or a simple microphone for hum detection.
• USB cable (for USB-MIDI) or MIDI DIN cable (if device supports DIN output).
• Optional: breadboard, jumper wires, resistors, and basic soldering tools if assembling a DIY kit.

Software:

• Digital Audio Workstation (DAW) or any MIDI-capable software (Ableton Live, Reaper, Logic Pro, GarageBand, VCV Rack, etc.).
• MIDI monitoring utility (e.g., MIDI-OX for Windows, MIDI Monitor for macOS) for debugging.
• Device configuration tool or firmware uploader if your MIDIHUM requires flashing (often based on Arduino/CircuitPython/STM32 tools).

Skills:

• Basic electronics (reading wiring diagrams, connecting sensors).
• Familiarity with your DAW’s MIDI input settings.
• Optional: simple scripting or firmware tweaks for advanced mappings.

Step-by-step setup

1. Unpack and inspect

   • Check the device for damage and ensure connectors are clean. Confirm included documentation and pinouts.

2. Connect sensor(s)

   • Attach your chosen sensor to the designated analog input pins. For example:
     • Piezo sensor → A0 (with series resistor or protective diode).
     • Electret mic → mic preamp or amplifier stage → A1.
     • Capacitive sensor → designated cap-sense pin.
   • If using modular breadboard wiring, keep jumper leads short to reduce noise.

3. Power and connect to your computer

   • Connect MIDIHUM to your computer via USB (or to a synth via MIDI DIN).
   • If the device requires external power for amplifiers, attach the appropriate supply.

4. Install drivers and software (if needed)

   • Most modern USB-MIDI devices are class-compliant and need no drivers. If your device does need drivers, follow the manufacturer’s instructions.
   • Open your DAW and enable the MIDIHUM as an input device in Preferences → MIDI/Devices.

5. Verify MIDI output

   • Open a MIDI monitor utility and actuate the sensor (tap, hum, press). You should see MIDI messages (Note On/Off, CC, Pitch Bend) correspond to the input.
   • If nothing appears, check wiring, power, and input pin configuration.

6. Map controls in your DAW or synth

   • Choose a target instrument (soft synth or hardware).
   • Use MIDI learn in the instrument to assign a sensor’s output to a parameter (filter cutoff, volume, vibrato depth).
   • Adjust sensitivity, smoothing, and scaling in either the device config tool or the DAW’s MIDI mapping settings.

7. Calibrate and refine

   • Set thresholds so ambient noise doesn’t trigger messages.
   • Apply smoothing or low-pass filtering to remove jitter if needed.
   • Map ranges so subtle gestures produce musical results (e.g., map a small breath to a wide filter sweep by adjusting curve/expansion).

Basic wiring examples (conceptual)

• Piezo → series resistor → analog input → ground
• Electret mic → small preamp (op-amp) → analog input
• FSR → voltage divider with fixed resistor → analog input
• Capacitive pad → cap-sense pin (follow microcontroller recommendations)

Example mappings and use cases

• Breath sensor → MIDI CC 2 (Breath) to control filter cutoff or expression.
• Piezo/contact mic → Note On velocity or Drum Gate to trigger samples.
• Capacitive touch → MIDI CC for modulation wheel or sustain toggle.
• Hum/vibration sensor → Pitch Bend mapped to subtle pitch modulation for expressive vocals/instruments.

Creative projects:

• Convert a humming voice into pitch-bend and vibrato for a synth pad.
• Create a wearable glove with FSRs and capacitive pads to control live looping and effects.
• Build an interactive installation where proximity triggers ambient pads and lights.

Troubleshooting common issues

• No MIDI messages:

  • Confirm device appears in OS MIDI devices.
  • Check USB cable and power.
  • Verify sensor wiring and that the sensor produces a measurable voltage.

• Noisy or jittery control:

  • Add shielding to sensor wires.
  • Add smoothing/filtering in firmware or DAW MIDI mapping.
  • Use proper biasing or a preamp for microphone signals.

• Too sensitive or unresponsive:

  • Adjust thresholds, mapping curves, and scaling.
  • Implement dead zones for tiny fluctuations.

• Latency problems:

  • Use low-latency USB ports and update drivers/firmware.
  • In DAW, reduce buffer size if using software instruments.

Expanding skills and next steps

• Learn basic firmware editing (Arduino/CircuitPython) to customize mappings and add features like velocity curves, multiple simultaneous CC outputs, or note quantization.
• Experiment with Max/MSP, Pure Data, or TouchDesigner to build complex mappings and visuals linked to MIDIHUM inputs.
• Join communities (forums, Discords) focused on experimental controllers and MIDI hacking to share patches and designs.
• Try combining MIDIHUM with other protocols (OSC, CV) for modular synth control and multimedia installations.

Safety and good practices

• When working with microphones and op-amps, power circuits correctly and double-check polarities.
• Avoid connecting sensors directly to mains power or high-voltage sources.
• Use current-limiting resistors and protective components (diodes, clamping) where recommended.

Conclusion

MIDIHUM opens the door to accessible, low-cost, and highly expressive control of MIDI instruments using small gestures and environmental inputs. Start simple — one sensor mapped to a single CC — then iterate: refine sensitivity, add smoothing, and explore creative mappings. With a little experimentation you can create unique controllers, accessible instruments, and interactive installations that breathe new life into MIDI performance.