robótica

Dic

2014

Paso 7. Montando los bigotes

Última actualizacón: 16 noviembre 2017 a las 17:00

Muchas máquinas robotizadas dependen de una variedad de interruptores táctiles para, por ejemplo, contar objetos en una línea de producción o alinearlos durante los procesos industriales. En estos casos los interruptores ofrecen una entrada de datos que ordenan otro tipo de salida programada de datos.

En el paso anterior enseñamos a andar al robot, pero lo hacía a ciegas ya que si tropezaba con un obstáculo allí se quedaba. Ahora vamos a colocarle unos sensores que le avisen de la presencia de obstáculos en su camino, además de indicarle si dicho obstáculo se encuentra a la derecha o a la izquierda. Con esa información podremos indicarle que realice un movimiento de desvío que lo evite y así pueda proseguir hacia su objetivo.

Para ello vamos a emplear dos bumpers, nombre técnico con el que se conoce a ciertos interruptores que cierran sus contactos cuando se presiona uno de ellos. En nuestro caso, los bumpers están conformados por dos alambres de acero y tienen el aspecto de bigotes o antenas. Los llamaremos bigotes porque sirven para detectar objetos como lo hacen los bigotes de un gato. En este paso los utilizaremos solos, pero pueden ser combinados con otros sensores como veremos más adelante.

Montando los bigotes

Antes de grabar un programa para que robot se mueva en función de lo que encuentra en su camino, necesitamos montarlos y probarlos primero. Vamos a utilizar los siguientes materiales:

Dos alambres de acero.
Dos tornillos de cabeza plana de 3×15 mm.
Dos separadores metálicos de 3×10 mm.
Dos arandelas de baquelita de 3 mm.
Dos conectores de tres pines.
Dos resistencias de 220 Ω.
Dos resistencias de 10 Ω.

Material para el montaje de los bigotes.

Primero debemos quitar los tornillos que unen la tarjeta Home Work con los dos separadores frontales. Colocamos un separador y una arandela de baquelita en cada uno de los tornillos.

Retirar el tornillo.

Colocamos el separador y la arandela.

Colocamos los tornillos sobre los agujeros de la tarjeta y atornillamos a los separadores que hay debajo, pero no debemos apretarlos completamente todavía. Enganchamos los bigotes a los tornillos y colocamos uno por encima de una de las arandelas y el otro por debajo, de tal forma que no se toquen entre sí.

Insertamos los bigotes.

Ahora podemos terminar de apretar los tornillos y colocar los conectores de tres pines:

Resultado.

Colocamos los conectores de tres pines.

Prueba de funcionamiento

Ahora vamos a construir el circuito eléctrico de los bigotes para añadirlo a los circuitos de zumbador y los servos que montamos en el paso anterior:

Diagrama de circuito para el montaje de los bigotes.

Cada bigote es una extensión mecánica de un interruptor normalmente abierto que tiene un extremo conectado a tierra. La razón de que los bigotes estén conectados a tierra (Vss) es que los agujeros en los bordes exteriores de la tarjeta están conectados a tierra. Los separadores y tornillos metálicos conectan la señal de tierra con los bigotes.

Podemos programar el módulo del microcontrolador para que detecte cuándo se presiona un bigote. Los pines o patitas de E/S conectados a cada interruptor están configurados como entradas y reciben un voltaje. Cuando los bigotes no se presionan, el voltaje que reciben es de 5 V (1 lógico). Pero si son presionados, el circuito se cierra con tierra y los pines reciben 0 V (0 lógico).

Colocamos las conexiones y resistencias como hemos visto en el diagrama anterior y ya podemos pasar a crear el programa de control:

Montaje del circuito.

Resultado final.

Programa de prueba

Este programa está diseñado para que se puedan probar los bigotes y asegurar que funcionan correctamente. Lo que hace es mostrar el estado lógico de las entradas que corresponden a los pines P7 y P5 conectados a los bigotes (IN7 e IN5).

Todos los pines de E/S son de entrada por defecto, a menos que se programe lo contrario. Por lo tanto, los pines conectados a los bigotes tendrán un “1” si el voltaje que reciben es de 5 V (cuando el bigote no está presionado), o un “0” si lo que reciben es 0 V (cuando el bigote está presionado). Vamos a utilizar el debug terminal para mostrar esos valores:

‘ Programa de prueba. pruebabigotes.bs2
‘ Visualizar las líneas de E/S conectadas a los «bigotes»
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
DEBUG «Estado bigotes», CR,
«Izquierda derecha», CR,
«_____ _____»
DO
DEBUG CRSRXY, 0, 3,
«P5 = «, BIN1 IN5,
«P7 = «, BIN1 IN7
PAUSE 50
LOOP

El terminal debería mostrar que que P7 y P5 tienen unos valores igual a 1. Si presionamos el bigote derecho contra el conector de tres pines hasta que haga buen contacto, deberíamos ver en el terminar: P5 = 1, P7 = 0. Si presionamos el bigote izquierdo de la misma forma, debería aparecer: P5 = 0, P7 = 1. Si presionamos ambos al mismo tiempo debería mostrar: P5 = 0, P7 = 0. Una vez que todo es correcto seguimos adelante.

Escribimos el código en el programa de edición y lo guardamos.

Ejecutamos e introducimos en el robot. No presionamos ningún bigote.

Presionamos el bigote derecho.

Presionamos el bigote izquierdo.

Presionamos ambos bigotes.

NOTA: el comando CRSRXY es un formateador que permite ordenar la información que el programa envía al terminal. En el programa, el formateador coloca el cursor en la columna 0 y fila 3 para mostrar los datos de forma ordenada.

Otra forma de probar los bigotes

Imaginemos que tenemos que probar los bigotes cuando no disponemos de un ordenador para ver su estado en la terminal. ¿Cómo podríamos comprobar que se han montado correctamente? Una solución pasa por programar el microprocesador para que saque un valor determinado en función de cuál es la entrada que reciba. Podemos visualizarlo con un par de circuitos LED´s que se enciendan y se apaguen en función de si los bigotes están presionados o no.

Para montar este circuito necesitamos:

Dos resistencias de 220 Ω (bandas roja, roja y marrón).
Dos diodos LED.

Como siempre, antes de montar el circuito sobre la placa debemos recordar desconectar las pilas de la tarjeta y los servos. Seguiremos el siguiente esquema:

Diagrama de circuito LED para la comprobación del funcionamiento de los bigotes con LED.

Prueba de funcionamiento con LEDs.

Una vez montado, volvemos a conectar las pilas, e introducimos el siguiente programa en el editor:

‘ Programa de prueba. pruebabigotesconleds.bs2
‘ Visualizar las líneas de E/S conectadas a los «bigotes»
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
DEBUG «Estado bigotes», CR,
«Izquierda derecha», CR,
«_____ _____»
DO
DEBUG CRSRXY, 0, 3,
«P5 = «, BIN1 IN5,
» P7 = «, BIN1 IN7
PAUSE 50
IF (IN7 = 0) THEN
HIGH 1
ELSE
LOW 1
ENDIF
IF (IN5 = 0) THEN
HIGH 10
ELSE
LOW 10
ENDIF
LOOP

Escribir el código en el programa de edición. Ejecutarlo e introducirlo en el robot.

Como vemos, lo que hemos hecho ha sido insertar dos bloques de código IF…THEN entre el comando de pausa y el comando de bucle. Los comandos IF…THEN los explicaremos un poco más tarde pero baste decir ahora que se emplean en PBASIC para tomar decisiones. La primera declaración pone P1 a nivel alto, de forma que el LED se iluminará cuando el bigote conectado a P7 esté presionado (IN7=0). La parte del ELSE hace que el LED se apague cuando el bigote no está presionado. La segunda declaración hace lo mismo para el otro bigote. Veamos cómo funciona:

Programando el robot para navegar con los bigotes

Ha llegado el momento de poner en práctica todo lo aprendido hasta ahora para lograr que el robot reaccione a la información que le facilitan los bigotes acerca de los obstáculos que puede encontrar en su camino y pueda guiarse con ella. Cuando el robot esté en movimiento y uno de sus bigotes se presione significará que ha tropezado con un obstáculo. El programa de exploración deberá comprobar esa entrada de información, decidir qué significa y, a partir de ahí, realizar la maniobra hay que ejecutar para evitar el obstáculo y dirigir al robot en otra dirección (debemos tener presente que se trata de un movimiento libre y no podremos controlar dónde acabará el recorrido).

El siguiente programa hace que el robot vaya hacia delante hasta que se encuentre con un obstáculo. En el momento en que sea detectado por los bigotes, las rutinas y subrutinas escritas en el capítulo anterior harán que el robot retroceda y gire. Después volverá a avanzar hacia delante hasta que se encuentre con otro obstáculo.

El microcontrolador que gobierna el robot tiene que ser programado para que tome decisiones cuando uno de los bigotes es presionado. El lenguaje PBASIC dispone de un comando llamado IF…THEN. La sintaxis es como sigue:

IF (condición) THEN… {ELSEIF (condición)}…{ELSE}…ENDIF

Los puntos suspensivos significan que se puede meter un trozo de código en su lugar. El comando hace que el robot ejecute el bloque de código para la primera condición que sea verdadera. Entonces, salta hasta el comando ENDIF y continúa desde ahí.

El siguiente programa muestra una forma de evaluar las entradas de datos proporcionadas por los bigotes para decidir a qué subrutina de movimiento llamar utilizando los comandos IF…THEN:

‘ Sorteo de obstaculos. andandoconbigotes.bs2
‘ El robot utiliza los bigotes para detectar
‘ objetos y navegar en función de los mismos
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
DEBUG «Programa funcionando»
‘—–[ Variables ]
pulseCount VAR Byte
‘—–[ Inicializacion ]
FREQOUT 4, 2000, 3000
‘—–[ Rutina principal ]
DO
IF (IN5 = 0) AND (IN7 = 0) THEN
GOSUB Back_Up
GOSUB Turn_Left
GOSUB Turn_Left
ELSEIF (IN5 = 0) THEN
GOSUB Back_Up
GOSUB Turn_Right
ELSEIF (IN7 = 0) THEN
GOSUB Back_Up
GOSUB Turn_Left
ELSE
GOSUB Forward_Pulse
ENDIF
LOOP
‘—–[ Subrutinas ]
Forward_Pulse:
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
RETURN
Turn_Left:
FOR pulseCount = 0 TO 20
PULSOUT 13, 650
PULSOUT 12, 650
PAUSE 20
NEXT
RETURN
Turn_Right:
FOR pulseCount = 0 TO 20
PULSOUT 13, 850
PULSOUT 12, 850
PAUSE 20
NEXT
RETURN
Back_Up:
FOR pulseCount = 0 TO 20
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
RETURN

Escribir el código en el programa de edición. Ejecutarlo e introducirlo en el robot.

El comando IF…THEN en el programa principal comprueba el estado de los bigotes. Si los dos bigotes están presionados (IN5 = 0, IN7 = 0), el robot realizará un giro en “U” llamando a la subrutina Back_Up seguida de la subrutina Turn_Left dos veces (lo que supone un giro de 180o).

Si el bigote izquierdo es el único que está presionado (IN5 = 0), el programa ejecutará la subrutina Back_Up seguida de la subrutina Turn_Right para retroceder y girar a la derecha 90o. Por el contrario, si el bigote presionado es el derecho (IN7 = 0), el programa ejecutará la subrutina Back_Up seguida de la subrutina Turn_Left para retroceder y girar a la izquierda 90o. La única posibilidad que no está resuelta en el programa es cuando los dos bigotes no están presionados (IN5 = 1, IN7 = 1) en cuyo caso el comando ELSE llama a la subrutina Forward_Pulse y envía un pulso para que el robot avance en línea recta al no haber obstáculos.

Esta subrutina tiene un detalle que hemos resaltar:

Forward_Pulse:
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
RETURN

Sólo envía un pulso y después devuelve el control al programa principal. Esto es importante porque permite al robot comprobar sus bigotes entre cada pulso que le hace avanzar (esto lo hace gracias al comando ENDIF). Significa que el robot comprueba si hay obstáculos alrededor de 40 veces por segundo mientras avanza hacia delante: cada pulso hacia delante hace que el robot avance medio centímetro por lo que es una buena idea enviar sólo un pulso para volver a comprobar los bigotes. Dado que el comando IF…THEN está dentro de un bucle DO…LOOP, cada vez que el programa realiza un pulso hacia delante entra en el bucle que envía el programa arriba hasta el comando DO. ¿Qué sucede entonces? Que el comando IF…THEN vuelve a comprobar los bigotes de nuevo y así sucesivamente. Si no lo hiciéramos así, cuando el robot entrara en la subrutina Forward_Pulse ya no volvería a comprobarlos.

Veamos el resultado de nuestros esfuerzos:

Jun

2014

Paso 6. Programando los movimientos del robot

Última actualizacón: 16 noviembre 2017 a las 13:40

En esta anotación aprenderemos a programar las maniobras fundamentales del robot: hacia delante, atrás, giros y rotaciones. Es fundamental que comprendamos bien estas maniobras y sus técnicas de programación porque las utilizaremos de ahora en adelante, aunque ahora el robot andará “a ciegas” porque aún no hemos instalado los sensores que le permitan informarse acerca del entorno que lo rodea. Nuestra tarea en los próximos pasos será instalar estos dispositivos que permitirán a nuestro robot esquivar obstáculos o seguir un camino marcado en el suelo.

Como parte indispensable de este paso, también vamos a aprender a poner a punto y calibrar la navegación del robot para que se mueva en línea recta, haga giros precisos y podamos hacer cálculos de distancias. Al final hay un vídeo donde se muestran en la práctica los mismos pasos que iremos dando.

En la imagen inferior vemos los diferentes movimientos que puede hacer el robot (como ya indicamos en pasos anteriores, debemos recordar que cuando el robot se mueve hacia delante su rueda derecha gira en el sentido de las agujas del reloj, mientras que la izquierda lo hace en sentido contrario):

Movimiento hacia delante

Con el programa que indicamos a continuación el robot avanzará en línea recta durante tres segundos.

Recordemos que el argumento Duración del comando PULSOUT controla la velocidad y la dirección de giro de los servos. Los argumentos StartValue y EndValue del bucle FOR…NEXT controlan por su parte el número de pulsos que se envían. Dado que cada pulso tiene la misma duración, el argumento EndValue también controla el tiempo que funcionan los servos.

‘ Programa de movimiento. Avancetressegundos.bs2
‘ El robot avanza hacia delante durante tres segundos
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
Counter VAR Word
FREQOUT 4, 2000, 3000 ‘señal de inicio/reset
FOR counter = 1 TO 122 ‘marcha hacia delante durante 3 s
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
NEXT
END

Controlando la distancia y la velocidad

Si cambiamos por ejemplo el valor EndValue del bucle FOR…NEXT de 122 a 61, haremos que el robot se desplace hacia delante durante la mitad de tiempo, y que recorra, por tanto, la mitad de la distancia.

Hagamos la comprobación:

Ahora podemos repetir lo mismo pero cambiando el valor EndValue a 244. ¿Qué ocurre?

Los cambios que hemos hecho están relacionados con la distancia que recorre el robot, pero también podemos modificar su velocidad. Por ejemplo, si ajustamos el parámetro Duración de PULSOUT cerca de 650 o 850, los servos girarán a su máxima velocidad; mientras que si se aproximan a 750, haremos que se muevan más lentos.

Modificamos el programa de la siguiente forma:

PULSOUT 13, 720

PULSOUT 12, 780

Mover el robot hacia atrás, rotarlo y pivotarlo

Todo lo que tenemos que hacer para conseguir otros movimientos del robot es utilizar diferentes combinaciones del parámetro Duración del comando PULSOUT. Por ejemplo, estas dos instrucciones hacen que el robot vaya hacia atrás:

PULSOUT 13, 850

PULSOUT 12, 650

Estas dos para que el robot gire a la izquierda:

PULSOUT 13, 650

PULSOUT 12, 650

Y éstas para que lo haga a la derecha:

PULSOUT 13, 850

PULSOUT 12, 850

Podemos combinar estos comandos para el robot vaya en diferentes direcciones como muestra el ejemplo del siguiente programa:

‘ Programa de movimiento. Delanteizquierdaderechaatras.bs2
‘ Hacer que el robot realice los cuatro movimientos básicos
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
Counter VAR Word
FREQOUT 4, 2000, 3000 ‘señal de inicio/reset
FOR counter = 1 TO 122 ‘marcha hacia delante durante 3s
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
NEXT
PAUSE 200 ‘espera
FOR counter = 1 TO 24 ‘rotación izquierda ¼ de vuelta
PULSOUT 13, 650
PULSOUT 12, 650
PAUSE 20
NEXT
PAUSE 200 ‘espera
FOR counter = 1 TO 24 ‘rotación derecha ¼ de vuelta
PULSOUT 13, 850
PULSOUT 12, 850
PAUSE 20
NEXT
PAUSE 200 ‘espera
FOR counter = 1 TO 122 ‘retroceso
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
END

También podemos hacer que el robot pivote sobre una rueda. Para ello basta con que sólo gire una rueda mientras la otra permanece parada. Por ejemplo, si se quiere que la rueda izquierda permanezca parada y la derecha gire hacia delante para que el robot pivote, se deberán utilizar las siguientes líneas de código:

PULSOUT 13, 750

PULSOUT 12, 650

Si por el contrario se quiere que pivote hacia delante y a la derecha, simplemente se detiene la rueda derecha y hacemos que la rueda izquierda gire hacia delante:

PULSOUT 13, 850

PULSOUT 12, 750

Hacia atrás y la derecha:

PULSOUT 13, 650

PULSOUT 12, 750

Hacia atrás y a la izquierda:

PULSOUT 13, 750

PULSOUT 12, 850

Retocando las maniobras básicas

Más abajo veremos un vídeo con todas estas maniobras realizadas en la práctica y comprobamos que, a pesar de que el robot está programado para avanzar en línea recta, es frecuente que se vaya desviando ligeramente hacia uno de los lados. Vamos a corregir este desajuste mediante el software, para lo cual deberemos modificar el programa Avancetressegundos.bs2 para que en vez de 3 segundos se mueva durante 10, tiempo necesario para comprobar si se desvía o no. Esta modificación se hace cambiando el valor de EndValue en el comando FOR Counter de 122 a 407:

‘ Programa de movimiento. Avancediezsegundos.bs2
‘ El robot avanza hacia delante durante diez segundos
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
Counter VAR Word
FREQOUT 4, 2000, 3000 ‘señal de inicio/reset
FOR counter = 1 TO 407 ‘giro hacia delante durante 10 s
PULSOUT 13, 650 ‘servo izquierdo máxima velocidad
PULSOUT 12, 850 ‘servo derecho máxima velocidad
PAUSE 20
NEXT
END

Pongamos por caso que el robot se desvía hacia la izquierda. Esto puede pasar por dos motivos: o bien la rueda izquierda gira más lenta, o es la rueda derecha la que lo hace más rápido. Como el robot está programado para que cada servo gire a la máxima velocidad, lo más lógico será pensar que la rueda derecha debería girar un poco más despacio.

Ya hemos visto que la velocidad de los servos está determinada por el argumento Duración del comando PULSOUT. Cuanto más se acerque este valor a 750, más lento girará el servo. Esto significa que hay que cambiar el valor 850 del comando PULSOUT 12 a un valor más cercano a 750. Si el robot no se desvía demasiado, con un valor de 837 será suficiente. Si por el contrario el grado de desvío es grande, habrá que poner como mínimo un valor de 810. Como vemos, será necesario hacer varias pruebas modificando este argumento hasta lograr que el robot siga una línea completamente recta.

En nuestro caso, ha sido necesario un valor de 800 para conseguir un movimiento rectilíneo.

Al igual que hemos hecho para el avance, tendremos que hacer los mismos ajustes para el movimiento hacia atrás.

También es posible regular los giros del robot mediante el software. El tiempo que dura el movimiento de las ruedas del robot es lo que determina el ángulo de giro. Como ya hemos visto que el comando que controla el tiempo de giro en el programa es el bucle FOR … NEXT, lo que tenemos que hacer es modificar el argumento EndValue para que gire más o menos según queramos.

En el programa Delanteizquierdaderechaatras.bs2 introdujimos una serie de órdenes para que el robot realizase distintos giros, por lo que si hay cualquier tipo de desviación deberemos modificar el contador del bucle FOR counter = 1 TO 24 y disminuir el tiempo de giro (probamos primero con 23, 22 etc.) Si sigue sin girar los 90o exactos, modificaremos el comando PULSOUT a un valor más cercano a 750, como hicimos para que fuese recto. Repetiremos la acción hasta que gire los 90o exactos.

Cálculo de distancias

Es frecuente que en las competiciones que se organizan los robots tengan que seguir un recorrido desde un punto inicial hasta un destino situado a cierta distancia, para luego regresar al punto de partida. Vamos a aprender a calcular distancias, para lo cual aplicamos la fórmula general de la velocidad:

Tiempo = distancia / velocidad

Distancia = velocidad x tiempo

Lo que traducido al funcionamiento de nuestro robot sería:

Tiempo de movimiento del servo = distancia recorrida / velocidad del robot

Para poder aplicar esta sencilla fórmula debemos calcular en primer lugar la velocidad del robot. La forma más fácil de hacerlo es poner una regla a su lado y ver qué distancia recorre en un tiempo dado (un segundo por ejemplo). Conociendo los centímetros que ha recorrido y el tiempo en segundos empleado en ello, podremos determinar la velocidad del robot en centímetros por segundo. Emplearemos para ello el siguiente programa:

‘ Programa de movimiento. Avanceunsegundo.bs2
‘ El robot avanza hacia delante durante un segundo
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
Counter VAR Word
FREQOUT 4, 2000, 3000 ‘señal de inicio/reset
FOR counter = 1 TO 41 ‘marcha hacia delante durante 1s
PULSOUT 13, 650
PULSOUT 12, 800
PAUSE 20
NEXT
END

Este programa controla el movimiento del robot durante un segundo por lo que si ha recorrido 23 cm durante su ejecución, la velocidad será de 23 cm/s (es conveniente recordar que en un paso anterior aprendimos que los servos tardan 24,6 milisegundos (0,0246 segundos) en completar un ciclo de ejecución del bucle FOR … NEXT, por lo que el microcontrolador envía 40,65 pulsos cada segundo a los servos (1/0,0246 pulsos por segundo).

Una vez aclarado este concepto, podemos hacer que el robot se desplace en cualquier dirección una distancia concreta. Por ejemplo, sabiendo la velocidad que alcanza, podemos calcular el tiempo que necesitaría el robot para recorrer una distancia de 51 centímetros:

Tiempo = 51 cm / 23 cm/s = 2,22 s

Cuando tenemos este dato, basta calcular los pulsos que han de enviarse a los servos para que el robot recorra esa distancia, teniendo en cuenta que para que el robot se mueva durante un segundo son necesarios 40,65 pulsos:

Pulsos = 2,22 s x 40,65 pulsos/s = 90,24 pulsos = 90 pulsos

90 es el valor que tendremos que usar en el argumento EndValue del bucle FOR … NEXT

En cualquier caso tenemos que tener presente que estas mediciones no son completamente exactas. No hemos tenido en cuenta, por ejemplo, que el robot necesita un determinado número de pulsos para alcanzar la máxima velocidad, ni tampoco la distancia que recorre hasta que se detiene por completo o el hecho de que los servos girarán más despacio cuando las baterías pierdan potencia.

Maniobras de aceleración y desaceleración

Lo que pretendemos es que el robot acelere y desacelere de forma gradual. De esta forma conseguiremos que los servos y las baterías duren más y que el arranque y la parada no sean tan bruscos.

La clave para acelerar es ajustar el parámetro Duración del comando PULSOUT. Gracias al bucle FOR … NEXT podemos hacer que el robot acelere:

PulseCount VAR Word

FOR pulseCount = 1 TO 100

PULSOUT 13, 750 – pulseCount

PULSOUT 12, 750 + pulseCount

PAUSE 20

Cada vez que se ejecuta el bucle FOR … NEXT la variable pulseCount se incrementa en 1. A medida que el valor de pulseCount es mayor, la velocidad de los servos también. La primera vez que se ejecuta el bucle, la variable pulseCount vale 1, que es lo mismo que usar los comandos PULSOUT 13, 749 y PULSOUT 12, 751. La segunda vez, la variable valdrá 2, y así, a la centésima vez que hemos ejecutaado el bucle, la variable pulseCount valdrá 100 que es lo mismo que usar los comandos PULSOUT 13, 650 y PULSOUT 12, 850 (máxima velocidad hacia delante)

Si por el contrario hacemos que el bucle FOR … NEXT reduzca la variable pulseCount, el robot desacelerará hasta pararse. Hagamos las pruebas:

‘ Programa de movimiento. Arranqueyparo.bs2
‘ El robot acelera y luego decelera hasta pararse
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
pulseCount VAR Word ‘contador del bucle FOR … NEXT
FREQOUT 4, 2000, 3000 ‘señal de inicio/reset
‘aceleración gradual
FOR pulseCount = 1 TO 100 ‘bucle aceleración de 100 pulsos
PULSOUT 13, 750 – pulseCount
PULSOUT 12, 747 + pulseCount
PAUSE 20
NEXT
‘avance constante de 75 pulsos
FOR pulseCount = 1 TO 75
PULSOUT 13, 650
PULSOUT 12, 800
PAUSE 20
NEXT
‘desaceleración hasta detenerse
FOR pulseCount = 100 TO 1 ‘bucle desaceleración de 100 pulsos
PULSOUT 13, 750 – pulseCount
PULSOUT 12, 747 + pulseCount
PAUSE 20
NEXT
END

Facilitar los movimientos con subrutinas

En los siguientes pasos de la construcción del robot vamos a programarlo para que sea capaz de realizar maniobras con el fin de evitar obstáculos. Una de las formas más eficientes de hacerlo es realizando maniobras pre-programadas mediante el empleo de subrutinas. Ahora vamos a aprender a crear y utilizar esta herramienta.

Una subrutina es una secuencia de instrucciones que se repite en diversas ocasiones a lo largo del programa principal. Para no tener que reescribirla e insertarla cada vez que se necesite, lo que hacemos es ponerla como un programa independiente al que se “llama” cada vez que sea preciso.

Hay dos partes dentro de una subrutina en PBASIC. La primera es la “llamada a la subrutina”, es decir, la instrucción que hace que una vez que el programa llegue allí, se ejecute la parte de código que se contiene dentro de la subrutina. La otra parte es la propia subrutina en sí, la parte reutilizable del código. La subrutina comienza cuando se referencia con GOSUB su nombre (también llamado etiqueta) y finaliza con el comando RETURN, que devuelve el control a la siguiente instrucción después de GOSUB. El código que hay entre la etiqueta del nombre de la subrutina y RETURN es lo que se ejecutará en cada llamada a esa subrutina:

DEBUG “Antes de la subrutina”, CR

PAUSE 1000

GOSUB Mi_subrutina

DEBUG “Después de la subrutina”, CR

PAUSE 1000

LOOP

Mi_subrutina:

DEBUG “Subrutina en ejecución”, CR

PAUSE 1000

RETURN

Este trozo de código nos muestra una llamada a una subrutina y la propia subrutina. Como hemos dicho, la llamada a la subrutina se realiza con el comando GOSUB y el nombre de la subrutina, en nuestro caso “Mi_subrutina” (ojo con los espacios en blanco). Una vez se inicia la subrutina se ejecuta línea a línea hasta encontrar el comando RETURN que obliga a salir de la subrutina y continuar ejecutando el programa en el punto en que se dejó.

Vamos a usar esta herramienta para manejar los movimientos del robot:

‘ Programa de movimiento con subrutinas. Movimientoconsubrutina.bs2
‘ El robot realiza los movimientos básicos mediante subrutinas
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
Counter VAR Word
FREQOUT 4, 2000, 3000 ‘señal de inicio/reset
GOSUB Delante
GOSUB Izquierda
GOSUB Derecha
GOSUB Atras
END
‘movimiento hacia delante
Delante:
FOR counter = 1 TO 64
PULSOUT 13, 650
PULSOUT 12, 800
PAUSE 20
NEXT
PAUSE 200
RETURN
‘giro a la izquierda
Izquierda:
FOR counter = 1 TO 24
PULSOUT 13, 650
PULSOUT 12, 650
PAUSE 20
NEXT
PAUSE 200
RETURN
‘giro a la derecha
Derecha:
FOR counter = 1 TO 24
PULSOUT 13, 850
PULSOUT 12, 850
PAUSE 20
NEXT
PAUSE 200
RETURN
‘movimiento hacia atrás
Atras:
FOR counter = 1 TO 64
PULSOUT 13, 840
PULSOUT 12, 650
PAUSE 20
NEXT
RETURN

Feb

2014

Pasos 5.1, 5.2 y 5.3 Diversas comprobaciones

Última actualizacón: 15 noviembre 2017 a las 22:55

En este nuevo paso de la construcción del robot, vamos a comprobar que las conexiones eléctricas entre la tarjeta y los servos son correctas. Es preciso que nos aseguremos de que el servo de la derecha gira cuando recibe señales procedentes de P13 y que el servo de la izquierda hace lo propio cuando recibe señales de P12 según el montaje realizado en el paso anterior.

En la siguiente imagen vemos nuestro robot con las indicaciones de posición que se seguirán de ahora en adelante para evitar confusiones:

5.1 Comprobando el funcionamiento de las ruedas

Vamos a ejecutar un sencillo programa para probar el servo conectado a la rueda derecha. Hará que la rueda gire en la dirección de las agujas del reloj durante 3 segundos, parará durante un segundo y, después, girará en sentido contrario durante otros 3 segundos.

‘ Programa de prueba de servos. Pruebaservoderecho.bs2
‘ El servo derecho gira en sentido horario 3s, se para 1s
‘ y vuelve a girar 3s en sentido antihorario
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
Counter VAR Word
FREQOUT 4, 2000, 3000 ‘señal de inicio/reset
FOR counter = 1 TO 122 ‘giro horario durante 3s
PULSOUT 13, 650
PAUSE 20
NEXT
FOR counter = 1 TO 40 ‘parada 1s
PULSOUT 13, 750
PAUSE 20
NEXT
FOR counter = 1 TO 122 ‘giro antihorario durante 3s
PULSOUT 13, 850
PAUSE 20
NEXT
END

Para ponerlo en marcha, cargaremos el programa en el editor de Basic Stamp y lo introduciremos en la tarjeta del robot como hemos visto en pasos anteriores. Acto seguido colocamos el interruptor de energía en la posición 2 (que alimenta los servos) y ejecutamos el programa.

Los mismos pasos daremos con el servo de la rueda izquierda:

‘ Programa de prueba de servos. Pruebaservoderecho.bs2
‘ El servo derecho gira en sentido horario 3s, se para 1s
‘ y vuelve a girar 3s en sentido antihorario
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
Counter VAR Word
FREQOUT 4, 2000, 3000 ‘señal de inicio/reset
FOR counter = 1 TO 122 ‘giro horario durante 3s
PULSOUT 12, 650
PAUSE 20
NEXT
FOR counter = 1 TO 40 ‘parada 1s
PULSOUT 12, 750
PAUSE 20
NEXT
FOR counter = 1 TO 122 ‘giro antihorario durante 3s
PULSOUT 12, 850
PAUSE 20
NEXT
END

Vemos cómo la única diferencia entre estos dos programas es que hemos sustituido el punto de enganche del servo derecho (P13) por el servo izquierdo (P12) en el segundo programa.

Ahora vamos a comprobar como el robot se mueve según las indicaciones de la programación: la rueda derecha girará en sentido horario durante tres segundos, se detendrá un segundo, y volverá a girar en sentido antihorario otros 3 segundos (lo mismo sucederá con la rueda izquierda).

5.2 Detector acústico de baja tensión y reinicio

Cuando el suministro de voltaje eléctrico cae por debajo del nivel que el dispositivo necesita para funcionar correctamente se produce un apagón parcial. La tarjeta se protege a sí misma de esta situación haciendo que el procesador y los microchips de memoria permanezcan en estado de reposo hasta que el suministro de energía vuelva a niveles normales.

Una bajada de tensión en Vin por debajo de 5,2 V provoca un voltaje inferior a 4,3 V en el regulador interno de la tarjeta, valor insuficiente que origina una anomalía y que provoca, como hemos señalado, que se ponga en marcha un mecanismo de autoprotección del sistema en el que tanto el procesador como la memoria pasan a un estado de reposo que detiene la ejecución de instrucciones. Cuando el voltaje vuelve a niveles adecuados, la tarjeta se pone en funcionamiento de nuevo pero no donde había quedado ejecutándose el programa, sino desde el principio del mismo. Es lo mismo que sucede cuando pulsamos el botón de reinicio del sistema.

Cuando las baterías están bajas, es posible que estas bajadas de tensión hagan reiniciarse al robot cuando menos lo esperamos, haciendo que tome direcciones erróneas, dé vueltas sobre sí mismo etc.

Esto hace que un programa que indique la posibilidad de reinicio del robot sea muy útil (de esta forma sabemos claramente cuál ha sido la causa del funcionamiento incorrecto de nuestro robot). Una forma para avisar de un posible reinicio es incluir una señal inconfundible al comienzo de todos los programas del robot. La señal se produce cada vez que se conecta el suministro de energía y cuando se produce un reinicio debido a una bajada de tensión.

En este ejercicio vamos a colocar un dispositivo llamado zumbador piezoeléctrico que se puede usar para generar diferentes tonos en función de la frecuencia de las señales que se envíen desde la tarjeta.

El programa que vamos a cargar a continuación produce un pitido a través del zumbador. Utiliza el comando FREQOUT para enviar las señales de la frecuencia que se deseemos por una patita de la tarjeta. Su sintaxis es como sigue:

FREQOUT Pin, duración, frecuencia1, {Frecuencia2

Un ejemplo sería FREQOUT 4, 2000, 3000: envía una señal de 3000 hercios (3 kHz) durante 2000 ms (2 segundos) por el pin 4.

En este punto debemos tener presente que la frecuencia es una magnitud que mide el número de repeticiones por unidad de tiempo de cualquier fenómeno o suceso periódico. Nuestro zumbador funciona gracias a la piezoelectricidad: es un fenómeno presentado por determinados cristales que al ser sometidos a tensiones mecánicas adquieren una polarización eléctrica en su masa, apareciendo una diferencia de potencial y cargas eléctricas en su superficie. Este fenómeno también se presenta a la inversa, esto es, se deforman bajo la acción de fuerzas internas al ser sometidos a un campo eléctrico. El efecto piezoeléctrico es normalmente reversible: al dejar de someter los cristales a un voltaje exterior o campo eléctrico, recuperan su forma.

De esta forma, cuando aplicamos cambios de voltaje a gran velocidad hacemos que el cristal piezoeléctrico cambie de forma rápidamente. Esto provoca una vibración. Los objetos que vibran hacen que el aire que los rodea vibre también, y esta vibración es lo que nuestros oídos detectan como sonido y tonos.

La frecuencia se mide en hercios (Hz). Un hercio representa un ciclo por cada segundo, entendiendo ciclo como la repetición de un suceso. De esta forma, un kHz representa mil ciclos por segundo.

Más abajo se muestra el símbolo del zumbador y el esquema de conexión del terminal positivo del zumbador a la patita P4 de E/S.

Para el montaje tomamos el zumbador y lo colocamos sobre la tarjeta. Vemos que una pegatina indica cuál de las dos patas es de signo positivo así que solo tenemos que presionar y listo. Para dejar más espacio para el resto de componentes, y dado que este elemento quedará fijo de forma permanente, es mejor colocarlo lo más esquinado posible.

Una vez colocado, sólo tenemos que realizar la conexión de los cables, uno conectando el polo positivo del zumbador a P4 (cable azul) y el otro al conector de energía (Vss)

Programa ejemplo

El siguiente programa emite un pitido del zumbador al iniciarse su ejecución y luego envía mensajes visualizadores de DEBUG cada medio segundo dentro de un bucle infinito. Se puede simular una bajada de tensión presionando el botón de reinicio o bien desconectando la batería del robot; entonces el programa se reiniciará, emitiendo un pitido de nuevo. Cada vez que se produce un pitido sabemos que el programa se ha iniciado desde el principio.

‘ Programa de reinicio. Indicadorinicioreinicio.bs2
‘ Prueba del altavoz piezoeléctrico.
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
DEBUG CLS, “Beep!!!” ‘visualiza el mensaje mientras suena
FREQOUT 4, 2000, 3000 ‘señal sonora
DO ‘bucle DO…LOOP
DEBUG CR, “Esperando el reinicio” ‘visualiza el mensaje
PAUSE 5000 ‘cada medio Segundo
LOOP ‘hasta que se reinicie el sistema

El programa comienza mostrando el mensaje (en la pantalla del ordenador) “Beep!!!” cuando se inicia su ejecución. Inmediatamente envía una señal de 3 kHz al zumbador durante 2 segundos. Como la tarjeta ejecuta muy rápidamente las instrucciones dará la sensación de que el mensaje se muestra al mismo tiempo que el zumbador comienza a pitar.

Cuando cesa el pitido, el programa entra en un bucle infinito mostrando una y otra vez el mensaje “Esperando el reinicio”. Cada vez que se produzca un reinicio, bien porque se aprieta el botón o porque se desconectan las baterías o pierden tensión, el programa se reiniciará.

De ahora en adelante vamos a usar este programa cada vez que escribamos otro. Lo consideraremos parte de la rutina de inicialización de cada programa.

5.3 Probando el control de velocidad del robot

En este paso de comprobación vamos a dibujar las curvas que relacionan la velocidad de giro de los servos con la amplitud de los pulsos que se aplican desde la tarjeta Home Work. Este gráfico nos resultará muy útil ya que cuando queramos obtener una velocidad concreta de las ruedas del robot sólo tendremos que consultar éste para saber la amplitud del pulso que se debe aplicar a cada una. Para ello vamos a utilizar el panel de transmisión del terminal DEBUG del programa de edición para enviar valores al programa de ejecución de la tarjeta.

Empleo del comando DEBUGIN

Ya hemos visto en anteriores ocasiones que gracias al comando DEBUG se visualizan los mensajes en la pantalla del ordenador que manda la tarjeta al ejecutar un programa determinado. El terminal DEBUG del programa de edición Basic Stamp también tiene una ventana de transmisión que nos permite enviar información al microcontrolador mientras se está ejecutando un programa. Esto lo hacemos a través del comando DEBUGIN, que toma el valor que introducimos con el teclado y lo envía al programa que está ejecutando la tarjeta para que una o más variables queden fijadas por dicho valor. Es decir, con este comando se introducen valores de variables que se usan en los programas de la tarjeta Home Work.

En el siguiente programa de ejemplo, utilizaremos la variable pulseWidth (amplitud de pulso) para almacenar los valores que el comando DEBUGIN recibe. Evidentemente, tendremos que declarar previamente esta variable al programa

pulseWidth VAR Word

Ahora, el comando DEBUGIN captura los valores decimales que introducimos con el teclado a través del panel de transmisión y los almacena en la variable pulseWidth:

DEBUGIN DEC pulseWidth

De esta forma podemos programar el microcontrolador para que use este valor. En el siguiente ejemplo se utiliza la variable pulseWidth como el argumento Duración del comando PULSOUT:

PULSOUT 12, pulseWidth

Programa ejemplo

Este programa nos va a permitir establecer el argumento Duración del comando PULSOUT introduciéndolo a través del panel de transmisión del terminal DEBUG del programa de edición.

‘ Programa de control de velocidad. Pruebavelocidadservo.bs2
‘ Introducir la amplitud del pulso y contar el número de vueltas
‘ que gira la rueda durante 6 segundos. Multiplicando por 10
‘ este valor conocemos las revoluciones por minuto (RPM)
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
counter VAR Word
pulseWidth VAR Word
pulseWidthComp VAR Word
FREQOUT 4, 2000, 3000 ‘ señal de inicio/reinicio
DO
DEBUG “Indicar la amplitud del pulso:”
DEBUGIN DEC pulseWidth
pulseWidthComp = 1500 – pulseWidth
FOR counter = 1 TO 244
PULSOUT 12, pulseWidth
PULSOUT 13, pulseWidthComp
PAUSE 20
NEXT
LOOP

Nota importante: cuando en un programa se definen variables, tanto el tipo como la dirección hay que colocarlas alineadas para su correcta ejecución.

Pasos a seguir

Haremos una pequeña marca en la rueda del robot para tener un punto de referencia.
Colocamos el interruptor de encendido del robot en la posición “2” (que envía energía a los servos).
Ejecutar el programa Pruebavelocidadservo.bs2
Introducir el valor 650 en el panel de transmisión del terminal DEBUG y pulsar ENTER
Contar las vueltas que da la rueda izquierda (el servo habrá girado durante 6 segundos en el sentido de las agujas del reloj, por lo que si multiplicamos el número de vueltas por 10 obtendremos el número de RPM).
Escribimos el valor en la tabla que reproducimos más abajo junto a la celda de 1300 ms.
Introducir el valor 655.
Contar las vueltas que da la rueda.
Multiplicar el valor por 10 y escribirlo junto al valor 1310 ms de la tabla.
Ir incrementando los valores de 5 en 5 (0,01 ms) hasta llegar a 850 (1700 ms).
Repetir el proceso para el otro servo (para ello tendremos que modificar el comando PULSOUT del programa de forma que los pulsos se envíen a P12).

¿Cómo trabaja el programa?

Se declaran tres variables: counter para el bucle FOR…NEXT, pulseWidth para los comandos DEBUGIN y PULSOUT, y pulseWidthComp, que almacena un valor que se usa en un segundo comando PULSOUT.

counter VAR Word

pulseWidth VAR Word

pulseWidthComp VAR Word

El commando FREQOUT (como vimos en el paso 5.2) lo utilizamos para indicar mediante un pitido del zumbador que el programa se ha iniciado.

El resto del programa se incluye dentro del bucle DO…LOOP lo que indica que se ejecutará una y otra vez. El programa le pide al operador del terminal DEBUG (nosotros) que introduzcamos un valor decimal que determinará la duración del pulso que se va a guardar en la variable pulseWidth. Para lograr una medición del tiempo más exacta se envían dos comandos PULSOUT cuyos argumentos Duración sumarán 1500 entre los dos

pulseWidthComp = 1500 – pulseWidth

Así se consigue que el bucle FOR…NEXT tarde siempre el mismo tiempo en ejecutarse independientemente del valor del argumento Duración que hayamos introducido y, por tanto, que las mediciones de las RPM que hagamos sean más exactas. Este bucle FOR…NEXT envía pulsos al servo izquierdo (P12) durante 6 segundos. El valor de la variable pulseWidthComp se envía al servo derecho (P13), haciendo que gire en la dirección contraria.

En el paso 4 vimos cómo se calculaba el tiempo: recordemos que el argumento Duración del comando PULSOUT se expresa en unidades de 2 millonésimas de segundo por lo que un valor de 650 envía pulsos de 1,3 ms de duración (a lo que es lo mismo 1300 ms).

Con los datos que vayamos obtenido vamos a completar la siguiente tabla para obtener nuestra propia curva de transferencia (debemos tener en cuenta que nuestro programa de ejemplo controla la rueda izquierda con los valores que introducimos. La rueda derecha gira en dirección contraria).

Una vez completada la tabla para la rueda izquierda, debemos modificar el comando PULSOUT para enviar el pulso a la rueda derecha, cambiando los parámetros como se indica

PULSOUT 13, pulseWidth

PULSOUT 12, pulseWidthComp

realizando a continuación las mismas mediciones.

Debemos tener en cuenta que los valores positivos de RPM se dan cuando la rueda gira en el sentido de las agujas del reloj, mientras que los valores negativos indican un giro de las ruedas en sentido antihorario. Recordar igualmente que, dada la disposición de los servos, para que el robot ande hacia adelante la rueda derecha tendrá que girar en sentido de las agujas del reloj, mientras que la izquierda en sentido antihorario.

Dic

2013

Siete días … 25 de noviembre a 1 de diciembre (Stonehenge)

Última actualizacón: 27 octubre 2017 a las 13:49

BIOQUÍMICA

Un grupo internacional de investigadores consigue descifrar desde cero la estructura de una proteína y prueba las posibilidades de una tecnología para conocer las piezas que componen el rompecabezas de la vida.

Un grupo internacional de investigadores ha logrado por primera vez generar con láseres de rayos X un modelo 3D de la lisozima, una proteína que abunda en la clara del huevo, sin tener conocimiento previo de su estructura. Eso ha sido posible gracias al láser de rayos X LCLS del Laboratorio Nacional de Aceleradores SLAC y a un sistema de análisis de datos por ordenador que ha dado sentido a la información obtenida con el láser.

Esta tecnología puede superar algunas de las limitaciones de la cristalografía de rayos X tradicional. Normalmente, los rayos X, cuando se proyectan sobre los compuestos orgánicos que se pretende estudiar, pueden descolocar los átomos y sacarlos de su posición natural dentro de la estructura de la molécula. Además, para conocer esa estructura es necesario exponer a las moléculas que se quieren analizar a dosis importantes de radiación que dañan la información que contienen. Este problema se puede resolver en moléculas que forman grandes cristales bien ordenados, pero ese no es el caso de la mayor parte de las moléculas orgánicas. El sistema de cristalografía de láseres de rayos X somete a las estructuras que quiere estudiar a intensos bombardeos de rayos X, pero en un periodo extremadamente breve, del orden de los femtosegundos (en un segundo hay mil billones de femtosegundos). De esta manera, es posible obtener la información necesaria para reconstruir la estructura natural de la molécula antes de destruirla.

Los autores del artículo quieren pulir su técnica para poder estudiar proteínas aún más complejas, como las proteínas de la membrana que cubre las células, que son la diana a la que van dirigidos más de la mitad de los nuevos fármacos en desarrollo. Hasta ahora, solo se conoce en detalle la estructura de unas pocas de esas proteínas de membrana y el diseño de los medicamentos que funcionan porque se vinculan a ellas podría ser mucho más preciso, mejorando un sistema que tiene mucho de ensayo y error.

• Noticia Materia

• Artículo: De novo protein crystal structure determination from X-ray free-electron laser data

GENÉTICA

Exigen la retirada del estudio que vinculaba transgénicos con tumores.

Ratas alimentadas con maíz transgénico que desarrollaban en una proporción alarmante unos tumores del tamaño de una pelota de ping-pong. El estudio que el año pasado publicó la revista Food and Chemical Toxicology parecía mostrar el vínculo entre los alimentos modificados genéticamente y el cáncer. De hecho, se trataba, aparentemente, de la primera prueba científica de esta relación. El artículo, firmado por el biólogo molecular Gilles-Eric Séralini, fue recibido con escepticismo por la comunidad científica desde el primer día. Ahora, un año después, el director de la revista ha hecho pública una carta dirigida a Séralini en la que le pide que se retracte del artículo. Si no lo hace, le dice, será la publicación la que lo retire.

El editor jefe de la revista, A. Wallace Hayes, explica que un comité de expertos lleva meses revisando los datos proporcionados por los investigadores después de haber recibido cartas al editor posteriores a la publicación del artículo. «El comité expresó muchas dudas sobre la calidad de los datos y finalmente recomendó la retirada del artículo. He intentado contactar con usted para hablar de las razones de esta recomendación. Si no está de acuerdo con retractarse del artículo, este será retirado», le dice a Séralini.

El equipo de la Universidad de Caen, liderado por Séralini, investigó durante dos años a 200 ratas de laboratorio a las que dividió en tres grupos: las que alimentaron con el maíz transgénico NK603 (producido por Monsanto) en distintas proporciones (11%, 22% y 33% de su dieta); aquellas a las que además le suministraron Roundup, el herbicida al que la modificación genética las hace resistentes; y los roedores que crecieron tan solo con maíz no transgénico. Resultó que, pasados 17 meses desde el comienzo del estudio, habían muerto cinco veces más animales masculinos alimentados con el maíz modificado genéticamente.

“Por primera vez en el mundo, se ha evaluado un transgénico y un pesticida por su impacto en la salud de una forma más amplia que la realizada hasta ahora por los Gobiernos y la industria. Los resultados son alarmantes”, declaró entonces Séralini. Pero otros científicos enseguida pusieron en tela de juicio dos cuestiones: el reducido número de animales estudiados y la elección de un tipo de rata, llamado Dawley, que es muy sensible a las mutaciones y a los tumores.

• Noticia El País

NEUROCIENCIA

Investigadores del Centro de Regulación Genómica (CRG) de Barcelona han hallado un gen responsable de la susceptibilidad a padecer un trastorno de pánico, una patología que afecta a un 5 % de la población y que se encuentra incluida entre las enfermedades relacionadas con la ansiedad.

Cinco de cada cien personas en España sufren un trastorno de pánico, una enfermedad incluida dentro de los trastornos de la ansiedad, y padecen ataques de miedo frecuentes y repentinos que pueden acabar influyendo en su vida cotidiana y, en ocasiones, incluso incapacitarlas para realizar acciones cotidianas, han señalado fuentes del CRG.

Aunque se sabía que esta enfermedad tenía una base neurobiológica y genética y se intentaban hallar los genes implicados en el desarrollo de la enfermedad, hasta ahora no se conocía la contribución fisiopatológica de los genes.

Esta investigación ha descrito por primer vez que el gen ‘ntrk3′, responsable de codificar una proteína esencial para la formación del cerebro, es un factor para desarrollar el pánico.

“Hemos visto que la desregulación de ‘ntrk3′ produce cambios en el desarrollo cerebral que conllevan que la memoria relacionada con el miedo no funcione correctamente”, ha explicado la investigadora Mara Dierssen, líder del grupo de Neurobiología celular y de sistemas del CRG.

• Noticia EFE

• Artículo: Hippocampal hyperexcitability underlies enhanced fear memories in TgNTRK3, a panic disorder mouse model

CIENCIAS PLANETARIAS

Un equipo de astrofísicos del Centro Aeroespacial Alemán (DLR) ha descubierto a 2.500 años luz de la Tierra el sistema planetario más extenso hasta la fecha, con la excepción del nuestro propio. Siete planetas giran alrededor de la estrella KOI-351, dispuestos en una manera similar a los ocho mundos del Sistema Solar, con pequeños planetas rocosos cerca de la estrella madre y los gaseosos gigantes a distancias mayores. Estos mundos se mueven más cerca unos de otros que los de nuestro hogar cósmico, pero proporcionan una interesante comparación, afirman sus descubridores.

«Ningún otro sistema planetario muestra una “arquitectura” tan similar a la de nuestra casa cósmica como lo hace el sistema planetario alrededor de KOI -351», dice Cabrera, uno de los investigadores.

• Artículo: The planetary system to KIC 11442793: A compact analogue to the Solar System (descarga directa en formato PDF)

INGENIERÍA

Hasta ahora tenían forma de avión de juguete caro, pero no es extraño que dentro de poco aparezcan con forma de pájaros, insectos…o de medusas. La revista “The American Physical Society” ha publicado un estudio de la Universidad de Nueva York sobre el diseño de un robot aéreo inspirado en el mecanismo de locomoción de este animal marino.

Este prototipo pesa tan sólo dos gramos y tiene únicamente ocho centímetros de envergadura. Vuela con cuatro alas, que asemejan los tentáculos de las medusas o los pétalos de una flor. De momento, es capaz de mantenerse suspendido en el aire, de ascender y de volar hacia una dirección concreta.

Su sistema de locomoción se basa en una fuente de energía externa a la que está unida, pero con la que no puede ni volar automáticamente ni a través de control remoto. Para sus creadores, estas limitaciones no son importantes porque su objetivo era ser capaz de reducir el tamaño de los robots aéreos de modo que puedan infiltrarse fácilmente sin ser detectados. «Cuanto más sencillo, mejor. Y nuestro modelo es uno de los más sencillos, puesto que sólo utiliza alas desplegables», explica Leif Ristroph, uno de los componentes del grupo de investigación.

Otro aspecto del que sus autores se muestran especialmente satisfechos es que han conseguido que el aparato sea estable. «Para mantenerse y maniobrar, una mosca debe estar constantemente controlando su ambiente, ajustando sus movimientos en fracciones de segundo», continúa Ristroph. Es este complejo mecanismo de vuelo el que dificulta recrear un robot-insecto y uno de los motivos por los que Ristroph y su equipo cambiaron de ‘musa’.

• Noticia El Mundo

• Artículo: A simple computational model of a jellyfish-like flying machine

ARQUEOLOGÍA

El origen de las piedras de Stonehenge no está donde se creía. Durante casi un siglo los arqueólogos que han trabajado para resolver uno de los misterios que envuelven el anillo de Stonehenge, el origen de las piedras, habrían estado buscando en el lugar incorrecto. Los enormes bloques que se necesitaron para construir el conjunto del Neolítico, uno de los mayores quebraderos de cabeza para los expertos, se habían situado hasta ahora en las Colinas Preseli en Pembrokshire.

Sin embargo, el responsable de Geología del Museo Nacional de Gales, Richard Bevins, ha llevado a cabo un estudio geoquímico comparativo de las piedras de Stonehenge y de las que hay en el supuesto lugar de su origen, Carn Meini, en Preseli cuyo resultado evidencia que tienen perfiles distintos.

Bevins y su equipo han utilizado muestras del célebre anillo del Neolítico, uno de los monumentos más emblemáticos de la humanidad, envuelto en todo tipo de cábalas y teorías y han concluido que en realidad las piedras se corresponden con una cantera situada en las mismas colinas Preseli, pero en Carn Goedog, a casi dos kilómetros de distancia.

Preseli, y concretamente Carn Meini, fue el lugar identificado en 1923 por el renombrado geólogo Herbert Henry Thomas que estableció que el tipo de piedra conocido como “Bluestone” fue el utilizado por los habitantes prehistóricos de Gran Bretaña para erigir Stonehenge. Desde entonces, numerosos equipos de arqueólogos y geólogos han trabajado en lugar con el objetivo de averiguar más datos sobre el mítico conjunto.

Las revelaciones de Richard Bevins siguen sin responder el verdadero enigma de las piedras de Stonehenge, la forma en la que fueron trasportadas desde Preseli, ya fuera Carn Meini o Carn Goedog, como apunta el nuevo estudio, ya que ambas se encuentran a una distancia de más de 300 km de Wiltshire, cerca de Salisbury, en el corazón del Sur de Inglaterra, donde se erige desde hace unos 4.500 años Stonehenge.

• Noticia La Aventura de la Historia

• Artículo: Carn Alw as a source of the rhyolitic component of the Stonehenge bluestones: a critical re-appraisal of the petrographical account of H.H. Thomas

PSICOLOGÍA

Los sentimientos automáticos, viscerales y más bien inconscientes que tenemos hacia nuestras nuevas parejas tienden a ser acertados, según se puede comprobar en la vida real cuatro años después. De hecho, son siempre más acertados que esos otros sentimientos, los que albergamos con plena consciencia y admitimos abiertamente a la mínima ocasión. Son los resultados de una investigación de psicología experimental que tres universidades estadounidenses han estado haciendo con 135 parejas durante los últimos cuatro años, y lo bastante sólido como para presentarlo en la revista Science.

El responsable de la investigación, el psicólogo James McNulty de la Universidad Estatal de Florida, tal vez sea el primer científico que ha titulado un artículo técnico con un twit: “Aunque lo desconozcan, los recién casados conocen de forma implícita si su matrimonio será grato”. Directo, al punto y claro como el cristal.

Una tradición de la psicología social ha sostenido durante décadas que los procesos automáticos de la mente producen efectos sociales, pero la teoría carecía hasta ahora de soporte empírico y había empezado a ser cuestionada. El experimento de McNulty y sus colegas aporta exactamente esa clase de evidencia que se echaba de menos.

Los psicólogos han estudiado a 135 parejas heterosexuales desde que estaban recién casadas hasta cuatro años después, haciéndoles un examen cada seis meses durante ese periodo. Cada vez les han preguntado —por supuesto, a cada miembro de la pareja por separado— sus sentimientos explícitos sobre el cónyuge. Pero también han medido, con los trucos enrevesados típicos de la psicología experimental, sus sensaciones viscerales sobre su pareja, la clase de sentimiento que no se revela filtrada ni metabolizada por la razón, sino que surge virgen y brutal de las capas más oscuras de nuestro cerebro profundo o reptiliano.

• Noticia El País

• Artículo: Though they may be unaware, newlyweds implicitly know whether their marriage will be satisfying

PUBLICACIONES CIENTÍFICAS

Una investigación del departamento de prensa de Science revela un mercado negro en auge de las publicaciones científicas en China, donde los investigadores están dispuestos a pagar decenas de miles de yuanes para que añadan sus nombres al trabajo de otra persona. Añadir dos nombres costaría unos 26.300 dólares.

Mara Hvistendahl, editora colaboradora de Science, publica un artículo en la última edición de la revista sobre la investigación a 27 empresas chinas para comprobar si venden la autoría de los artículos científicos al mejor postor. Según la autora del texto, esta práctica “sin escrúpulos” ha ido en aumento.

“Muchos artículos de revistas científicas chinas los venden las empresas, de acuerdo con los editores. Así que los investigadores que ponen sus nombres a los documentos no son necesariamente las personas que lo escribieron”, declara a SINC Hvistendahl.

Para llevar a cabo esta investigación encubierta que duró cinco meses, el personal del departamento de prensa de Science se hizo pasar por estudiantes de posgrado y científicos que querían comprar la autoría de un artículo o pagar a la empresa por escribir un estudio para ellos.

Solo cinco de las 27 empresas contactadas declararon que se negarían a hacer una de estas prácticas.

“El científico encubierto accedía a los teléfonos que aparecen en sus webs y a las ventanas de chats que se abren en sus páginas para contactar. Este es uno de los muchos ejemplos: http://sciedit.cn/”, indica Hvistendahl.

La investigación recalca que no hay víctimas obvias de esta práctica ilegítima ya que tanto los científicos como las empresas y las editoras se benefician de ella.

• Noticia Agencia SINC

• Artículo: China’s publication bazaar

Nov

2013

Paso 5. El montaje

Última actualizacón: 14 noviembre 2017 a las 16:52

Bien, es hora de ponernos manos a la obra. Tras aprender a programar y hacer las debidas comprobaciones con los componentes esenciales, ha llegado el momento de montar el robot en sí mismo.

Describiremos paso a paso las operaciones necesarias para montar la estructura, las ruedas del robot y hacer las primeras conexiones. Se trata de un trabajo muy sencillo que, en mi caso, no me ha llevado más de una hora (y eso que he ido tomando las fotografías que ilustran cada explicación).

Las herramientas que vamos a emplear son el destornillador que acompaña el kit de montaje, unos alicates de punta y las pinzas de relojero que ya he utilizado con anterioridad.

Montaje del chasis

Para montar el chasis vamos a necesitar los siguientes componentes:

Chasis metálico.
4 tubos metálicos (llamados separadores) de 20 mm.
4 tornillos de 10 mm.
1 goma que recubre el hueco interior por donde pasarán los cables.

Lo primero que haremos será introducir a presión la goma con la que vamos a recubrir el hueco situado en el centro del chasis ya que será por donde pasarán los diferentes cables. Acto seguido atornillaremos los cuatro tubos metálicos que actuarán como separadores entre el chasis en sí mismo y la tarjeta Home Work. Los puntos de fijación están situados en cada esquina:

Ya tenemos la estructura básica. Lo siguiente que haremos será colocar los servos en su lugar (recordemos que actúan como los motores de las ruedas). Para ello, primero debemos retirar las aspas quitando el tornillo central (recomiendo sujetar las aspas mientras se realiza esta operación para evitar forzar el servo). Las aspas salen fácilmente aplicando una leve presión. Una vez hecho lo anterior, guardaremos los dos tornillos porque serán necesarios más adelante.

Montaje de los servos en el chasis

Para montar los servos necesitaremos los siguientes elementos:

8 tornillos de 6 mm.
8 tuercas.

De nuevo la operación es muy sencilla. Elegiremos uno de los laterales del chasis e insertaremos el servo correspondiente como se muestra en la imagen inferior, de forma que el rotor sobresalga por el exterior (aquí irá montada la rueda). Acto seguido atornillaremos cada uno de los cuatro tornillos en su lugar junto con sus tuercas correspondientes:

Haremos lo mismo en el otro lateral:

Vemos como en este caso el potenciómetro queda «mirando» al interior del chasis con un acceso bastante difícil debido a la posición del portapilas (como nosotros hemos centrado los servos con anterioridad no resulta relevante). Sin embargo, esto se hace así porque el robot gana en maniobrabilidad. En cualquier caso, no hay problema en situar el potenciómetro hacia afuera aunque habría que hacer unos pequeños ajustes en la programación para corregir esta ubicación.

Una vez montados ambos servos, procederemos a introducir los cables por el hueco interior donde antes pusimos la goma protectora:

Instalación del portapilas

Como ya hemos explicado, el robot utiliza cuatro baterías para el movimiento de los servos, que constituyen la mayor parte de su peso y va situado detrás de los dos servos. Este elemento de plástico ya cuenta con dos orificios donde se introducirán los tornillos. Para su sujeción necesitamos los siguientes elementos:

2 tornillos de 10 mm. con la cabeza plana.
2 tuercas.

De nuevo el montaje es muy sencillo. Colocamos el portapilas, introducimos los dos tornillos y los sujetamos con las tuercas. Es importante colocarlo de forma que el cable quede lo más cerca posible del hueco central para evitar enredos:

Una vez colocados los servos y el portapilas, e introducidos los cables por el hueco central, esta es la vista de la parte superior del chasis:

Como detalle decir que he colocado dos etiquetas de colores para diferenciar el servo izquierdo y el derecho ya que será necesario tener claro cuál es cuál a la hora de hacer la conexión en la tarjeta Home Work y programar el movimiento del robot:

Montaje de las ruedas

Para montar las ruedas vamos a necesitar los siguientes elementos:

2 ruedas de plástico.
2 gomas elásticas (actúan como neumáticos).
1 bola de plástico (es la rueda trasera).
2 tornillos (los que reservamos al retirar las aspas de los servos).
1 chaveta metálica.

Lo primero que vamos a hacer es colocar la rueda trasera. Se trata de una bola de plástico con un agujero que la atraviesa. La chaveta metálica funcionará como un eje y permitirá que el robot tome cualquier dirección con el movimiento de las dos ruedas motrices delanteras.

Para ello, colocaremos la bola entre los dos agujeros en la parte trasera del chasis e introduciremos la chaveta metálica:

Acto seguido doblaremos los dos extremos para impedir que se salga de su lugar (más adelante podremos recortarlos ya que, aunque no impide el libre movimiento de la rueda, resulta algo antiestético).

Antes de posicionar las ruedas en los servos, tenemos que estirar las gomas elásticas y ajustarlas a la superficie exterior de cada rueda:

La colocación de las ruedas delanteras es muy sencilla ya que cada una tiene un hueco que encaja con el eje exterior de los servos. Presionamos levemente y empleamos los tornillos que antes retenían las aspas para sujetar las ruedas. Estas son las imágenes que muestran el robot con todas sus ruedas y el cableado asomando por el agujero central:

El último paso consistirá en montar la tarjeta Home Work de control sobre el chasis. Para ello emplearemos cuatro tornillos de cabeza redonda de 10 mm. y los fijaremos en los tubos metálicos que actúan como separadores:

Podemos darnos cuenta de que los cables tienen una longitud excesiva por lo que es recomendable utilizar una presilla o cualquier otro medio de recogerlos entre el chasis y la parte inferior de la tarjeta, dejando solo el tramo necesario para realizar las conexiones. Esto evitará que sobresalgan y se enreden con las ruedas:

Acto seguido conectamos el cable del portapilas en su lugar:

Y por último, conectamos los cables de los servos a los conectores adecuados de la tarjeta Home Work como hemos hecho en los pasos anteriores a este montaje:

Muy bien, ya tenemos listo nuestro robot para comenzar a instalar diversos sensores y realizar las pruebas.