micro-color-panel-controller

KO | EN

gitlite — search

#javascript #python #hacktoberfest #react #ai #typescript #llm #go #golang #android #machine-learning #rust #deep-learning #linux

micro-color-panel-controller

★ 10 Open GitHub ↗

Use Blackmagic DaVinci Resolve Micro Color Panel outside Resolve

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# DaVinci Micro Panel Universal Controller

Use your DaVinci Micro Color Panel outside of DaVinci Resolve for any application - Blender scene navigation, audio mixing, photo editing, and more!

## 🎉 Current Status: **WORKING PROTOTYPE**

✅ **USB Protocol Reverse Engineered**: Complete understanding of communication
✅ **61 Controls Mapped**: All buttons, encoders, and trackballs identified
✅ **Illumination Control**: Global button lighting with multiple brightness levels
✅ **Robust USB Handling**: Stable connection with automatic recovery
✅ **Ready for Integration**: Framework ready for application development

📊 **Hardware Discovered**: 12 encoders, 52+ buttons, 2 working trackballs (LEFT+CENTER), global illumination

## 🎯 Project Goals

- **Universal Control**: Map panel controls to any application (Blender, Photoshop, OBS, etc.)
- **Flexible Mapping**: Customizable control schemes for different applications
- **Real-time Feedback**: Button illumination and display updates
- **Plugin Architecture**: Easy to extend for new applications

## 🔧 Hardware Details

**Device Info:**

- USB Vendor ID: `1edb` (Blackmagic Design)
- Product ID: `da0f` (DaVinci Resolve Micro Color Panel)
- Protocol: USB HID (Human Interface Device)
- Interfaces: 3 (HID, vendor-specific control, vendor-specific data)

**Controls Available:**

- 12 Rotary encoders with push buttons
- 3 Trackballs with rotary wheels around each trackball
- 40 Additional function buttons
- Illuminated buttons (global on/off control)
- Small displays/labels

**Total Controls:**

- 15 Rotary encoders (12 main + 3 trackball wheels)
- 52 Buttons (12 rotary buttons + 40 function buttons)
- 3 Trackballs for X/Y movement

## 📋 Implementation Status

### Phase 1: Device Communication ✅ **COMPLETED**

1. [x] Research USB HID protocol for the panel
2. [x] Identify device interfaces and endpoints
3. [x] Create robust HID communication layer with error recovery
4. [x] Parse all input reports (buttons, encoders, trackballs)
5. [x] Implement output reports for button illumination
6. [x] Map all 61+ controls with complete documentation
7. [x] Discover non-linear brightness mapping and USB stability solutions

### Phase 2: Application Integration

1. [ ] Create Blender addon for viewport navigation
2. [ ] Implement virtual MIDI controller mode
3. [ ] Add support for mouse/keyboard simulation
4. [ ] Create configuration GUI

### Phase 3: Advanced Features

1. [ ] Application auto-detection
2. [ ] Profile switching
3. [ ] Custom scripting support
4. [ ] Community plugin marketplace

## 🚀 Quick Start

### Prerequisites

**Linux:**

```bash
# Install conda (if not already installed)
# Visit: https://docs.conda.io/en/latest/miniconda.html

# Add udev rules for device access
sudo cp udev/99-davinci-micro-panel.rules /etc/udev/rules.d/
sudo udevadm control --reload-rules
sudo udevadm trigger
```

**Requirements:**

- Conda package manager
- Linux/Windows/macOS
- DaVinci Micro Color Panel connected via USB

### Basic Usage

```bash
# Clone and setup
git clone <repo-url>
cd micro-panel

# Create conda environment
conda env create -f environment.yml
conda activate micro-panel

# Test device connection
python src/core/device.py

# Option 1: Install as Blender addon (recommended)
# Quick install: ln -s $(pwd)/blender_addon ~/.config/blender/4.*/scripts/addons/davinci_micro_panel
# See: src/applications/BLENDER_ADDON_INSTALL.md for detailed instructions

# Option 2: Run standalone Blender integration
python src/applications/blender.py

# Alternative: pip installation (if you prefer)
python -m venv venv
source venv/bin/activate  # Linux/Mac
pip install -r requirements.txt
```

## 🗂️ Project Structure

```
micro-panel/
├── src/
│   ├── core/
│   │   ├── device.py          # Main panel interface (working!)
│   │   └── input_parser.py    # Input event parsing
│   └── applications/
│       ├── blender.py         # Blender integration example
│       └── BLENDER_ADDON_INSTALL.md  # Detailed installation guide
├── blender_addon/             # 🎮 Ready-to-install Blender addon
│   └── __init__.py           # Self-contained Blender addon (link this!)
├── udev/
│   └── 99-davinci-micro-panel.rules  # Linux device permissions
├── investigation/             # 🔬 Development & testing tools
│   ├── map_*.py              # Control mapping tools used for discovery
│   ├── test_*.py             # Testing and validation tools
│   ├── *_capture.py          # USB data capture tools
│   ├── debug_*.py            # Debugging utilities
│   └── README.md             # Investigation tools documentation
├── data/                     # 📊 Generated data & results
│   ├── *.pcapng              # Raw USB captures from Wireshark
│   ├── *_results.py          # Analysis results
│   ├── *_mapping_*.py        # Generated mapping data
│   └── README.md             # Data documentation
├── davinci_panel_mapping.json # 🎯 Complete control mapping (machine-readable)
├── davinci_panel_controls.py  # 🎯 Python constants for development
├── environment.yml            # Conda environment setup
├── requirements.txt           # Pip dependencies (alternative)
└── README.md                 # This file
```

### 🧹 Clean Organization

The project has been organized into focused directories:

- **Root**: Essential files for using the panel (device interface, mapping data, setup)
- **investigation/**: All the tools used during reverse engineering (25+ files)
- **data/**: Generated data and raw USB captures from the investigation process

This separation keeps the main project clean while preserving all development history and tools for future reference or extending functionality.

## 🎮 Supported Applications

### ✅ **Blender Integration (Ready!)**

**🔧 Full Blender Addon Available**

- **Install as addon**: Seamless integration with Blender's interface
- **3D Navigation**: Use trackballs for viewport rotation, panning, zooming
- **Tool Control**: Encoders control various Blender parameters
- **UI Panel**: Connect/disconnect panel directly from Blender sidebar
- **Settings**: Sensitivity control, axis inversion, custom mappings

📁 **Installation**: See [`src/applications/BLENDER_ADDON_INSTALL.md`](src/applications/BLENDER_ADDON_INSTALL.md)

**Control Mapping:**

- **Left Trackball**: Rotate 3D viewport (all axes)
- **Center Trackball**: Pan viewport (X/Y movement)
- **Trackball Wheel**: Zoom in/out
- **12 Encoders**: Tool parameters, brush size, material properties
- **52+ Buttons**: Mode switching, tool shortcuts, timeline control

### Current Status

- [x] **Device Framework**: Complete USB protocol with 61+ controls mapped
- [x] **Robust Connection**: Auto-recovery, stable USB handling
- [x] **Blender Ready**: Full addon with UI panel and settings

### Planned Extensions

- [ ] **OBS Studio**: Scene switching, filter control, audio mixing
- [ ] **Adobe Photoshop**: Brush controls, layer adjustments
- [ ] **Lightroom**: Photo editing controls
- [ ] **Fusion 360**: CAD navigation and tool control
- [ ] **DCS/Flight Sims**: Aircraft systems control
- [ ] **Custom Applications**: Plugin API for any software

## 🔧 Technical Architecture

### Device Communication Layer

```python
# Core device interface
from micro_panel import MicroPanel

panel = MicroPanel()
panel.connect()

# Read controls
for event in panel.read_events():
    if event.type == 'rotary':
        print(f"Rotary {event.id} turned {event.delta}")
    elif event.type == 'button':
        print(f"Button {event.id} {'pressed' if event.pressed else 'released'}")

# Control feedback
panel.set_button_illumination(True)  # Turn on button lights
panel.set_display(0, "Blender")  # Update display
```

### Application Integration

```python
# Blender example
from applications.blender import BlenderController

controller = BlenderController(panel)
controller.map_rotary(0, 'viewport.rotate_x')
controller.map_rotary(1, 'viewport.rotate_y')
controller.map_trackball(0, 'viewport.pan')
controller.start()
```

## 🐛 Troubleshooting

### Linux Permissions

If you get permission denied errors:

```bash
# Check device permissions
ls -la /dev/hidraw*

# Add user to dialout group
sudo usermod -a -G dialout $USER

# Log out and log back in
```

### Device Not Found

```bash
# Check if device is connected
lsusb | grep 1edb:da0f

# Check kernel logs
dmesg | tail
```

## 🤝 Contributing

We welcome contributions! See our [Contributing Guide](CONTRIBUTING.md) for details.

### Development Setup

```bash
# Clone and setup development environment
git clone <repo-url>
cd micro-panel

# Create conda environment (includes dev dependencies)
conda env create -f environment.yml
conda activate micro-panel

# Run tests
python -m pytest tests/

# Format code
black src/
isort src/

# Alternative: pip development setup
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
```

## 📄 License

MIT License - see [LICENSE](LICENSE) file for details.

## 🙏 Acknowledgments

- Blackmagic Design for creating excellent hardware
- The DaVinci Resolve community
- HID protocol reverse engineering community
- Open source projects that inspired this work

## 📚 Resources

- [USB HID Protocol Documentation](docs/PROTOCOL.md)
- [Control Mapping Reference](docs/API.md)
- [Application Integration Guide](docs/APPLICATIONS.md)
- [Community Forum](https://github.com/your-repo/discussions)

---

**Note**: This project is not affiliated with Blackmagic Design. DaVinci and related names are trademarks of Blackmagic Design.

micro-color-panel-controller

Today's picks

Was this content helpful?

Recent Feedback

micro-color-panel-controller

Today's picks

Was this content helpful?

Recent Feedback

Download README