basically, the sketch you do is take an amplitude value of the incoming signal amplitude discriminate between sounds low, medium and high and plays audio.

have problems with the state diagram ... help!

here is the upper class

2. import ddf.minim.*;
3. import oscP5.*;
4. import netP5.*;
5. 
   
6. OscP5 oscP5;
7. int puerto;
8. 
   
9. Minim minim;
10. AudioInput in;
11. AudioPlayer player;
12. 
    
13. Sonido suena;
14. Promedio analisis;
15. 
    
16. GestorSenial altura;
17. GestorSenial amplitud;
18. 
    
19. float inFrec;
20. float inAmp;
21. boolean monitor = true;
22. 
    
23. /////////////////////////////////////////////////////////////////////////
24. 
    
25. void setup () {
26.   frameRate(30);
27.   size (700, 300);
28.   background(0);
29. 
    
30.   minim= new Minim(this);
31.   suena= new Sonido(); // sonidos 
32.   analisis=new Promedio(50, 5, 10); // tamaño umbral y tolerancia 
33. 
    
34.   altura = new GestorSenial (40, 99); // valores maximos de pd
35.   amplitud = new GestorSenial(40, 99); // valor en pd 
36. 
    
37.   puerto = 12000;
38.   oscP5 = new OscP5( this, puerto );
39.   //suena.actualizar(); // lllamando a el usuari 
40.   
41.   
42.   
43.    
44. }
45. 
    
46. /////////////////////////////////////////////////////////////////////////
47. 
    
48. void draw() { 
49. 
    
50.   altura.actualizar( inFrec );
51.   amplitud.actualizar(inAmp);
52. 
    
53.   println("amp: " + inAmp);
54.   println("amp procesada: " + amplitud.filtradoNorm());
55.   
56.   
57.   println("entrega: " + analisis.entregar());
58. 
    
59.  
60.    analisis.actualizar(inAmp);  //llama a la funcion de analisis 
61. 
    
62.    suena.parametros(analisis.entregar()); // este es para sonidos 
63.   
64.   if ( monitor ) {
65.     altura.imprimir( 50, 50, 600, 200, false, false, true, true );
66.   }
67.   
68.   println( analisis);
69. 
    
70.   if ( analisis.estaCompleto() ) {
71.     println( "-------------------------------------------->"+analisis.entregar() );
72.   }
73.     
74.   
75.   
76.    
77. }
78. 
    
79. ////////////////////////////////////////////////////////////
80. 
    
81. void oscEvent(OscMessage theOscMessage) {
82. 
    
83.   if (theOscMessage.checkAddrPattern("/datos")==true) {
84. 
    
85.     if (theOscMessage.checkTypetag("f")) {
86.       inFrec = theOscMessage.get(0).floatValue();
87.     }
88.   }
89.   else if (theOscMessage.checkAddrPattern("/vel")==true) {
90. 
    
91.     if (theOscMessage.checkTypetag("f")) {
92.       inAmp = theOscMessage.get(0).floatValue();
93.     }
94.   }
95. }
96. 
    
97. 
    
98. //////////////////////////////////////////////// here is the average class /////////////////////////////////////////////////////////
99. 
    
101. class Promedio {
102. 
     
103.   int tPromedio;// tamaño de la ventana
104.   int cantidad; // numero de muestras por analizar
105.   
106.   float total; // cantidad de mueestras
107.   float umbral; // maximo de muestras que toma 
108.   float promedio; // el resultado de total/ cantidad
109. 
     
110.   int cont; // contador 
111.   int toleranciaTiempoEspera; // para reinicializar si no hay señal 
112. 
     
113.   String estado;
114.   boolean okEntrego; //  valor de la entrega
115. 
     
116.   ////////////////////////////////////////////////// //---------------------------
117. 
     
118.   Promedio (int tPromedio_, float umbral_, int toleranciaTiempoEspera_) {
119. 
     
120. 
     
121.     okEntrego = false;
122. 
     
123.     toleranciaTiempoEspera = toleranciaTiempoEspera_;
124.     tPromedio = tPromedio_;
125.     umbral = umbral_;
126. 
     
127. 
     
128.     estado = "espera"; // tener en cuenta cambio de  reinicia
129.   }
130.   /////////////////////////////////////////////////////////// //--------------------
131. 
     
132.   void actualizar( float esteEvento) {
133. 
     
134.     boolean superaUmbral = esteEvento>umbral;
135. 
     
136.     if (estado.equals("espera")) {
137.       if (superaUmbral) {
138.         agregar(esteEvento);
139.         estado="agrega";
140.         cont=0;
141.       } 
142.       else {
143.         cont++;
144.         if ( cont>toleranciaTiempoEspera ) {
145.           estado = "reinicia";
146.         }
147.       }
148.     }
149.     else if ( estado.equals( "agrega" ) ) {
150. 
     
151.       if ( superaUmbral ) {
152.         agregar( esteEvento );
153.         if ( estaCompleto() ) {
154.           estado = "entrega";
155.         }
156.       }
157.       else {
158.         estado = "espera";
159.       }
160.     }
161.     else if ( estado.equals( "entrega" ) ) {
162.       if ( okEntrego ) {
163.         estado = "reinicia";
164.         okEntrego = false;
165.       }
166.     }
167.     else if ( estado.equals( "reinicia" ) ) {
168.       cont = 0;
169.       cantidad = 0;
170.       total = 0;
171.       promedio = 0;
172.       estado = "espera";
173.     }
174.   }
175. 
     
176.  //--------------------------------
177. void agregar( float suena ) {
178.   total += suena;
179.   cantidad ++;
180.   promedio = total*1.0/cantidad;
181. }
182. 
     
183.  //--------------------------------
184. float entregar() {
185.     okEntrego = true;
186.     return promedio;
187.   }
188.   //--------------------------------
189.   boolean estaCompleto() {
190.     return cantidad >= tPromedio;
191.   }
192.   //--------------------------------
193. 
     
194.   String toString() {
195.     return "["+cantidad+"]->"+promedio;
196.   }
197. }
199. 
     
200. //////////////////////////////////////////////////////////////////////////here is the sound class///////////////////////////////////
201. 
     
203. class Sonido {
204. 
     
205.   String estado;
206.   AudioPlayer[] baja;
207.   AudioPlayer[] media;
208.   AudioPlayer[] alta;
209.   int num_sonido;
210.   int sonidoAnterior = -1;
211. 
     
212.   float arranca = 35;
213.   //////////////////////////////////////////////////////////////////////
214.   Sonido() {
215.     num_sonido=int(random(1, 10));
216. 
     
217.     baja =new AudioPlayer[10];
218.     media = new AudioPlayer[10];
219.     alta= new AudioPlayer[10];
220. 
     
221.     for (int i = 0; i < 10 ; i++ ) {
222. 
     
223.       int sonido = i + 1;
224. 
     
225.       baja[i]= minim.loadFile("baja" + sonido + ".wav");
226.       println(baja[i]);
227.       media[i]=minim.loadFile("media" + sonido + ".wav");
228.       println(media[i]);
229.       alta[i]=minim.loadFile("alta" + sonido + ".wav");
230.       println(alta[i]);
231.     }
232.     estado="espera";
233.   }
234.   ///////////////////////////////////////////////////////////////////////
235. 
     
236. 
     
237.   void actualizar() {
238.     player = minim.loadFile("inactividad1.wav");
239.     player.play();
240.   }
241. 
     
242.   void parametros(float promedio) {
243. 
     
244.     boolean haySenial=inAmp>arranca;
245. 
     
246.     if (estado.equals("espera")) {
247.       if (!haySenial) {
248.         // suena.actualizar();
249.       } 
250.       else { 
251.         estado="inicializar";
252.       }
253.     }
254.     else if   
255.       (estado.equals("inicializar")) {
256.       analisis.actualizar(inAmp);  //llama a la funcion de analisis 
257.       if (!haySenial) {
258.         estado="espera";
259.       } 
260.       else { 
261.         estado="avanzar";
262.       }
263.     }
264.     else if (estado.equals("avanzar")) {
265.       if (analisis.entregar() > 40 && analisis.entregar() < 70) {
266.         //  Si entro aca asumimos que va a reproducir un sonido
267.         //  pausamos y retrocedemos cualquiera de los anteriores que pueda estar reproduciendose
268.         if (sonidoAnterior!=-1) {
269.           baja[sonidoAnterior].pause();
270.           // baja[sonidoAnterior].rewind();
271.           media[sonidoAnterior].pause();
272.           //media[sonidoAnterior].rewind();
273.           alta[sonidoAnterior].pause();
274.           // media[sonidoAnterior].rewind();
275.         }
276.       }
277. 
     
278.       if (analisis.entregar() >40 && analisis.entregar()< 50) {
279.         baja[num_sonido].play();
280.       }  
281.       else  if (analisis.entregar() > 50 && analisis.entregar()< 60) {
282.         media[num_sonido].play();
283.       }
284.       else  if (analisis.entregar() >60 && analisis.entregar()< 70) {
285.         alta[num_sonido].play();
286.       }
287.       //      if (analisis.entregar() > 40 && analisis.entregar() < 70) {
288.       //        sonidoAnterior = num_sonido;
289.       //       
290.       //      }
291. 
     
292.       if (!haySenial) {
293.         estado="espera";
294.       }  
295.       else {
296.         estado="inicializar";
297.       }
298.     }
299.   }
300. 
     
301.   String toString() {
302.     return "estado = "+estado;
303.   }
304. }
305. ////////////////////////////////////this is the manager takes data signal with pure data but this works////////////////////
306. 
     
308. //--------------------------------------
309. // Gestor de seniales (con enie)
310. // Emiliano Causa 2011-2012
311. //--------------------------------------
312. /*
313. 
     
314.  Constructores:
315.  ==============
316.  
317.  - GestorSenial( ) 
318.  
319.  - GestorSenial( float minimo_, float maximo_ ) 
320.  
321.  - GestorSenial( String etiqueta_, 
322.  float minimo_, float maximo_, //minimo y maximo del rango de entrada
323.  int tamanioMuestra_, //tamanio con el que visualiza la senial
324.  float factorAmortiguacion_, //factor con el que filtra 
325.  float amplitudMaxDerivada_, //rango en el que toma la derivada
326.  int maxMuestrasPromedio_, //cantidad de muestras para el promedio
327.  float amplitudMaxVarianza_ ) 
328.  
329.  Miembros de devolucion:
330.  =======================
331.  - float valorIn 
332.  - float filtrado
333.  - float derivada
334.  - float varianza
335.  - float promedio
336.  
337.  Funciones de devolucion:
338.  ========================
339.  - float filtradoNorm()
340.  - float derivadaNorm()
341.  - float varianzaNorm()
342.  
343.  Ejecutar en cada ciclo:
344.  =======================
345.  void actualizar( float valorIn_ ) 
346.  
347.  */
348. class GestorSenial {
349. 
     
350.   String etiqueta;
351.   float valorIn, filtrado;
352.   float minimo;
353.   float maximo;
354.   //float factor;
355. 
     
356.   float derivada;
357.   float promedio, varianza;  
358.   int cantDatos;
359. 
     
360.   int tamanioMuestra;
361.   float factorAmortiguacion;
362.   float amplitudMaxDerivada;
363.   int maxMuestrasPromedio;
364.   float amplitudMaxVarianza;
365. 
     
366.   GrafXvsTime grafica, graficaFilt, graficaDeriv, graficaPromedio, graficaVarianza;
367. 
     
368.   //-------------------------------------------
369. 
     
370.   GestorSenial( ) {
371.     this( "", 0, 100, 200, 0.1, 0.5, 50, 3 );
372.   }
373.   //-------------------------------------------
374.   GestorSenial( float minimo_, float maximo_ ) {
375.     this( "", minimo_, maximo_, 200, 0.1, 0.5, 50, 3 );
376.   }
377.   //-------------------------------------------
378. 
     
379.   GestorSenial( String etiqueta_, 
380.   float minimo_, float maximo_, //minimo y maximo del rango de entrada
381.   int tamanioMuestra_, //tamanio con el que visualiza la senial
382.   float factorAmortiguacion_, //factor con el que filtra 
383.   float amplitudMaxDerivada_, //rango en el que toma la derivada
384.   int maxMuestrasPromedio_, //cantidad de muestras para el promedio
385.   float amplitudMaxVarianza_ ) { //rango en el que toma la varianza
386. 
     
387.     etiqueta = etiqueta_;
388.     amplitudMaxVarianza = amplitudMaxVarianza_;
389.     cantDatos = 0;
390.     maxMuestrasPromedio = maxMuestrasPromedio_;
391.     factorAmortiguacion = factorAmortiguacion_;
392.     amplitudMaxDerivada = amplitudMaxDerivada_;
393.     minimo = minimo_;
394.     maximo = maximo_;
395.     tamanioMuestra = tamanioMuestra_;
396. 
     
397.     grafica = new GrafXvsTime( tamanioMuestra, minimo, maximo );
398.     graficaFilt = new GrafXvsTime( tamanioMuestra, minimo, maximo );
399.     graficaPromedio = new GrafXvsTime( tamanioMuestra, minimo, maximo );
400. 
     
401.     graficaDeriv = new GrafXvsTime( tamanioMuestra, -amplitudMaxDerivada, amplitudMaxDerivada );
402.     graficaVarianza = new GrafXvsTime( tamanioMuestra, -amplitudMaxVarianza, amplitudMaxVarianza );
403.   }
404.   //-------------------------------------------
405. 
     
406.   float filtradoNorm() {
407.     return constrain( map( filtrado, minimo, maximo, 0, 1 ), 0, 1);
408.   }  
409.   //-------------------------------------------
410. 
     
411.   float derivadaNorm() {
412.     return constrain( map( derivada, -amplitudMaxDerivada, amplitudMaxDerivada, -1, 1 ), -1, 1);
413.   }  
414.   //-------------------------------------------
415. 
     
416.   float varianzaNorm() {
417.     return constrain( map( varianza, -amplitudMaxVarianza, amplitudMaxVarianza, -1, 1 ), -1, 1);
418.   }  
419.   //-------------------------------------------
420. 
     
421.   void actualizar( float valorIn_ ) {
422. 
     
423.     valorIn = valorIn_;
424.     float anterior = filtrado;
425.     filtrado = valorIn * factorAmortiguacion + filtrado * (1-factorAmortiguacion);
426.     derivada = filtrado-anterior;
427.     varianza = filtrado-promedio;
428. 
     
429.     if ( cantDatos <= 0 ) {
430.       promedio = filtrado;
431.     }
432.     else {
433.       int maxDatos = min( cantDatos, maxMuestrasPromedio );
434.       float esteFactor = 1.0/maxDatos;
435.       promedio = filtrado * esteFactor + promedio * (1-esteFactor);
436.     }
437. 
     
438.     cantDatos ++;
439. 
     
440.     grafica.agregar( valorIn ); 
441.     graficaFilt.agregar( filtrado ); 
442.     graficaDeriv.agregar( derivada );
443.     graficaPromedio.agregar( promedio );
444.     graficaVarianza.agregar( varianza );
445.   }
446.   //-------------------------------------------
447. 
     
448.   void imprimir( float left, float top ) {
449.     imprimir( left, top, 500, 100, true, false, false, false );
450.   }
451.   //-------------------------------------------
452. 
     
453.   void imprimir( float left, float top, float ancho, float alto ) {
454.     imprimir( left, top, ancho, alto, true, false, false, false );
455.   }
456.   //-------------------------------------------
457. 
     
458.   void imprimir( float left, float top, float ancho, float alto, 
459.   boolean mostrarFiltrado, boolean mostrarDerivada, boolean mostrarPromedio, 
460.   boolean mostrarVarianza ) {
461. 
     
462.     fill( 0 );
463.     stroke( 255, 255, 255 );
464.     grafica.imprimir( left, top, ancho, alto, true );
465. 
     
466.     if ( mostrarVarianza || mostrarDerivada ) {
467.       stroke( 100 );
468.       line( left, top + alto*0.5, left+ancho, top + alto*0.5 );
469.     }
470. 
     
471.     if ( mostrarFiltrado ) {
472.       stroke( 0, 255, 0 );
473.       graficaFilt.imprimir( left, top, ancho, alto, false );
474.     }
475. 
     
476.     if ( mostrarDerivada ) {
477.       stroke( 255, 255, 0 );
478.       graficaDeriv.imprimir( left, top, ancho, alto, false );
479.     }
480. 
     
481.     if ( mostrarPromedio ) {
482.       stroke( 50, 50, 255 );
483.       graficaPromedio.imprimir( left, top, ancho, alto, false );
484.     }
485. 
     
486.     if ( mostrarVarianza ) {
487.       stroke( 150, 150, 255 );
488.       graficaVarianza.imprimir( left, top, ancho, alto, false );
489.     }
490.   }
491.   //-------------------------------------------
492. 
     
493.   String generarXML() {
494.     String cadena = "";
495. 
     
496.     cadena += "< ";
497.     cadena += etiqueta;
498.     cadena += " minimo=\"" + minimo + "\" ";
499.     cadena += " maxmimo=\"" + maximo + "\" ";
500. 
     
501.     cadena += " tamanioMuestra=\"" + tamanioMuestra + "\" ";
502. 
     
503.     cadena += " factorAmortiguacion=\"" + factorAmortiguacion + "\" ";
504.     cadena += " amplitudMaxDerivada=\"" + amplitudMaxDerivada + "\" ";
505.     cadena += " maxMuestrasPromedio=\"" + maxMuestrasPromedio + "\" ";
506.     cadena += " amplitudMaxVarianza=\"" + amplitudMaxVarianza + "\" ";
507. 
     
508.     cadena += "/>";
509.     return cadena;
510.   }
511. }
512. // ------------------------------------------------------------------------------------------------------
513. // MARCA: Grafica X versus TIME - Grafica X versus TIME - Grafica X versus TIME - Grafica X versus TIME -
514. // ------------------------------------------------------------------------------------------------------
515. // Este objeto permite grafica evoluciones en el tiempo
516. // Emiliano Causa - Julio 2006
517. //
518. // GrafXvsTime(int cantPuntos_, float minimo_, float maximo_) - inicializa el objeto, definiendo la cantidad de puntos
519. //                                                              a monitorear, y los valores minimo y maximos
520. // void agregar( float dato ) - agrega puntos a la grÔøΩfica
521. // void imprimir( float left, float top, float ancho, float alto ) - imprime los datos en pantalla en la posiciÔøΩn y las
522. //                                                                   dimensiones indicadas
523. //
524. class GrafXvsTime {
525.   float minimo;
526.   float maximo;
527. 
     
528.   int cantPuntos;
529.   int cont;
530. 
     
531.   float datos[];
532. 
     
533.   GrafXvsTime(int cantPuntos_, float minimo_, float maximo_) {
534.     minimo = minimo_;
535.     maximo = maximo_;
536.     cantPuntos = cantPuntos_;
537.     datos = new float[cantPuntos];
538.     cont = 0;
539.   }
540. 
     
541.   void agregar( float dato ) {
542.     datos[cont] = dato;
543.     cont = (cont+1) % cantPuntos;
544.   }
545. 
     
546.   void imprimir( float left, float top, float ancho, float alto, boolean conFondo ) {
547. 
     
548.     if ( conFondo ) {
549.       rectMode(CORNER);
550.       rect(left, top, ancho, alto);
551.     }
552.     float paso = ancho/cantPuntos;
553.     for (int i=1 ; i<cantPuntos ; i++) {
554.       if (i != cont) {
555.         float valor1 = map( constrain( datos[i-1], minimo, maximo ), minimo, maximo, top+alto, top );
556.         float valor2 = map( constrain( datos[i], minimo, maximo ), minimo, maximo, top+alto, top);
557.         line( left + paso * (i-1), valor1, left + paso * i, valor2 );
558.       }
559.     }
560.   }
561. }