Hi, I'm a total newbie on pd, and I was trying to compose a sine wave. But there's something I really confused about.

So why these two patches behave differently, like in opposite? (1)
I have read the help file but still cannot figure out the reason, besides, it's saying [osc~] used to compose cosine wave, then why use it for sine wave? I'm aware that sin wave and cosine wave are the same shape but different starting point, in that case, how does [osc~] here handle? (2)
Also, it seems like every time I run the patches, the outcome is different, why is that? (3)
My questions may be naive, but still thanks in advance.

NoxSiren is a modular synthesizer system where the punishment of failure is the beginning of a new invention.

--DOWNLOAD-- NoxSiren for :

• Pure Data :
  NoxSiren v15.rar
  NoxSiren v14.rar

• Purr Data :
  NoxSiren v15.rar
  NoxSiren v14.rar

--DOWNLOAD-- ORCA for :

• x64, OSX, Linux :
  https://hundredrabbits.itch.io/orca

In order to connect NoxSiren system to ORCA system you also need a virtual loopback MIDI-ports:

--DOWNLOAD-- loopMIDI for :

• Windows 7 up to Windows 10, 32 and 64 bit :
  https://www.tobias-erichsen.de/software/loopmidi.html

#-= Cyber Notes [v15] =-#

• added BORG-IMPLANT module.
• introduction to special modules.
• more system testing.

#-= Special Modules [v15] =-#

• BORG-IMPLANT (connects ORCA MIDI system to NoxSiren system)

#-= Current Modules [v15] =-#

• VCO (voltage-controlled-oscillator)
• VCO2 (advance voltage-controlled-oscillator)
• WAVEBANK (additive synthesis oscillator)
• ADSR (Attack-Decay-Sustain-Release envelope)
• C-ADSR (Curved Attack-Decay-Sustain-Release envelope)
• CICADAS (128 steps-Euclidean rhythm generator)
• CICADAS-2 (advance 128-steps polymorphic-Euclidean rhythm generator)
• COMPRESSOR (lookahead mono compressor unit)
• DUAL-COMPRESSOR (2-channel lookahead mono compressor unit)
• STEREO-COMPRESSOR (lookahead stereo compressor unit)
• MONO-KEYS (virtual 1-voice monophonic MIDI keyboard)
• POLY-KEYS-2 (virtual 2-voice polyphonic MIDI keyboard)
• POLY-KEYS-3 (virtual 3-voice polyphonic MIDI keyboard)
• POLY-KEYS-4 (virtual 4-voice polyphonic MIDI keyboard)
• POLY-KEYS-5 (virtual 5-voice polyphonic MIDI keyboard)
• POLY-KEYS-6 (virtual 6-voice polyphonic MIDI keyboard)
• BATTERY (simple manual triggered machine for drumming.)
• REVERB (reverb unit with lowpass control)
• STEREO-REVERB (stereo reverb unit with lowpass control)
• RESIN (advanced rain effect/texture generator)
• NOISE (generates black,brown,red and orange noise)
• NOISE2 (generates yellow,blue,pink and white noise)
• COBALT (6-stage polyrhythm generator)
• SHAPER (basic shaper unit)
• FOLDER (basic wave folding unit)
• STEREO-FOLDER (stereo wave folding unit)
• DUAL-FOLDER (advance wave folding unit)
• POLARIZER (transform a signal into bi-polar, uni-polar, inverted or inverted uni-polar form)
• CLOCK (generates a BPM clock signal for sequencing other modules)
• CLOCKDIVIDER (a clock divider with even division of clock signal)
• CLOCKDIVIDER2 (a clock divider with odd division of clock signal)
• DELAY-UNIT (delay unit)
• STEREO-DELAY (stereo delay unit)
• CHORUS (chorus unit)
• STEREO-CHORUS (stereo chorus unit)
• SEQ (advance 16-step/trigger sequencer)
• KICK (synthesize kick unit)
• KICK2 (synthesize flavor of KICK module)
• KICK3 (synthesize flavor of KICK module)
• SNARE (synthesize snare unit)
• CLAP (synthesize clap unit)
• CYMBAL (synthesize cymbal unit)
• RAND (RNG generator for other modules parameters)
• FMOD (feedback modulation unit)
• AM (amplitude modulation unit)
• RM (ring modulation unit)
• LFO (low-frequency-oscillator)
• LFO2 (advance low-frequency-oscillator)
• COMBINATOR (combine two waves)
• COMBINATOR2 (combine three waves)
• COMBINATOR3 (combine four waves)
• STRING (Karplus-Strong string synthesis unit)
• STRING2 (advance Karplus-Strong string synthesis unit)
• DETUNER (parametric 4-channel detuner unit)
• CRUSHER (basic audio resolution unit)
• STEREO-CRUSHER (basic stereo audio resolution unit)
• DUAL-CRUSHER (advance audio resolution unit)
• FILTER (basic filter)
• VCF (voltage-controlled-filter)
• MAR (Moog-analog-resonant filter)
• VCA (voltage-controlled-amplifier)
• DUAL-VCA (advance voltage-controlled-amplifier)
• FMUX (multiplexer with fast A/D internal envelope)
• MMUX (multiplexer with medium A/D internal envelope)
• SMUX (multiplexer with slow A/D internal envelope)
• FDMX (demultiplexer with fast A/D internal envelope)
• MDMX (demultiplexer with medium A/D internal envelope)
• SDMX (demultiplexer with slow A/D internal envelope)
• MIXER (mix 1-4 possible waves)
• SCOPE (oscilloscope analyzer)
• MASTER (fancy DAC~)
• BOX (useless decorative module)

NoxSiren integrated modules menu system.

Hello friends,

I was trying to make a virtual instrument patch playable via midi and that uses wav samples of each note of a real instrument.
Normally each sample would be called C1.wav C#1.wav D1.wav and so on, I've made a patch to transform from midi note number to note file name so it could fit into a message going to soundfiler like "read -resize $1 array1" where $1 is the name of the corresponding wav file.

It seems to be working, with the only flaw that it doesn't sound as immidiate, I think loading the file in the moment of the note being pressed creates a delay.

As workaround I was wondering if there was a more efficient way of managing the samples?

As I'm writing I've just thought I could load a really long array that stores all the notes wav files in consecutive order, and then just use math to play the segment that corresponds to the note. Would that imply it'll be monophonic though?

A last resort would be copying and paste the single voice with the soundfiler 36 times, one for each sample, and have them preload on start. But I'm sure there's a more elegant solution!

Thank you in advance, I feel both blessed and damned now that I've put myself into this puredata rabbithole

A

Hi Everyone,

I would like to use sigmund~ to trigger a sound through adc~
So when there is a signal between 100Hz-349HZ (with some amplitude value) it will trigger 2.wav
and 350Hz-1000Hz (with some amplitude value) it will trigger 3.wav 3.wav 2.wav
Thx in advance.

This is a real world example:

1p24p(sin)-example(amsynth).pd
1p24p(sin)-help.pd
1p24p(sin).pd

Controlling amsynth with an 8 knob usb midi controller

Aligning the midi map to the patch or sending in your current midi map to the patch, you can control the (primary) 8 sections of amsynth with a (standard) 8 knob usb midi controller. (I've added a few sliders to control some of the params that don't "fit").

The jack connections need to look like the below.

And

the patch works out to:

The abs synchronizes one line and three sine curves using the controlling knob/cc's values (between 0 and 127), i.e. the input, as their angle and their frequency dependent on which sine curve (2^n). Thus, it captures all combinations, just with fewer possible values depending on which sine curve is assigned to which outlet.

1p24p(sin).pd
1p24p(sin)-help.pd
adsr.pd

It takes 5 creation arguments:

$1 the identifying index for the abstraction

and

$2,$3,$4,$5 to determine which outlet receives which frequency/input. So, if used, for instance, with an adsr then [1p24p(sin) 1 0 1 2 3] then "a" would have 127 possible values, d 64, s 32, and r 16. Where as, in the case of ]1p24p(sin) 1 3 2 1 0] r would have 127, s 64, d 32, and a 16.

While it does limit the possible values for the controls/parameters to [127,64,32,16] (respectively) it offers a Lot of flexibity (as the -help file shows) and is very easy to understand.

So basically, for example, in a given synth setup using the abs as input and only 2 knobs/cc you control 16,129 (127^2) adsr presets.

The state chart is as follows (where🔺🔻represents a value going either up or down, and each arrow represents a set of 16 possible values).

parameter:
0 1 2 3
🔺🔺🔺🔺
🔺🔺🔺🔻
🔺🔺🔻🔺
🔺🔺🔻🔻
🔺🔻🔺🔺
🔺🔻🔺🔻
🔺🔻🔻🔺
🔺🔻🔻🔻.

I hope this is easy to understand and that it might "serve(s) you well".

Love through Music,
-S

Let me know if you need help with this. I will (power allowing:-)) be happy to oblige.

p.s. the help files offers a lot of information and two examples (the classicsynth-help and 4 arrays to visually show what's happening).

@beem PWM (Pulse-Width-Modulation) for the square/pulse wave. It affects the duty cycle of the wave. You can also make a shifting wave where you can smoothly transition from one shape type to another but this is a far more complex non-standard wave. I use only basic standard waves. It is also possible to combine this standard waves to have something more complex..

For example I have five different sounds: sound1.wav, sound2.wav, sound3.wav, sound4.wav, sound5.wav.
I want to play sound2.wav after sound1.wav has finished playing. The same for the following sounds.

How to do this in pd?

@EMR66

A couple of illustrations.

Let's say we want a sine wave covering 16.5 samples. To illustrate, I used SuperCollider to put two sine wave cycles into 33 samples.

The second cycle begins when the wave crosses the 0 line in the middle.

This is between samples.

So, the second cycle must be represented by sample values that are different from the sample values for the first cycle.

That is, it is possible to have that zero crossing between samples -- but the sampling process produces different values.

Let's look at it a different way: blue samples = one sine wave cycle covering 33 samples; green samples = 2 cycles in 33 samples.

If we start counting samples at 0:

• Blue 0 = Green 0.
• Blue 2 = Green 1.
• Blue 4 = Green 2. etc.

That is: read through the blue samples at double speed, and you get the 16.5 wavelength. (This is exactly what David said.)

What about the second cycle starting at 16.5?

• Blue 1 = Green 17.
• Blue 3 = Green 18. etc.

These are the sample values that were skipped the first time.

So, Green 17 (the first concrete sample value after the second cycle begins) is the value in between Green 0 and Green 1. Green 18 is in between Green 1 and Green 2.

This is interpolation.

Interpolation is the mathematically correct way to represent fractional cycles in a sampled signal.

You can try to say that this "isn't the real problem," but... this is the problem, and interpolation is the solution.

hjh

Hi there,

I have two quesitons:

I want to upload a ton of .wav files into a folder and play them randomly. What is the best way to proceed?
So far I called them 1.wav, 2.wav, 3.wav, I create a random number and call the file $.wav ... but this can become exhausting, and more than that, see question 2

I wanted in question 1 to be able to play a file with a random name (e.g. "random guy from puredata forum yelling.wav") and having the name of that track printed. So far I was thinking of using names of approach 1, and have a stored .txt file with the "real name" of the track and have it printed, but i can't neither do this.

Thanks in advance for your support
Nando