Demiurge Sound Processing Engine

The Demiurge Sound Processing Engine is a sound processing platform. It is designed as processing blocks that are wired together once (typically at boot) and then handles the update cycle (no buffering) automatically and without jitter.

Mental Model

The mental model for the Demiurge Sound Processing Engine (DSPE) is that of blocks of computations that are wired together in the directed acyclical graph (DAG) where the wires represents audio, CV or gate/trig voltage levels.

Here is an example of what that could look like, a Voltage Controlled Amplifier

Blocks

There are a large set of standard blocks and more are developed over time and your contribution is welcome.

Each block will call the read_fn() on each block connected to its inputs, passing the block instance and "current time" as arguments. Returned is the output value as a float.

DSPE runs at a "Sample Rate" which is set at start, and a timer is set up to activate DSPE at that periodicity. DSPE will start the graph activity by calling the read_fn() on each so called "SINK", which is a hardware destination of a signal/value. These are currently Analog Outputs, LEDs and Digital Output. This also means that blocks that don't connect to a graph that has a SINK will NOT be executed. This can be utilized for slow processes, independent of the very timing critical sample loop (driven by the hardware timer interrupt).

See Demiurge/Standard Blocks for detailed information about each standard block.

See the Block Implementation Guide to understand how to create new blocks.

Example

In the "Mental Model" section above, we saw a complete VCA. To code that, we need to declare each of the Inputs, Outputs,ControlPairs and Scale as follows

   #include "demiurge.h"
   #include "demiurge-board.h"
   
   static audio_inport_t input1;        // Declaration of Audio Input Ports
   static audio_inport_t input2;
   
   static control_pair_t pair1;         // Declaration of CV+Potentiometer Input pairs
   static control_pair_t pair2;
   
   static audio_outport_t out1;         // Declaration of Audio Output Ports
   static audio_outport_t out2;
   
   static scale_t scale1;
   static scale_t scale2;
   
   /*
    * Dual VCA.
    */
   void vca_prepare() {
       demiurge_samplerate = 48000;     // 48000 samples/second
       demiurge_set_inport_audio(1);    // set the first jack as Audio input.
       demiurge_set_inport_cv(2);       // set the second jack as Control Voltage input
       demiurge_set_inport_audio(3);    // set the third jack as Audio input.
       demiurge_set_inport_cv(4);       // set the fourth jack as Control Voltage input
   
       demiurge_set_potentiometer(2, 0.0f, 10.0f);  // Potentiometers to a 0-10 range
       demiurge_set_potentiometer(4, 0.0f, 10.0f);
   
       demiurge_set_outport_audio(1);   // Set the outputs to Audio output.
       demiurge_set_outport_audio(2);
   }
   
   void vca_setup() {
   
      control_pair_init(&pair1, 2);       // CV+Pot at the second position from the top of Demiurge
      control_pair_init(&pair2, 4);       // CV+Pot at the fourth position from the top of Demiurge
      audio_inport_init(&input1, 1);      // Audio In on first input from the top
      audio_inport_init(&input2, 3);      // Audio In on third input from the top
      audio_outport_init(&out1, 1);       // Audio Out on left output channel
      audio_outport_init(&out2, 2);       // Audio Out on right output channel
   
      scale_init(&scale1);
      scale_configure(&scale1, &input1.me, &pair1.me); 
      scale1.scale = 0.1f;                // 0-10 control in --> 0-1.0 change of input signal.
   
      scale_init(&scale2);
      scale_configure(&scale2, &input2.me, &pair2.me);
      scale2.scale = 0.1f;
   
      // Connect scale output to out1
      audio_outport_configure_input(&out1, &scale1.me);
   
      // Connect scale output to out2
      audio_outport_configure_input(&out2, &scale2.me);
   }
   
   void vca_loop() {
   }

The `setup()` and `loop()` functions are also custom, just to create a familiarity from the Arduino environment. In reality, this is defined in our `main.c` file, after starting the DSPE and part of the creatioin of a Demiurge project for the STM32CubeMX and optionally the STM32CubeIDE.

   vca_prepare();                  // Prepare the board for the functionality
   demiurge_driver_init();         // Initialize the hardware driver
   demiurge_init();                // Initialize the Demiurge platform
   vca_setup();                    // Set up the functionality
   demiurge_start();               // Start the audio processing
   while(1)
   {
       vca_loop();                 // Give time for LEDs and Buttons
   }

More Examples

All examples are in the Examples Repository and showcases many common Eurorack modules, in the most basic form.

Mute

A Dual channel Mute.

VCA

A Dual channel VCA.

VCO

Dual channel Voltage Controlled Oscillator.

Envelope Generator

A standard Envelope Generator (Attack, Decay, Sustain, Release)

LFO

Dual channel Low Frequency Oscillator.