Minim

micabal

in Contributed Library Questions • 4 months ago

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

import ddf.minim.*;
import oscP5.*;
import netP5.*;
OscP5 oscP5;
int puerto;
Minim minim;
AudioInput in;
AudioPlayer player;
Sonido suena;
Promedio analisis;
GestorSenial altura;
GestorSenial amplitud;
float inFrec;
float inAmp;
boolean monitor = true;
/////////////////////////////////////////////////////////////////////////
void setup () {
frameRate(30);
size (700, 300);
background(0);
minim= new Minim(this);
suena= new Sonido(); // sonidos
analisis=new Promedio(50, 5, 10); // tamaño umbral y tolerancia
altura = new GestorSenial (40, 99); // valores maximos de pd
amplitud = new GestorSenial(40, 99); // valor en pd
puerto = 12000;
oscP5 = new OscP5( this, puerto );
//suena.actualizar(); // lllamando a el usuari
}
/////////////////////////////////////////////////////////////////////////
void draw() {
altura.actualizar( inFrec );
amplitud.actualizar(inAmp);
println("amp: " + inAmp);
println("amp procesada: " + amplitud.filtradoNorm());
println("entrega: " + analisis.entregar());
analisis.actualizar(inAmp); //llama a la funcion de analisis
suena.parametros(analisis.entregar()); // este es para sonidos
if ( monitor ) {
altura.imprimir( 50, 50, 600, 200, false, false, true, true );
}
println( analisis);
if ( analisis.estaCompleto() ) {
println( "-------------------------------------------->"+analisis.entregar() );
}
}
////////////////////////////////////////////////////////////
void oscEvent(OscMessage theOscMessage) {
if (theOscMessage.checkAddrPattern("/datos")==true) {
if (theOscMessage.checkTypetag("f")) {
inFrec = theOscMessage.get(0).floatValue();
}
}
else if (theOscMessage.checkAddrPattern("/vel")==true) {
if (theOscMessage.checkTypetag("f")) {
inAmp = theOscMessage.get(0).floatValue();
}
}
}
//////////////////////////////////////////////// here is the average class /////////////////////////////////////////////////////////
class Promedio {
int tPromedio;// tamaño de la ventana
int cantidad; // numero de muestras por analizar
float total; // cantidad de mueestras
float umbral; // maximo de muestras que toma
float promedio; // el resultado de total/ cantidad
int cont; // contador
int toleranciaTiempoEspera; // para reinicializar si no hay señal
String estado;
boolean okEntrego; // valor de la entrega
////////////////////////////////////////////////// //---------------------------
Promedio (int tPromedio_, float umbral_, int toleranciaTiempoEspera_) {
okEntrego = false;
toleranciaTiempoEspera = toleranciaTiempoEspera_;
tPromedio = tPromedio_;
umbral = umbral_;
estado = "espera"; // tener en cuenta cambio de reinicia
}
/////////////////////////////////////////////////////////// //--------------------
void actualizar( float esteEvento) {
boolean superaUmbral = esteEvento>umbral;
if (estado.equals("espera")) {
if (superaUmbral) {
agregar(esteEvento);
estado="agrega";
cont=0;
}
else {
cont++;
if ( cont>toleranciaTiempoEspera ) {
estado = "reinicia";
}
}
}
else if ( estado.equals( "agrega" ) ) {
if ( superaUmbral ) {
agregar( esteEvento );
if ( estaCompleto() ) {
estado = "entrega";
}
}
else {
estado = "espera";
}
}
else if ( estado.equals( "entrega" ) ) {
if ( okEntrego ) {
estado = "reinicia";
okEntrego = false;
}
}
else if ( estado.equals( "reinicia" ) ) {
cont = 0;
cantidad = 0;
total = 0;
promedio = 0;
estado = "espera";
}
}
//--------------------------------
void agregar( float suena ) {
total += suena;
cantidad ++;
promedio = total*1.0/cantidad;
}
//--------------------------------
float entregar() {
okEntrego = true;
return promedio;
}
//--------------------------------
boolean estaCompleto() {
return cantidad >= tPromedio;
}
//--------------------------------
String toString() {
return "["+cantidad+"]->"+promedio;
}
}
//////////////////////////////////////////////////////////////////////////here is the sound class///////////////////////////////////
class Sonido {
String estado;
AudioPlayer[] baja;
AudioPlayer[] media;
AudioPlayer[] alta;
int num_sonido;
int sonidoAnterior = -1;
float arranca = 35;
//////////////////////////////////////////////////////////////////////
Sonido() {
num_sonido=int(random(1, 10));
baja =new AudioPlayer[10];
media = new AudioPlayer[10];
alta= new AudioPlayer[10];
for (int i = 0; i < 10 ; i++ ) {
int sonido = i + 1;
baja[i]= minim.loadFile("baja" + sonido + ".wav");
println(baja[i]);
media[i]=minim.loadFile("media" + sonido + ".wav");
println(media[i]);
alta[i]=minim.loadFile("alta" + sonido + ".wav");
println(alta[i]);
}
estado="espera";
}
///////////////////////////////////////////////////////////////////////
void actualizar() {
player = minim.loadFile("inactividad1.wav");
player.play();
}
void parametros(float promedio) {
boolean haySenial=inAmp>arranca;
if (estado.equals("espera")) {
if (!haySenial) {
// suena.actualizar();
}
else {
estado="inicializar";
}
}
else if
(estado.equals("inicializar")) {
analisis.actualizar(inAmp); //llama a la funcion de analisis
if (!haySenial) {
estado="espera";
}
else {
estado="avanzar";
}
}
else if (estado.equals("avanzar")) {
if (analisis.entregar() > 40 && analisis.entregar() < 70) {
// Si entro aca asumimos que va a reproducir un sonido
// pausamos y retrocedemos cualquiera de los anteriores que pueda estar reproduciendose
if (sonidoAnterior!=-1) {
baja[sonidoAnterior].pause();
// baja[sonidoAnterior].rewind();
media[sonidoAnterior].pause();
//media[sonidoAnterior].rewind();
alta[sonidoAnterior].pause();
// media[sonidoAnterior].rewind();
}
}
if (analisis.entregar() >40 && analisis.entregar()< 50) {
baja[num_sonido].play();
}
else if (analisis.entregar() > 50 && analisis.entregar()< 60) {
media[num_sonido].play();
}
else if (analisis.entregar() >60 && analisis.entregar()< 70) {
alta[num_sonido].play();
}
// if (analisis.entregar() > 40 && analisis.entregar() < 70) {
// sonidoAnterior = num_sonido;
//
// }
if (!haySenial) {
estado="espera";
}
else {
estado="inicializar";
}
}
}
String toString() {
return "estado = "+estado;
}
}
////////////////////////////////////this is the manager takes data signal with pure data but this works////////////////////
//--------------------------------------
// Gestor de seniales (con enie)
// Emiliano Causa 2011-2012
//--------------------------------------
/*
Constructores:
==============
- GestorSenial( )
- GestorSenial( float minimo_, float maximo_ )
- GestorSenial( String etiqueta_,
float minimo_, float maximo_, //minimo y maximo del rango de entrada
int tamanioMuestra_, //tamanio con el que visualiza la senial
float factorAmortiguacion_, //factor con el que filtra
float amplitudMaxDerivada_, //rango en el que toma la derivada
int maxMuestrasPromedio_, //cantidad de muestras para el promedio
float amplitudMaxVarianza_ )
Miembros de devolucion:
=======================
- float valorIn
- float filtrado
- float derivada
- float varianza
- float promedio
Funciones de devolucion:
========================
- float filtradoNorm()
- float derivadaNorm()
- float varianzaNorm()
Ejecutar en cada ciclo:
=======================
void actualizar( float valorIn_ )
*/
class GestorSenial {
String etiqueta;
float valorIn, filtrado;
float minimo;
float maximo;
//float factor;
float derivada;
float promedio, varianza;
int cantDatos;
int tamanioMuestra;
float factorAmortiguacion;
float amplitudMaxDerivada;
int maxMuestrasPromedio;
float amplitudMaxVarianza;
GrafXvsTime grafica, graficaFilt, graficaDeriv, graficaPromedio, graficaVarianza;
//-------------------------------------------
GestorSenial( ) {
this( "", 0, 100, 200, 0.1, 0.5, 50, 3 );
}
//-------------------------------------------
GestorSenial( float minimo_, float maximo_ ) {
this( "", minimo_, maximo_, 200, 0.1, 0.5, 50, 3 );
}
//-------------------------------------------
GestorSenial( String etiqueta_,
float minimo_, float maximo_, //minimo y maximo del rango de entrada
int tamanioMuestra_, //tamanio con el que visualiza la senial
float factorAmortiguacion_, //factor con el que filtra
float amplitudMaxDerivada_, //rango en el que toma la derivada
int maxMuestrasPromedio_, //cantidad de muestras para el promedio
float amplitudMaxVarianza_ ) { //rango en el que toma la varianza
etiqueta = etiqueta_;
amplitudMaxVarianza = amplitudMaxVarianza_;
cantDatos = 0;
maxMuestrasPromedio = maxMuestrasPromedio_;
factorAmortiguacion = factorAmortiguacion_;
amplitudMaxDerivada = amplitudMaxDerivada_;
minimo = minimo_;
maximo = maximo_;
tamanioMuestra = tamanioMuestra_;
grafica = new GrafXvsTime( tamanioMuestra, minimo, maximo );
graficaFilt = new GrafXvsTime( tamanioMuestra, minimo, maximo );
graficaPromedio = new GrafXvsTime( tamanioMuestra, minimo, maximo );
graficaDeriv = new GrafXvsTime( tamanioMuestra, -amplitudMaxDerivada, amplitudMaxDerivada );
graficaVarianza = new GrafXvsTime( tamanioMuestra, -amplitudMaxVarianza, amplitudMaxVarianza );
}
//-------------------------------------------
float filtradoNorm() {
return constrain( map( filtrado, minimo, maximo, 0, 1 ), 0, 1);
}
//-------------------------------------------
float derivadaNorm() {
return constrain( map( derivada, -amplitudMaxDerivada, amplitudMaxDerivada, -1, 1 ), -1, 1);
}
//-------------------------------------------
float varianzaNorm() {
return constrain( map( varianza, -amplitudMaxVarianza, amplitudMaxVarianza, -1, 1 ), -1, 1);
}
//-------------------------------------------
void actualizar( float valorIn_ ) {
valorIn = valorIn_;
float anterior = filtrado;
filtrado = valorIn * factorAmortiguacion + filtrado * (1-factorAmortiguacion);
derivada = filtrado-anterior;
varianza = filtrado-promedio;
if ( cantDatos <= 0 ) {
promedio = filtrado;
}
else {
int maxDatos = min( cantDatos, maxMuestrasPromedio );
float esteFactor = 1.0/maxDatos;
promedio = filtrado * esteFactor + promedio * (1-esteFactor);
}
cantDatos ++;
grafica.agregar( valorIn );
graficaFilt.agregar( filtrado );
graficaDeriv.agregar( derivada );
graficaPromedio.agregar( promedio );
graficaVarianza.agregar( varianza );
}
//-------------------------------------------
void imprimir( float left, float top ) {
imprimir( left, top, 500, 100, true, false, false, false );
}
//-------------------------------------------
void imprimir( float left, float top, float ancho, float alto ) {
imprimir( left, top, ancho, alto, true, false, false, false );
}
//-------------------------------------------
void imprimir( float left, float top, float ancho, float alto,
boolean mostrarFiltrado, boolean mostrarDerivada, boolean mostrarPromedio,
boolean mostrarVarianza ) {
fill( 0 );
stroke( 255, 255, 255 );
grafica.imprimir( left, top, ancho, alto, true );
if ( mostrarVarianza || mostrarDerivada ) {
stroke( 100 );
line( left, top + alto*0.5, left+ancho, top + alto*0.5 );
}
if ( mostrarFiltrado ) {
stroke( 0, 255, 0 );
graficaFilt.imprimir( left, top, ancho, alto, false );
}
if ( mostrarDerivada ) {
stroke( 255, 255, 0 );
graficaDeriv.imprimir( left, top, ancho, alto, false );
}
if ( mostrarPromedio ) {
stroke( 50, 50, 255 );
graficaPromedio.imprimir( left, top, ancho, alto, false );
}
if ( mostrarVarianza ) {
stroke( 150, 150, 255 );
graficaVarianza.imprimir( left, top, ancho, alto, false );
}
}
//-------------------------------------------
String generarXML() {
String cadena = "";
cadena += "< ";
cadena += etiqueta;
cadena += " minimo=\"" + minimo + "\" ";
cadena += " maxmimo=\"" + maximo + "\" ";
cadena += " tamanioMuestra=\"" + tamanioMuestra + "\" ";
cadena += " factorAmortiguacion=\"" + factorAmortiguacion + "\" ";
cadena += " amplitudMaxDerivada=\"" + amplitudMaxDerivada + "\" ";
cadena += " maxMuestrasPromedio=\"" + maxMuestrasPromedio + "\" ";
cadena += " amplitudMaxVarianza=\"" + amplitudMaxVarianza + "\" ";
cadena += "/>";
return cadena;
}
}
// ------------------------------------------------------------------------------------------------------
// MARCA: Grafica X versus TIME - Grafica X versus TIME - Grafica X versus TIME - Grafica X versus TIME -
// ------------------------------------------------------------------------------------------------------
// Este objeto permite grafica evoluciones en el tiempo
// Emiliano Causa - Julio 2006
//
// GrafXvsTime(int cantPuntos_, float minimo_, float maximo_) - inicializa el objeto, definiendo la cantidad de puntos
// a monitorear, y los valores minimo y maximos
// void agregar( float dato ) - agrega puntos a la grÔøΩfica
// void imprimir( float left, float top, float ancho, float alto ) - imprime los datos en pantalla en la posiciÔøΩn y las
// dimensiones indicadas
//
class GrafXvsTime {
float minimo;
float maximo;
int cantPuntos;
int cont;
float datos[];
GrafXvsTime(int cantPuntos_, float minimo_, float maximo_) {
minimo = minimo_;
maximo = maximo_;
cantPuntos = cantPuntos_;
datos = new float[cantPuntos];
cont = 0;
}
void agregar( float dato ) {
datos[cont] = dato;
cont = (cont+1) % cantPuntos;
}
void imprimir( float left, float top, float ancho, float alto, boolean conFondo ) {
if ( conFondo ) {
rectMode(CORNER);
rect(left, top, ancho, alto);
}
float paso = ancho/cantPuntos;
for (int i=1 ; i<cantPuntos ; i++) {
if (i != cont) {
float valor1 = map( constrain( datos[i-1], minimo, maximo ), minimo, maximo, top+alto, top );
float valor2 = map( constrain( datos[i], minimo, maximo ), minimo, maximo, top+alto, top);
line( left + paso * (i-1), valor1, left + paso * i, valor2 );
}
}
}
}

Replies(1)

PhiLho

" Minim" " have problems with the state diagram"
I fail to see a relation between the subject and the... question?
Not having the contributed libraries you use, I cannot run your code (and thus, I moved the topic here from Programming Questions). If the libraries are unrelated to your problem, show a simpler sketch isolating your problem without them.

The Spanish comments doesn't help (me) in understanding your code, so I fail to understand what is this "state diagram", how it can cause problems with Minim, and what are your problems exactly.

Top Reply

Minim

Replies(1)

Re: Minim

Statistics

Tags

Actions

Related Posts