“ASTILLEROS DE SEVILLA FUERON ORGULLO NACIONAL, LOS MAS PRODUCTIVOS DEL MUNDO, DABAN DE COMER A MAS DE 40. 000 PERSONAS.”

Así es el libre mercado… Despiadadas empresas compiten con empresas justas, un partido de futbol donde algunas empresas pueden cometer todas las faltas que quieran. Un enfoque donde la corporación más sarnosa es premiada con la victoria. Para estas empresas el respeto a los trabajadores y el medio ambiente son una carga… Tenemos que ser conscientes que la corporación justa SIEMPRE será más cara, o visto de otro modo, más coherente y razonable con el coste que supone respetar a las personas y a nuestro planeta.

En ocasiones la empresa justa (incluso con grandes gestores e ideas) son hoy etiquetadas  con argumentos falaces económicos como “empresa poco competitiva”. Y es que todas las argumentaciones acaban en dinero…¿Hacia donde vamos?

Puede que un día nos lamentemos de la cultura industrial que estamos destruyendo, y eso no tiene precio porque la incultura nos hace esclavos de otros… Ayer comprábamos los barcos de fuera porque eran más baratos … a partir de ahora lo haremos por necesidad… Espero que no llegue el día en el que potencias extranjeras hagan negocio de nuestra incultura industrial como hoy nosotros lo hacemos con muchos países del tercer mundo.

Mientras en casa del gran gran rico..

Mientras los 200 más ricos de España ganan más dinero en uno de los peores años de la crisis, crisis que amenaza ponerlo todo patas arriba y cambiar este sistema tal y como lo conocemos… Muchos de estos ricos mueven su dinero a Luxemburgo y Holanda… el dinero es miedoso dicen…

La gran corporación privada

Y es que cada día creo menos en las grandes corporaciones privadas nacionales. Zaras, Abengoas, Telefónicas y Santanderes no buscan la mejorar esta pequeña península, sino que, como cualquier empresa beneficio a toda costa…Para mí no pueden considerarse corporaciones justas. También, cuando dicen que son grandes españolas suenan a palabras huecas y vacías dado que no existe ya un compromiso real y equilibrado con la sociedad que lo ha engendrado y donde ha florecido.

Estas empresas cada día más y más mueven los puestos de trabajo a países del tercer mundo, pagando sueldos míseros a pobres que se sienten agraciados por poder llevarse algo a la boca… Escándalos como el de Zara dan asco.También Telefónica con miles de millones de beneficios destruye empleo de un sector que un día fue público (NUESTRO) mientras crea empleos de “bajo coste” en paises menos agraciados.

Todo esto sin considerar que el día menos pensado viene un banco chino y pagará cualquier precio por adquirirla y dirigirla… Nuestra sociedad y economía que un día engendró esta industria por supuesto no se llevará ni un duro dado que los dueños (por muy españoles que sean) moverán sus beneficios a un paraíso fiscal… ¿Entonces qué nos queda?

La pequeña empresa y lo público

En mi opinión solo la pequeña industria local presenta un sólido compromiso con la misma sociedad que lo ha engendrado. Creando DE VERDAD, riqueza y cultura en su entorno, revirtiendo su propio beneficio y éxito. Por el contrario, en mi opinión, las grandes corporaciones, las grandes fortunas, con tanto poder económico y social NO PUEDEN estar fuera de un estricto control público. Esto ya lo decia Keynes incluso siendo un conservador. O públicas o semi-públicas o unas leyes de control radicales que incluyan la fuga de capitales al extranjero, etc (que por cierto sacaría el tema de discusión de una banca pública). Debemos vencer los clichés de “Lo público es anticompetitivo e ineficiente”. Incluso si así fuera, en un mercado libre donde las prácticas despreciables están justificadas en la búsqueda de beneficios

De verdad, creo en la empresa privada y creo en los emprendedores. Un país no puede funcionar sin emprendedores y arrojados… este arrojo, esfuerzo y sacrificio debe ser premiado. Todo tiene una medida y un límite: Nadie es tan bueno como para merecer lo que cobran los Botines, los Amancios y ¿por qué no? los Beckams… pero el famoseo y la salsa rosa es otra discusión más … otro reflejo de nuestra sociedad en crisis. Civilización en crisis según algunos buenos pensadores.

Start
$ screen

Exit and close:
$$ CTRL + D
or
$$ exit

Disconect from the screen program but leaving it opened:
$$ CTRL +A CTRL+D

Reconect to an opened screen program:
$ screen -r

From the screen, create another “tab”:
$$ CTRL+A C

Switch selected tab:
$$ CTRL+A CTRL+A

List existing tabs:
$$ CTRL+A W

In the one-dimensional case, a simple tuple mean, variance is enough information to imagine how the samples are behaving. This tuple can be also reinterpreted as an interval where the samples most probably are located. For higher dimensions the \mu it is clear, but the equivalent element to describe the diversity, the covariance matrix  it is much lesser intuitive for most of people. The trick is imagine the ND gaussian bell as NDimensional ellipse. The shape and rotation of this ellipse is described by the covariance matrix. In this way the diversity of the distribution is intuitive.

It is extremely interesting to see and understand the relationship with the rotation and scale of the ellipsoid. If we define as the rotation transform of the ellipsoid and is a vector with the variances in the local frame of the ellipse (much easier to imagine)  , then the relationship between and is this:

This have important implications because if you want to synthesizer a gaussian belief from a theoretical model can be hard imagine the covariance matrix values but it is very easy to think in an ellipse with a rotation and scale.

The inverse operation is also useful. For instance if you have a covariance matrix obtained experimentally and you wish to make a geometric interpretation of the distribution or just plot it, you can obtain the rotation matrix and the scale vector . Then the it is needed to compute the eigenvectors and eigenvalues. That is because:

and

Of course notice that if number of eigenVectors is lower than the dimensionality of the problem is because the ellipse is infinitely slim and as a consequence the determinant and then the matrix is singular. This means that one dimension should be removed if you want to compute likelihoods over that gaussian function.

Here I show how to represent a 3D gaussian function with ROS and rivz:

And here the code in python. Discussion about this subject in: http://answers.ros.org/question/2043/plot-a-gaussian-3d-representation-with-markers-in:

import roslib
roslib.load_manifest ("gaussian_markers")
import rospy
import PyKDL
from visualization_msgs.msg import Marker, MarkerArray
import visualization_msgs
from geometry_msgs.msg import Point
import numpy
from numpy import concatenate

#syntetic 3-D Gaussian probabilistic model for sampling
covMatModel =[[10, 10, 0],[10, 1, 0],[0, 0, 4]]
meanModel =[10, 10, 10]

#used to paint the autovectors
def markerVector(id,vector,position):
	marker = Marker ()
	marker.header.frame_id = "/root";
	marker.header.stamp = rospy.Time.now ()
	marker.ns = "my_namespace2";
	marker.id = id;
	marker.type = visualization_msgs.msg.Marker.ARROW
	marker.action = visualization_msgs.msg.Marker.ADD
	marker.scale.x=0.1
	marker.scale.y=0.3
	marker.scale.z=0.1
	marker.color.a= 1.0
	marker.color.r = 0.33*float(id)
	marker.color.g = 0.33*float(id)
	marker.color.b = 0.33*float(id)
	(start,end)=(Point(),Point())

	start.x = position[0]
	start.y = position[1]
	start.z = position[2]
	end.x=start.x+vector[0]
	end.y=start.y+vector[1]
	end.z=start.z+vector[2]

	marker.points.append(start)
	marker.points.append(end)
	print str(marker)
	return marker

rospy.init_node ('markersample', anonymous = True)
points_pub = rospy.Publisher ("visualization_markers", visualization_msgs.msg.Marker)
gauss_pub = rospy.Publisher ("gaussian", visualization_msgs.msg.Marker)

while not rospy.is_shutdown ():
	syntetic_samples = None

	#painting all the syntetic points
	for i in xrange (10, 5000):
		p = numpy.random.multivariate_normal (meanModel, covMatModel)
		if syntetic_samples == None:
			syntetic_samples =[p]
		else:
			syntetic_samples = concatenate ((syntetic_samples,[p]), axis = 0)

		marker = Marker ()
		marker.header.frame_id = "/root";
		marker.header.stamp = rospy.Time.now ()
		marker.ns = "my_namespace2";
		marker.id = i;
		marker.type = visualization_msgs.msg.Marker.SPHERE
		marker.action = visualization_msgs.msg.Marker.ADD
		marker.pose.position.x = p[0]
		marker.pose.position.y = p[1]
		marker.pose.position.z = p[2]
		marker.pose.orientation.x = 1
		marker.pose.orientation.y = 1
		marker.pose.orientation.z = 1
		marker.pose.orientation.w = 1
		marker.scale.x = 0.05
		marker.scale.y = 0.05
		marker.scale.z = 0.05
		marker.color.a = 1.0
		marker.color.r = 0.0
		marker.color.g = 0.0
		marker.color.b = 0.0
		points_pub.publish (marker)

	#calculating Gaussian parameters
	syntetic_samples = numpy.array (syntetic_samples)
	covMat = numpy.cov (numpy.transpose (syntetic_samples))
	mean = numpy.mean ([syntetic_samples[: , 0], syntetic_samples[: , 1], syntetic_samples[:, 2]], axis = 1)

	#painting the gaussian ellipsoid marker
	marker = Marker ()
	marker.header.frame_id ="/root";
	marker.header.stamp = rospy.Time.now ()
	marker.ns = "my_namespace";
	marker.id = 0;
	marker.type = visualization_msgs.msg.Marker.SPHERE
	marker.action = visualization_msgs.msg.Marker.ADD
	marker.pose.position.x = mean[0]
	marker.pose.position.y = mean[1]
	marker.pose.position.z = mean[2]

	#getting the distribution eigen vectors and values
	(eigValues,eigVectors) = numpy.linalg.eig (covMat)

	#painting the eigen vectors
	id=1
	for v in eigVectors:
		m=markerVector(id, v*eigValues[id-1], mean)
		id=id+1
		points_pub.publish(m)

	#building the rotation matrix
	eigx_n=PyKDL.Vector(eigVectors[0,0],eigVectors[0,1],eigVectors[0,2])
	eigy_n=-PyKDL.Vector(eigVectors[1,0],eigVectors[1,1],eigVectors[1,2])
	eigz_n=PyKDL.Vector(eigVectors[2,0],eigVectors[2,1],eigVectors[2,2])
	eigx_n.Normalize()
	eigy_n.Normalize()
	eigz_n.Normalize()
  	rot = PyKDL.Rotation (eigx_n,eigy_n,eigz_n)
	quat = rot.GetQuaternion ()

	#painting the Gaussian Ellipsoid Marker
	marker.pose.orientation.x =quat[0]
	marker.pose.orientation.y = quat[1]
	marker.pose.orientation.z = quat[2]
	marker.pose.orientation.w = quat[3]
	marker.scale.x = eigValues[0]*2
	marker.scale.y = eigValues[1]*2
	marker.scale.z =eigValues[2]*2

	marker.color.a = 0.5
	marker.color.r = 0.0
	marker.color.g = 1.0
	marker.color.b = 0.0

	gauss_pub.publish (marker)
	rospy.sleep (.5)

1. Costes (hablo únicamente de dinero). ¿Qué energía es más barata, cuanto y porqué? ¿Cuantos nos costaría una factura de electricidad únicamente renovable? El tema de las subvenciones.. me parece un auténtico lío.

2. ¿Qué es y como funciona la subasta energética?

3. ¿Podría sostenerse solo un país con energía renovables? ¿solo para la producción de electricidad? En el caso de que se pueda, ¿podemos asumir eso?

4. Si las eléctricas han estado vendiendo por debajo del coste tantos años (es lo que han dicho cuando la subida de la luz), ¿porque han ganado lo que han ganado? ¿porqué ha estado congelado el precio de electricidad tantos años?

En fin, te pones a buscar por ahí y encuentras una cosa y la contraria..

Son en mi opinión, preguntas equivocadas.

El dinero en general, y en especial el dinero que nosotros pagamos en la factura de la luz y la indignación que despierta en nosotros no es más que otro ejemplo del mito de la caverna de Platón (una simple proyección de la compleja realidad). Realizar cualquier argumentación a favor o en contra de una energía basada en lo que pagamos en la factura de la luz es -en mi opinión- absolutamente simplista.

Independientemente de que algún día las renovables puedan ser más rentables o no bajo este enfoque simplista – algo que ignoro – Se puede intuir que con las reglas y mentalidad actuales es difícil que las renovables encuentren su lugar y que hagan más barata nuestra factura. Principalmente porque la mayoría de las energías no-renovables son mucho más competitivas ya que externalizan costes de una forma brutal…y de esta forma, a nuestra visión simplista son más atractivas y más baratas para nuestro bolsillo.

Pero una cosa tengo clara. Las energías renovables forman parte de un CICLO de vida económico, energético y social muchísimo más limpio, transparente, JUSTO y sostenible. En ese ciclo cerrado se puede ver de forma clara que hay un trato justo y respetuoso con las personas y hacia el entorno. Y donde las mismas sociedades que realizan el esfuerzo de cultivar, recogen los beneficios. No hay sociedades explotadas y explotadoras. Recogemos lo que sembramos. Creo que eso es una ley universal que nunca deberíamos olvidar (y hoy día en occidente lo hemos hecho).

Hay algo más allá. Nosotros hemos estado “comprando” con nuestro silencio hipócrita-democrático injusticias, dictadores y opresión en buena parte del mundo (incluida Libia) por el mero y simple hecho de la estabilidad, por interés de nuestros mercados. Nuestros mercados, nuestro Santo Grial. Es decir, hemos estado escupiendo a los valores de los derechos humanos y la democracia. ¿Donde está nuestra dignidad? Occidente, potencia cultural, tecnológica y diplomática. Nosotros deberíamos ser los defensores de los valores y derechos humanos. Una vergüenza, … a su vez una bomba de relojería para nosotros mismos.

Nuestra dignidad humana no tiene precio, y la estamos vendiendo. Y nunca podremos tener la legitimidad de exigir (y nunca habrá) justicia, igualdad y derechos humanos, cuando nosotros con nuestro silencio interesado fomentamos lo opuesto.

En mi opinión, sin lugar a dudas las renovables pueden tecnológicamente mantener un país y lo están demostrando. Es cierto que presenta nuevos retos tecnológicos y sociales. Pero es posible. España en concreto tiene un potencial renovable brutal, una situación de cabeza, una oportunidad para mejorar (no ya económicamente) sino humanamente. Oportunidad que no podemos ni debemos perder.

Volviendo a lo que pagamos en nuestra factura. Parto de que las empresas ganan de lo que nos quitan. Si nos quitan más, más ganan. Nos mentirán hasta la saciedad para mantener o mejorar su posición. Y si pueden intentarán engañarnos y a la vez lograr una sonrisa en nuestra cara y agradecimiento (como en las rebajas de enero). Incluido el lobby renovable. Pero superar esto es para nota. Pero como sociedad tenemos que mirar que haríamos según nuestras necesidades, no según las necesidades de las corporaciones.

Pienso que la energía es cara (sí, es solo una intuición). Porque si las renovables son “caras” (conociendo su ciclo de vida transparente) y la gasolina está como está (conociendo su forma brutal de externalizar) y viendo la que se está liando en Japón… la energía no debe de ser barata… La energía debe valorarse. Esto implica que tenemos que pagar más por la energía, pagar más por el I+D+I en nuevas energías. Y sin lugar a dudas tenemos que cambiar nuestra forma de consumir energía.

Estoy seguro que con tecnología, implicación social y legal las renovables explotarán, madurarán y acabarán convirtiéndose en un símbolo de justicia y un tesoro de valor incalculable para nuestra sociedad.

Los artículos de investigación (Papers) son muy útiles para estar a la última, sin embargo la cantidad de papers que aparecen cada mes es desorbitarte, hay mucha información que no es relevante y en ocasiones es difícil discernir si las aportaciones son buenas, interesantes para tu investigación y merece la pena una profundización.

Sin embargo existe una fuente de información complementaria e igual o más importante que los papers: los libros. Los libros habitualmente están más atrasados que los papers, sin embargo, estos presentan innumerables cualidades: se profundiza mucho más en la temática, formato y notación unificada, aprendizaje progresivo, etc. Además, los libros ofrecen contenidos habitualmente más aceptados y reconocidos por la comunidad científica con una madurez media o alta. De esta forma se convierten en un pilar básico para la formación alrededor de los cuales debe girar el conocimiento adquirido en los artículos científicos (más efímeros y traicioneros). Aquí dejo una lista de los 4 libros (hay alguno más que me encantaron, pero estos son los principales) que para mí son sobresalientes y que están permitiéndome como estudiante de doctorado con vagos conocimientos previos en la robótica ir adquiriendo poco a poco destreza y experiencia como para poder aportar nuevas ideas.

Probabilistic Robotics – Año 2006. Un libro absolutamente imprescindible para comprender los enfoques probabilísticos que utiliza hoy día la robótica para aportar soluciones. Tiene una matemática dura, y todas las técnicas presentadas ofrecen su demostración matemática. En cualquier caso es un libro muy aplicable de manera casi directa en el software para robots. Se centra en las áreas de localización, construcción de mapas, modelos de sensores y modelos de movimiento de robots y planificación, todo desde un enfoque probabilístico. A pesar de explicar diversas técnicas exitosas en estas áreas el enfoque del libro no son estas sino más bien pretende ilustrar un punto de partida para enfocar los problemas robóticos de una forma mas realista y robusta haciendo uso de la estadística. Su principal autor Sebastian Thrun es hoy día una de las principales referencias mundiales en el área de la robótica.

Planning Algorithms – Año 2010. Este libro profundiza de forma exhaustiva en muchísimas técnicas y aspectos importantes en la planificación para robot. Se centra especialmente en la planificación de movimiento (aunque también trata temas de planificación de más alto nivel, tareas, etc). Es muy profundo, duro y formal matemáticamente. Más específicamente se centra en técnicas de planificación de movimiento global deterministas y basadas en muestras, planificación con restricciones kinodinámicas y no-holónomas, etc. Una de las principales ventajas de este libro es que está disponible online de forma gratuita, y además que es actualizado frecuentemente.

Springer Handbook of Robotics – La biblia de la robótica. Casi 1600 páginas de conocimiento. Bastante actualizado, finales del año 2008. Libro para ser utilizado como referencia para introducirse a cualquier temática de la robótica y encontrar fuentes. Trata de todos los temas: Fundamentos de la robótica (Cinemática, Dinámica, Mecánica, Control, Planificación, IA, Arquitecturas software), Estructuras de Robots, Sensores y percepción, manipulación, robótica distribuida, robótica de servicios, robótica en el ámbito de los seres humanos. El libro ha sido realizado por decenas de autores, especialistas en cada área. El nivel de formalismo y profundización varía según el capítulo y la madurez del tema. Otro libro muy recomendable para tener a mano.

¡¡Se trata de un día de jornadas abiertas en la escuela!! ¡¡Por lo tanto estáis todos invitados a venir!! Primos y hermanos, pequeños y mayores aficionados de Lego y Robots pueden disfrutar como enanos viendo los distintos robots enfrentándose a las pruebas!

La “First Lego League” es un torneo internacional de robótica para niños que se desarrolla en un ambiente deportivo y festivo (padres, amigos, música, speakers, cámaras, etc.. como una party). Se trata de un evento donde el principal objetivo es despertar en el interior de los niños y adolescentes el interés e inquietud por la ciencia y la ingeniería . Todo en un ambiente sano, divertido y donde se premian los valores humanos como la amistad, el esfuerzo, el trabajo en equipo y el respeto.

El evento consta de tres competiciones:

• Competición de robots LEGO real. (Los robots deberán mover, empujar, golpear o transportar objetos)
• Presentación de un proyecto técnico
• Presentación de un proyecto científico

Adjunto un vídeo del mismo torneo realizado en Barcelona para que veas sobre qué estoy hablando:  . Los robots son diseñados usando LEGO NXT (robots para niños) y todos ellos disponen ya de las mesas de pruebas donde competirán.

Vídeo de un SuperRobot de lego Noruego haciendo las pruebas de este año!!

En la robótica probabilística, el estado no es conocido con precisión. Por ejemplo, la posición de un robot (x,y,z) (que podría ser descrito por una tupla de tres reales) es descrita por una función probabilística tridimensional. Esta función que describe el estado se denomina en la literatura creencia bel(x). De esta forma la posibilidad de que un robot se encuentre en un estado determinado queda definida estocásticamente. Este enfoque puede describir de una forma mas realista el conocimiento que tenemos sobre el estado. Además permite otras ventajas como mantener múltiples hipótesis sobre el estado del robot. Por ejemplo, un robot se encuentra en la mezquita de córdoba y detecta con sus sensores que se encuentra delante de una columna, sin embargo si el estado en que se encontraba anteriormente no describía una mejor hipótesis clara, esta columna podría ser cualquiera de las cientos de columnas existentes en la mezquita.

La dos gráficas ilustran el comportamiento típico de los métodos de estimación recursivos gaussianos. En concreto este  ejemplo ha sido generado a partir del método UKF. Supongamos que el estado es monodimensional (por ejemplo la posición en el eje x):

La primera figura muestra en azul la creencia en el instante anterior del estado del robot. bel[t-1](x) Se observa como se cree que su valor es aproximadamente uno. Sin embargo el valor real podría ser 1.1 (representado mediante la línea vertical roja).

Supongamos que pasa un instante de tiempo. Haciendo uso del conocimiento teórico (modelo matemático) que tenemos del sistema y dadas las entradas conocidas, predecimos que el estado en el instante actual será alrededor de 3 (función amarilla). Esta función de probabilidad se denomina creencia anterior (predicción) ^bel[t](x). Dado que nuestro modelo es teórico  es evidente que tiene un error. Este error puede ser típicamente acotado teóricamente o mediante métodos empíricos en forma de matriz de covarianza. Por lo tanto podemos estimar que la creencia anterior ^bel[t](x) tendrá una mayor desviación típica que la creencia del instante anterior bel[t-1](x). Es decir, tras la predicción, tenemos una mayor incertidumbre del estado del robot. La línea vertical roja representa la posible posición real del robot en el estado actual.

A continuación recibimos las medidas del sensor. Estas medidas nos indican el estado de forma total o parcial (de forma directa o tras algún tipo de de procesamiento). Pero también, los sensores presentan un error (típicamente indicado por el fabricante o también se podría obtener mediante métodos empíricos).  En la segunda figura, la función de probabilidad roja representa tal medida y su error. En la misma también se muestra en azul la creencia anterior ^bel[t](x) predicha por el modelo teórico.

El método UKF (al igual que KF, EKF y otros) nos permite estimar a partir de los errores del modelo teórico y de la medida, en cual de ambos debemos confiar más, obteniendo un factor de ganancia K para ponderar ambas funciones de probabilidad. Una vez obtenido este factor de ganancia K se puede calcular la creencia posterior (final) del instante actual bel[t](x). La función discontinua verde representa tal creencia.

Para una descripción matemática mas detallada del funcionamiento del método UKF:
http://www.cslu.ogi.edu/nsel/ukf/node6.html

A continuación muestro una implementaicón personal en python del método UKF acompañada en la simulación utilizada en este ejemplo:

# This code is subject under the terms of the BSD License
# 2011 - Pablo Iñigo Blasco
# http://techbase.kde.org/Policies/Licensing_Policy#BSD_License</p>
import scipy.stats
from numpy import *
from matplotlib.pyplot import *

def getSigmaPoints(mu, sigma, n=1., alpha=1., kappa=1., betta=2.):
 #space for sigma points
 X = zeros(2 * n + 1)
 wm = zeros(2 * n + 1)
 wc = zeros(2 * n + 1)
 lambd = alpha * alpha * (n + kappa) - n

 #calculate sigma points
 X[0] = mu
 X[1] = mu + (math.sqrt((n + lambd) * sigma))
 X[2] = mu - (math.sqrt((n + lambd) * sigma))

 #calculate weights
 #first weight
 wm[0] = lambd / (n + lambd)
 wc[0] = lambd / (n + lambd) + (1 - alpha * alpha + betta)

 #rest of weights
 wm[1] = wc[1] = 1 / (2. * (n + lambd))
 wm[2] = wc[2] = 1 / (2. * (n + lambd))

 return [X, wm, wc]

def process_state_transition(x, u):
 return u +  x*x

def measurement(x):
 return x;

def measurement_noise(measurement_cov):
 return scipy.stats.norm.rvs(loc=0, scale=measurement_cov, size=1)

def process_noise(process_cov):
 return scipy.stats.norm.rvs(loc=0, scale=process_cov, size=1)

def h(x):
 return x;

#UKF parameters
alpha = 1.;
kappa = 0.;
betta = 2.;
n = 1;

#model parameters
#process noise covariance matrix
R = 0.45
Q = 0.3

#suppose the control input u = 1
u = 2;

#previous state believe
mu_prev = 1;
sigma_prev = 0.1;

real_prior_state = scipy.stats.norm.rvs(loc=mu_prev, scale=sigma_prev, size=1)
print "real previous state %f"%(real_prior_state)
print "posterior belief of the previous state (mu=%f,sigma=%f)"%(mu_prev,sigma_prev)

f = scipy.stats.norm(mu_prev, sigma_prev)
#getting sigma points from previous state belief
[X_prior_state, wm, wc] = getSigmaPoints(mu_prev, sigma_prev, n, alpha, kappa, betta)

#plot this previous state belief
#http://matplotlib.sourceforge.net/users/pyplot_tutorial.html
abcises = linspace(-1, 5, 400)
pX = f.pdf(X_prior_state)
figure(1)
subplot(211)
#plot gaussian function
plot(abcises, f.pdf(abcises),"b")
#plot sigma points
plot(X_prior_state, pX, "r+")
show();

#plot real previous state
axvline(real_prior_state,color="r")

print "...process happening..."
real_current_state = process_state_transition(real_prior_state,u) +  process_noise(R);
print "real current state %f"%(real_current_state)

#applying the process_state_transition to all sigma points to later build the prior belief
X_current_state = [process_state_transition(x, u) for x in X_prior_state]
plot(X_current_state, pX, "b+")

#rebuild the gaussian function after applying the process state transition to the sigma points samples
prior_bel_mu = sum(wm*X_current_state);
prior_bel_sigma_without_noise = sum (wc * (X_current_state - prior_bel_mu)* (X_current_state - prior_bel_mu))
prior_bel_sigma = prior_bel_sigma_without_noise + R

prior_bel_f_without_noise = scipy.stats.norm(prior_bel_mu, prior_bel_sigma_without_noise)
prior_bel_f = scipy.stats.norm(prior_bel_mu, prior_bel_sigma)
print "prior belief (mu=%f,sigma=%f)"%(prior_bel_mu,prior_bel_sigma)

#plot the prior belief after the process state transition without noise
#plot(abcises, prior_bel_f_without_noise.pdf(abcises),"g")
#plot the prior belief (with noise)
plot(abcises, prior_bel_f.pdf(abcises),"y")
#plot real current state
axvline(real_current_state,color="r")
subplot(212)
#also plot it in the bottom frame
axvline(real_current_state,color="r")

#so now our best guess is the prior belief. Then we get its sigma points
[X_prior_bel, wm, wc] = getSigmaPoints(prior_bel_mu, prior_bel_sigma, n, alpha, kappa, betta)

#so given the sigma points hypotesys, we get the expected measurements given our measurement model and noise
#in some way this is a substate of the prior_belief
Z_expected = [h(x) for x in X_prior_bel]
z_mu_expected = sum(wm*Z_expected);
z_sigma_expected_without_noise = sum (wc * (Z_expected - z_mu_expected)* (Z_expected - z_mu_expected))
z_sigma_expected = z_sigma_expected_without_noise + Q;
print "expected measurement (mu=%f,sigma=%f)"%(z_mu_expected,z_sigma_expected)

#plot the expected measurement given our best state guess (prior_belief)
#observe how the quality in this expectation depends on the prior belief convariance which
#at the same time depends on process covariance R
#In any case the expected measurement can be "more precise" or "less precise" that the prior belief
plot(abcises, scipy.stats.norm(z_mu_expected,z_sigma_expected).pdf(abcises),"b")

# calculate the gain, who we trust: process or measurement
K = sum(wc*(X_prior_bel - prior_bel_mu)*(Z_expected - z_mu_expected))/z_sigma_expected
print "Gain: %f"%K

# if K gets 1 trust the measurement
# if K gets 0 trust the process state transition model

#simulate observation
z = measurement(real_current_state) + measurement_noise(Q);
print "measurement %f"%(z)
plot(abcises, scipy.stats.norm(z,Q).pdf(abcises),"r")

#calculate the posterior gain
post_bel_mu = prior_bel_mu + K * h(z - z_mu_expected)
post_bel_sigma = prior_bel_sigma - K * z_sigma_expected *K

print "posterior belef (mu=%f,sigma=%f)"%(post_bel_mu,post_bel_sigma)
plot(abcises, scipy.stats.norm(post_bel_mu,post_bel_sigma).pdf(abcises),"g--")

- Calabacín mediano
- Cebolla grande
- Atún
- Ajo
- Queso
- Pimiento
- una andaluza

Se pica un calabacín, una cebolla y tres dientes de ajos en trozos muy pequeñitos. Se sofrie lentamente con un chorreón de aceite de oliva, se le añade un puñado de pimiento picado (yo uso el congelado del mercadona). Cuando están las verduras un poco blanditas (2 o 3 minutos a fuego medio) se añaden dos latas de atún al sofrito y una hoja de laurel partida en trocitos muy pequeños (quitando el tallo de la hoja y otras durezas). Orégano al gusto.

Antes de que se dore se saca y se distribuye sobre dos rebanadas de andaluzas o barrita. Yo las suelo tener congeladas por lo que primero las tuesto un poco. Luego se raya queso encima de los paninis y se les echa un poco mas de orégano encima. Finalmente de 10 a 15 minutos al horno a 260 grados al gusto.

Here you can watch some basic samples:

sudo apt-get install mencoder
mencoder input.ogm -ovc xvid -oac mp3lame -xvidencopts pass=1 -o output.avi

Regards.

Aquí dejo las slides por si a alguien les pudiera servir. Gracias por los contenidos Creative Commons de la web de ROS y de las transparencias creadas por “Radu Bogdan Rusu” para el evento “CoTeSys-ROS Fall School on Cognition-enabled Mobile Manipulation“. Este documento en sí es Creative Commons.

Instalamos el sistema de archivos samba (Samba File System)

geus@geus-vaio:~$ sudo apt-get install smbfs

Creamos un archivo de credenciales donde ubicar la contraseña y el usuario. El principal problema de este archivo para mi gusto es que tiene que ir en texto plano. No he encontrado otra alternativa (si alguien la conoce que lo diga ). Seguro que algún gurú de la seguridad se me echa encima jeje. Una solución es eliminar todos los permisos de lectura/escritura/ejecución. De este modo aseguramos que el único que podría alcanzar tal información tendría que conocer la contraseña de root o ser sudo del sistema.

geus@geus-vaio:~$ echo username=MYUSER>.smbcredential
geus@geus-vaio:~$ echo password=MYPASS>>.smbcredential
geus@geus-vaio:~$ cat .smbcredentials
user=MYUSER
password=MYPASS
geus@geus-vaio:~$ sudo chmod a-xrw .smbcredentials
geus@geus-vaio:~$ sudo mkdir /media/NOMBRE_DIRECTORIO_MONTAJE
geus@geus-vaio:~$ sudo chown geus\: /media/NOMBRE_DIRECTORIO_MONTAJE

Finalmente en el archivo /etc/fstab añadimos la siguiente linea

//NOMBREHOST_REMTO/NOMBRE_CARPETA    /media/NOMBRE_DIRECTORIO_MONTAJE    smbfs    credentials=/home/geus/.smbcredential,user,auto,gid=geus,uid=geus,umask007 0 0

Al estar en modo auto, durante la inicialización del sistema, se intentará montar la carpeta compartida. En cualquier caso siempre se puede hacer manualmente:

geus@geus-vaio:~$ sudo mount /media/NOMBRE_DIRECTORIO_MONTAJE

Existen otros mecanismos para compartir directorios como sshfs, algo más lentos, pero más seguros y con capacidad de compartir en internet. Hace algunos años ya escribí sobre ellos: http://geus.wordpress.com/2008/05/17/sshfs-hints/

Saving Legacy Software is always a challenge and it’s sometimes funny. This evening, after be struggling a bit with the source code, makefile and debugging with ddd I achieved make it run again properly on Ubuntu 10.4 in a x64 bit processor.

There were several problems:

• Some pieces of code uses some deprecated system functionality related with error handling.
• Some data types names overlapped others actual standard data structures.
• Used libraries were quite old.

Hence in such situation building the code wasn’t possible. However some precompiled versions exist on the internet. They apparently worked fine in my system, but when an dlx-assembly file was loaded the program crashed. It was due to a buffer overflow in his code (specifically in the ReadFile function in the asm.c file). I’m not sure if this is related with the use of 64-bit processor or if it’s related with some changes of Tcl/Tk libraries for using unicode strings. Anyways it was solved making a  specific buffer bigger and using the function snprintf.

Of course these changes don’t assert that old or news problem appear. However it seems to be working fine, as it used to be.
Corrections and suggestions are welcome.

• The old and official tarball
• The diff File:

diff -crB dlxview0.9/asm.c dlxview0.9b/asm.c
*** dlxview0.9/asm.c    1997-09-27 00:00:08.000000000 +0200
— dlxview0.9b/asm.c    2010-12-07 19:13:40.000000000 +0100
***************
*** 1368,1375 ****
register LoadInfo *infoPtr;    /* Information about the state of the
* assembly process. */
{
! #define MAX_LINE_SIZE 200
! #define MAX_NAME_SIZE 10
char line[MAX_LINE_SIZE];
char pseudoOp[MAX_NAME_SIZE+1];
FILE *f;
— 1368,1375 —-
register LoadInfo *infoPtr;    /* Information about the state of the
* assembly process. */
{
! #define MAX_LINE_SIZE 2000
! #define MAX_NAME_SIZE 100
char line[MAX_LINE_SIZE];
char pseudoOp[MAX_NAME_SIZE+1];
FILE *f;
***************
*** 1377,1383 ****
int i, nullTerm;
char *end, *curToken;
char savedChar;
!     char msg[40];
double strtod();

f = fopen(fileName, “r”);
— 1377,1383 —-
int i, nullTerm;
char *end, *curToken;
char savedChar;
!     char msg[255];
double strtod();

f = fopen(fileName, “r”);
Only in dlxview0.9: dlxview
diff -crB dlxview0.9/Makefile dlxview0.9b/Makefile
*** dlxview0.9/Makefile    1997-09-27 00:00:08.000000000 +0200
— dlxview0.9b/Makefile    2010-12-07 19:00:28.000000000 +0100
***************
*** 1,8 ****
# environment dependent variables; change these to their appropriate
# directory paths for the X11 and tcl/tk library and header paths
# Solaris paths
! TCL_LIB = /usr/local/lib
! TCL_INC = /usr/local/include
X_LIB = /opt/x11r5/lib
X_INC = /usr/local/X11R5/include
# Linux paths
— 1,8 —-
# environment dependent variables; change these to their appropriate
# directory paths for the X11 and tcl/tk library and header paths
# Solaris paths
! TCL_LIB = /usr/lib
! TCL_INC = /usr/include/tcl
X_LIB = /opt/x11r5/lib
X_INC = /usr/local/X11R5/include
# Linux paths
***************
*** 20,26 ****

# Solaris may need the -lsocket and -lnsl flags added.  Tk4.1 and newer
# also require the -ldl flag.
! LLIBS = ${TCL_LIB}/libtcl7.6.a ${TCL_LIB}/libtk4.2.a -L${X_LIB} -lX11 -lnsl -lsocket -lm -ldl
# LLIBS = ${TCL_LIB}/libtcl.so ${TCL_LIB}/libtk.so -L${X_LIB} -lX11 -lm -ldl
# LLIBS = ${TCL_LIB}/libtcl.a ${TCL_LIB}/libtk.a -L${X_LIB} -lX11 -lm

— 20,26 —-

# Solaris may need the -lsocket and -lnsl flags added.  Tk4.1 and newer
# also require the -ldl flag.
! LLIBS = -g ${TCL_LIB}/libtcl.a ${TCL_LIB}/libtk.a ${TCL_LIB}/libpthread.so ${TCL_LIB}/libc.so -L${X_LIB} -lX11 -lnsl -lm -ldl
# LLIBS = ${TCL_LIB}/libtcl.so ${TCL_LIB}/libtk.so -L${X_LIB} -lX11 -lm -ldl
# LLIBS = ${TCL_LIB}/libtcl.a ${TCL_LIB}/libtk.a -L${X_LIB} -lX11 -lm

***************
*** 30,36 ****
###########################################################################

CC = gcc
! CFLAGS = ${CPPFLAGS} -O -I. -I${TCL_INC} -I${X_INC}
TARGET = dlxview

OBJS = asm.o cop0.o getput.o io.o issue.o main.o script.o sim.o stop.o sym.o trap.o
— 30,36 —-
###########################################################################

CC = gcc
! CFLAGS = ${CPPFLAGS} -O -I. -I${TCL_INC} -I${X_INC} -g
TARGET = dlxview

OBJS = asm.o cop0.o getput.o io.o issue.o main.o script.o sim.o stop.o sym.o trap.o
Only in dlxview0.9: .project
diff -crB dlxview0.9/script.h dlxview0.9b/script.h
*** dlxview0.9/script.h    1997-09-27 00:00:08.000000000 +0200
— dlxview0.9b/script.h    2010-12-07 17:16:15.000000000 +0100
***************
*** 927,934 ****
set help_cmd_stack \”HelpGeneral\”\n\
$t delete 1.0 end\n\
HelpIn help_title {\n\
!                        DLXview: Interactive Animated DLX Pipeline
!                Visualization\n\
}\n\
HelpIn HelpInfo {\n\
1. General Information\n\
— 927,933 —-
set help_cmd_stack \”HelpGeneral\”\n\
$t delete 1.0 end\n\
HelpIn help_title {\n\
!                        DLXview: Interactive Animated DLX Pipeline Visualization\n\
}\n\
HelpIn HelpInfo {\n\
1. General Information\n\
diff -crB dlxview0.9/sim.c dlxview0.9b/sim.c
*** dlxview0.9/sim.c    1997-09-27 00:00:08.000000000 +0200
— dlxview0.9b/sim.c    2010-12-07 17:30:43.000000000 +0100
***************
*** 27,32 ****
— 27,33 —-
#include <string.h>
#include <stdlib.h>
#include <tcl.h>
+ #include <errno.h>
#include “dlx.h”
#include “sym.h”

***************
*** 1033,1049 ****
static char *
errstring(void)
{
!     extern int errno, sys_nerr;
!     extern char *sys_errlist[];
static char msgbuf[64];

if( !errno )
return “no error”;
!     if( errno >= sys_nerr ) {
sprintf( msgbuf, “unknown error %d”, errno );
return msgbuf;
}
!     return sys_errlist[ errno ];
}

— 1034,1051 —-
static char *
errstring(void)
{
!     extern int errno;
!     char * strerror_msg;
static char msgbuf[64];

+     strerror_msg=strerror( errno);
if( !errno )
return “no error”;
!     if( strerror_msg == 0 ) {
sprintf( msgbuf, “unknown error %d”, errno );
return msgbuf;
}
!     return strerror_msg ;
}

Recordar que para utilizar esta funcionalidad en C#/LINQ hay que importar el “namespace System.Linq”. Así mismo para algunas de las operaciones propuestas para python hay que importar el paquete “itertools“. También es interesante tener a mano la documentación de las estructuras de datos en Python.

Si conocéis mas equivalencias animáos y añadirlas a los comentarios.
Saludos.

var a= new int[]{1,2,3,4,5,5,6,8};
var b= new int[]{9,8,6,5,4};
a= [1,2,3,4,5,5,6,8]
b= [9,8,6,5,4]

Selección/Transformación

var res= from i in a select i*i;
res= [ i*i for i in a ] ;

Proyección Anónima

var res= from i in a select new{prop1=i,prop2=Math.Sin(i)};
res= [ {'prop1': i, 'propb2':sin(i)} for i in a ] ;

a.ToDictionary(i=> i*i);
a.ToDictionary(i=> i*i, i=>i);
dic([(i*i, i) for i in a])

Max/Min

maxsinval = a.Max(i=>Math.Sin(i))
maxsinval = max(a, lambda i: sin(i))

Distinct

res = a.Distinct()
res = set(a)

Union

res = a.Union(b);
res = Set(a).union(b)

Filtrado

res = from i in a where i%2==0 select i*i;
res = [ i*i for i in a if i%2==0] ;

Ordenación

res = a.Sort(i=>i %2 ==0);
res = sorted(a, key= lambda i: i %2 ==0)

All/Any

a.All(i=> i%2 ==0 )
all ([i%2==1 for i in a])

a.Any(i=> i%2==0)
any ([i%2==1 for i in a])

First/Last/Count

a.Count(i=>i%2==0)
len([i for i in a if i%2==0])

a.Count(i=>i==3)
a.count(3)

Agregation/Reduction

a.Agreggate((i,j)=>i*j);
reduce(lambda i, j: i*j,a)

Take/Skip

res = a.Take(3);
res = a[:3];

res = a.Skip(2);
res = a[2:];

res = a.Take(3).Skip(2);
res = a[2:3]

res = a.Skip(2).Take(3);
res = a[2:][:3]

a.TakeWhile(i=>i%2==0)
[i for i in takewhile(lambda i: i %2==0)]

a.SkipWhile(i=>i%2==0)
[i for i in dropwhile(lambda i: i%2==0)]

GroupBy

groups = []
uniquekeys = []
data = sorted(a)
for k, g in groupby(a, lambda i: i+’a'):
uniquekeys.append(k)
groups.append(list(g))

Combinatories Functions

permutations('ABCD', 2)
combinations('ABCD', 2)
combinations_with_replacement('ABCD', 2)

Join/Cross Product

Conclusiones

No demasiadas, simplemente que me gusta mas la notación de C#. Especialmente porque se puede leer secuencialmente las operaciones y transformaciones. Por el contrario las operaciones de Python se aplican de forma anidada por lo que se leen en orden inverso de aplicación. Un muy buen aspecto positivo de Python es que sus librerías incluyen la diversas funciones combinatorias cosa que c# no, esto es algo que me parece básico.

También, desde mi punto de vista decir que tiene mas mérito que c# llegue a este nivel de expresividad dado que es un lenguaje fuertemente tipado y estático (en su mayor parte). El compilador de c# hace un buen trabajo.

Referencias

Trabajo en python:
http://docs.python.org/library/itertools.html
http://www.siafoo.net/article/52
http://www.artima.com/weblogs/viewpost.jsp?thread=98196

Read related developerWorks articles by David Mertz:

• Functional programming in Python, Part 1
• Functional programming in Python, Part 2
• Functional programming in Python, Part 3

http://sayspy.blogspot.com/2006/02/why-python-doesnt-need-something-like.html
http://srtsolutions.com/public/blog/251010
http://docs.python.org/py3k/tutorial/datastructures.html#sets

Copias de linq a python:
http://lost-theory.org/python/enum2.txt
http://themechanicalbride.blogspot.com/2007/03/linq-to-python.html
http://lost-theory.org/python/enum3.txt

ROS dispone de varios paquetes para realizar SLAM usando visión  con cámaras y principalmente usando Lasers Rangers: vslam, gmapping, kartoMapping, graphmapping.

Este post trataremos como arrancar un ejemplo básico con gmapping, El objetivo es aprender vagamente como funciona y poder aplicarlo en nuestros proyectos.

El algoritmo GMapping

GMapping es una librería libre perteneciente al proyecto OpenSLAM y que implementa una extensión la técnica SLAM Grid Mapping. En cualquier caso, utilizaremos este software como si fuera una caja negra. Sabemos que su salida son la localización del robot en el mapa y el mapa en si mismo. Como entradas toma  información periódica sobre una estimación de la posición del robot (odometría – calculada por los encoders del motor) y la medida del sensor laser ranger (vector de distancia) en un entorno con superficie plana.

Demo GMapping en ROS

¿Como probar este software en ROS? Sencillo, la gente de Bosch ya ha realizado una demo, con el simulador stage para que podamos abordar el problema. Esta demo está localizado en el paquete explore_stage. Consiste en un mapa desconocido por un robot móvil tipo erratic. Observemos la wiki del paquete vemos la siguiente información de repositorio donde se ubica el código:

• Repository: bosch-ros-pkg
• Source: svn https://bosch-ros-pkg.svn.sourceforge.net/svnroot/bosch-ros-pkg/trunk/stacks/exploration/explore_stage

Descargaremos todo el directorio [...]stacks/exploration/demos ya que contiene algunos paquetes adicionales con mapas y modelos que nos serán necesarios.

geus@geus-vaio:/opt/ros/cturtle/stacks/external/demos$ svn co https://bosch-ros-pkg.svn.sourceforge.net/svnroot/bosch-ros-pkg/trunk/stacks/exploration
[...]
geus@geus-vaio:/opt/ros/cturtle/stacks/external/demos/exploration$ roscd explore_stage/
geus@geus-vaio:/opt/ros/cturtle/stacks/external/demos/exploration/explore_stage$ ls
config   explore.launch       explore_slam.xml  explore.xml   move.xml
explore  explore_slam.launch  explore.vcg       manifest.xml

Como se observa el paquete es muy sencillo, solo algunos componentes .launch con la aplicaciones.  Antes que nada compilemos el stack exploration ya que contiene un paquete exploration/explore con el código para realizar la exploración en el mapa desconocido.

geus@geus-vaio:/opt/ros/cturtle/stacks/external/demos/exploration/explore$ rosmake exploration
[ rosmake ] Packages requested are: ['exploration']
[...]
[ rosmake ] Results:
[ rosmake ] Built 53 packages with 0 failures.

En concreto la aplicación de explorar está en el explore_slam.launch. Lanzamos la aplicación:

geus@geus-vaio:/opt/ros/cturtle/stacks/external/demos/exploration/explore_stage$ roslaunch explore_slam.launch

Algunos problemas con Stage

Pueden que los usuarios de ubuntu reciban el siguiente error, debido a los cambios en la política de archivos del servidor gráfico X11. Existe un problema que no se encuentra el archivo rgb.txt que es una base de datos con colores.

[Loading /opt/ros/cturtle/stacks/external/full_organization_repositories/bosh-ros-pkg/bosch_demos/bosch_worlds/maze-noisy.world][Include segway-noisy.inc][Include sick.inc][ INFO] [1291307466.316198795]: Subscribed to Topics: base_scan
err: unable to open color database: No such file or directory (try adding rgb.txt’s location to your STAGEPATH) (/tmp/buildd/ros-cturtle-simulator-stage-1.2.1/debian/ros-cturtle-simulator-stage/opt/ros/cturtle/stacks/simulator_stage/stage/build/Stage-3.2.2-Source/libstage/color.cc Color)

El problema se soluciona de forma sencilla añadiendo a la variable de entorno $STAGEPATH una ruta que contenga un rgb.txt correcto. En nuestro caso, el mismo paquete stage contiene ese archivo. Lo añadimos:

geus@geus-vaio:/opt/ros/cturtle/stacks$ find $ROS_PACKAGE_PATH | grep rgb.txt
/opt/ros/cturtle/stacks/simulator_stage/stage/share/stage/assets/rgb.txt
/opt/ros/cturtle/stacks/simulator_stage/stage/share/stage/rgb.txt
/opt/ros/cturtle/stacks/simulator_stage/stage/build/Stage-3.2.2-Source/assets/rgb.txt
/opt/ros/cturtle/stacks/simulator_stage/stage/build/Stage-3.2.2-Source/libstage/rgb.txt
geus@geus-vaio:/opt/ros/cturtle/stacks$ export STAGEPATH=`rospack find stage`/share/stage
geus@geus-vaio:/opt/ros/cturtle/stacks$ echo $STAGEPATH
/opt/ros/cturtle/stacks/simulator_stage/stage/share/

Ahora si. Lanzamos y ya funciona y podemos ver como arrancan varios procesos definidos en el archivo .launch.

geus@geus-vaio:/opt/ros/cturtle/stacks/external/demos/exploration/explore_stage$ roslaunch ./explore_slam.launch

Otra alternativa es añadir en el archivo explore_slam.launch el valor de la variable de entorno:

...

Interpretación de resultados

Tras lanzar el explore_slam.launch se ejecutan diversos procesos ROS. Entre ellos se abre el simulador stage, mostrado en la imagen. A los pocos segundos, tras algo de proceso el robot empieza a navegar y a explorar su entorno. Para poder ver bien que está ocurriendo podemos abrir la herramienta rviz. Primera imagen de este artículo.

geus@geus-vaio:/opt/ros/cturtle/stacks$ rosrun rviz rviz

Añadimos los visualizadores (plugins) de rviz “map”, “tf” y “laser scan”.

• “map” – sirve para que podamos ver el mapa que se está construyendo.  Mas concretamente monitorizar los mensajes de tipo nav_msgs/OccupancyGrid publicados en el topic “/map”.
• “tf” – sirve para monitorizar la posición estimada por el sistema SLAM.
• “laser scan”- sirve para monitorizar el escaneo laser que está realizando el robot. Mas concretamente mensajes del tipo sensor_msgs/LaserScan

Podemos observar que se han creado tres procesos principales: “/explore” “/move_base” “/stage” “/gmaping”.

• “/stage”- es el nodo simulador. Se limita a enviar al exterior mensajes de las lecturas del laser y la posición del robot a través del tópic /tf. También acepta comandos de movimiento a través del topic /cmd_vel
• “/gmaping”- es el nodo que crea que realiza el SLAM. Crea el mapa a partir de la posición estimada y las lecturas del sensor Laser (topic /base_scan de tipo “sensor_msgs/LaserScan”).
• “/explore” – es el nodo que realiza el algoritmo de exploración. Utiliza el mapa resultante y la posición del robot para estimar zonas donde es mas interesante seguir explorando. Una vez decidido un plan de exploración se lo indica al nodo “/move_base”
• “/move_base” – es el nodo que se encarga de ejecutar un plan de ejecución. Se trata de un paquete esencial y genérico que ROS provee. Simplente sigue las ordenes del nodo “/explore” y ordena al “/stage” como debe mover los motores haciendo uso del topic “/cmd_vel” de tipo de mensaje “geometry_msgs/Twist
  “, siempre intentando crear una trayectoria sin colisionar.

Esto es todo. Si lográis sustituir el nodo stage por un robot real con odometría y sensor laser, tenéis un sistema de SLAM listo para ser ejecutado.

Saludos y Happy Robotics!

Filed under: Robotics, Science and Technical Tagged: linkedin, ROS ]]> http://geus.wordpress.com/2010/12/02/robotics-simultaneous-localization-and-mapping-slam-con-ros/feed/ 4 GeuS rviz-slam stage_slam_2 rxgraph_slam http://geus.wordpress.com/2010/10/31/delitos-telematicos/ http://geus.wordpress.com/2010/10/31/delitos-telematicos/#comments Sun, 31 Oct 2010 15:23:13 +0000 geus http://geus.wordpress.com/?p=783 ]]> Hoy día, las estafas y los ataques en internet están a la orden del día. Algunos son difíciles de detectar, especialmente para el internauta de a pie. Otros sin embargo, son sencillos de identificar y deberíamos educarnos como sociedad en identificarlos y denunciarlos. Algunos ejemplos clásicos son los intentos de obtención de datos bancarios vía email (pishing), los premios ficticios, el mercado de alquiler y venta de pisos online hay estafas flagrantemente llamativas de inquilinos “que están de viaje” y que solo aceptan los pagos por pasarelas electrónicas como “western union”.

Una notificación o denuncia a los delitos telemáticos puede hacerse en cuestión de 30 segundos, escribiendo una nota y añadiendo un par de enlaces y/o indicios de delitos, ips, emails, etc. Solo es necesario ir a la página web de Delitos Telemáticos de la Guardia Civil (añadirla favoritos) y rellenar un formulario (email, localidad y descripción).

Aún no somos conscientes de la enorme importancia que tiene para una sociedad y país tener una educación en hábitos y seguridad fuerte en internet.  Muchas guerras de hoy día son ya en internet, y mas aún lo serán en el futuro, nosotros somos simples civiles. Hoy día internet es lo mas parecido a una jungla o al salvaje oeste: estafadores, pistoleros, bandas organizadas, sherifs, heroes, villanos y gente inocente/ingenua.  Cada uno intenta aplicar su propia ley y solo los precavidos consiguen vivir muchos años sin tener problemas. Tenemos que educarnos a nosotros mismos a denunciar y protestar contra estos ataques.

using System;
using System.Collections.Generic;
using System.Linq;

namespace Combinatory
{
	public static class Combinatory
	{
		public static IEnumerable<IEnumerable<T>> Combinations<T> (IEnumerable<T> elements, int setLenght)
		{
		int elementLenght=elements.Count ();
			if ( setLenght == 1) 
				return elements.Select(e=>Enumerable.Repeat (e, 1));
			else if(setLenght==elementLenght)
				return Enumerable.Repeat(elements,1);
			else 
			{
				return Combinations (elements.Skip (1), setLenght - 1)
								.Select (tail => Enumerable.Repeat (elements.First (), 1).Union (tail))
								.Union(Combinations (elements.Skip (1), setLenght));
			}
		}
	}
}

• ROS ¿El nuevo estándar de facto en robótica?
• Como instalar y utilizar un paquete de un repositorio federado

Por desgracia ROS, a pesar de su buena organización y documentación no presenta una curva de aprendizaje rápida. Inicialmente cuesta ubicarse entre tantos paquetes existentes y además el proceso de desarrollo puede ser lento si no se dispone de un IDE adecuado.

Eclipse puede solucionar ambos problemas simultáneamente, nos permitirá desarrollar de una manera mas cómoda y a la vez nos permitirá ubicarnos entre los distintos paquetes de ROS y aprender mas rápidamente. Con Eclipse es mas sencillo navegar entre los ficheros de código, paquetes y stacks. Por ejemplo cuando un símbolo en c++ es extraño para nosotros podemos ir a su definición usando ctrl+ left click. Además el desarrollo de nuevos paquetes es también mas sencillo dado que se puede utilizar el autocompletar. Por último también podrás depurar tu proyecto. Algo bastante importante.

Pasos para poder compilar y usar la herramienta de auto-completar:

1. Descargar Eclipse con soporte CDT
2. Establecer el workspace de eclipse en la raíz de la instalación (el directorio base de roscd)
3. Arrancar desde consola el eclipse (se supone que tenéis registrado en vuestro .bashrc el setup.sh de ROS)
4. Crear un nuevo proyecto C++ llamado stacks (directorio ya existente, aparecerá un warning)
   • Utilizar el tipo C++ -> Makefile Project -> Empty Project -> Ohter Toolchain
5. Crear otro proyecto C++ llamado ros (directorio ya existente)
6. Si te interesa compilar un paquete concreto, en las propiedades del proyecto-> C/C++ Build
   1. • make -C .
      • make -C . VERBOSE=1
      • rosmake nombrepaquete
   • Elige en BuildLocation-> Build Directory -> La url del paquete que deses compilar (es útil utilizar el botón workspace)
   • Deschequea el checkbox “Use Default Build Command” para utilizar un comando de construcción personalizado. Puedes poner varias alternativas
7. Establece en el “Build Directory” el directorio del paquete que desees construir (haciendo uso del botón Workspace)
8. Fin. Estas listo para navegar por el código de ros y recompilar paquetes
9. Realizar el mismo proceso de creación de un proyecto para la carpeta /opt/ros/cturtle/ros, de esta forma podrás también navegar en las librerías básicas de ROS

Observaciones:

1. El autocompletar dentro del proyecto “stacks” funcionará correctamente pero solo con el código que esté situado en stacks. Por ejemplo <ros/ros.h> no funcionará puesto que está en el otro proyecto “ros”, para que funcione el autocompletar hay que establecer los Paths and Symbols en las propiedades del proyecto.
2. Suponiendo que la instalación del código que estás utilizando es cturtle u otra instalación por defecto proveniente de un repositorio, es interesante crear un enlace simbólico en la carpeta /opt/ros/cturtle/stacks ($ROS_PACKAGE_PATH) a una carpeta externa donde ubiquemos nuestros proyectos y otras descargas o compilaciones manuales (por ejemplo de otros repositorios federados)