# data[].attributes.headline
Mi mbot os desea un feliz año con Jingle bells

# data[].attributes.subject
Mi mbot os desea un feliz año con Jingle bells

# data[].attributes.body
Feliz año!!

# data[].attributes.attachment_link.authors[].name
Susana Oubiña FalcónFollow this publisher

# data[].attributes.attachment_link.title
Divirtiéndome con mBot: Guia de manejo y programacióm (Libro Junio 2016)

# data[].attributes.attachment_link.description
Dentro del Universo Scratch nos encontramos con mBlock, un software fantástico que nos facilita la programación en scratch de una gran cantidad de sensores y actuadores en diferentes placas (placas de makeblock, Picoboard y la serie Arduino), En este libro se muestran ejemplos de programación de mut…

# data[].attributes.attachment_link.title
Sensor sigue-líneas del robot mBot con mBlock

# data[].attributes.attachment_link.description
Programación del sensor sigue-líneas en el robot mBot utilizando Scratch y mblock.

# data[].attributes.attachment_link.readable_text
Introducción

En este tutorial aprenderás a programar el sensor de ultrasonidos o distancia del robot mBot. Para ello se programará sobre el lenguaje de programación por bloques de mBlock.

Sensor de ultrasonidos en mBot

Sensor de ultrasonidos

El sensor de ultrasonidos o distancia son detectores de proximidad que detectan objetos a distancias que van desde pocos centímetros hasta varios metros. El sensor emite un sonido y mide el tiempo que la señal tarda en regresar. Estos reflejan en un objeto, el sensor recibe el eco producido y lo convierte en señales eléctricas, las cuales son elaboradas en el aparato de valoración.

Sensor de ultrasonidos

El funcionamiento del sensor es muy sencillo; se utiliza un emisor para emitir una onda de sonido de alta frecuencia (ultrasonido) y un receptor para escuchar la onda reflejada. En mBlock solamente tenemos que utilizar el bloque que nos devuelve la longitud a la cual se encuentra de un obstáculo. A partir de esa distancia podemos actuar según nuestro objetivo.

mBlock 3

En este apartado se va a programar un sencillo código encargado de detectar un obstáculo y detenerse ante él. Para ello, utilizaremos una condición encargada de comparar el valor obtenido del sensor de ultrasonidos, y en caso de ser mayor que 5 centímetros, parará los motores (izquierdo - M1 y derecho - M2). En caso contrario, los motores funcionarán al máximo permitido en mBlock, que es el valor de 255.

Programación en mBlock 3

mBlock 5 (versión actual)

Para programar el código encargado de detener el robot si estamos a menos de 5 centímetros de un objeto utilizaremos los bloques del apartado de acción de mBlock. Para ello, utilizaremos una condición encargada de comparar el valor obtenido del sensor de ultrasonidos, y en caso de ser mayor que 5 centímetros, parará los motores (izquierdo - M1 y derecho - M2). En caso contrario, los motores funcionarán al 100% de la velocidad máxima de los motores.

Programación en mBlock 5

Retos propuestos

Si ya has completado todas las lecciones del tutorial te proponemos resolver los siguientes retos.

Reto 1: Pelotas de tenis

En este reto de programación con mBot deberás calcular el número de pelotas de tenis que caben en tu habitación utilizando el sensor de ultrasonidos de mBot. Para ello deberás realizar operaciones matemáticas sobre el papel.

Reto 1: Pelotas de tenis

Reto 2: Disminuyendo la velocidad

En este reto de programación con mBot deberás programar el código que haga que el robot mBot se vaya deteniendo a medida que se va acercando a un obstáculo.

Reto 2: Disminuyendo la velocidad

# data[].attributes.attachment_link.title
Sensor ultrasonidos del robot mBot con mBlock

# data[].attributes.attachment_link.description
Programación del sensor de ultrasonidos en el robot mBot utilizando mblock.

# data[].attributes.attachment_link.readable_text
Introducción

En este tutorial aprenderás a programar los Led RGB que encontrarás en la carcasa del robot educativo mBot programándolos mediante el lenguaje de programación por bloques de mBlock.

LEDs RGB del robot educativo mBot

Diodo LED RGB

El led RGB (Red, Green, Blue) es un led que combina estos tres colores para formar más de 16 millones de tonos de luz. De esta forma, dependiendo de la tonalidad pasada como parámetro, podemos emitir un colo de luz u otro. En mBot tenemos por defecto 2 led RGB en la parte superior del robot, no obstante, se puede adquirir por separado un módulo encargado para tal fin.

LEDs RGB del robot mBot

Antes de nada veamos las diferencias entre RGB y CMYK. El codigo RGB es un modelo de colores que tiene su base en los tres colores primarios rojo (Red), verde (Green), y azul (Blue). El acrónimo CMYK indica el modelo de colores cian (Cyan), magenta (Magenta), amarillo (Yellow) y negro (black).

Colores RGB vs CMYK

Los colores del Led RGB vienen representados con números comprendidos entre el valor 0 y el valor 255. De esta forma, para componer el color rojo pondríamos el valor máximo del rojo y el valor mínimo de los otros colores, es decir, el rojo equivale a "R=255; G=0; B=0". Y así sucesivamente con el resto de colores.

Valores en formato RGB

mBlock 3

Para programar el siguiente código debemos tener en cuenta la gama de colores en formato RGB como se acaba de explicar utilizando los siguientes bloques que encontraremos en el apartado de robots de mBlock 3.

Bloques en mBlock 3

Vamos a añadir el programa encargado de modificar los valores de los Led RGB de forma que cambie de color cada segundo, pasando por los colores rojo, verde y azul cuyos valores estarán comprendidos entre 0 y 255.

Programación en mBlock 3

mBlock 5 (versión actual)

Para programar el siguiente código debemos tener en cuenta la gama de colores en formato RGB como se acaba de explicar utilizando los siguientes bloques que encontraremos en el apartado de luces y sonido de mBlock 5.

Bloques en mBlock 5

Vamos a añadir el programa encargado de modificar los valores de los Led RGB de forma que cambie de color cada segundo, pasando por los colores rojo, verde y azul cuyos valores estarán comprendidos entre 0 y 255.

Programación en mBlock 5

En la nueva versión de mBlock se ha modificado la asignación de colores para que sea más sencillo a los alumnos y principiantes. De esta forma ya no es necesario saber la gama de colores en formato RGB para programar el robot, aunque sería recomendable en caso de querer utilizar varias tonalidades de forma dinámica.

Programación en mBlock 5

Retos propuestos

Si ya has completado todas las lecciones del tutorial te proponemos resolver los siguientes retos.

Reto 1: Luces aleatorias

En este reto de programación con mBot deberás programar un código encargado de mostrar un color aleatorio utilizando los LEDs RGB del robot, además, cada uno de los dos LEDs deberá mostrar un color diferente.

Reto 1: Luces aleatorias

Reto 2: Detecta el sonido

En este reto de programación con mBot deberás detectar el sonido del micrófono de tu ordenador (utilizando realidad aumentada), para cambiar los LEDs RGB del robot mBot. Esta programación solamente podrá funcionar conectado a mBlock.

Reto 2: Detecta el sonido

Reto 3: Tonalidades RGB

En este reto de programación con mBot deberás mostrar las distintas tonalidades de los LED RGB pasando por los colores rojo, verde y azul de los LEDs RGB del robot mBot.

Reto 3: Tonalidades RGB

# data[].attributes.attachment_link.description
Programación de los Led RGB en el robot mBot utilizando mblock.

# data[].attributes.body
Pelea de Globos

# data[].attributes.body
Recoge pelotas

# data[].attributes.attachment_link.entities[].name
Transformable Robot Kit for STEM Education

# data[].attributes.attachment_link.title
A new way to play with mBot:  Ping pong  snatch

# data[].attributes.attachment_link.description
Educational robot car #mBot, find new way to play with #mBot, #mBlock. Get mBot from http://www.makeblock.cc/mbot/

# data[].attributes.body
Jugando a futbol

# data[].attributes.body
Baila conmigo please!!

# data[].attributes.attachment_link.entities[].name
Transformable Robot Kit for STEM Education

# data[].attributes.attachment_link.title
New way to play with #mBot - Dancing robot

# data[].attributes.attachment_link.description
Now, you can adjust your #mBot as a dancing robot. Let's dance with mBot! Get a mBot from: http://www.makeblock.cc/mbot/

# data[].attributes.body
Abrazo mortal

# data[].attributes.attachment_link.title
Install the hands on #mBot, he can grasp something for you!

# data[].attributes.body
Chuta y ... gooooool

# data[].attributes.attachment_link.entities[].name
Transformable Robot Kit for STEM Education

# data[].attributes.attachment_link.entities[].name
Will Smith & Jaden Smith vs Van Der Sar & Lehmann

# data[].attributes.attachment_link.title
Do you know #mBot can play football like this? Cute? LOL (@makeblock)

# data[].attributes.attachment_link.description
Do you know #mBot can play football like this? Cute? LOL (@makeblock) Learn more about mdrawbot, please visit: http://www.makeblock.cc

# data[].attributes.body
Pelea con garras, nos damos un beso ....

# data[].attributes.body
MBOT+RASPBERRY+WEBCAM=ESPÍA!!

Para esto se necesitan conocimientos de Linux, VNC, Raspberry... ver página

# data[].attributes.body
Hazlo y cuelgalo en el muro

# data[].attributes.attachment_link.title
Música con mBot. Aprende a programar sonidos y notas con este vídeo.

# data[].attributes.body
Con ayuda de una webcam

# data[].attributes.attachment_link.title
Tutorial: how to make an object follower robot (with mBot + Pixy)

# data[].attributes.attachment_link.description
Want to make a smart robot that follows objects? In this video I show how to make one! Easy! Using just the Makeblock mBot and Pixy CMUcam5 Image Sensor and a few additional components.

# data[].attributes.body
Se necesita relé Curso BeeBot II

# data[].attributes.attachment_link.description
An mBot robot navigating a maze. To print you own bumper, see http://www.thingiverse.com/thing:1806547.

# data[].attributes.body
Solución en https://juegosrobotica.es/retos/reto-con-mbot-04/

# data[].attributes.attachment_link.readable_text
El cuarto reto con mBot consiste en programar a mBot como un robot mentalista adivinador.

Se trata de un reto de mBot de nivel medio.

Reto con mBot #4: Robot mentalista.

El reto lanzado en el twitter de Juegos Robótica era el siguiente:

Para entender mejor este reto el planteamiento se lanzó a través del siguiente vídeo:

El reto consiste en hacer que mBot pueda responder correctamente "si" o "no" a una pregunta que se le haga. Realmente el truco está en que si nosotros queremos engañar a la persona que está realizando la pregunta deberemos de grabar la respuesta correcta al robot sin que la persona que pregunte se de cuenta.

Para ello haremos un bucle mostrando los LEDs en verde y rojo a intervalos y para grabar la respuesta "si" o "no" pasaremos la mano discretamente por el sensor de ultrasonidos en el momento justo que estén los LEDs en verde para grabar una respuesta positiva o en rojo para una respuesta negativa.

Luego tan sólo tendremos que mostrar la respuesta positiva o negativa mediante color de los LEDs y sonido una vez nuestra "víctima" pulsa el botón en placa.

El programa que os propongo quedaría de la siguiente manera:

Podéis ver el diseño del programa para mBot con mBlock paso a paso en el siguiente vídeo:

Utilizad los comentarios en esta entrada o en Youtube para plantear vuestras preguntas, pero no os quedéis con ninguna duda.

La semana que viene tendremos nuevo reto, estad atent@s!

Dani S.

# data[].attributes.attachment_link.description
El cuarto reto con mBot consiste en programar a mBot como un robot mentalista adivinador. Se trata de un reto de mBot de nivel medio. El reto lanzado en el twitter de Juegos Robótica era el siguiente: Para entender mejor este reto el planteamiento se lanzó a través del siguiente vídeo: El reto consiste en hacer que mBot pueda responder correctamente "si" o "no" a una pregunta que se le haga.

# data[].attributes.body
Solución https://juegosrobotica.es/retos/reto-con-mbot-03/

# data[].attributes.attachment_link.readable_text
El tercer reto con mBot consiste en programar a mBot como un radar.

Se trata de un reto de mBot de nivel medio.

Reto con mBot #3: Barrido de radar en pantalla de PC.

El reto lanzado en el twitter de Juegos Robótica era el siguiente:

Para resolver este reto con el kit básico de mBot ya os daba la pista de que habría que hacer girar al robot, para captar los objetos próximos en un ángulo de 360º.

Además debemos de utilizar el sensor de ultrasonidos para medir dichas distancias.

Utilizaremos instrucciones de dibujo de mBlock para representar en la pantalla del PC las distancias de los objetos y el ángulo aproximado en el que se encuentran.

En esta ocasión os dejo el programa para que practiquéis, pero lo interesante es que lo modifiquéis o lo hagáis de nuevo para entender mejor el funcionamiento.

En este vídeo podéis ver la solución del reto 3 con mBot representada a través de mBlock

La semana que viene nuevo reto!

Dani S.

# data[].attributes.attachment_link.title
Reto con mBot #3: barrido de radar en pantalla de PC mediante ultrasonidos.

# data[].attributes.attachment_link.description
El tercer reto con mBot consiste en programar a mBot como un radar. Se trata de un reto de mBot de nivel medio. El reto lanzado en el twitter de Juegos Robótica era el siguiente: Para resolver este reto con el kit básico de mBot ya os daba la pista de que habría que hacer girar al robot, para captar los objetos próximos en un ángulo de 360º.

# data[].attributes.body
Solución https://juegosrobotica.es/retos/reto-05/

# data[].attributes.attachment_link.description
Solución al reto 5 programando un sensor de aparcamiento para mBot de Makeblock. Puedes ver más detalles sobre la solución de este reto y también cómo resolverlo en Arduino UNO mediante Bitbloq en https://juegosrobotica.es/retos/reto-05/

# data[].attributes.body
Solución https://juegosrobotica.es/retos/reto-02/

# data[].attributes.attachment_link.description
Resolución del reto 2 con mBot donde hay que hacer un seguidor de luz que permita a mBot salir de un túnel y buscar la luz. Tenéis los detalles y el programa para descargar en la siguiente entrada de la web de Juegos Robótica.

# data[].attributes.body
Solución : https://juegosrobotica.es/retos/reto-01/

# data[].attributes.attachment_link.title
Reto 1. Canasta baloncesto y marcador con mBot. 1ª parte.

# data[].attributes.attachment_link.description
Canasta de baloncesto y marcador con mBot. Resolvemos la primera parte del reto lanzado en Twitter resolviendo la detección del paso de la bola de papel en la canasta. La solución que os propongo para compartir con vuestros alumnos o para practicar en casa es la de detectar el paso de la bola de papel por el interior de la canasta mediante el sensor de ultrasonidos.

# data[].attributes.body
Solución : https://juegosrobotica.es/retos/reto-01b/

# data[].attributes.attachment_link.title
Reto 1. Canasta baloncesto y marcador con mBot. 2ª parte.

# data[].attributes.attachment_link.description
Canasta de baloncesto y marcador con mBot. Resolvemos la segunda parte del reto lanzado en Twitter instalando un marcador para el tanteo de las canastas. Una vez realizadada en un vídeo anterior la detección del paso de la bola de papel a través de la canasta, la solución que os propongo para el marcador es colocar un disco de cartón en una de las ruedas de mBot con unas ventanas.

# data[].attributes.body
Solución en https://juegosrobotica.es/retos/reto-06/

# data[].attributes.wish_content.attachment_props.text
Y por último, nuestro #mBot ha estado haciendo lanzamiento de peso. Los alumnos tenían que dejar pulsada la pantalla para que girara y soltar para lanzar.
#robótica #DonBenito @Makeblock  #mBlock

# data[].attributes.wish_content.attachment_props.original_text
Y por último, nuestro #mBot ha estado haciendo lanzamiento de peso. Los alumnos tenían que dejar pulsada la pantalla para que girara y soltar para lanzar.
#robótica #DonBenito @Makeblock  #mBlock https://t.co/ZvMpiCqmc9

# data[].attributes.attachment_link.embed_code
Y por último, nuestro #mBot ha estado haciendo lanzamiento de peso. Los alumnos tenían que dejar pulsada la pantalla para que girara y soltar para lanzar.#robótica #DonBenito @Makeblock #mBlock pic.twitter.com/ZvMpiCqmc9
— Antonino Vara (@antoninovara) March 30, 2022

# data[].attributes.attachment_link.metadata.attachment_props_source.data.text
Y por último, nuestro #mBot ha estado haciendo lanzamiento de peso. Los alumnos tenían que dejar pulsada la pantalla para que girara y soltar para lanzar.
#robótica #DonBenito @Makeblock  #mBlock https://t.co/ZvMpiCqmc9

# data[].attributes.attachment_link.metadata.attachment_props.original_text
Y por último, nuestro #mBot ha estado haciendo lanzamiento de peso. Los alumnos tenían que dejar pulsada la pantalla para que girara y soltar para lanzar.
#robótica #DonBenito @Makeblock  #mBlock https://t.co/ZvMpiCqmc9

# data[].attributes.attachment_link.metadata.attachment_props.text
Y por último, nuestro #mBot ha estado haciendo lanzamiento de peso. Los alumnos tenían que dejar pulsada la pantalla para que girara y soltar para lanzar.
#robótica #DonBenito @Makeblock  #mBlock

# data[].attributes.attachment_link.readable_text
Los jugadores tendrán que colocarse a cierta distancia del robot y ganará el jugador que logre pulsar el botón que se encuentra en la parte superior sin ser detectado.

Operativa del juego:

Al activar el interruptor de encendido se mostrará en la matriz de LEDs el texto " seguido de una cuenta atrás qué irá del 30 al 1 con el objetivo de esperar un tiempo hasta que el sensor de movimiento se inicialice correctamente. Durante este tiempo los LEDs de la parte superior estarán de color rojo. Una vez pasado ese tiempo se mostrará el texto y los LEDS de la parte superior pasarán a estar de color verde señalando que ya se puede activar el juego.

Mientras no se active el juego mostrará en la matriz de LEDs una secuencia de cara de .

Para comenzar el juego se deberá mantener pulsado el botón de la parte superior durante más de 1 segundo momento en el cual se iniciará una secuencia de inicio de juego con sonido mostrándose en la matriz de LEDs una cara de "despierto" seguido de cuenta atrás del 5 al 1 que finalizará mostrándose el texto

Una vez iniciado el juego los LEDS situados en la parte superior del robot se pondrán aleatoriamente de color rojo o verde y se mostrará en la matriz de LEDs una secuencia de cara de .

Si se ponen los LEDS de la parte superior de color verde te podrás acercar hacia el robot e intentar apretar el botón antes de que se pongan de color rojo. Cuando están en verde nunca podrás ser detectado. Si logras apretar el botón mientras se encuentra el color verde activo "habrás ganado" y el robot realizará una secuencia de fin de juego con sonido mostrando en la matriz de LEDs una cara de " " y el texto

Si se ponen los LEDs de color rojo tendrás que quedarte quieto porque ahora el robot sí que te podrá detectar. Si has sido detectado el robot se abalanzará hacia adelante mostrando una cara de "sorpresa" y haciendo que acoplado al servomotor baje creando el efecto de querer atraparte. Si has sido detectado más de 3 veces "habrás perdido" y el robot emitirá una secuencia de fin de juego con sonido mostrando en la matriz de LEDs una cara de " " y el texto: "GAME OVER!" . Si todavía te quedan " " se mostrará en la matriz de LEDs una cuenta atrás del 3 al 1 para señalar que el juego continúa.

Para ver el funcionamiento de lo anteriormente descrito aquí os dejo el video demostrativo del juego:

En la siguiente imagen se puede ver estos dos módulos ya instalados en la parte superior del robot junto con el módulo de sensor de sonido que para este juego no utilizaremos.

También instalaremos la matriz de LEDs en la parte frontal del robot.

Primero pondremos una de las partes del velcro en la base de robot donde fijaremos el servomotor y la otra parte del velcro en una de las caras del servomotor.

Posteriormente fijaremos la viga al servomotor y con cinta transparente pegaremos la mano en un extremo de la viga:

Observación 1:
Nuestro sensor de movimiento lo configuraremos en modo "non-retriggering" . Para ello pondremos en la parte de de nuestro la instrucción:
pir.SetPirMotionMode(0);
En el siguiente diagrama se puede apreciar el funcionamiento del sensor en modo "non-retriggering":

El pulso generado al detectarse un movimiento consta de dos tiempos:

Tx. Tiempo de duración que se mantiene la salida en "high" cuando se detecta un movimiento.

Ti. Tiempo durante el cual el sensor no detectará movimiento.

Como se puede apreciar en la imagen anterior cuando se activa la salida al detectarse movimiento se genera un pulso de duración "Tx" más un tiempo Ti donde el sensor no puede detectar movimiento. Aunque durante el tiempo "Tx" se detecte otro movimiento el sensor no vuelve a generar nuevamente un pulso y solo al terminar el periodo Tx + Ti del pulso activo el sensor podrá generar un nuevo pulso al detectar un nuevo movimiento.

Lo ideal es que la suma de estos dos tiempos sea lo más baja posible y por suerte en nuestro sensor la suma de esos dos tiempos es muy pequeño (menos de 1 segundo).
Observación 2:
Otro tema a tener en cuenta es que si utilizamos la librería de Arduino que viene ya incluida en la librería observaremos que el servomotor realiza pequeños movimientos haciendo como si el brazo " ". Esto sucede por utilizar la librería junto con la librería que controla los LEDs RGB de la placa .

La solución y explicación a este problema lo podéis ver en el siguiente enlace de la página Web de Adafruit (en este caso hace referencia al problema de utilizar la librería con la librería ):
https://learn.adafruit.com/neopixels-and-servos/overview
La solución está en utilizar otra librería, la Adafruit_TiCoServo que funcionará perfectamente en nuestro y nos quitará este problema.

Para poder utilizarla tendremos que quitar la librería que se incluye automáticamente al utilizar el . Para ello tendremos que ir al fichero " MeConfig.h" y comentar la línea para que de esta manera no cargue la librería.
Descargar sketch y librerías
// ---------------------------------------------------------------------------
// mBot: Juego del escondite inglés - v1.0 - 01/04/2018
//
// AUTOR/LICENCIA:
// Creado por Angel Villanueva - @avilmaru
// Copyright 2018 Licencia: GNU GPL v3 http://www.gnu.org/licenses/gpl-3.0.html
//
// LINKS:
// Blog: http://www.mecatronicalab.es
//
//
// HISTORICO:
// 01/04/2018 v1.0 - Release inicial.
//
// ---------------------------------------------------------------------------

  /*
   *  IMPORTANTE: Comentar en el fichero MeConfig.h la linea #include <utility/Servo.h> para que no cargue la libreria Servo ya
   *  que utilizaremos la libreria Adafruit_TiCoServo.h y si no hacemos esto habrá conflicto entre ambas librerías.
   *  Utilizaremos esta librería en vez de la libreria Servo por problemas al utilizarla junto con la libreria MeRGBLed
   */

  // Notas
  #include "pitches.h"

  // Utilizaremos esta librería en vez de la libreria Servo por problemas al utilizarla junto con la libreria MeRGBLed
  #include <Adafruit_TiCoServo.h>

  #include <MeMCore.h>

  MeDCMotor motor1(M1);
  MeDCMotor motor2(M2);

  MePIRMotionSensor pir(PORT_1);
  MePort port(PORT_2);
  MeLEDMatrix ledMx(PORT_4);
  MeRGBLed led(PORT_7,2);
  MeBuzzer buzzer;

  Adafruit_TiCoServo servo;
  int16_t servopin =  port.pin1(); // SLOT1

  const int pinPulsador = A7;

  const int TIEMPO_VERIFICACION = 10;
  const int MAX_FALLOS = 3;
  const int MAS_DE_1S = 1000;
  const int MAX_COLOR_TIME = 5000;

  const int melodia_inicio_notas[7] = {NOTE_F5, NOTE_FS5, NOTE_G5, NOTE_GS5, 0, NOTE_F5, NOTE_GS5};
  const int melodia_inicio_duracion[] = {8, 8, 8, 8, 8, 8, 2}; // duracion de las notas: 2 = 1/2,  4 = 1/4, 8 = 1/8,  etc
  const int melodia_inicio_total_notas = 7;

  const int melodia_fin_notas[] = {NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4};
  const int melodia_fin_duracion[] = {4, 8, 8, 4, 4, 4, 4, 4};
  const int melodia_fin_total_notas = 8;

  const int melodia_perder_notas[] = {NOTE_E3, NOTE_DS3, NOTE_D3, NOTE_CS3};
  const int melodia_perder_duracion[] = {4, 4, 4, 1};
  const int melodia_perder_total_notas = 4;

  const int melodia_ganar_notas[] = {NOTE_F5, NOTE_G5, NOTE_A5, NOTE_B6, NOTE_C6};
  const int melodia_ganar_duracion[] = {8, 8, 8, 8, 4};
  const int melodia_ganar_total_notas = 5;

  unsigned long tiempoAcumuladoMismoColor = 0;
  unsigned long startTime = 0;
  unsigned long endTime = 0;
  unsigned long loopTime = 0;
  unsigned long SwitchPressedTime = 0;
  unsigned long t0;

  int fin_de_juego = 0;
  int total_veces_persona_detectada = 0;
  int activa_aviso_nueva_deteccion = 0;
  int secuencia =0;
  String colorActivo = "";
  String ultimoColorActivo = "";
  String modo = "SIN DETERMINAR";
  String ultimoTipo= "";

  double factor_delay=0.3;

  unsigned char *cara;

void setup()
{
  // PULSADOR
  pinMode(pinPulsador, INPUT);

  // PIR: modo funcionamiento: non-repeatable trigger
  pir.SetPirMotionMode(0);

  // MATRIZ LEDS
  ledMx.setBrightness(6);
  ledMx.setColorIndex(1);
  ledMx.clearScreen();

  // SERVO
  servo.attach(servopin);
  compruebaServo();

  // Para que la secuencia cambie cada vez que se inicie el programa --> Se conecta a una entrada analógica que no tenga nada conectado
  randomSeed(analogRead(A3));

  activarLed("ROJO");

  // Texto wait!
  for(int i=0; i < 45; i++)
  {
    ledMx.drawStr(0-i,8,"  WAIT! ");
    delay(50);
  }

  // Esperamos un tiempo  para que el PIR se inicialice correctamente!
  for(int i=0; i < 30; i++)
  {
      ledMx.showNum(30-i,1);
      delay(1000);
  }

  // Texto ready!
  for(int i=0; i < 50; i++)
  {
    ledMx.drawStr(0-i,8,"  READY! ");
    delay(50);
  }

}

void loop()
{
      if (modo == "JUEGO")
      {

          if (fin_de_juego == 0)
          {

              /*
               *  Seleccionar aleatoriamente el color que se mostrará
               */

              int randColor = random(0, 101);   // max es max -1

              if (randColor & 0x11)  // Impar --> color rojo
                colorActivo = "ROJO";
              else                   // Par --> color verde
                colorActivo = "VERDE";

              /*
               *  Corrección del color para evitar que un mismo color se repita demasido tiempo de manera seguida
               */

              if (ultimoColorActivo == colorActivo)
              {
                  if (tiempoAcumuladoMismoColor > MAX_COLOR_TIME)
                  {
                    if (colorActivo == "VERDE")
                      colorActivo = "ROJO";
                    else if (colorActivo == "ROJO")
                      colorActivo = "VERDE";

                    tiempoAcumuladoMismoColor = 0;

                  }
              }else
                    tiempoAcumuladoMismoColor = 0;

              /*
               *  Duracion aleatoria que estará el color anterior activo
               */

              loopTime = random(2, 5) * 1000;  // Entre 2s y 4 s   (el valor máximo especificado es max -1 )


             /*
              *  Ponemos el LED azul y esperamos 1,5s antes de volver a detectar (es un modo de avisar que estamos a punto de volver a detectar)
              *  de esta manera damos tiempo de que el jugador no se mueva.
              *
              *  En el sensor de makeblock aproximadamente los tiempos medidos son:
              *  Tx: 0,4s  Ti: 0,3s
              */

              if (activa_aviso_nueva_deteccion)
              {
                activa_aviso_nueva_deteccion = 0;
                avisoDeteccion();
              }


              /*
               * NOTA: Es posible que mientras está el color ROJO activo estemos dentro de un periodo Ti (Block Time), en este caso
               * el PIR no podrá detectar este movimiento hasta que termine el Ti.
               */

              startTime = millis();
              endTime = startTime;

              do
              {

                 if (colorActivo == "VERDE")
                 {
                      activarLed("VERDE");

                      int lecturaPULSADOR = lecturaPin(pinPulsador);

                      // Luz VERDE y has pulsado --> Has ganado --> Fin de juego
                      if (lecturaPULSADOR == LOW) // PULL-UP
                      {
                          fin_de_juego = 1;

                          //Cara de ganar
                          cara = new unsigned char[16]{0,16,32,64,68,34,19,3,3,19,34,68,64,32,16,0};
                          mostrarCara(cara);

                          //Melodia de ganar
                          melodia(melodia_ganar_notas,melodia_ganar_duracion,melodia_ganar_total_notas);

                          // Texto you win!
                          for(int i=0; i < 65; i++)
                          {
                            ledMx.drawStr(0-i,8,"  YOU WIN! ");
                            delay(50);
                          }

                          break;
                      }

                 }else if (colorActivo == "ROJO")
                 {

                      activarLed("ROJO");

                      // Luz ROJA y has sido detectado...
                      if (pir.isHumanDetected())
                      {

                             ++total_veces_persona_detectada;

                            //Has superado el numero de veces que podias ser detectado --> Has perdido --> Fin de juego
                            if (total_veces_persona_detectada > MAX_FALLOS)
                            {
                                fin_de_juego = 1;

                                //Cara de perder
                                cara = new unsigned char[16]{0,32,16,16,16,17,33,1,1,33,17,16,16,16,32,0};
                                mostrarCara(cara);

                                //Melodias de perder
                                melodia(melodia_perder_notas,melodia_perder_duracion,melodia_perder_total_notas);
                                melodia(melodia_fin_notas,melodia_fin_duracion,melodia_fin_total_notas);

                                //Texto game over!
                                for(int i=0; i < 70; i++)
                                {
                                  ledMx.drawStr(0-i,8,"  GAME OVER! ");
                                  delay(50);
                                }

                            }else{

                              //secuencia de pillado
                              secuenciaAlerta();
                              activa_aviso_nueva_deteccion = 1;
                           }

                          break;

                    }

                 }

                 secuenciaCara(1000,"ESPERANDO");
                 endTime = millis();

              } while (endTime - startTime < loopTime);  // Hasta que no se supere los segundos generados aleatoriamente

              // Vamos acumulando el tiempo en que esta activo el mismo color
              tiempoAcumuladoMismoColor = tiempoAcumuladoMismoColor + (endTime - startTime);

              ultimoColorActivo = colorActivo;



          }
          else
            modo = "SIN DETERMINAR";


      }else
      {

          // Determinar el modo de juego  mirando el tiempo en que se ha mantenido el botón pulsado

          activarLed("VERDE");
          secuenciaCara(1000,"DORMIDO");

          startTime = millis();
          endTime = startTime;
          while (lecturaPin(pinPulsador) == LOW) // PULL-UP
            endTime = millis();

          SwitchPressedTime = endTime - startTime;

          if ( SwitchPressedTime > MAS_DE_1S)
          {
             modo = "JUEGO";
             cara = new unsigned char[16]{0,60,66,74,74,66,60,0,0,60,66,74,74,66,60,0};
             mostrarCara(cara);
             senalAcusticaConIndicador(2, 250, NOTE_C5, "AZUL");
             secuenciaInicio();
          }
          else
            modo = "SIN DETERMINAR";

      }

}


/*
 *  FUNCIONES
*/

  void Avance()
  {
    /*
       Debido a no tenemos un enconder y cada motor no va a la misma velocidad aquí ajustaremos las velocidades de ambos (si aplica)
       para conseguir que vaya lo mas recto posible
    */
    motor1.run(-255);
    motor2.run(255);
  }

  void Retroceso()
  {

    /*
       Debido a no tenemos un enconder y cada motor no va a la misma velocidad aquí ajustaremos las velocidades de ambos (si aplica)
       para conseguir que vaya lo mas recto posible
    */
    motor1.run(255);
    motor2.run(-255);
  }

  void Parar()
  {
    motor1.run(0);
    motor2.run(0);
  }


  void desactivarLed()
  {
   led.setColor(0, 0, 0, 0);
   led.show();
  }


  void activarLed(String color)
  {
    if (color == "VERDE")
      led.setColor(0, 0, 255, 0);
    else if (color == "ROJO")
      led.setColor(0, 255, 0, 0);
    else if (color == "AZUL")
      led.setColor(0, 0, 0, 255);

    led.show();

  }


  void secuenciaInicio()
  {

      // Inicializar las variables
      fin_de_juego = 0;
      total_veces_persona_detectada = 0;
      tiempoAcumuladoMismoColor = 0;
      ultimoColorActivo = "";

      desactivarLed();
      melodia(melodia_inicio_notas,melodia_inicio_duracion,melodia_inicio_total_notas);

      for(int i=0; i < 5; i++)
      {
          activarLed("ROJO");
          ledMx.showNum(5-i,1);
          buzzer.tone(NOTE_C5, 500);
          desactivarLed();
          buzzer.noTone();
          delay(500);

      }

       // Texto go!
      for(int i=0; i < 30; i++)
      {
        ledMx.drawStr(0-i,8,"  GO! ");
        delay(50);
      }


  }


  void avisoDeteccion()
  {

    for(int i=0; i < 3; i++)
    {
        activarLed("AZUL");
        ledMx.showNum(3-i,1);
        buzzer.tone(NOTE_C5, 500);
        desactivarLed();
        buzzer.noTone();
        delay(500);
    }

  }


  void melodia(const int notas_melodia[], const int duracion_notas[], const int total_notas)
  {

    for (int nota = 0; nota < total_notas; nota++)
    {
      int duracionNota = 1000 / (duracion_notas[nota]);
      buzzer.tone(notas_melodia[nota], duracionNota);

      /*
        La función  "buzzer.tone" ya introduce el delay de la duración de la nota a diferencia de la librería "tone" --> con lo cual solo hay que añaidr el 30%
        ojo! que si la nota es 0 no se introduce el delay de la duración de la nota y solo en este caso si que hay que añadir la duración de la nota + 30% en el delay
      */

      factor_delay=0.3;
      if (notas_melodia[nota] == 0)
        factor_delay=1.3;

      int pausaEntreNotas = duracionNota * factor_delay;
      delay(pausaEntreNotas);
      buzzer.noTone();

    }
  }


  void senalAcusticaConIndicador(int n_veces, int duracion_nota, int nota, String color)
  {

    for(int i=0; i < n_veces; i++)
    {
        activarLed(color);
        buzzer.tone(nota, duracion_nota);
        desactivarLed();
        buzzer.noTone();
        delay(duracion_nota);

    }

  }


  boolean lecturaPin(int pin)
  {
    boolean estado;
    boolean estadoAnterior;

    estadoAnterior = analogRead(pin);
    for(int i=0; i < TIEMPO_VERIFICACION; i++)
    {
      delay(1);                       // esperar 1 milisegundo
      estado = analogRead(pin);
      if( estado != estadoAnterior)  // si el estado cambia -> resetear el contador y guardar el estado
      {
        i = 0;
        estadoAnterior = estado;
      }
    }

    // si hemos llegado aqui el estado se ha mantenido estable (no ha cambiado) por un periodo de tiempo y damos por válida la lectura
    return estado;
  }




/*

En esta función no podemos utilizar instrucciones como el delay o permanecer en un bucle  ya que pararía la ejecución en un punto concreto.
Para ello se ha utilizadola instrucción millis()  (Ej:. if (millis() - t > intervalo) ) que nos permite ejecutar cada x tiempo ciertas instrucciones sin detenerse
en un punto.
De esta manera no paramos la ejecución en ningún punto concreto y el hilo de ejecución podrá detectar si se produce un sonido mientras se está ejecutando una secuencia
de la cara y por tanto iniciar la secuencia de alerta lo antes posible

*/
void secuenciaCara(unsigned long intervalo, String tipo)
{

  if (millis() - t0 > intervalo)
  {

    t0 = millis();

    if (ultimoTipo != tipo)
      secuencia = 0;

    secuencia++;

    if (tipo == "ESPERANDO")
    {
          switch (secuencia)
          {
            case 1:
                cara = new unsigned char[16]{0,60,66,74,74,66,60,0,0,60,66,74,74,66,60,0};
                break;
            case 2:
                cara = new unsigned char[16]{0,60,66,66,66,90,60,0,0,60,66,66,66,90,60,0};
                break;
            case 3:
                cara = new unsigned char[16]{0,60,90,66,66,66,60,0,0,60,90,66,66,66,60,0};
                secuencia=0;
                break;
          }

    }else if (tipo == "DORMIDO")
    {
        switch (secuencia)
        {
            case 1:
                cara = new unsigned char[16]{0,16,8,8,8,16,0,0,0,0,16,8,8,8,16,0};
                break;
            case 2:
                cara = new unsigned char[16]{0,0,16,8,8,8,16,0,0,0,0,16,8,8,8,16};
                secuencia=0;
                break;
        }

    }

    mostrarCara(cara);
    ultimoTipo = tipo;

  }

}

/*

En esta función si que utilizaremos delays ya que nos interesa que se ejecute entera y no tenga en cuenta si existe o no un sonido mientras se ejecuta
a diferencia de la función anterior.

*/

void secuenciaAlerta()
{

  activarLed("ROJO");

  cara = new unsigned char[16]{60,66,129,153,153,129,66,60,60,66,129,153,153,129,66,60};
  mostrarCara(cara);

  Retroceso();
  delay(150);
  Avance();
  delay(500);
  servo.write(70);
  Parar();
  buzzer.tone(784, 500); // esto ya produce delay
  servo.write(170);
  buzzer.tone(784, 500); // esto ya produce delay
  desactivarLed();
  delay(300);

}

void mostrarCara(unsigned char *cara)
{

  unsigned char drawBuffer[16];

  memcpy(drawBuffer,cara,16);
  free(cara);
  ledMx.drawBitmap(0,0,16,drawBuffer);

}

void compruebaServo()
{
  // Si el servo no se encuentra en su posicion inicial lo ponemos
  if (servo.read() != 170)
  {
     servo.write(170);     // Ponemos el servo en la posición inicial
     delay(2000);          // Damos 2s para que de tiempo a volver a la posicion
  }

}

# data[].attributes.attachment_link.title
mBot: juego del escondite inglés - Mecatrónica Lab

# data[].attributes.attachment_link.description
INTRODUCCIÓN La idea de este juego que realizaremos con nuestro robot mBot es intentar simular el famoso juego del "escondite inglés" pero lógicamente con algunas variantes para que nuestro robot lo pueda hacer. Los jugadores tendrán que colocarse a cierta distancia del robot y ganará el jugador que logre pulsar el botón que se encuentra ...

# data[].attributes.attachment_link.readable_text
La idea con este juego que realizaremos con nuestro robot es experimentar las características del sensor de luz integrado dentro de la placa y el módulo adicional de sensor de sonido.

Por otro lado también experimentaremos con la matriz de LEDs de 8×16 que nos permitirá poner caras divertidas a nuestro robot.

También utilizaremos otros componentes integrados en la placa como el zumbador y los LEDs RGB.

Operativa del juego:

Pondremos un umbral de luminosidad en el cual consideramos que es de día y el robot está " ". Si no se supera este umbral querrá decir que es de noche y por tanto el robot estará " ".

Si está " " el robot mostrará una serie de secuencia de gestos de ojos en la matriz de LEDs que cambiará si se encuentra " ".

Cuando se detecte un sonido que supere un cierto umbral el robot se " " y se iniciará una secuencia de gestos en la matriz de LEDs (ojos de sorpresa) acompañados de sonidos.

Si se considera que es de noche y por tanto está " " esta secuencia se acompañará con la iluminación de los dos LEDs que se encuentran integrados en la placa por el contrario si consideramos que es de día y por tanto está "despierto" en vez de encender los LEDs haremos que realice unos pequeños movimientos a izquierda y derecha. Durante la noche el umbral de sonido será más sensible que durante el día.

Para ver el funcionamiento de lo anteriormente descrito aquí os dejo el video demostrativo del juego:

Para poder realizar el juego necesitaremos instalar el módulo de sensor de sonido mediante el pack de estructuras para

También instalaremos la matriz de LEDs en la parte frontal del robot.

La conexiones de los diferentes módulos a los puertos de la placa serán:

Antes de mostrar el con toda la programación del juego hay que tener en cuenta la siguiente observación:

En la función secuenciaCara() no podemos utilizar instrucciones como el o permanecer en un bucle ya que pararía la ejecución en un punto concreto.

Para ello se ha utilizado la instrucción : if (millis() - t > intervalo) que nos permite ejecutar cada " x" tiempo ciertas instrucciones sin detenerse en un punto.

De esta manera no paramos la ejecución en ningún punto concreto y el hilo de ejecución podrá detectar si se produce un sonido mientras se está ejecutando una secuencia de la cara y por tanto iniciar la secuencia de alerta lo antes posible.

Por otro lado para la realización de las caras he utilizado el entorno de programación de que tiene una herramienta visual para realizar esta tarea de un modo fácil.

Por último os dejo el con toda la programación:

// ---------------------------------------------------------------------------
// mBot (asuntando al mBot) - v1.0 - 04/02/2018
//
// AUTOR/LICENCIA:
// Creado por Angel Villanueva - @avilmaru
// Copyright 2018 Licencia: GNU GPL v3 http://www.gnu.org/licenses/gpl-3.0.html
//
// LINKS:
// Blog: http://www.mecatronicalab.es
//
//
// HISTORICO:
// 04/02/2018 v1.0 - Release inicial.
//
// ---------------------------------------------------------------------------

#include <MeMCore.h>

MeLEDMatrix ledMx(PORT_3);
MeSoundSensor sensorSonido(PORT_4);

MBotDCMotor motor(PORT_1);
MeLightSensor sensorLuz(PORT_6);
MeRGBLed rgbLed(PORT_7,2);
MeBuzzer buzzer;

const int UMBRAL_LUZ  = 300;
const int UMBRAL_SONIDO_DIURNO = 500;
const int UMBRAL_SONIDO_NOCTURNO = 300;

unsigned char *cara;
String ultimoModo = "";

unsigned int luminosidad;
unsigned int sonido;
unsigned long t0 = 0;
uint8_t secuencia = 0;

void setup()
{

  ledMx.setBrightness(6);
  ledMx.setColorIndex(1);
  ledMx.clearScreen();

  motor.move(1,0);

  rgbLed.setColor(0,0,0,0);
  rgbLed.show();

}

void loop()
{

    luminosidad = sensorLuz.read();
    if (luminosidad > UMBRAL_LUZ)
    {
        sonido = sensorSonido.strength();
        if (sonido > UMBRAL_SONIDO_DIURNO)
            secuenciaAlerta("DESPIERTO");
        else
            secuenciaCara(1000,"DESPIERTO");

    }else{

        sonido = sensorSonido.strength();
        if (sonido > UMBRAL_SONIDO_NOCTURNO)
           secuenciaAlerta("DORMIDO");
        else
            secuenciaCara(1000,"DORMIDO");
    }

}


/*

En esta función no podemos utilizar instrucciones como el delay o permanecer en un bucle  ya que pararía la ejecución en un punto concreto.
Para ello se ha utilizadola instrucción millis()  (Ej:. if (millis() - t > intervalo) ) que nos permite ejecutar cada x tiempo ciertas instrucciones sin detenerse
en un punto.
De esta manera no paramos la ejecución en ningún punto concreto y el hilo de ejecución podrá detectar si se produce un sonido mientras se está ejecutando una secuencia
de la cara y por tanto iniciar la secuencia de alerta lo antes posible

*/
void secuenciaCara(unsigned long intervalo, String modo)
{

  if (millis() - t0 > intervalo)
  {

    t0 = millis();

    if (ultimoModo != modo)
      secuencia = 0;

    secuencia++;

    if (modo == "DESPIERTO")
    {
          switch (secuencia)
          {
            case 1:
                cara = new unsigned char[16]{0,60,66,74,74,66,60,0,0,60,66,74,74,66,60,0};
                break;
            case 2:
                cara = new unsigned char[16]{0,60,66,66,66,90,60,0,0,60,66,66,66,90,60,0};
                break;
            case 3:
                cara = new unsigned char[16]{0,60,90,66,66,66,60,0,0,60,90,66,66,66,60,0};
                secuencia=0;
                break;
          }

    }else if (modo == "DORMIDO")
    {
        switch (secuencia)
        {
            case 1:
                cara = new unsigned char[16]{0,16,8,8,8,16,0,0,0,0,16,8,8,8,16,0};
                break;
            case 2:
                cara = new unsigned char[16]{0,0,16,8,8,8,16,0,0,0,0,16,8,8,8,16};
                secuencia=0;
                break;
        }

    }

    mostrarCara(cara);
    ultimoModo = modo;

  }

}

/*

En esta función si que utilizaremos delays ya que nos interesa que se ejecute entera y no tenga en cuenta si existe o no un sonido mientras se ejecuta
a diferencia de la función anterior.

*/

void secuenciaAlerta(String modo)
{

  bool activaMovimiento = false;
  rgbLed.setColor(0,0,0,0);
  rgbLed.show();

  if (modo == "DESPIERTO")
  {
     activaMovimiento = true;
  }
  else
  {
    rgbLed.setColor(0,0,0,255); // Azul
    rgbLed.show();

  }


  cara = new unsigned char[16]{60,66,129,153,153,129,66,60,60,66,129,153,153,129,66,60};
  mostrarCara(cara);
  buzzer.tone(784, 500); // esto ya produce delay

  cara = new unsigned char[16]{60,66,129,129,129,129,66,60,60,66,129,129,129,129,66,60};
  mostrarCara(cara);

  if (activaMovimiento)
      motor.move(3,255);

  delay(300);

  cara = new unsigned char[16]{60,66,129,153,153,129,66,60,60,66,129,153,153,129,66,60};
  mostrarCara(cara);

  if (activaMovimiento)
    motor.move(4,255);

  buzzer.tone(330, 300);  // esto ya produce delay


  cara = new unsigned char[16]{60,66,129,129,129,129,66,60,60,66,129,129,129,129,66,60};
  mostrarCara(cara);

  if (activaMovimiento)
    motor.move(3,255);

  delay(300);

  cara = new unsigned char[16]{60,66,129,153,153,129,66,60,60,66,129,153,153,129,66,60};
  mostrarCara(cara);

  if (activaMovimiento)
    motor.move(4,255);

  buzzer.tone(330, 300);  // esto ya produce un delay

  motor.move(1,0);
  rgbLed.setColor(0,0,0,0);
  rgbLed.show();

  delay(400);

}

void mostrarCara(unsigned char *cara)
{

  unsigned char drawBuffer[16];

  memcpy(drawBuffer,cara,16);
  free(cara);
  ledMx.drawBitmap(0,0,16,drawBuffer);

}

# data[].attributes.attachment_link.description
INTRODUCCIÓN La idea con este juego que realizaremos con nuestro robot mBot es experimentar las características del sensor de luz integrado dentro de la placa mCore y el módulo adicional de sensor de sonido. Por otro lado también experimentaremos con la matriz de LEDs de 8×16 que nos permitirá poner caras divertidas a nuestro robot.

# data[].attributes.body
https://www.youtube.com/watch?v=mON5J68ucAc&feature=emb_logo

# data[].attributes.attachment_link.title
Proyecto con mBot y brújula - Encontrar el norte

# data[].attributes.attachment_link.title
Reto 53 robótica educativa: Moviendo pixel en matriz de LEDs con mBot

# data[].attributes.body
https://www.youtube.com/watch?time_continue=333&v=X5M1acb9pHM

# data[].attributes.attachment_link.title
Reto 48 robótica educativa: Volver al punto de partida después de encontrar obstáculo con mBot.

# data[].attributes.attachment_link.title
Reto 12: Lector de código de barras con mBot de Makeblock

# data[].attributes.attachment_link.description
Solución al reto 12 en el que se programa mBot para que funcione como un lector de código de barras. Más información sobre este reto en https://juegosrobotica.es/retos/reto-12/

# data[].attributes.wish_content.attachment_props.text
Después de montar y programar nuestros robots hicimos una competición de sumo.
Así terminó la sesión de hoy en @Sed-vies Diversión y aprendizaje en buena compañía. #stem #code #roboticaporlaigualdad #yosoyrobot

# data[].attributes.wish_content.attachment_props.original_text
Después de montar y programar nuestros robots hicimos una competición de sumo.
Así terminó la sesión de hoy en @Sed-vies Diversión y aprendizaje en buena compañía. #stem #code #roboticaporlaigualdad #yosoyrobot https://t.co/2KMHB2kJJz

# data[].attributes.attachment_link.embed_code
Después de montar y programar nuestros robots hicimos una competición de sumo.
Así terminó la sesión de hoy en @Sed-vies Diversión y aprendizaje en buena compañía. #stem #code #roboticaporlaigualdad #yosoyrobot pic.twitter.com/2KMHB2kJJz
— Asociacion ByLinedu (@bylinedu) April 23, 2018

# data[].attributes.attachment_link.metadata.attachment_props_source.data.text
Después de montar y programar nuestros robots hicimos una competición de sumo.
Así terminó la sesión de hoy en @Sed-vies Diversión y aprendizaje en buena compañía. #stem #code #roboticaporlaigualdad #yosoyrobot https://t.co/2KMHB2kJJz

# data[].attributes.attachment_link.metadata.attachment_props.original_text
Después de montar y programar nuestros robots hicimos una competición de sumo.
Así terminó la sesión de hoy en @Sed-vies Diversión y aprendizaje en buena compañía. #stem #code #roboticaporlaigualdad #yosoyrobot https://t.co/2KMHB2kJJz

# data[].attributes.attachment_link.metadata.attachment_props.text
Después de montar y programar nuestros robots hicimos una competición de sumo.
Así terminó la sesión de hoy en @Sed-vies Diversión y aprendizaje en buena compañía. #stem #code #roboticaporlaigualdad #yosoyrobot

# data[].attributes.body
Esta vez calcula si cabe o no

# data[].attributes.attachment_link.title
Reto 32 robótica educativa: Aparcamiento autónomo con mBot. 2ª parte.

# data[].attributes.attachment_link.title
Reto 32 robótica educativa: Aparcamiento autónomo con mBot.

# data[].attributes.body
https://lacienciaparatodos.files.wordpress.com/2017/05/prc3a1cticas-mbot-javier-fernc3a1ndez-panadero-05-05-2017.pdf

# data[].attributes.attachment_link.title
Reto 30 robótica educativa: ascensor con mBot sin sensores adicionales.

# data[].attributes.attachment_link.title
Install the hands on #mBot, he can grasp something for you!

# data[].attributes.body
https://lacienciaparatodos.wordpress.com/2017/05/06/practicas-de-robotica-con-mbot-especial-profes/

# data[].attributes.body
https://juegosrobotica.es/retos/reto-12/

# data[].attributes.attachment_link.title
Reto 12: Lector de código de barras con mBot de Makeblock

# data[].attributes.attachment_link.description
Solución al reto 12 en el que se programa mBot para que funcione como un lector de código de barras. Más información sobre este reto en https://juegosrobotica.es/retos/reto-12/

# data[].attributes.attachment_link.title
Reto 10: Sensor sigue líneas de Makeblock como detector de objetos.

# data[].attributes.attachment_link.description
Solución al reto 10 de robótica educativa. Se trata de utilizar el sensor sigue líneas como detector de objetos para poder utilizarlo posteriormente sobre mBot para hacer un robot resuelve laberintos. Preparamos un sencillo programa en mBlock para resolver el reto. Tienes más detalles en https://juegosrobotica.es/retos/reto-10/

# data[].attributes.headline
selección de subprogramas con mando infrarrojos

# data[].attributes.subject
selección de subprogramas con mando infrarrojos

# data[].attributes.body
COMO SALIR DE UN BUCLE A OTRO (BUCLES INFINITOS)

# data[].attributes.attachment_link.title
Consultorio mBlock: selección de subprogramas con mando infrarrojos.

# data[].attributes.attachment_link.description
¿Cómo poder seleccionar entre varios programas que utilizan la instrucción "por siempre" para que puedan salir de ese bucle y pasen de uno a otro? Mario me consulta a través del formulario de contacto de https://juegosrobotica.es de qué manera poder seleccionar diferentes programas cargados en mBot pero que pueden tener la intrucción "por siempre".

# data[].attributes.body
Uploaded by M Millán

# data[].attributes.attachment_link.title
Dancing robot! mBot makes party at bedtime (with mBlock programming)