I am using ControlP5 for the sequencer matrix (16x16) which plays notes according to the position of the matrix pointer and the placement of blocks in the matrix. I want to implement an ADSR on the waveforms. I am using the Minim library and the sine, square, saw and noise functions.

I can't use Ugens because there is a problem with Ugens and processing 2.07 on the Uni computers so I want to write a class of an ADSR (envelope generator) with Attack, decay, sustain and release controls to give more dynamism to the sounds.

I have only just started using processing so am a noob although I have some programming experience using Arduino and am concurrently learning VHDL.

I have included my code which is very messy at the moment and the example of the ADSR class is only a half arsed attempt at the moment.. The sequencer works but I can't work out how I could implement an envelope generator as an object. Has anyone attempted this before??

If so, I would love some pointers....

The code for the sequencer and the ADSR class are below:

2. import controlP5.*; 
3. import ddf.minim.*; 
4. import ddf.minim.signals.*; // new code
5. import ddf.minim.effects.*; // new code
6. //import ddf.minim.ugens.*;
7. import rwmidi.*;
8. 
   
9. ControlP5 gui;  // new controlP5 gui instance called"gui"
10.  ControlWindow controlWindow;
11. 
    
12.  
13.  
14.  Dong[][] d;
15.  public int temp=200;
16.  int tem;
17.  int note;
18. // public float maxamp,attack,decay,sustain,release;
19. int nx = 16;  // x co-ord cells
20. int ny = 16;  // y co-ord cells
21.  float god;     // public var for control outside of ....function
22.  float fref;
23.  float pref;
24.  float p;
25. Minim minim; // new minim instance called "minim"
26. ADSR my_ADSR;
27. Knob maxA,att,dec,sus,rel; // ADSR controls
28. MidiInput input;  // new Midiinput instance called "input"
29. MidiOutput output2;  // new Midioutput instance called "output"
30. ListBox l;          // new controlP5 menubox called "l"
31. Knob Freq;          // new controlP5 Knob instance called Freq (controls pitch of wave
32. Knob Amp;
33. Knob tempo;
34. Slider lpfSlider; // slider for low pass cutoff
35. Slider bpfSlider; // slider for band pass cutoff
36. Slider bpfBW ;     //slider for band pass bandwidth
37. LowPassFS lpf;
38. BandPass bpf;
39. WhiteNoise noise;   // new minim instance of white noise called "noise"
40. SquareWave sqr1;    // new minim instance of squarewave called "sqr1"
41. SawWave saw ;       // new minim instance of sawwave called "saw"
42. SineWave sine;      // new minim instance of sinewave called "sine"
43. AudioOutput out; // new minim instance of audio output called "out"
44. boolean noise_is_on = false;  /* boolean cases for waves. not used yet.
45. boolean sqr_is_on = false;
46. boolean saw_is_on = false;
47. boolean sine_is_on = false;
48. */
49. 
    
50. 
    
51. 
    
52. 
    
53. void setup() {
54. size(1200, 700);
55. 
    
56. minim = new Minim(this); // "minim" is a new call to open minim for use
57. out = minim.getLineOut(Minim.STEREO); // declaration of out as minims' line out for audio
58. gui = new ControlP5(this);         // declaration of gui as controlP5s' gui for use
59. 
    
60. ADSR my_ADSR = new ADSR();
61. // gui.printPublicMethodsFor(Matrix.class);
62.  
63. // gui.printPublicMethodsFor(Matrix.class);
64. 
    
65.   gui.addMatrix("myMatrix")
66.      .setPosition(50, 100)
67.      .setSize(600, 400)
68.      .setGrid(nx, ny)
69.      .setGap(10, 2)
70.      .setInterval(temp)
71.      .setMode(ControlP5.MULTIPLES)
72.      .setColorBackground(color(120))
73.      .setBackground(color(40))
74.      ;
75.   
76.   gui.getController("myMatrix").getCaptionLabel().alignX(CENTER);
77. 
    
78. 
    
79.  d = new Dong[nx][ny];
80.   for (int x = 0;x<nx;x++) {
81.     for (int y = 0;y<ny;y++) {
82.       d[x][y] = new Dong();
83.     }
84.   }  
85.   noStroke();
86.   smooth();
87. 
    
88. 
    
89. lpfSlider=gui.addSlider("LPCutoff",60.0,7000.0,800,135,20,130);
90. bpfSlider=gui.addSlider("BPCutoff",60.0,200.0,850,135,20,130);
91. bpfBW=gui.addSlider("BPBandWidth",0.0,250.0,900,135,20,130);
92. tempo=gui.addKnob("Tempo",1.0,300.0,860,350,60);
93. maxA=gui.addKnob("MaxAmp",0.0,1.0,700,500,60);
94. att=gui.addKnob("Attackx",0.0,1000,780,500,60);
95. dec=gui.addKnob("Decay",0.0,1000,860,500,60);
96. sus=gui.addKnob("Sustain",0.0,1000,940,500,60);
97. rel=gui.addKnob("Release",0.0,1000,1020,500,60);
98. Freq= gui.addKnob ("Pitch",0.0,5000,0,700,350,60);  //name of knob and parameters
99. Amp = gui.addKnob ("Amplitude",0.0,1.0,0,780,350,60); // amplitude knob
100. Freq.setViewStyle(2); // set the style of knob marker to ellipse
101. Amp.setViewStyle(2); // set amp knob style same as above
102. Freq.setTickMarkLength(5); // set start and end lines on knob graphic
103. Amp.setTickMarkLength(5);
104. sine = new SineWave(440, 0.5, out.sampleRate()); // set sine as a new sine wave and set output frequency, amplitude and size
105. noise = new WhiteNoise(0.5); // set noise as a white noise with amplitude of 0.5
106. sqr1= new SquareWave(220,0.5,out.sampleRate()); // sqr1 setup
107. saw= new SawWave(330,0.5,out.sampleRate()); // saw setup
108. lpf = new LowPassFS(60,out.sampleRate());
109. bpf = new BandPass(700,20,out.sampleRate());
110. 
     
111.  input = RWMidi.getInputDevices()[0].createInput(this); // set up ins and outs for MIDI
112.   output2 = RWMidi.getOutputDevices()[0].createOutput();
113. 
     
114. l = gui.addListBox("Wave Selector") /* set parameters for the  menu box */
115.          .setPosition(50, 15)       
116.          .setSize(170, 170)
117.          .setItemHeight(15)
118.          .setBarHeight(15)
119.          .setColorBackground(color(0))
120.          .setColorActive(color(129))
121.          .setColorForeground(color(0, 100,0))
122.          ;
123.           l.captionLabel().toUpperCase(true);
124.   l.captionLabel().set("Wave Select");
125.   l.captionLabel().setColor(0x11ff0000);
126.   l.captionLabel().style().marginTop = 3;
127.   l.valueLabel().style().marginTop = 3;
128.   
129.     ListBoxItem lbi = l.addItem("Off",1);
130.     ListBoxItem lbi1 = l.addItem("SineWave",2);
131.     ListBoxItem lbi2 = l.addItem("SquareWave",3);
132.     ListBoxItem lbi3 = l.addItem("SawWave",4);
133.     ListBoxItem lbi4 = l.addItem("WhiteNoise",5);
134.     lbi.setColorBackground(0xffff0000);
135.     out.addSignal(sine);
136. out.disableSignal(sine);
137. out.addSignal(sqr1);
138. out.disableSignal(sqr1);
139. out.addSignal(saw);
140. out.disableSignal(saw);
141. out.addSignal(noise);
142. out.disableSignal(noise);
143. out.addEffect(lpf);
144. out.addEffect(bpf);
145. 
     
146.   }
147. void controlEvent(ControlEvent theEvent) {
148.   // ListBox is if type ControlGroup.
149.   // 1 controlEvent will be executed, where the event
150.   // originates from a ControlGroup. therefore
151.   // you need to check the Event with
152.   // if (theEvent.isGroup())
153.   // to avoid an error message from controlP5.
154. 
     
155.   if (theEvent.isGroup()) {
156.     // an event from a group e.g. scrollList
157.   //  println(theEvent.group().value()+" from "+theEvent.group());
158.     
159.      if (theEvent.group().value() == 1) {
160.      out.disableSignal(sine);
161.      out.disableSignal(saw);
162.       out.disableSignal(sqr1);
163.        out.disableSignal(noise);
164.       }
165.       if (theEvent.group().value() == 2) {
166.      out.enableSignal(sine);
167.      out.disableSignal(saw);
168.       out.disableSignal(sqr1);
169.        out.disableSignal(noise);
170.       }
171.      if (theEvent.group().value() == 3) {
172.      out.enableSignal(sqr1);
173.       out.disableSignal(sine);
174.      out.disableSignal(saw);
175.       out.disableSignal(noise);
176.      }
177.      if (theEvent.group().value() == 4) {
178.      out.enableSignal(saw);
179.      out.disableSignal(sqr1);
180.        out.disableSignal(noise);
181.        out.disableSignal(sine);
182.      }
183.      if (theEvent.group().value() == 5) {
184.      out.enableSignal(noise);
185.       out.disableSignal(saw);
186.       out.disableSignal(sqr1);
187.        out.disableSignal(sine);
188.      }
189.   }
190.   
191.   
192.   if(theEvent.isGroup() && theEvent.name().equals("Wave Select")){
193.     int test = (int)theEvent.group().value();
194.  //   println("test "+test);
195.      
196. }
197. }
198. 
     
199.  
200.  
201.  
202.   
203. 
     
204.  
205. void draw() {
206.  background(0,3,20);
207. 
     
208.   // scroll the scroll List according to the mouseX position
209.   // when holding down SPACE.
210.   if (keyPressed && key==' ') {
211.     //l.scroll(mouseX/((float)width)); // scroll taks values between 0 and 1
212.   }
213.   if (keyPressed && key==' ') {
214.     l.setWidth(mouseX);
215.   }
216. 
     
217.    pushMatrix();
218.   translate(width/2 + 150, height/2);
219.   rotate(frameCount*0.001);
220.   for (int x = 0;x<nx;x++) {
221.     for (int y = 0;y<ny;y++) {
222.       //float r=random(x*20); // color for graphics-not used here
223.       //fill(r,r,r);  // see above
224.       //d[x][y].display();
225.      // println(y);
226.     }
227.   }
228.   popMatrix(); 
229.    
230. }
231. void myMatrix(int theX, int theY) {
232. 
     
233.   d[theX][theY].update();
234.   int note=theY;
235.   switch(note)
236.   {
237.     case 0:
238.     note=208;
239.     break;
240.     case 1:
241.     note=220; // A3
242.     break;
243.     case 2:
244.     note=233;  //A#3
245.     break;
246.     case 3:
247.     note=247;  // B3
248.     break;
249.     case 4:
250.     note=262;  //c4
251.     break;
252.     case 5:
253.     note=278;  //c#4
254.     break;
255.     case 6:
256.     note=294;   //D4
257.     break;
258.     case 7:
259.     note=311; // D#4
260.     break;
261.     case 8:
262.     note=330;   //E4
263.     break;
264.     case 9:
265.     note=349;    // F4
266.     break;
267.     case 10:
268.     note=370; // F#4
269.     break;
270.     case 11:
271.     note=392;   // G4
272.     break;
273.     case 12:
274.     note=415; // G#4
275.     break;
276.     case 13:
277.     note=440;  //A4
278.     break;
279.     case 14:
280.     note=466; //A#4;
281.     break;
282.     case 15:
283.     note=494; //B4
284.     break;
285.     case 16:
286.     note=523; // C5
287.     break;
288.     
289.     
290.   }
291.  out.enableSignal(saw);
292.   out.enableSignal(sqr1);
293.   saw.setFreq(note/2);
294.   sqr1.setFreq(note);
295. 
     
296. }
297. public float Pitch(float freqVal)
298. {
299.   sine.setFreq(freqVal);
300.   saw.setFreq(freqVal);
301.   sqr1.setFreq(freqVal);
302.   god=freqVal;
303.   return freqVal;
304. }
305. void Amplitude(float amp)
306. {
307.   sine.setAmp(amp);
308.   sqr1.setAmp(amp);
309.   saw.setAmp(amp);
310.   noise.setAmp(amp);
311. }
312. void Tempo(int time)
313. {
314.   
315. gui.get(Matrix.class, "myMatrix").setInterval(time);
316. 
     
317. }
318. 
     
319. void Attackx(int attackVal)
320. {
321. // my_ADSR.attack_time=attackVal;
322. my_ADSR.setattack();
323. 
     
324. println("attack"+attackVal);
325. }
326. 
     
327. void Decay (float decayVal)
328. {
329.   my_ADSR.decay_time=decayVal;
330. }
331. 
     
332. void Sustain(float sustainVal)
333. {
334.   my_ADSR.sustain_level=sustainVal;
335. }
336. 
     
337. void Release (float releaseVal)
338. {
339.   my_ADSR.release_time=releaseVal;
340. }
341. 
     
342. void LPCutoff(float lCut)
343. {
344.   lpf.setFreq(lCut*2);
345. }
346. void BPCutoff(float bcut)
347. {
348.  bpf.setFreq(bcut); 
349. }
350. void BPBandWidth(float bbw)
351. {
352.   bpf.setBandWidth(bbw);
353. }
354.  /* void controllerChangeReceived(Controller control){
355.     int x=control.getValue();
356.     int y=control.getCC();
357.      int z=control.getValue();
358.   println(control.getCC());
359.   println(control.getValue()); 
360. 
     
361.    }
362.    */
363.    void sysexReceived(rwmidi.SysexMessage msg) {
364.  // println("sysex " + msg);
365. }
366. void noteOnReceived(Note note) {
367.   int v= note.getPitch();
368. //  println("note on " + note.getPitch());
369.  
370. out.enableSignal(saw);
371. if (v==45)
372. out.enableSignal(sqr1);
373. }
374. 
     
375. 
     
376.  void controllerChangeReceived(rwmidi.Controller controller){
377.     int x=controller.getValue();
378.     int y=controller.getCC();
379.      int z=controller.getValue();
380.  // println(controller.getCC());
381.  // println(controller.getValue());
382.  
383.   if (y==102)
384. {
385.   map(x,0,127,0,500);
386.      //Freq.setValue(x*10);
387.   bpf.setFreq(x*10);
388.   if ((x*10)<=60)
389.   {
390.     x=6;
391.   }
392.  // println("bpf="+x*10);
393. }
394.  if (y==105)
395. {
396. map(z,0,127,0,1000);
397. Freq.setValue(x*30);
398. sine.setFreq(x*30);
399. 
     
400. }
401.   
402.   } 
403.   void keyPressed()
404.   {
405.   if (key=='0')
406.   {
407.     gui.get(Matrix.class,"myMatrix").clear();
408.   }
409.   if (key=='p')
410.   {
411.     gui.get(Matrix.class,"myMatrix").pause();
412.     out.disableSignal(sqr1);
413.     out.disableSignal(saw);
414.     
415.     if (mousePressed)
416.     
417.       out.enableSignal(sqr1);
418.       sqr1.setFreq(note);
419.       //out.disableSignal(sqr1);
420.     
421.     
422.       
423.     
424.   }
425.   if(key=='s')
426.   {
427.     gui.get(Matrix.class,"myMatrix").play();
428.     out.enableSignal(sqr1);
429.     out.disableSignal(saw);
430.     
431.   }
432.   }
433.   class Dong {
434.   float x, y;
435.   float s0, s1;
436. 
     
437.   Dong() {
438.     float f= random(-PI, PI);
439.     x = cos(f)*random(100, 150);
440.     y = sin(f)*random(100, 150);
441.     s0 = random(2, 10);
442.   }
443.   
444.  /* void display() {
445.     s1 += (s0-s1)*0.1;
446.     rect(x, y, s1, s1);
447.   }*/
448.    void update() {
449.    
450.     s1 = 50;
451.   }
452.   void mousePressed()
453.   {
454.   }
455.   
456.   }
457.  

This is the sequencer code. I used the minim and controlp5 libraries, oh and Ruin wesens RW MIDI because I intend to build a wireless MIDI transmitter box to enable the user to manipulate sound parameters from afar.. :)

The start of the ADSR class is below:

2. class ADSR
3.  {
4.  int attack_time;
5.  float decay_time; 
6.  float sustain_level;
7.  float release_time;
8.  ADSR () {  
9.    attack_time=50;
10.    decay_time=70;
11.    sustain_level=0.5;
12.    release_time=500;
13.    
14.   }
15.  
16. void setattack()
17. {
18. 
    
19. delay(attack_time/4); 
20. sqr1.setAmp(0.1);
21. delay(attack_time/4);
22. sqr1.setAmp(0.2);
23. delay(attack_time/4);
24. sqr1.setAmp(0.4);
25. delay(attack_time/4);
26. sqr1.setAmp(0.6);
27. }
28.  
29.  
30.  
31.  }

Any help of comments or feedback of good or bad kind welcome.

Cheers!!

Steve.