He cogido el script para generar los tonos del otro post y lo he cambiado para los pitidos duren 40ms (que se resume a cambiar que use 320 muestras en lugar de 1200 para cada pitido o silencio), para que sea un poco más real. El wav que voy a usar será el siguiente: ring.wav

Empezamos, ¿qué necesitamos? Cada pitido estará compuesto por una pareja de tonos así que para saber qué número es deberemos reconocer las dos frecuencias principales que tienen los pitidos, y conocer la frecuencia viene a ser lo mismo que saber el periodo.

Hace un tiempo hice una práctica de Tratamiento Digital de la Señal en la que se hacían cosas de estas, uno de los códigos no es mío, está indicado. El resto los hicimos Rafa y yo en su día.

Aprovechándonos de la Transformada de Fourier:

function [P,f]=periodograma(x,N)
% [P f]=periodograma(x,N)
% Calcula N muestras del periodograma de las muestras en x
% N debe ser > que length(x)
%
% P: Periodograma propiamente
% f frecuencias correspondientes
 
k=0:N-1;
f=k./N;
 
L=length(x);
P=1/L*(fft(x,N)).^2;

Pero lo propio será usar un programa que use ventanas para su propósito:

function [P,f]=periodmodif(x,ventana,N)
% [P ,f]=periodmodif(x,ventana,N)
%
% Calcula N muestras del periodograma modificado de las muestras en x
% N debe ser > que length(x)
%
% P: Periodograma propiamente
% f frecuencias correspondientes
 
if N <= length(x)
   error('N debe ser > que length(x)');
else
   k=0:N-1;
   f=k./N;
 
   L=length(x);
   m=0:L-1;
 
   U=1/L*(sum(ventana(m+1).^2));
   P=1/(L*U)*abs(fft(x.*ventana,N)).^2;
end

Cargamos el fichero ring.wav

>> [x,fs,nbits]= wavread('ring.wav')
>> t=0:1/fs:1/fs*(length(x)-1);
>> plot(x)

Ahora tendremos que calcular de cuanto es nuestra ventana mínima. La separación mínima entre tonos es de 320 muestras (que además en este caso es la misma entre todos los tonos) luego la frecuencia digital será 320 / fs = 320/8000 = 0.04

Y aquí un poco de teoría sobre ventanas gracias a los Apuntes de Pak:

Pero no voy a aburriros con ella así que nos quedaremos en que vamos a usar una ventana tipo Hamming, luego necesitaremos una longitud de ventana L = 4 / resolución = 4 / 0.04 = 100 muestras

Ahora vamos a determinar los dígitos, y para ello vamos a hacer uso de la siguiente función para búscar máximos:

function p=buscapicosu(x,umbral)
%posi_picos=buscapicosu(x,umbral)
% Busca los máximos locales de un vector mayores que un cierto umbral
% umbral se expresa en % respecto al valor máximo del vector.
% Ej. buscapicos(x,60) buscaria los picos mayores o iguales al 60% del
% pico más alto
%
% posi_picos son los indices del vector de entrada correspondientes a los picos.
 
% (C) Antonio Albiol , 2003
 
%Primero descarto los valores menores que el umbral
 
umbral=max(x(:))*umbral/100;
 
x=x.*(x>umbral);
 
%Ahora buscaré los máximos
 
%Primero creo un vector con dos valores muy pequeños en los extremos
xe=[-inf;x(:);-inf];
 
%Ahora calculo la derivada
d1=diff(xe);
ld1=length(d1);
%Ahora busco valores de la derivada de signo diferente consecutivos y que sean máximos
p=find(sign(d1(2:ld1)).*sign(d1(1:(ld1-1)))<0 & sign(d1(1:ld1-1))>0);

Cada pitido y cada silencio dura 320 muestras luego calculamos periodos en esas zonas. Vamos a por el primer dígito, con ventana Hamming de 100 y usando 1024 puntos:

>> [P,f]=periodmodif(x(320:320+99),hamming(100),1024);
>> buscapicosu(abs(P),50)
 
ans =
 
   110
   190
   836
   916

En el espectro digital, de 0 a 1, veremos que las frecuencias se repiten en espejo a partir de 0.5. Luego la frecuencia 110 se corresponde con la 916, igualmente ocurre entre la de 190 y 836, son lo mismo. Así que sólo tenemos que ver a qué corresponden 110 y 190.

Nota a tener en cuenta: en las FFTs (Fast Fourier Transforms) el cálculo se hace mucho más rapido cuando N es una potencia de 2, por eso la elección de hacerlo en 1024 puntos no ha sido del todo al azar.

>> 110/1024*fs
 
ans =
 
  859.3750
 
>> 190/1024*fs
 
ans =
 
  1.4844e+003

Nos vamos a la tablita y vemos con qué 2 valores más cercanos concuerdan 859.375 y 1484.4 Hz. Claramente sería con 852 y 1477 Hz que juntos corresponden con el dígito 9.

Y así con cada uno de los dígitos

Sé que estaría mucho mejor un script que hiciera todo el proceso entero y obtuviera qué número es de la tabla pero últimamente necesito días de 30 horas así os tendréis que conformar con esto. ¿A qué número he llamado?

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Llamando por teléfono con Matlab
• Cuestión de optimización

A día de hoy contamos con ordenadores chorrecientas veces más rápidos que hace pocos años y cuando se programa haces pruebas con sistemas de 3GHz, varios MB de cache y 2GB de RAM mínimo y todo tira para adelante. Bueno, todo tira hasta cierto punto, tus programas luego se van a estar ejecutando juntos con otras decenas de programas o simplemente se van a estar ejecutando constantemente y vas a perder un gran porcentaje de la capacidad de proceso de cómo lo podrías estar haciendo.

Bueno, y es normal, cosas de la comodidad, yo el primero. Ahora te quedas tranquilo con que funcione, en los 80 tenía que funcionar y caber en 64kB de RAM. No digo que se programe peor (seguramente sí xD) pero ya no nos fijamos en muchos detalles que antes eran totalmente necesarios (la de trucos que usaba la gente para poder aprovechar el 100% del hardware del Commodore64) y ahora desperdiciamos por todos lados y al final sí que pasa factura. La gente que programe sistemas embebidos lo tiene muy claro aunque casi se va a acabar el asunto también ahí porque ya los procesadores de los móviles/PDAs/cosas_pequeñas tirán mucho.

Me he encontrado con programas que están al 100% de CPU en idle, con programas que daban su salida en unos 12~15 minutos cuando otro para el mismo propósito lo hacía en aproximadamente 1 segundo (no daré nombres xD), programas en los que notas el ‘refresco’ de los elementos cuando lo usas cuando te sobra CPU para hacerlo bien, etc. Hay que intentar evitar marañas de bucles for anidados!

Al final todo pasa por conocer muy bien el lenguaje que usas, haber pasado horas y horas, pensar las cosas antes de hacerlas, incluso un poquito de sentido común, cosa que creo que es difícil de abstraer a veces cuando se programa.

Por ejemplo, en matlab es muy importante reservar el espacio para las variables antes y crear los vectores del tamaño que van a ser al final de las operaciones porque si aumentamos el tamaño de un vector[n], internamente lo que siempre hace es crear un nuevo vector[n+1] y copiar los datos del antiguo.

Hace unos meses me comentó un amigo que en el trabajo tenían un método númerico que disminuyó su tiempo de ejecución en más de un 20% (siendo su tiempo varias horas) al sustituir un resultado de una operación que siempre era el mismo por el valor guardado en una variable! Es de cajón pero hay que caer.

Y ahora vienen algunos ejemplos, por no meterme en un lenguaje tipo C en el que hay muchas posibilidades de hacer las cosas y hay que currarse más los ejemplo iré a algo más sencillo como es hacer scripts cerdos para administrar un máquinas o similares.

Un ejemplo sería un uso poco adecuado de las órdenes cat, grep, ls, awk y similares. Cuando manipulamos algo pequeño no pasa nada pero cuando se trata de varios ficheros logs y son decenas de MB pues la cosa empieza a tomar importancia.

Respecto a grep cuando una persona empieza y se plantea buscar una cadena lo primero que piensa es ‘muestro el archivo y luego saco las líneas coincidentes’:

# cat tinyproxy.log | grep remote
real    0m55.071s
user    0m24.477s
sys     0m0.727s

Luego descubres que en realidad lo puedes hacer ‘todo en uno’ y es bastantes más rápido:

# grep remote tinyproxy.log
real    0m36.024s
user    0m22.550s
sys     0m0.527s

Luego, sin querer, entras en el man y te das cuenta de que existen varios tipos: grep, egrep (similar pero no idéntico a grep -E ) y  fgrep (idéntico a grep -F). Así que pruebas:

# egrep remote tinyproxy.log
real    0m55.122s
user    0m25.029s
sys     0m0.659s

Joder, vuelve a ser lento a pesar de no hacer un cat. ¿Por qué? Porque es una función más compleja.

• grep: soporta expresiones regulares básicas.
• fgrep: no soporta expresiones regulares => el más rápido.
• egrep: soporta expresiones regulares avanzadas => el más lento.

Para los curiosos, el nombre grep viene de g/re/p y significa lo que hace tal cual, buscar una expresión regular y hacer print de las coincidencias. En realidad a una escala grande ni siquiera deberíamos usar grep sino sed que es más rápido.

Lo mucha gente desconoce es que hay otra manera de evitar el cat de antes y ganar tiempo, y es que en realidad las concatenaciones siempre están ahí… así que lo podríamos hacer del siguiente modo:

# <tinyproxy.log grep remote
real    0m43.931s
user    0m22.338s
sys     0m0.578s

Del mismo modo estos conceptos se puede usar en otras órdenes

# cat tinyproxy.log | wc -l
104265

real    0m0.088s
user    0m0.021s
sys     0m0.053s

# wc -l tinyproxy.log
104265 tinyproxy.log

real    0m0.021s
user    0m0.013s
sys     0m0.006s

Y del mismo modo:

# cat tinyproxy.log | tail -n 200
real    0m0.121s
user    0m0.026s
sys     0m0.056s

# tail -n 200 tinyproxy.log
real    0m0.010s
user    0m0.000s
sys     0m0.003s

Cambiando de tercio también solemos usar echo más veces de las que toca. Por ejemplo si tenemos :

var="valor_o_resultado_de_una_evaluacion"
command -options `echo $var`

en la mayoría de los casos podremos sustituirlo por:

var="valor_o_resultado_de_una_evaluacion"
command -options $var

Y así mil chorradas. Por cierto, el que sólo se conozca la opción de awk para coger columnas le recomiendo que se mire manules que termina siendo muy útil.

Creo que este post lleva más de 6 meses en drafts y no he añadido nada (de hecho tampoco tengo ganas), así que aunque es un tema que da mucho de sí ha quedado bastante descafeinado técnicamente, pero ajo y agua!

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Descodificar tonos DTMF usando Matlab
• Port-Knocking y Crypt-Port-Knocking
• Para los amantes de XKCD llega…

Lo quería hacer en Octave (por aquello del software libre y tal) pero es una _censored_ patata pinchada en un palo y me he cansado de sus pejiguerías.

¿En qué se basa esto? A cada número se le asigna una pareja de tonos según la tabla siguiente y se envía la suma de éstos, el nombre es bastante explicativo: Dual Tone Multi Frequency.

En mi portátil no funciona porque mis altavoces están cascadísimos y no reproducen como deberían xDDD En el portátil de Rafa sí que iba.

Aquí está el código:

function y = ring(x)
 
number = x;
numberstr = int2str(number);
 
% Sampling Frequency
fs = 8000;
% initializing arrays, 1200 samples
digit = 0:1199;
silence = zeros(1,1200);
 
disp('Calculating DTMF tones...');
 
% row sinusoids
sin697 = sin(2*pi*697*digit/fs);
sin770 = sin(2*pi*770*digit/fs);
sin852 = sin(2*pi*852*digit/fs);
sin941 = sin(2*pi*941*digit/fs);
% column sinusoids
sin1209 = sin(2*pi*1209*digit/fs);
sin1336 = sin(2*pi*1336*digit/fs);
sin1477 = sin(2*pi*1477*digit/fs);
 
% numbers
num1 = (sin1209+sin697)/2;
num2 = (sin1336+sin697)/2;
num3 = (sin1477+sin697)/2;
num4 = (sin1209+sin770)/2;
num5 = (sin1336+sin770)/2;
num6 = (sin1477+sin770)/2;
num7 = (sin1209+sin852)/2;
num8 = (sin1336+sin852)/2;
num9 = (sin1477+sin852)/2;
num0 = (sin1336+sin941)/2;
% an asterisk would be: (sin1336+sin941)/2);
% a pad would be: (sin1477+sin941)/2);
 
% insert a silence in the begining
y = zeros(1, 1200);
% fill the rest
for i = 1:length(numberstr)
	num = str2num(numberstr(i));
	switch num
		case 0
			dtmf = num0;
		case 1
			dtmf = num1;
		case 2
			dtmf = num2;
		case 3
			dtmf = num3;
		case 4
			dtmf = num4;
		case 5
			dtmf = num5;
		case 6
			dtmf = num6;
		case 7
			dtmf = num7;
		case 8
			dtmf = num8;
		case 9
			dtmf = num9;
		otherwise
			disp('O_o');
    end
    % insert the number samples
    y = [y dtmf];
    % insert the silence samples
    y = [y silence];
end
 
wavwrite(y,fs,'ring.wav');
 
disp('Ringing number:');
disp(numberstr);
 
% play it
wavplay(y,fs);
 
disp('Happy talking');

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Descodificar tonos DTMF usando Matlab
• Cuestión de optimización