Frequently Asked Questions
No. DU-INO uses a 10-pin power connector and uses the +/-12VDC supply. 5VDC power for the Arduino and peripherals is provided by the voltage regulator on the Arduino.Last updated:
The pushbuttons are connected to digital inputs GT3 and GT4, respectively. Since these inputs are wired to hardware interrupt capable pins on the Arduino, they are useful for responsive gate or trigger inputs such as clocks and resets. If the inputs aren't being used for anything like that, the pushbuttons can also serve as additional user interface inputs.Last updated:
DU-INO is in many respects similar in concept to the venerable o_C. They're both open source 14 HP microcontroller breakouts, with I/O in groups of 4 and an OLED and click encoder interface. As a result, some have asked what makes them different.
Where o_C is primarily focused on CV generation and manipulation (and is a better tool for that job), DU-INO aims to be a more general-purpose platform for control and modulation.
DU-INO breaks out to a standard Arduino shield form factor with 5V I/O, which is compatible with many other boards, and makes no assumptions (in hardware) about what will be connected to it beyond that. The Arduino Uno (8-bit AVR) is less powerful than the Teensy (32-bit Cortex-M4), but we find it more accessible as a default option, and have been able to do quite a bit with it.
In line with its general-purpose nature, DU-INO includes a built-in analog computer, which we discuss in our first feature spotlight in Update #5. The signal path in the VCA portion of the ADSR/VCA demo, for example, is entirely analog. There is so much that can be done with it.
DU-INO also has a full -10V to +10V CV swing, though not quite as precise as o_C's (DU-INO uses 12-bit DACs and is calibrated with 25-turn potentiometers rather than compensated in the loop). It also has very handy potentiometers for unconnected CV inputs.Last updated:
Besides the obvious OLED and encoder knob interface, DU-INO has a more comprehensive set of I/O and a greater range of possible I/O configurations, not least of which include the analog computer. This comes at the cost of additional HP, and no front-facing programming port.Last updated:
The issue is that you need access to more than just the USB socket. In order to accommodate a wide range of I/O configurations, the digital pins can be toggled between input and output in hardware, and the analog pins can be routed to the inputs of the analog computer. This requires a set of eight SPDT switches, which are only accessible from the rear of the module. I considered using an SPI analog multiplexer to handle that directly from the Arduino, but that would have added substantially to the cost of the module, and also required the use of smaller SMD packages like LFCSP (where currently SOIC is the smallest thing you need to worry about for a DIY build). There is also a program/run switch on the rear of the module.
Ultimately, we decided that loading a new firmware to the Arduino would effectively be changing a module in your rack, which in a "production" system usually happens infrequently enough that it's best to only have run-time controls at the front. For developers who will be iterating frequently on firmware (which, of course, includes me), I'd recommend seating the DU-INO externally while working on it.
If there's enough demand, it is of course possible to develop a full front-panel breakout of the USB socket and switches, that can be wired to a DU-INO built without the rear switches.Last updated:
In theory, you can store multiple functions on the module simultaneously, and switch between them. There are, however, a few practical limitations of which you should be aware. First, the function objects would have to be instantiated together in the same sketch; this is possible, but with existing functions that assume they're alone on the Arduino, it might take a bit of massaging to make them work harmoniously. Second, on an Arduino Uno, you only have 2KB of RAM to work with, which can fill up pretty quickly; you can give yourself more headroom with some fancy dynamic allocation/deallocation, but right now all of my examples just allocate assuming they're in the spotlight for the rest of the Arduino's power lifetime. Third, how easy this is to do UI-wise depends on the function: you only have a three-action encoder and two buttons (which are actually just the GT3 and GT4 inputs) to work with, so you'd have to decide how the switching fits into that already limited UI. Fourth, you'd need to make sure any parameter saving to EEPROM in the individual functions plays nicely between them. And fifth, you'd only be able to switch between functions using the same switch configuration for I/O, which is not a huge limitation (particularly since you'll probably want similar patching between functions) but does restrict you somewhat.
I think it makes more sense to merge separate functions into a single, cohesive function, perhaps with different modes, to get this effect. However, if there's enough demand for actual flipping between separate functions, I can write a "super-function" class that provides a standard way to do multi-function switching, including the UI stuff, managing the allocation and deallocation of the sub-functions, and automatically addressing the EEPROM saves/loads correctly.Last updated:
Don't see the answer to your question? Ask the project creator directly.Ask a question