Proyecto Butiá - Contribuciones del usuario [es]

Ejemplos de Aplicaciones en Butialo

2012-10-15T19:00:08Z

Vacosta: /* Introducción */

__TOC__

==Integrantes==

* Vicente Acosta
* Lourdes Cairelli
* Leticia Vilariño

==Introducción==
[[Butialo|Butialo]] es un entorno fácil de usar que permite programar a Butiá en el lenguaje Lua.

Lua es un lenguaje de scripting imperativo simple pero que a la vez permite crear programas sofisticados. Es un lenguaje dinámico, con manejo de memoria automático y es extremadamente rápido.

Butialo es un IDE derivado de Pippy (el entorno para Python provisto con las XO), que simplifica la creación de programas para Butiá autodetectando la presencia de componentes Butiá conectados y ofreciendo snippets de código para accederlos.

==Objetivos==
Crear programas que sirvan de ejemplo e inspiración. Además del clásico seguidor de línea, se pueden crear ejemplos que saquen provecho de la mayor potencia y expresividad de Lua comparado con TortugArte.

Alguno de los ejemplos a continuación podrán hacer uso de una programación con eventos que ofrece el lenguaje Lua. Se puede encontrar información sobre el uso de los mismos en la [[Butialo|página del entorno Butialo]].

==Ejemplos==

[[Butialo: Ejemplo 1 - Seguidor de líneas sin eventos, utilizando un sensor de grises|Ejemplo 1: Seguidor de líneas sin eventos, utilizando un sensor de grises]]

[[Butialo: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises|Ejemplo 2: Seguidor de líneas con eventos, utilizando un sensor de grises]]

[[Butialo: Ejemplo 3 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises|Ejemplo 3: Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises]]

[[Butialo: Ejemplo 4 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises|Ejemplo 4: Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises]]

[[Butialo: Ejemplo 5 - Seguidor de líneas con eventos, utilizando dos sensores de grises|Ejemplo 5: Seguidor de líneas con eventos, utilizando dos sensores de grises]]

[[Butialo: Ejemplo 6 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises y uno de distancia|Ejemplo 6: Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises y uno de distancia]]

[[Butialo: Ejemplo 7 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia|Ejemplo 7: Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia]]

[[Butialo: Ejemplo 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia|Ejemplo 8: Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia]]

Ejemplos de Aplicaciones en Butialo

2012-10-15T18:59:51Z

Vacosta: /* Objetivos */ Agrego el tema de los eventos

__TOC__

==Integrantes==

* Vicente Acosta
* Lourdes Cairelli
* Leticia Vilariño

==Introducción==
Butialo es un entorno fácil de usar que permite programar a Butiá en el lenguaje Lua.

Lua es un lenguaje de scripting imperativo simple pero que a la vez permite crear programas sofisticados. Es un lenguaje dinámico, con manejo de memoria automático y es extremadamente rápido.

Butialo es un IDE derivado de Pippy (el entorno para Python provisto con las XO), que simplifica la creación de programas para Butiá autodetectando la presencia de componentes Butiá conectados y ofreciendo snippets de código para accederlos.

==Objetivos==
Crear programas que sirvan de ejemplo e inspiración. Además del clásico seguidor de línea, se pueden crear ejemplos que saquen provecho de la mayor potencia y expresividad de Lua comparado con TortugArte.

Alguno de los ejemplos a continuación podrán hacer uso de una programación con eventos que ofrece el lenguaje Lua. Se puede encontrar información sobre el uso de los mismos en la [[Butialo|página del entorno Butialo]].

==Ejemplos==

[[Butialo: Ejemplo 1 - Seguidor de líneas sin eventos, utilizando un sensor de grises|Ejemplo 1: Seguidor de líneas sin eventos, utilizando un sensor de grises]]

[[Butialo: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises|Ejemplo 2: Seguidor de líneas con eventos, utilizando un sensor de grises]]

[[Butialo: Ejemplo 3 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises|Ejemplo 3: Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises]]

[[Butialo: Ejemplo 4 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises|Ejemplo 4: Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises]]

[[Butialo: Ejemplo 5 - Seguidor de líneas con eventos, utilizando dos sensores de grises|Ejemplo 5: Seguidor de líneas con eventos, utilizando dos sensores de grises]]

[[Butialo: Ejemplo 6 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises y uno de distancia|Ejemplo 6: Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises y uno de distancia]]

[[Butialo: Ejemplo 7 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia|Ejemplo 7: Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia]]

[[Butialo: Ejemplo 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia|Ejemplo 8: Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia]]

Butialo: Ejemplo 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-15T18:55:04Z

Vacosta: /* Configuración */

__TOC__

==Descripción==

Se desea implementar un seguidor de líneas de nivel avanzado que permita al robot Butiá seguir el rastro de una línea de color negro sobre el suelo eludiendo obstáculos.

El robot deberá avanzar mientras se encuentre en una zona oscura y no detecte la proximidad de un obstáculo. En caso de salirse de la línea, deberá girar para poder encontrar nuevamente una zona oscura y en caso de detectar un obstáculo procederá a aplicar una técnica de rodeo poder continuar avanzando por la línea de color negro.

==Solución==

'''Descripción'''

Obtenemos el valor de la variable COLOR_NEGRO de la misma forma que lo hicimos en el Ejemplo 1. Además, debemos calibrar el valor de la variable DISTANCIA_OBSTACULO que refiera a la distancia mínima a partir de la cual el robot detecta la presentacia de un obstáculo y por lo tanto deberá esquivar el mismo utilizando una técnica de rodeo.

El robot deberá seguir el rastro de la línea de color negro de la misma forma que se realizó en el Ejemplo 1, chequeando además la presencia de un obstáculo que deberá esquivar para luego regresar a línea negra.

Una vez calibrados los valores de los sensores, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se encuentre en peligro de caer de la mesa, en caso contrario deberá retroceder de forma aleatoria. Luego de que se retrocede aleatoriamente, por un tiempo determinado, se utiliza la función girar_aleatorio() para que la siguiente vez que se avance, se haga en una dirección aleatoria.

<syntaxhighlight lang="lua">
while true do
avanzar()
while (es_negro() and not hay_obstaculo()) do
util.wait(INTERVALO_CHEQUEO)
end
if hay_obstaculo() then
esquivar_obstaculo()
else
buscar_negro()
util.wait(TIEMPO_CENTRADO)
invertir_sentido()
end
end
</syntaxhighlight>

* '''invertir_sentido'''
Cambia el sentido de izquierda a derecha o viceversa.

<syntaxhighlight lang="lua">
local function invertir_sentido()
if sentido == "I" then
sentido = "D"
else
sentido = "I"
end
end
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''retroceder'''
Retrocede el Butiá haciendo que los motores giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function retroceder()
Motors.setvel2mtr(1, MOTOR_VEL, 1, MOTOR_VEL)
end
</syntaxhighlight>

* '''es_negro'''
Retorna un valor booleano que indica si el robot está parado sobre la zona oscura, según el valor obtenido por el sensor de grises y su comparación con la constante COLOR_NEGRO.

<syntaxhighlight lang="lua">
local function es_negro()
local color = Grey_1.getValue()
return (color > COLOR_NEGRO)
end
</syntaxhighlight>

* '''girar'''
Gira el robot en el sentido correspondiente, el cual estará definido por la variable sentido.

<syntaxhighlight lang="lua">
local function girar()
if sentido == "I" then
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
end
end
</syntaxhighlight>

* '''buscar_negro'''
Si el robot no encuentra color negro entonces deberá buscarlo. El robot hace un abanico, girando determinado tiempo en un sentido, para luego girar el doble de tiempo en el sentido opuesto. Esta acción culminará cuando se detecte que el robot está en una zona oscura.

<syntaxhighlight lang="lua">
local function buscar_negro()
tiempo = 0.5
local tiempo_girando
while true do
tiempo_girando = 0
girar()
invertir_sentido()
while (not es_negro() and tiempo_girando <= tiempo) do
util.wait(0.1)
tiempo_girando = tiempo_girando + 0.1
end
if es_negro() then
break
else
tiempo = tiempo * 2
end
end
end
</syntaxhighlight>

* '''hay_obstaculo'''
Retorna un valor booleano que indica si el robot ha detectado la presencia de un obstáculo, según el valor obtenido por el sensor de distancia y su comparación con la constante DISTANCIA_OBSTACULO.

<syntaxhighlight lang="lua">
local function hay_obstaculo()
local distancia = Distanc_2.getValue()
return (distancia > DISTANCIA_OBSTACULO)
end
</syntaxhighlight>

* '''esquivar_obstaculo'''
Al detectar la presencia de un obstáculo, el robot deberá actuar de la siguiente forma:
1) Retroceder un tiempo determinado hasta alejarse lo suficiente como para poder girar.
2) Girar a la derecha 90°.
3) Avanza un tiempo determinado para alejarse del obstáculo.
4) Girar a la izquierda 90°.
5) Avanza un tiempo determinado para poder pasar el obstáculo.
6) Girar a la izquierda 120° (=90*4/3)
7) Avanza para volver a retomar la línea.

<syntaxhighlight lang="lua">
local function esquivar_obstaculo()
local sentido_previo = sentido
retroceder()
util.wait(TIEMPO_RETROCESO)
sentido = "D"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS)
avanzar()
util.wait(TIEMPO_AVANCE)
sentido = "I"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS)
avanzar()
util.wait(TIEMPO_AVANCE * 3)
sentido = "I"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS * 4 / 3)
avanzar()
while (not es_negro()) do
util.wait(INTERVALO_CHEQUEO)
end
sentido = sentido_previo
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano al suelo, pero siempre sin tocarlo, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras del suelo.

Además se debe colocar un sensor de distancia al frente del Butiá, de manera que sense lo que tiene por delante.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_8.png|300px|thumb|center|Configuración]]

==Video==

<youtube>maY-Xjjofp4</youtube>

==Código==

[[Butialo: Ejemplo 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia - Código]]

Butialo: Ejemplo 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-15T18:53:37Z

Vacosta: /* Solución */

__TOC__

==Descripción==

Se desea implementar un seguidor de líneas de nivel avanzado que permita al robot Butiá seguir el rastro de una línea de color negro sobre el suelo eludiendo obstáculos.

El robot deberá avanzar mientras se encuentre en una zona oscura y no detecte la proximidad de un obstáculo. En caso de salirse de la línea, deberá girar para poder encontrar nuevamente una zona oscura y en caso de detectar un obstáculo procederá a aplicar una técnica de rodeo poder continuar avanzando por la línea de color negro.

==Solución==

'''Descripción'''

Obtenemos el valor de la variable COLOR_NEGRO de la misma forma que lo hicimos en el Ejemplo 1. Además, debemos calibrar el valor de la variable DISTANCIA_OBSTACULO que refiera a la distancia mínima a partir de la cual el robot detecta la presentacia de un obstáculo y por lo tanto deberá esquivar el mismo utilizando una técnica de rodeo.

El robot deberá seguir el rastro de la línea de color negro de la misma forma que se realizó en el Ejemplo 1, chequeando además la presencia de un obstáculo que deberá esquivar para luego regresar a línea negra.

Una vez calibrados los valores de los sensores, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se encuentre en peligro de caer de la mesa, en caso contrario deberá retroceder de forma aleatoria. Luego de que se retrocede aleatoriamente, por un tiempo determinado, se utiliza la función girar_aleatorio() para que la siguiente vez que se avance, se haga en una dirección aleatoria.

<syntaxhighlight lang="lua">
while true do
avanzar()
while (es_negro() and not hay_obstaculo()) do
util.wait(INTERVALO_CHEQUEO)
end
if hay_obstaculo() then
esquivar_obstaculo()
else
buscar_negro()
util.wait(TIEMPO_CENTRADO)
invertir_sentido()
end
end
</syntaxhighlight>

* '''invertir_sentido'''
Cambia el sentido de izquierda a derecha o viceversa.

<syntaxhighlight lang="lua">
local function invertir_sentido()
if sentido == "I" then
sentido = "D"
else
sentido = "I"
end
end
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''retroceder'''
Retrocede el Butiá haciendo que los motores giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function retroceder()
Motors.setvel2mtr(1, MOTOR_VEL, 1, MOTOR_VEL)
end
</syntaxhighlight>

* '''es_negro'''
Retorna un valor booleano que indica si el robot está parado sobre la zona oscura, según el valor obtenido por el sensor de grises y su comparación con la constante COLOR_NEGRO.

<syntaxhighlight lang="lua">
local function es_negro()
local color = Grey_1.getValue()
return (color > COLOR_NEGRO)
end
</syntaxhighlight>

* '''girar'''
Gira el robot en el sentido correspondiente, el cual estará definido por la variable sentido.

<syntaxhighlight lang="lua">
local function girar()
if sentido == "I" then
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
end
end
</syntaxhighlight>

* '''buscar_negro'''
Si el robot no encuentra color negro entonces deberá buscarlo. El robot hace un abanico, girando determinado tiempo en un sentido, para luego girar el doble de tiempo en el sentido opuesto. Esta acción culminará cuando se detecte que el robot está en una zona oscura.

<syntaxhighlight lang="lua">
local function buscar_negro()
tiempo = 0.5
local tiempo_girando
while true do
tiempo_girando = 0
girar()
invertir_sentido()
while (not es_negro() and tiempo_girando <= tiempo) do
util.wait(0.1)
tiempo_girando = tiempo_girando + 0.1
end
if es_negro() then
break
else
tiempo = tiempo * 2
end
end
end
</syntaxhighlight>

* '''hay_obstaculo'''
Retorna un valor booleano que indica si el robot ha detectado la presencia de un obstáculo, según el valor obtenido por el sensor de distancia y su comparación con la constante DISTANCIA_OBSTACULO.

<syntaxhighlight lang="lua">
local function hay_obstaculo()
local distancia = Distanc_2.getValue()
return (distancia > DISTANCIA_OBSTACULO)
end
</syntaxhighlight>

* '''esquivar_obstaculo'''
Al detectar la presencia de un obstáculo, el robot deberá actuar de la siguiente forma:
1) Retroceder un tiempo determinado hasta alejarse lo suficiente como para poder girar.
2) Girar a la derecha 90°.
3) Avanza un tiempo determinado para alejarse del obstáculo.
4) Girar a la izquierda 90°.
5) Avanza un tiempo determinado para poder pasar el obstáculo.
6) Girar a la izquierda 120° (=90*4/3)
7) Avanza para volver a retomar la línea.

<syntaxhighlight lang="lua">
local function esquivar_obstaculo()
local sentido_previo = sentido
retroceder()
util.wait(TIEMPO_RETROCESO)
sentido = "D"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS)
avanzar()
util.wait(TIEMPO_AVANCE)
sentido = "I"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS)
avanzar()
util.wait(TIEMPO_AVANCE * 3)
sentido = "I"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS * 4 / 3)
avanzar()
while (not es_negro()) do
util.wait(INTERVALO_CHEQUEO)
end
sentido = sentido_previo
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano al suelo, pero siempre sin tocarlo, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras del suelo.

Además se debe colocar un sensor de distancia al frente, en la parte de adelante del Butiá también encastrando piezas.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_8.png|300px|thumb|center|Configuración]]

==Video==

<youtube>maY-Xjjofp4</youtube>

==Código==

[[Butialo: Ejemplo 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia - Código]]

Butialo: Ejemplo 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-15T18:50:19Z

Vacosta: /* Solución */

__TOC__

==Descripción==

Se desea implementar un seguidor de líneas de nivel avanzado que permita al robot Butiá seguir el rastro de una línea de color negro sobre el suelo eludiendo obstáculos.

El robot deberá avanzar mientras se encuentre en una zona oscura y no detecte la proximidad de un obstáculo. En caso de salirse de la línea, deberá girar para poder encontrar nuevamente una zona oscura y en caso de detectar un obstáculo procederá a aplicar una técnica de rodeo poder continuar avanzando por la línea de color negro.

==Solución==

'''Descripción'''

Obtenemos el valor de la variable COLOR_NEGRO de la misma forma que lo hicimos en el Ejemplo 1. Además, debemos calibrar el valor de la variable DISTANCIA_OBSTACULO que refiera a la distancia mínima a partir de la cual el robot detecta la presentacia de un obstáculo y por lo tanto deberá esquivar el mismo utilizando una técnica de rodeo.

El robot deberá seguir el rastro de la línea de color negro de la misma forma que se realizó en el Ejemplo 1, chequeando además la presencia de un obstáculo que deberá esquivar para luego regresar a línea negra.

Una vez calibrados los valores de los sensores, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se encuentre en peligro de caer de la mesa, en caso contrario deberá retroceder de forma aleatoria. Luego de que se retrocede aleatoriamente, por un tiempo determinado, se utiliza la función girar_aleatorio() para que la siguiente vez que se avance, se haga en una dirección aleatoria.

<syntaxhighlight lang="lua">
while true do
avanzar()
while (es_negro() and not hay_obstaculo()) do
util.wait(INTERVALO_CHEQUEO)
end
if hay_obstaculo() then
esquivar_obstaculo()
else
buscar_negro()
util.wait(TIEMPO_CENTRADO)
invertir_sentido()
end
end
</syntaxhighlight>

* '''invertir_sentido'''
Cambia el sentido de izquierda a derecha o viceversa.

<syntaxhighlight lang="lua">
local function invertir_sentido()
if sentido == "I" then
sentido = "D"
else
sentido = "I"
end
end
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''retroceder'''
Retrocede el Butiá haciendo que los motores giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function retroceder()
Motors.setvel2mtr(1, MOTOR_VEL, 1, MOTOR_VEL)
end
</syntaxhighlight>

* '''es_negro'''
Retorna un valor booleano que indica si el robot está parado sobre la zona oscura, según el valor obtenido por el sensor de grises y su comparación con la constante COLOR_NEGRO.

<syntaxhighlight lang="lua">
local function es_negro()
local color = Grey_1.getValue()
return (color > COLOR_NEGRO)
end
</syntaxhighlight>

* '''girar'''
Gira el robot en el sentido correspondiente, el cual estará definido por la variable sentido.

<syntaxhighlight lang="lua">
local function girar()
if sentido == "I" then
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
end
end
</syntaxhighlight>

* '''buscar_negro'''
Si el robot no encuentra color negro entonces deberá buscarlo. El robot hace un abanico, girando determinado tiempo en un sentido, para luego girar el doble de tiempo en el sentido opuesto. Esta acción culminará cuando se detecte que el robot está en una zona oscura.

<syntaxhighlight lang="lua">
local function buscar_negro()
tiempo = 0.5
local tiempo_girando
while true do
tiempo_girando = 0
girar()
invertir_sentido()
while (not es_negro() and tiempo_girando <= tiempo) do
util.wait(0.1)
tiempo_girando = tiempo_girando + 0.1
end
if es_negro() then
break
else
tiempo = tiempo * 2
end
end
end
</syntaxhighlight>

* '''hay_obstaculo'''
Retorna un valor booleano que indica si el robot ha detectado la presencia de un obstáculo, según el valor obtenido por el sensor de distancia y su comparación con la constante DISTANCIA_OBSTACULO.

<syntaxhighlight lang="lua">
local function hay_obstaculo()
local distancia = Distanc_2.getValue()
return (distancia > DISTANCIA_OBSTACULO)
end
</syntaxhighlight>

* '''esquivar_obstaculo'''
Al detectar la presencia de un obstáculo, el robot deberá actuar de la siguiente forma:
1) Retroceder un tiempo determinado hasta alejarse lo suficiente como para poder girar.
2) Girar a la derecha 90°.
3) Avanza un tiempo determinado para poder pasar el obstáculo.
4) Girar a la izquierda 90°.
5) Avanza para volver a retomar la línea.

<syntaxhighlight lang="lua">
local function esquivar_obstaculo()
local sentido_previo = sentido
retroceder()
util.wait(TIEMPO_RETROCESO)
sentido = "D"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS)
avanzar()
util.wait(TIEMPO_AVANCE)
sentido = "I"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS)
avanzar()
util.wait(TIEMPO_AVANCE * 3)
sentido = "I"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS * 4 / 3)
avanzar()
while (not es_negro()) do
util.wait(INTERVALO_CHEQUEO)
end
sentido = sentido_previo
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano al suelo, pero siempre sin tocarlo, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras del suelo.

Además se debe colocar un sensor de distancia al frente, en la parte de adelante del Butiá también encastrando piezas.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_8.png|300px|thumb|center|Configuración]]

==Video==

<youtube>maY-Xjjofp4</youtube>

==Código==

[[Butialo: Ejemplo 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia - Código]]

Butialo: Ejemplo 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-15T18:50:02Z

Vacosta: /* Solución */

__TOC__

==Descripción==

Se desea implementar un seguidor de líneas de nivel avanzado que permita al robot Butiá seguir el rastro de una línea de color negro sobre el suelo eludiendo obstáculos.

El robot deberá avanzar mientras se encuentre en una zona oscura y no detecte la proximidad de un obstáculo. En caso de salirse de la línea, deberá girar para poder encontrar nuevamente una zona oscura y en caso de detectar un obstáculo procederá a aplicar una técnica de rodeo poder continuar avanzando por la línea de color negro.

==Solución==

'''Descripción'''

Obtenemos el valor de la variable COLOR_NEGRO de la misma forma que lo hicimos en el Ejemplo 1. Además, debemos calibrar el valor de la variable DISTANCIA_OBSTACULO que refiera a la distancia mínima a partir de la cual el robot detecta la presentacia de un obstáculo y por lo tanto deberá esquivar el mismo utilizando una técnica de rodeo.

El robot deberá seguir el rastro de la línea de color negro de la misma forma que se realizó en el Ejemplo 1, chequeando además la presencia de un obstáculo que deberá esquivar para luego regresar a línea negra.

Una vez calibrados los valores de los sensores, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se encuentre en peligro de caer de la mesa, en caso contrario deberá retroceder de forma aleatoria. Luego de que se retrocede aleatoriamente, por un tiempo determinado, se utiliza la función girar_aleatorio() para que la siguiente vez que se avance, se haga en una dirección aleatorio.

<syntaxhighlight lang="lua">
while true do
avanzar()
while (es_negro() and not hay_obstaculo()) do
util.wait(INTERVALO_CHEQUEO)
end
if hay_obstaculo() then
esquivar_obstaculo()
else
buscar_negro()
util.wait(TIEMPO_CENTRADO)
invertir_sentido()
end
end
</syntaxhighlight>

* '''invertir_sentido'''
Cambia el sentido de izquierda a derecha o viceversa.

<syntaxhighlight lang="lua">
local function invertir_sentido()
if sentido == "I" then
sentido = "D"
else
sentido = "I"
end
end
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''retroceder'''
Retrocede el Butiá haciendo que los motores giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function retroceder()
Motors.setvel2mtr(1, MOTOR_VEL, 1, MOTOR_VEL)
end
</syntaxhighlight>

* '''es_negro'''
Retorna un valor booleano que indica si el robot está parado sobre la zona oscura, según el valor obtenido por el sensor de grises y su comparación con la constante COLOR_NEGRO.

<syntaxhighlight lang="lua">
local function es_negro()
local color = Grey_1.getValue()
return (color > COLOR_NEGRO)
end
</syntaxhighlight>

* '''girar'''
Gira el robot en el sentido correspondiente, el cual estará definido por la variable sentido.

<syntaxhighlight lang="lua">
local function girar()
if sentido == "I" then
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
end
end
</syntaxhighlight>

* '''buscar_negro'''
Si el robot no encuentra color negro entonces deberá buscarlo. El robot hace un abanico, girando determinado tiempo en un sentido, para luego girar el doble de tiempo en el sentido opuesto. Esta acción culminará cuando se detecte que el robot está en una zona oscura.

<syntaxhighlight lang="lua">
local function buscar_negro()
tiempo = 0.5
local tiempo_girando
while true do
tiempo_girando = 0
girar()
invertir_sentido()
while (not es_negro() and tiempo_girando <= tiempo) do
util.wait(0.1)
tiempo_girando = tiempo_girando + 0.1
end
if es_negro() then
break
else
tiempo = tiempo * 2
end
end
end
</syntaxhighlight>

* '''hay_obstaculo'''
Retorna un valor booleano que indica si el robot ha detectado la presencia de un obstáculo, según el valor obtenido por el sensor de distancia y su comparación con la constante DISTANCIA_OBSTACULO.

<syntaxhighlight lang="lua">
local function hay_obstaculo()
local distancia = Distanc_2.getValue()
return (distancia > DISTANCIA_OBSTACULO)
end
</syntaxhighlight>

* '''esquivar_obstaculo'''
Al detectar la presencia de un obstáculo, el robot deberá actuar de la siguiente forma:
1) Retroceder un tiempo determinado hasta alejarse lo suficiente como para poder girar.
2) Girar a la derecha 90°.
3) Avanza un tiempo determinado para poder pasar el obstáculo.
4) Girar a la izquierda 90°.
5) Avanza para volver a retomar la línea.

<syntaxhighlight lang="lua">
local function esquivar_obstaculo()
local sentido_previo = sentido
retroceder()
util.wait(TIEMPO_RETROCESO)
sentido = "D"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS)
avanzar()
util.wait(TIEMPO_AVANCE)
sentido = "I"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS)
avanzar()
util.wait(TIEMPO_AVANCE * 3)
sentido = "I"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS * 4 / 3)
avanzar()
while (not es_negro()) do
util.wait(INTERVALO_CHEQUEO)
end
sentido = sentido_previo
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano al suelo, pero siempre sin tocarlo, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras del suelo.

Además se debe colocar un sensor de distancia al frente, en la parte de adelante del Butiá también encastrando piezas.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_8.png|300px|thumb|center|Configuración]]

==Video==

<youtube>maY-Xjjofp4</youtube>

==Código==

[[Butialo: Ejemplo 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia - Código]]

Butialo: Ejemplo 7 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia

2012-10-15T18:48:30Z

Vacosta: /* Solución */

__TOC__

==Descripción==
Se desea implementar utilizando eventos un programa que permita al robot Butiá poder desplazarse en una mesa sin caerse de la misma.

Inicialmente el robot sorteará hacia dónde desplazarse (avanzar o retroceder). En caso de detectar un color distinto al de la mesa o bien detectar una distancia mayor a la separación con la mesa el robot deberá volver al centro de la misma
para regresar al estado inicial y luego comenzar otra vez.

==Solución==

'''Descripción'''

Obtenemos los valores de la variable COLOR_MESA, DISTANCIA_MESA, MIN_TIEMPO_RETROCESO, MAX_TIEMPO_RETROCESO, MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO de la misma forma que lo hicimos en el Ejemplo 6.

Como podemos apreciar en el ejemplo anterior, el robot tiene un comportamiento que claramente se adapta al paradigma reactivo. Esto es, SENSAR - ACTUAR. Cambiará su estado dependiendo de dos condiciones que le indican si el color sensado se corresponde con el de la mesa (COLOR_MESA) o si la distancia sensada es distinta a la distancia que hay entre el sensor y la mesa (DISTANCIA_MESA).

Distinguimos entonces tres estados posibles según las diferentes condiciones (ADELANTE_FUERA_MESA, ATRAS_FUERA_MESA, EN_LA_MESA) sean verdaderas o falsas. Si se cumple la condición ADELANTE_FUERA_MESA (ATRAS_FUERA_MESA), el robot deberá retroceder (avanzar) un tiempo aleatorio definido entre el rango MIN_TIEMPO_RETROCESO y MAX_TIEMPO_RETROCESO y luego girar de forma aleatoria también por un tiempo entre el rango MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO. En caso contrario, el robot deberá desplazarse en la mesa.

Finalmente se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se cumpla alguna de las condiciones para cambiar de estado y en tal caso, se ejecutará la función asociada al evento correspondiente

<syntaxhighlight lang="lua">
events.add(puedo_seguir, '==', ADELANTE_FUERA_MESA, volver_inicio)
events.add(puedo_seguir, '==', ATRAS_FUERA_MESA, volver_inicio)
events.add(puedo_seguir, '==', EN_LA_MESA, moverse)

events.go()
</syntaxhighlight>

* '''moverse'''
Esta función permite que el robot avance o retroceda dependiendo del sentido que deba tomar.

<syntaxhighlight lang="lua">
local function moverse()
local sentido = chequear_avance_o_retrocedo();
if(sentido) then
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
else
Motors.setvel2mtr(1, MOTOR_VEL, 1, MOTOR_VEL)
end
end
</syntaxhighlight>

* '''chequear_avance_o_retrocedo'''
Retorna un valor booleano que indica si el robot debe avanzar. Para desplazarse de forma aleatoria, adelante o atrás, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el desplazamiento será hacia adelante, retornando True y en caso contrario deberá desplazarse hacia atrás retornando False.

<syntaxhighlight lang="lua">
local function chequear_avance_o_retrocedo()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''puedo_seguir'''
Retorna un valor booleano que indica si el robot se encuentra en peligro de caerse, según el valor obtenido por el sensor de grises y su comparación con la variable COLOR_MESA y el valor obtenido por el sensor de distancia y su comparación con la variable DISTANCIA_MESA. También define el valor de la variable debe_avanzar, la cual dependiendo de quién detecte que el robot se encuentra en peligro de caer definirá los valores para distinguir la acción a tomar: el valor será false si se detectó con el sensor de grises y será true si se detectó con el sensor de distancia.

<syntaxhighlight lang="lua">
local function puedo_seguir()
if Grey_2.getValue() > COLOR_MESA then
ret = ADELANTE_FUERA_MESA
else
if Distanc_6.getValue() < DISTANCIA_MESA then
ret = ATRAS_FUERA_MESA
else
ret = EN_LA_MESA
end
end
return ret
end
</syntaxhighlight>

* '''chequear_giro_izquierda'''
Retorna un valor booleano que indica si el robot debe girar hacia la izquierda. Para girar de forma aleatoria, a izquierda o derecha, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el giro será hacia la izquierda, retornando True y en caso contrario deberá girar a la derecha retornando False.

<syntaxhighlight lang="lua">
local function chequear_giro_izquierda()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''girar_aleatorio'''
Nuevamente utilizamos la función random para obtener un número aleatorio entre MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO y así definir el tiempo durante el cual el robot estará girando. Luego chequeamos con la función chequear_giro_izquierda() si el giro será en sentido izquierdo o derecho, dependiendo de ese valor se procederá entonces a girar en ese sentido con una velocidad definida por la variable VELOCIDAD_GIRO.

<syntaxhighlight lang="lua">
local function girar_aleatorio()
local tiempo_giro = math.random(MIN_TIEMPO_GIRO, MAX_TIEMPO_GIRO)
local izquierda = chequear_giro_izquierda()
if (izquierda) then
Motors.setvel2mtr(0, VELOCIDAD_GIRO, 1, VELOCIDAD_GIRO)
else
Motors.setvel2mtr(1, VELOCIDAD_GIRO, 0, VELOCIDAD_GIRO)
end
util.wait(tiempo_giro)
end
</syntaxhighlight>

* '''volver_inicio'''
Esta función se encarga de que el robot vuelva al centro de la mesa, que es su posición inicial. Para esto utiliza la variable debe_avanzar que indica si el robot debe avanzar o retroceder dependiendo su posición actual.

<syntaxhighlight lang="lua">
local function volver_inicio()
if (debe_avanzar) then
Motors.setvel2mtr(0, VELOCIDAD_RETROCESO, 0, VELOCIDAD_RETROCESO)
else
Motors.setvel2mtr(1, VELOCIDAD_RETROCESO, 1, VELOCIDAD_RETROCESO)
end
util.wait(TIEMPO_VOLVER_INICIO)
girar_aleatorio()
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano a la mesa, pero siempre sin tocarla, en la parte de adelante del Butiá. También se debe colocar un sensor de distancia en la parte trasera del Butiá, en nuestro caso a una altura de al menos 3 cm con respecto a la mesa. Esto último debe ser así pues el sensor de distancia utilizado devuelve valores incorrectos para distancias menores a 3cm.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras de la mesa.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_7.png|300px|thumb|center|Configuración]]

==Video==

<youtube>5SJudk4umpU</youtube>

==Código==

[[Butialo: Ejemplo 7 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia - Código]]

Butialo: Ejemplo 6 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-15T18:39:50Z

Vacosta: /* Solución */

__TOC__

==Descripción==
Se desea implementar un programa que permita al robot Butiá poder desplazarse en una mesa sin caerse de la misma.

Inicialmente el robot sorteará hacia dónde desplazarse (avanzar o retroceder). En caso de detectar un color distinto al de la mesa o bien detectar una distancia mayor a la separación con la mesa el robot deberá volver al centro de la misma
para regresar al estado inicial y luego comenzar otra vez.

==Solución==

'''Descripción'''

Como fue explicado en ejemplos anteriores, el sensor de escala de grises (en este caso, se conectó el sensor al puerto 2, por eso su nombre es “Grey_2”) debe ser calibrado previamente a la ejecución del programa a desarrollar para poder obtener los respectivos valores límites a partir del cual definimos que el robot se encuentra sobre la mesa.

Calculando el valor medio, obtuvimos el valor de la variable COLOR_MESA (55000 para las pruebas realizadas).
Determinamos entonces que si el valor arrojado por el sensor es menor a 55000, el robot puede continuar avanzando sin peligro de caer de la mesa, en caso contrario se deberá evitar la caída.

Además usaremos un sensor de distancia, el cual debe ser calibrado previamente también. Para ello, colocamos el sensor sobre la mesa y utilizamos la función Distanc_6.getValue() que nos brinda el entorno Butialo (en este caso se colocó el sensor de distancia en el puerto 6, por eso su nombre es Distanc_6). Nos arrojará un valor que tendremos identificado como “DISTANCIA_MESA”.

Posteriormente, colocamos el sensor fuera de la mesa y obtenemos un nuevo valor. Con dicho valor y el anterior, calculamos el valor medio (21000 para las pruebas realizadas). De esta forma obtenemos el valor de la variable DISTANCIA_MESA que refiere a la distancia a partir de la cual el robot detecta la presencia de la mesa. Determinamos entonces que si el valor arrojado por el sensor es menor a 21000, el robot puede continuar avanzando sin peligro de caer de la mesa, en caso contrario se deberá evitar la caída.

Una vez calibrados los sensores y obtenidos los respectivos valores de tiempo máximo y mínimo de giro y retroceso, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en desplazar el robot de forma aleatoria, para adelante o para atrás, hasta tanto no se encuentre en peligro de caer de la mesa. En caso contrario, deberá retroceder o avanzar dependiendo de cuál sensor detectó que el robot se encuentra en peligro de caer de la mesa. Luego de que el robot se encuentra lo más cercano a su posición inicial, el centro de la mesa, se utiliza la función girar_aleatorio() para que el siguiente movimiento del mismo se realice en una dirección aleatoria.

<syntaxhighlight lang="lua">
while true do
moverse()
while (puedo_avanzar()) do
util.wait(INTERVALO_CHEQUEO)
end
volver_inicio()
end
</syntaxhighlight>

* '''moverse'''
Esta función permite que el robot avance o retroceda dependiendo del sentido que deba tomar.

<syntaxhighlight lang="lua">
local function moverse()
local sentido = chequear_avance_o_retrocedo();
if(sentido) then
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
else
Motors.setvel2mtr(1, MOTOR_VEL, 1, MOTOR_VEL)
end
end
</syntaxhighlight>

* '''chequear_avance_o_retrocedo'''
Retorna un valor booleano que indica si el robot debe avanzar. Para desplazarse de forma aleatoria, adelante o atrás, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el desplazamiento será hacia adelante, retornando True y en caso contrario deberá desplazarse hacia atrás retornando False.

<syntaxhighlight lang="lua">
local function chequear_avance_o_retrocedo()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''puedo_avanzar'''
Retorna un valor booleano que indica si el robot se encuentra en peligro de caerse, según el valor obtenido por el sensor de grises y su comparación con la variable COLOR_MESA y el valor obtenido por el sensor de distancia y su comparación con la variable DISTANCIA_MESA. También define el valor de la variable debe_avanzar, la cual dependiendo de quién detecte que el robot se encuentra en peligro de caer definirá los valores para distinguir la acción a tomar: el valor será false si se detectó con el sensor de grises y será true si se detectó con el sensor de distancia.

<syntaxhighlight lang="lua">
local function puedo_avanzar()
local ret
if Grey_2.getValue() < COLOR_MESA and Distanc_6.getValue() >= DISTANCIA_MESA then
ret = true
else
ret = false
end
if(not ret) then
if(Grey_2.getValue() > COLOR_MESA) then
debe_avanzar = false
else
debe_avanzar = true
end
end
return ret
end</syntaxhighlight>

* '''chequear_giro_izquierda'''
Retorna un valor booleano que indica si el robot debe girar hacia la izquierda. Para girar de forma aleatoria, a izquierda o derecha, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el giro será hacia la izquierda, retornando True y en caso contrario deberá girar a la derecha retornando False.

<syntaxhighlight lang="lua">
local function chequear_giro_izquierda()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''girar_aleatorio'''
Nuevamente utilizamos la función random para obtener un número aleatorio entre MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO y así definir el tiempo durante el cual el robot estará girando. Luego chequeamos con la función chequear_giro_izquierda() si el giro será en sentido izquierdo o derecho, dependiendo de ese valor se procederá entonces a girar en ese sentido con una velocidad definida por la variable VELOCIDAD_GIRO.

<syntaxhighlight lang="lua">
local function girar_aleatorio()
local tiempo_giro = math.random(MIN_TIEMPO_GIRO, MAX_TIEMPO_GIRO)
local izquierda = chequear_giro_izquierda()
if (izquierda) then
Motors.setvel2mtr(0, VELOCIDAD_GIRO, 1, VELOCIDAD_GIRO)
else
Motors.setvel2mtr(1, VELOCIDAD_GIRO, 0, VELOCIDAD_GIRO)
end
util.wait(tiempo_giro)
end
</syntaxhighlight>

* '''volver_inicio'''
Esta función se encarga de que el robot vuelva al centro de la mesa, que es su posición inicial.
Para esto utiliza la variable debe_avanzar que indica si el robot debe avanzar o retroceder dependiendo su posición actual.

<syntaxhighlight lang="lua">
local function volver_inicio()
if (debe_avanzar) then
Motors.setvel2mtr(0, VELOCIDAD_RETROCESO, 0, VELOCIDAD_RETROCESO)
else
Motors.setvel2mtr(1, VELOCIDAD_RETROCESO, 1, VELOCIDAD_RETROCESO)
end
util.wait(TIEMPO_VOLVER_INICIO)
girar_aleatorio()
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano a la mesa, pero siempre sin tocarla, en la parte de adelante del Butiá. También se debe colocar un sensor de distancia en la parte trasera del Butiá, en nuestro caso a una altura de al menos 3 cm con respecto a la mesa. Esto último debe ser así pues el sensor de distancia utilizado devuelve valores incorrectos para distancias menores a 3cm.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras de la mesa.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_6.png|300px|thumb|center|Configuración]]

==Video==

<youtube>OsuOKwmCiqs</youtube>

==Código==

[[Butialo: Ejemplo 6 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises y uno de distancia - Código]]

Butialo: Ejemplo 5 - Seguidor de líneas con eventos, utilizando dos sensores de grises

2012-10-15T18:37:19Z

Vacosta: /* Configuración */

__TOC__

==Descripción==

Se desea implementar utilizando eventos un programa que permita al robot Butiá seguir el rastro de una línea de color negro sobre el suelo.

El robot deberá avanzar mientras se encuentre en una zona oscura y en caso de salirse de la misma se tendrán tres alternativas posibles para poder encontrar nuevamente una zona oscura, dependiendo de cuál sensor detectó que el robot se ha salido de la zona.

==Solución==

'''Descripción'''

Obtenemos el valor de la variable COLOR_NEGRO de la misma forma que lo hicimos en el Ejemplo 1.

Como podemos apreciar en el Ejemplo 1, el robot tiene un comportamiento que claramente se adapta al paradigma reactivo. Esto es, SENSAR - ACTUAR. Cambiará su estado dependiendo de una condición que le indica para cada sensor si el color sensado se corresponde con el color negro (COLOR_NEGRO).

Distinguimos entonces cuatro estados posibles: NEGRO_AMBOS, NEGRO_IZQUIERDO, NEGRO_DERECHO y BLANCO.
Cuando ambos sensores detectan el color negro, el robot se encuentra en el estado NEGRO_AMBOS. Por lo cual el robot deberá avanzar.
Si el sensor izquierdo detecta el color negro y el sensor derecho no, entonces el robot se encuentra en el estado NEGRO_IZQUIERDO. El robot aquí deberá girar en sentido izquierdo para tratar de no salirse de la línea.
Si el sensor derecho detecta el color negro y el sensor izquierdo no, entonces el robot se encuentra en el estado NEGRO_DERECHO. Análogamente, el robot deberá girar en sentido derecho.
En caso contrario, el estado será BLANCO y al perder la línea con ambos sensores el robot se detiene.

Finalmente se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se cumpla alguna de las condiciones para cambiar de estado y en tal caso, se ejecutará la función asociada al evento correspondiente.

<syntaxhighlight lang="lua">
events.add(obtener_estado, '==', NEGRO_IZQUIERDO, girar_izquierda)
events.add(obtener_estado, '==', NEGRO_DERECHO, girar_derecha)
events.add(obtener_estado, '==', NEGRO_AMBOS, avanzar)
events.add(obtener_estado, '==', BLANCO, detener)
events.go()
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''detener'''
Detiene los motores.

<syntaxhighlight lang="lua">
local function detener()
Motors.setvel2mtr(0, 0, 0, 0)
end
</syntaxhighlight>

* '''es_negro'''
Retorna un valor booleano que indica si el robot está parado sobre la zona oscura, según el valor obtenido por el sensor de grises y su comparación con la constante COLOR_NEGRO.

<syntaxhighlight lang="lua">
local function es_negro(valor)
return (valor > COLOR_NEGRO)
end
</syntaxhighlight>

* '''girar_derecha'''
Gira el robot hacia la derecha con una velocidad definida por la variable MOTOR_GIRO_VEL.

<syntaxhighlight lang="lua">
local function girar_derecha()
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,0,0)
end
</syntaxhighlight>

* '''girar_izquierda'''
Gira el robot hacia la izquierda con una velocidad definida por la variable MOTOR_GIRO_VEL.

<syntaxhighlight lang="lua">
local function girar_izquierda()
Motors.setvel2mtr(0,0,0,MOTOR_GIRO_VEL)
end
</syntaxhighlight>

* '''obtener_estado'''
Retorna el estado correspondiente, dependiendo de los valores obtenidos en cada uno de los sensores de grises.

<syntaxhighlight lang="lua">
local function obtener_estado()
negro_izquierda = es_negro(Grey_1.getValue())
negro_derecha = es_negro(Grey_2.getValue())
if (negro_izquierda and negro_derecha) then
return NEGRO_AMBOS
elseif (negro_izquierda) then
return NEGRO_IZQUIERDO
elseif (negro_derecha) then
return NEGRO_DERECHA
else
return BLANCO
end
end
</syntaxhighlight>

==Configuración==

Se deben colocar dos sensores de escala de grises lo más cercano al suelo, pero siempre sin tocarla, en la parte de adelante del Butiá. Dichos sensores deben estar lo suficientemente juntos como para que cuando se coloque el Butiá en el suelo, ambos sensores estén sobre la línea negra.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir los sensores al Butiá, quedando dichos sensores a ras del suelo.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_5.png|300px|thumb|center|Configuración]]

==Video==

<youtube>-P_puOseUMc</youtube>

==Código==

[[Butialo: Ejemplo 5 - Seguidor de líneas con eventos, utilizando dos sensores de grises - Código]]

Butialo: Ejemplo 5 - Seguidor de líneas con eventos, utilizando dos sensores de grises

2012-10-15T18:35:51Z

Vacosta: /* Solución */

__TOC__

==Descripción==

Se desea implementar utilizando eventos un programa que permita al robot Butiá seguir el rastro de una línea de color negro sobre el suelo.

El robot deberá avanzar mientras se encuentre en una zona oscura y en caso de salirse de la misma se tendrán tres alternativas posibles para poder encontrar nuevamente una zona oscura, dependiendo de cuál sensor detectó que el robot se ha salido de la zona.

==Solución==

'''Descripción'''

Obtenemos el valor de la variable COLOR_NEGRO de la misma forma que lo hicimos en el Ejemplo 1.

Como podemos apreciar en el Ejemplo 1, el robot tiene un comportamiento que claramente se adapta al paradigma reactivo. Esto es, SENSAR - ACTUAR. Cambiará su estado dependiendo de una condición que le indica para cada sensor si el color sensado se corresponde con el color negro (COLOR_NEGRO).

Distinguimos entonces cuatro estados posibles: NEGRO_AMBOS, NEGRO_IZQUIERDO, NEGRO_DERECHO y BLANCO.
Cuando ambos sensores detectan el color negro, el robot se encuentra en el estado NEGRO_AMBOS. Por lo cual el robot deberá avanzar.
Si el sensor izquierdo detecta el color negro y el sensor derecho no, entonces el robot se encuentra en el estado NEGRO_IZQUIERDO. El robot aquí deberá girar en sentido izquierdo para tratar de no salirse de la línea.
Si el sensor derecho detecta el color negro y el sensor izquierdo no, entonces el robot se encuentra en el estado NEGRO_DERECHO. Análogamente, el robot deberá girar en sentido derecho.
En caso contrario, el estado será BLANCO y al perder la línea con ambos sensores el robot se detiene.

Finalmente se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se cumpla alguna de las condiciones para cambiar de estado y en tal caso, se ejecutará la función asociada al evento correspondiente.

<syntaxhighlight lang="lua">
events.add(obtener_estado, '==', NEGRO_IZQUIERDO, girar_izquierda)
events.add(obtener_estado, '==', NEGRO_DERECHO, girar_derecha)
events.add(obtener_estado, '==', NEGRO_AMBOS, avanzar)
events.add(obtener_estado, '==', BLANCO, detener)
events.go()
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''detener'''
Detiene los motores.

<syntaxhighlight lang="lua">
local function detener()
Motors.setvel2mtr(0, 0, 0, 0)
end
</syntaxhighlight>

* '''es_negro'''
Retorna un valor booleano que indica si el robot está parado sobre la zona oscura, según el valor obtenido por el sensor de grises y su comparación con la constante COLOR_NEGRO.

<syntaxhighlight lang="lua">
local function es_negro(valor)
return (valor > COLOR_NEGRO)
end
</syntaxhighlight>

* '''girar_derecha'''
Gira el robot hacia la derecha con una velocidad definida por la variable MOTOR_GIRO_VEL.

<syntaxhighlight lang="lua">
local function girar_derecha()
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,0,0)
end
</syntaxhighlight>

* '''girar_izquierda'''
Gira el robot hacia la izquierda con una velocidad definida por la variable MOTOR_GIRO_VEL.

<syntaxhighlight lang="lua">
local function girar_izquierda()
Motors.setvel2mtr(0,0,0,MOTOR_GIRO_VEL)
end
</syntaxhighlight>

* '''obtener_estado'''
Retorna el estado correspondiente, dependiendo de los valores obtenidos en cada uno de los sensores de grises.

<syntaxhighlight lang="lua">
local function obtener_estado()
negro_izquierda = es_negro(Grey_1.getValue())
negro_derecha = es_negro(Grey_2.getValue())
if (negro_izquierda and negro_derecha) then
return NEGRO_AMBOS
elseif (negro_izquierda) then
return NEGRO_IZQUIERDO
elseif (negro_derecha) then
return NEGRO_DERECHA
else
return BLANCO
end
end
</syntaxhighlight>

==Configuración==

Se deben colocar dos sensores de escala de grises lo más cercano al suelo, pero siempre sin tocarla, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir los sensores al Butiá, quedando dichos sensores a ras del suelo.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_5.png|300px|thumb|center|Configuración]]

==Video==

<youtube>-P_puOseUMc</youtube>

==Código==

[[Butialo: Ejemplo 5 - Seguidor de líneas con eventos, utilizando dos sensores de grises - Código]]

Butialo: Ejemplo 3 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises

2012-10-15T18:29:58Z

Vacosta: /* Solución */

__TOC__

==Descripción==
Se desea implementar un programa que permita al robot Butiá poder desplazarse en una mesa sin caerse de la misma.

El robot deberá avanzar mientras detecte un color semejante al de la mesa. En caso de detectar un color distinto al de la mesa, procederá a retroceder por un tiempo aleatorio para luego girar en un sentido aleatorio (izquierda o derecha), y así poder avanzar nuevamente.

==Solución==

'''Descripción'''

Como fue explicado en ejemplos anteriores, el sensor de escala de grises (en este caso, se conectó el sensor al puerto 2, por eso su nombre es “Grey_2”) debe ser calibrado previamente a la ejecución del programa a desarrollar para poder obtener los respectivos valores límites a partir del cual definimos que el robot se encuentra sobre la mesa.

Calculando el valor medio, obtuvimos el valor de la variable COLOR_MESA (43000 para las pruebas realizadas).
Determinamos entonces que si el valor arrojado por el sensor es menor a 43000, el robot puede continuar avanzando sin peligro de caer de la mesa, en caso contrario se deberá evitar la caída.

El robot deberá retroceder en un tiempo aleatorio, dicho valor deberá ser calibrado en las variables MIN_TIEMPO_RETROCESO y MAX_TIEMPO_RETROCESO de forma de contemplar que no se caiga de la mesa en caso de que el tiempo sea muy grande. Para ello el robot se colocará en el centro de la mesa. De la misma forma, se calibrará los valores de MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO, considerando aquí los posibles valores entre 1° y 90° aproximadamente.

Una vez calibrado el sensor y obtenidos los respectivos valores de tiempo máximo y mínimo de giro y retroceso, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se encuentre en peligro de caer de la mesa, en caso contrario deberá retroceder de forma aleatoria. Luego de que se retrocede aleatoriamente, por un tiempo determinado, se utiliza la función girar_aleatorio() para que gire en un sentido aleatorio cuando deje de retroceder, y la siguiente vez que se avance, lo haga con otra dirección.

<syntaxhighlight lang="lua">
while true do
avanzar()
while (puedo_avanzar()) do
util.wait(INTERVALO_CHEQUEO)
end
retroceder_aleatorio()
girar_aleatorio()
end
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''puedo_avanzar'''
Retorna un valor booleano que indica si el robot se encuentra en peligro de caerse, según el valor obtenido por el sensor de grises y su comparación con la variable COLOR_MESA.

<syntaxhighlight lang="lua">
local function puedo_avanzar()
return (Grey_2.getValue() < COLOR_MESA)
end</syntaxhighlight>

* '''chequear_giro_izquierda'''
Retorna un valor booleano que indica si el robot debe girar hacia la izquierda. Para girar de forma aleatoria, a izquierda o derecha, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el giro será hacia la izquierda, retornando True y en caso contrario deberá girar a la derecha retornando False.

<syntaxhighlight lang="lua">
local function chequear_giro_izquierda()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''girar_aleatorio'''
Nuevamente utilizamos la función random para obtener un número aleatorio entre MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO y así definir el tiempo durante el cual el robot estará girando. Luego chequeamos con la función chequear_giro_izquierda() si el giro será en sentido izquierdo o derecho, dependiendo de ese valor se procederá entonces a girar en ese sentido con una velocidad definida por la variable VELOCIDAD_GIRO.

<syntaxhighlight lang="lua">
local function girar_aleatorio()
local tiempo_giro = math.random(MIN_TIEMPO_GIRO, MAX_TIEMPO_GIRO)
local izquierda = chequear_giro_izquierda()
if (izquierda) then
Motors.setvel2mtr(0, VELOCIDAD_GIRO, 1, VELOCIDAD_GIRO)
else
Motors.setvel2mtr(1, VELOCIDAD_GIRO, 0, VELOCIDAD_GIRO)
end
util.wait(tiempo_giro)
end
</syntaxhighlight>

* '''retroceder_aleatorio'''
Utilizamos la función random para obtener un número aleatorio entre MIN_TIEMPO_RETROCESO y MAX_TIEMPO_RETROCESO y así definir el tiempo durante el cual el robot estará retrocediendo.

<syntaxhighlight lang="lua">
local function retroceder_aleatorio()
local tiempo_retroceso = math.random(MIN_TIEMPO_RETROCESO, MAX_TIEMPO_RETROCESO)
Motors.setvel2mtr(1, VELOCIDAD_RETROCESO, 1, VELOCIDAD_RETROCESO)
util.wait(tiempo_retroceso)
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano a la mesa, pero siempre sin tocarla, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras de la mesa.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_3.png|300px|thumb|center|Configuración]]

==Video==

<youtube>H3Ri7VNSrM8</youtube>

==Código==

[[Butialo: Ejemplo 3 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises - Código]]

Butialo: Ejemplo 4 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises

2012-10-15T18:29:03Z

Vacosta: /* Solución */

__TOC__

==Descripción==
Se desea implementar utilizando eventos un programa que permita al robot Butiá poder desplazarse en una mesa sin caerse de la misma.

El robot deberá avanzar mientras detecte un color semejante al de la mesa. En caso de detectar un color distinto al de la mesa, procederá a retroceder por un tiempo aleatorio para luego cambiar de sentido (izquierda o derecha), y así poder avanzar nuevamente.

==Solución==

'''Descripción'''

Obtenemos los valores de la variable COLOR_MESA, MIN_TIEMPO_RETROCESO, MAX_TIEMPO_RETROCESO, MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO de la misma forma que lo hicimos en el Ejemplo 3.

Como podemos apreciar en el ejemplo anterior, el robot tiene un comportamiento que claramente se adapta al paradigma reactivo. Esto es, SENSAR - ACTUAR. Cambiará su estado dependiendo de una condición que le indica si el color sensado se corresponde con el de la mesa (COLOR_MESA).

Distinguimos entonces dos estados posibles según la condición sea verdadera o falsa. Si se cumple la condición, el robot deberá retroceder en un tiempo aleatorio definido entre el rango MIN_TIEMPO_RETROCESO y MAX_TIEMPO_RETROCESO y luego girar de forma aleatoria también por un tiempo entre el rango MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO.
En caso contrario, el robot deberá avanzar.

Finalmente se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se encuentre en peligro de caer de la mesa, en caso contrario deberá retroceder de forma aleatoria. Luego de que se retrocede aleatoriamente, por un tiempo determinado, se utiliza la función girar_aleatorio() para que gire en un sentido aleatorio cuando deje de retroceder, y la siguiente vez que se avance, lo haga con otra dirección.

<syntaxhighlight lang="lua">
events.add(Grey_2.getValue, '>=', COLOR_MESA,retroceder_y_girar_aleatorio)
events.add(Grey_2.getValue, '<', COLOR_MESA, avanzar)
events.go()
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''retroceder_y_girar_aleatorio'''
Retrocede y luego gira de forma aleatoria.

<syntaxhighlight lang="lua">
local function retroceder_y_girar_aleatorio()
retroceder_aleatorio()
girar_aleatorio()
end
</syntaxhighlight>

* '''chequear_giro_izquierda'''
Retorna un valor booleano que indica si el robot debe girar hacia la izquierda. Para girar de forma aleatoria, a izquierda o derecha, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el giro será hacia la izquierda, retornando True y en caso contrario deberá girar a la derecha retornando False.

<syntaxhighlight lang="lua">
local function chequear_giro_izquierda()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''girar_aleatorio'''
Nuevamente utilizamos la función random para obtener un número aleatorio entre MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO y así definir el tiempo durante el cual el robot estará girando. Luego chequeamos con la función chequear_giro_izquierda() si el giro será en sentido izquierdo o derecho, dependiendo de ese valor se procederá entonces a girar en ese sentido con una velocidad definida por la variable VELOCIDAD_GIRO.

<syntaxhighlight lang="lua">
local function girar_aleatorio()
local tiempo_giro = math.random(MIN_TIEMPO_GIRO, MAX_TIEMPO_GIRO)
local izquierda = chequear_giro_izquierda()
if (izquierda) then
Motors.setvel2mtr(0, VELOCIDAD_GIRO, 1, VELOCIDAD_GIRO)
else
Motors.setvel2mtr(1, VELOCIDAD_GIRO, 0, VELOCIDAD_GIRO)
end
util.wait(tiempo_giro)
end
</syntaxhighlight>

* '''retroceder_aleatorio'''
Utilizamos la función random para obtener un número aleatorio entre MIN_TIEMPO_RETROCESO y MAX_TIEMPO_RETROCESO y así definir el tiempo durante el cual el robot estará retrocediendo.

<syntaxhighlight lang="lua">
local function retroceder_aleatorio()
local tiempo_retroceso = math.random(MIN_TIEMPO_RETROCESO, MAX_TIEMPO_RETROCESO)
Motors.setvel2mtr(1, VELOCIDAD_RETROCESO, 1, VELOCIDAD_RETROCESO)
util.wait(tiempo_retroceso)
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano a la mesa, pero siempre sin tocarla, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras de la mesa.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_4.png|300px|thumb|center|Configuración]]

==Video==

<youtube>MmQjJZjHFgQ</youtube>

==Código==

[[Butialo: Ejemplo 4 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises - Código]]

Butialo: Ejemplo 3 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises

2012-10-15T18:24:09Z

Vacosta: /* Descripción */

__TOC__

==Descripción==
Se desea implementar un programa que permita al robot Butiá poder desplazarse en una mesa sin caerse de la misma.

El robot deberá avanzar mientras detecte un color semejante al de la mesa. En caso de detectar un color distinto al de la mesa, procederá a retroceder por un tiempo aleatorio para luego girar en un sentido aleatorio (izquierda o derecha), y así poder avanzar nuevamente.

==Solución==

'''Descripción'''

Como fue explicado en ejemplos anteriores, el sensor de escala de grises (en este caso, se conectó el sensor al puerto 2, por eso su nombre es “Grey_2”) debe ser calibrado previamente a la ejecución del programa a desarrollar para poder obtener los respectivos valores límites a partir del cual definimos que el robot se encuentra sobre la mesa.

Calculando el valor medio, obtuvimos el valor de la variable COLOR_MESA (43000 para las pruebas realizadas).
Determinamos entonces que si el valor arrojado por el sensor es menor a 43000, el robot puede continuar avanzando sin peligro de caer de la mesa, en caso contrario se deberá evitar la caída.

El robot deberá retroceder en un tiempo aleatorio, dicho valor deberá ser calibrado en las variables MIN_TIEMPO_RETROCESO y MAX_TIEMPO_RETROCESO de forma de contemplar que no se caiga de la mesa en caso de que el tiempo sea muy grande. Para ello el robot se colocará en el centro de la mesa. De la misma forma, se calibrará los valores de MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO, considerando aquí los posibles valores entre 1° y 90° aproximadamente.

Una vez calibrado el sensor y obtenidos los respectivos valores de tiempo máximo y mínimo de giro y retroceso, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se encuentre en peligro de caer de la mesa, en caso contrario deberá retroceder de forma aleatoria. Luego de que se retrocede aleatoriamente, por un tiempo determinado, se utiliza la función girar_aleatorio() para que la siguiente vez que se avance, se haga en un sentido aleatorio.

<syntaxhighlight lang="lua">
while true do
avanzar()
while (puedo_avanzar()) do
util.wait(INTERVALO_CHEQUEO)
end
retroceder_aleatorio()
girar_aleatorio()
end
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''puedo_avanzar'''
Retorna un valor booleano que indica si el robot se encuentra en peligro de caerse, según el valor obtenido por el sensor de grises y su comparación con la variable COLOR_MESA.

<syntaxhighlight lang="lua">
local function puedo_avanzar()
return (Grey_2.getValue() < COLOR_MESA)
end</syntaxhighlight>

* '''chequear_giro_izquierda'''
Retorna un valor booleano que indica si el robot debe girar hacia la izquierda. Para girar de forma aleatoria, a izquierda o derecha, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el giro será hacia la izquierda, retornando True y en caso contrario deberá girar a la derecha retornando False.

<syntaxhighlight lang="lua">
local function chequear_giro_izquierda()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''girar_aleatorio'''
Nuevamente utilizamos la función random para obtener un número aleatorio entre MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO y así definir el tiempo durante el cual el robot estará girando. Luego chequeamos con la función chequear_giro_izquierda() si el giro será en sentido izquierdo o derecho, dependiendo de ese valor se procederá entonces a girar en ese sentido con una velocidad definida por la variable VELOCIDAD_GIRO.

<syntaxhighlight lang="lua">
local function girar_aleatorio()
local tiempo_giro = math.random(MIN_TIEMPO_GIRO, MAX_TIEMPO_GIRO)
local izquierda = chequear_giro_izquierda()
if (izquierda) then
Motors.setvel2mtr(0, VELOCIDAD_GIRO, 1, VELOCIDAD_GIRO)
else
Motors.setvel2mtr(1, VELOCIDAD_GIRO, 0, VELOCIDAD_GIRO)
end
util.wait(tiempo_giro)
end
</syntaxhighlight>

* '''retroceder_aleatorio'''
Utilizamos la función random para obtener un número aleatorio entre MIN_TIEMPO_RETROCESO y MAX_TIEMPO_RETROCESO y así definir el tiempo durante el cual el robot estará retrocediendo.

<syntaxhighlight lang="lua">
local function retroceder_aleatorio()
local tiempo_retroceso = math.random(MIN_TIEMPO_RETROCESO, MAX_TIEMPO_RETROCESO)
Motors.setvel2mtr(1, VELOCIDAD_RETROCESO, 1, VELOCIDAD_RETROCESO)
util.wait(tiempo_retroceso)
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano a la mesa, pero siempre sin tocarla, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras de la mesa.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_3.png|300px|thumb|center|Configuración]]

==Video==

<youtube>H3Ri7VNSrM8</youtube>

==Código==

[[Butialo: Ejemplo 3 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises - Código]]

Butialo: Ejemplo 6 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-15T18:17:12Z

Vacosta: /* Video */

__TOC__

==Descripción==
Se desea implementar un programa que permita al robot Butiá poder desplazarse en una mesa sin caerse de la misma.

Inicialmente el robot sorteará hacia dónde desplazarse (avanzar o retroceder). En caso de detectar un color distinto al de la mesa o bien detectar una distancia mayor a la separación con la mesa el robot deberá volver al centro de la misma
para regresar al estado inicial y luego comenzar otra vez.

==Solución==

'''Descripción'''

Como fue explicado en ejemplos anteriores, el sensor de escala de grises (en este caso, se conectó el sensor al puerto 2, por eso su nombre es “Grey_2”) debe ser calibrado previamente a la ejecución del programa a desarrollar para poder obtener los respectivos valores límites a partir del cual definimos que el robot se encuentra sobre la mesa.

Calculando el valor medio, obtuvimos el valor de la variable COLOR_MESA (55000 para las pruebas realizadas).
Determinamos entonces que si el valor arrojado por el sensor es menor a 55000, el robot puede continuar avanzando sin peligro de caer de la mesa, en caso contrario se deberá evitar la caída.

Además usaremos un sensor de distancia, el cual debe ser calibrado previamente también. Para ello, colocamos el sensor sobre la mesa y utilizamos la función Distanc_6.getValue() que nos brinda el entorno Butialo (en este caso se colocó el sensor de distancia en el puerto 6, por eso su nombre es Distanc_6). Nos arrojará un valor que tendremos identificado como “DISTANCIA_MESA”.

Posteriormente, colocamos el sensor fuera de la mesa y obtenemos un nuevo valor. Con dicho valor y el anterior, calculamos el valor medio (21000 para las pruebas realizadas). De esta forma obtenemos el valor de la variable DISTANCIA_MESA que refiere a la distancia a partir de la cual el robot detecta la presencia de la mesa. Determinamos entonces que si el valor arrojado por el sensor es menor a 21000, el robot puede continuar avanzando sin peligro de caer de la mesa, en caso contrario se deberá evitar la caída.

Una vez calibrados los sensores y obtenidos los respectivos valores de tiempo máximo y mínimo de giro y retroceso, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en desplazar el robot de forma aleatoria, para adelante o para atrás, hasta tanto no se encuentre en peligro de caer de la mesa. En caso contrario, deberá retroceder o avanzar dependiendo de cuál sensor detectó que el robot se encuentra en peligro de caer de la mesa. Luego de que el robot se encuentra lo más cercano a su posición inicial, el centro de la mesa, se utiliza la función girar_aleatorio() para que el siguiente movimiento del mismo se realice en un sentido aleatorio.

<syntaxhighlight lang="lua">
while true do
moverse()
while (puedo_avanzar()) do
util.wait(INTERVALO_CHEQUEO)
end
volver_inicio()
end
</syntaxhighlight>

* '''moverse'''
Esta función permite que el robot avance o retroceda dependiendo del sentido que deba tomar.

<syntaxhighlight lang="lua">
local function moverse()
local sentido = chequear_avance_o_retrocedo();
if(sentido) then
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
else
Motors.setvel2mtr(1, MOTOR_VEL, 1, MOTOR_VEL)
end
end
</syntaxhighlight>

* '''chequear_avance_o_retrocedo'''
Retorna un valor booleano que indica si el robot debe avanzar. Para desplazarse de forma aleatoria, adelante o atrás, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el desplazamiento será hacia adelante, retornando True y en caso contrario deberá desplazarse hacia atrás retornando False.

<syntaxhighlight lang="lua">
local function chequear_avance_o_retrocedo()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''puedo_avanzar'''
Retorna un valor booleano que indica si el robot se encuentra en peligro de caerse, según el valor obtenido por el sensor de grises y su comparación con la variable COLOR_MESA y el valor obtenido por el sensor de distancia y su comparación con la variable DISTANCIA_MESA. También define el valor de la variable debe_avanzar, la cual dependiendo de quién detecte que el robot se encuentra en peligro de caer definirá los valores para distinguir la acción a tomar: el valor será false si se detectó con el sensor de grises y será true si se detectó con el sensor de distancia.

<syntaxhighlight lang="lua">
local function puedo_avanzar()
local ret
if Grey_2.getValue() < COLOR_MESA and Distanc_6.getValue() >= DISTANCIA_MESA then
ret = true
else
ret = false
end
if(not ret) then
if(Grey_2.getValue() > COLOR_MESA) then
debe_avanzar = false
else
debe_avanzar = true
end
end
return ret
end</syntaxhighlight>

* '''chequear_giro_izquierda'''
Retorna un valor booleano que indica si el robot debe girar hacia la izquierda. Para girar de forma aleatoria, a izquierda o derecha, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el giro será hacia la izquierda, retornando True y en caso contrario deberá girar a la derecha retornando False.

<syntaxhighlight lang="lua">
local function chequear_giro_izquierda()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''girar_aleatorio'''
Nuevamente utilizamos la función random para obtener un número aleatorio entre MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO y así definir el tiempo durante el cual el robot estará girando. Luego chequeamos con la función chequear_giro_izquierda() si el giro será en sentido izquierdo o derecho, dependiendo de ese valor se procederá entonces a girar en ese sentido con una velocidad definida por la variable VELOCIDAD_GIRO.

<syntaxhighlight lang="lua">
local function girar_aleatorio()
local tiempo_giro = math.random(MIN_TIEMPO_GIRO, MAX_TIEMPO_GIRO)
local izquierda = chequear_giro_izquierda()
if (izquierda) then
Motors.setvel2mtr(0, VELOCIDAD_GIRO, 1, VELOCIDAD_GIRO)
else
Motors.setvel2mtr(1, VELOCIDAD_GIRO, 0, VELOCIDAD_GIRO)
end
util.wait(tiempo_giro)
end
</syntaxhighlight>

* '''volver_inicio'''
Esta función se encarga de que el robot vuelva al centro de la mesa, que es su posición inicial.
Para esto utiliza la variable debe_avanzar que indica si el robot debe avanzar o retroceder dependiendo su posición actual.

<syntaxhighlight lang="lua">
local function volver_inicio()
if (debe_avanzar) then
Motors.setvel2mtr(0, VELOCIDAD_RETROCESO, 0, VELOCIDAD_RETROCESO)
else
Motors.setvel2mtr(1, VELOCIDAD_RETROCESO, 1, VELOCIDAD_RETROCESO)
end
util.wait(TIEMPO_VOLVER_INICIO)
girar_aleatorio()
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano a la mesa, pero siempre sin tocarla, en la parte de adelante del Butiá. También se debe colocar un sensor de distancia en la parte trasera del Butiá, en nuestro caso a una altura de al menos 3 cm con respecto a la mesa. Esto último debe ser así pues el sensor de distancia utilizado devuelve valores incorrectos para distancias menores a 3cm.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras de la mesa.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_6.png|300px|thumb|center|Configuración]]

==Video==

<youtube>OsuOKwmCiqs</youtube>

==Código==

[[Butialo: Ejemplo 6 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises y uno de distancia - Código]]

Butialo: Ejemplo 7 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia

2012-10-15T18:16:29Z

Vacosta:

__TOC__

==Descripción==
Se desea implementar utilizando eventos un programa que permita al robot Butiá poder desplazarse en una mesa sin caerse de la misma.

Inicialmente el robot sorteará hacia dónde desplazarse (avanzar o retroceder). En caso de detectar un color distinto al de la mesa o bien detectar una distancia mayor a la separación con la mesa el robot deberá volver al centro de la misma
para regresar al estado inicial y luego comenzar otra vez.

==Solución==

'''Descripción'''

Obtenemos los valores de la variable COLOR_MESA, DISTANCIA_MESA, MIN_TIEMPO_RETROCESO, MAX_TIEMPO_RETROCESO, MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO de la misma forma que lo hicimos en el Ejemplo 6.

Como podemos apreciar en el ejemplo anterior, el robot tiene un comportamiento que claramente se adapta al paradigma reactivo. Esto es, SENSAR - ACTUAR. Cambiará su estado dependiendo de dos condiciones que le indican si el color sensado se corresponde con el de la mesa (COLOR_MESA) o si la distancia sensada es distinta a la distancia que hay entre el sensor y la mesa (DISTANCIA_MESA).

Distinguimos entonces tres estados posibles según las diferentes condiciones (ADELANTE_FUERA_MESA, ATRAS_FUERA_MESA, EN_LA_MESA) sean verdaderas o falsas. Si se cumple la condición ADELANTE_FUERA_MESA (ATRAS_FUERA_MESA), el robot deberá retroceder (avanzar) un tiempo aleatorio definido entre el rango MIN_TIEMPO_RETROCESO y MAX_TIEMPO_RETROCESO y luego girar de forma aleatoria también por un tiempo entre el rango MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO. En caso contrario, el robot deberá desplazarse en la mesa.

Finalmente se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se cumpla alguna de las condiciones para cambiar de estado y en tal caso, se ejecutará la función asociada al evento correspondiente

<syntaxhighlight lang="lua">
events.add(puedo_seguir, '==', ADELANTE_FUERA_MESA, volver_inicio)
events.add(puedo_seguir, '==', ADELANTE_FUERA_MESA, volver_inicio)
events.add(puedo_seguir, '==', EN_MESA, moverse)

events.go()
</syntaxhighlight>

* '''moverse'''
Esta función permite que el robot avance o retroceda dependiendo del sentido que deba tomar.

<syntaxhighlight lang="lua">
local function moverse()
local sentido = chequear_avance_o_retrocedo();
if(sentido) then
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
else
Motors.setvel2mtr(1, MOTOR_VEL, 1, MOTOR_VEL)
end
end
</syntaxhighlight>

* '''chequear_avance_o_retrocedo'''
Retorna un valor booleano que indica si el robot debe avanzar. Para desplazarse de forma aleatoria, adelante o atrás, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el desplazamiento será hacia adelante, retornando True y en caso contrario deberá desplazarse hacia atrás retornando False.

<syntaxhighlight lang="lua">
local function chequear_avance_o_retrocedo()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''puedo_avanzar'''
Retorna un valor booleano que indica si el robot se encuentra en peligro de caerse, según el valor obtenido por el sensor de grises y su comparación con la variable COLOR_MESA y el valor obtenido por el sensor de distancia y su comparación con la variable DISTANCIA_MESA. También define el valor de la variable debe_avanzar, la cual dependiendo de quién detecte que el robot se encuentra en peligro de caer definirá los valores para distinguir la acción a tomar: el valor será false si se detectó con el sensor de grises y será true si se detectó con el sensor de distancia.

<syntaxhighlight lang="lua">
local function puedo_seguir()
if Grey_2.getValue() > COLOR_MESA then
ret = ADELANTE_FUERA_MESA
else
if Distanc_6.getValue() < DISTANCIA_MESA then
ret = ATRAS_FUERA_MESA
else
ret = EN_LA_MESA
end
end
return ret
end
</syntaxhighlight>

* '''chequear_giro_izquierda'''
Retorna un valor booleano que indica si el robot debe girar hacia la izquierda. Para girar de forma aleatoria, a izquierda o derecha, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el giro será hacia la izquierda, retornando True y en caso contrario deberá girar a la derecha retornando False.

<syntaxhighlight lang="lua">
local function chequear_giro_izquierda()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''girar_aleatorio'''
Nuevamente utilizamos la función random para obtener un número aleatorio entre MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO y así definir el tiempo durante el cual el robot estará girando. Luego chequeamos con la función chequear_giro_izquierda() si el giro será en sentido izquierdo o derecho, dependiendo de ese valor se procederá entonces a girar en ese sentido con una velocidad definida por la variable VELOCIDAD_GIRO.

<syntaxhighlight lang="lua">
local function girar_aleatorio()
local tiempo_giro = math.random(MIN_TIEMPO_GIRO, MAX_TIEMPO_GIRO)
local izquierda = chequear_giro_izquierda()
if (izquierda) then
Motors.setvel2mtr(0, VELOCIDAD_GIRO, 1, VELOCIDAD_GIRO)
else
Motors.setvel2mtr(1, VELOCIDAD_GIRO, 0, VELOCIDAD_GIRO)
end
util.wait(tiempo_giro)
end
</syntaxhighlight>

* '''volver_inicio'''
Esta función se encarga de que el robot vuelva al centro de la mesa, que es su posición inicial. Para esto utiliza la variable debe_avanzar que indica si el robot debe avanzar o retroceder dependiendo su posición actual.

<syntaxhighlight lang="lua">
local function volver_inicio()
if (debe_avanzar) then
Motors.setvel2mtr(0, VELOCIDAD_RETROCESO, 0, VELOCIDAD_RETROCESO)
else
Motors.setvel2mtr(1, VELOCIDAD_RETROCESO, 1, VELOCIDAD_RETROCESO)
end
util.wait(TIEMPO_VOLVER_INICIO)
girar_aleatorio()
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano a la mesa, pero siempre sin tocarla, en la parte de adelante del Butiá. También se debe colocar un sensor de distancia en la parte trasera del Butiá, en nuestro caso a una altura de al menos 3 cm con respecto a la mesa. Esto último debe ser así pues el sensor de distancia utilizado devuelve valores incorrectos para distancias menores a 3cm.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras de la mesa.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_7.png|300px|thumb|center|Configuración]]

==Video==

<youtube>5SJudk4umpU</youtube>

==Código==

[[Butialo: Ejemplo 7 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia - Código]]

Butialo: Ejemplo 7 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia

2012-10-15T18:12:28Z

Vacosta:

__TOC__

==Descripción==
Se desea implementar utilizando eventos un programa que permita al robot Butiá poder desplazarse en una mesa sin caerse de la misma.

Inicialmente el robot sorteará hacia dónde desplazarse (avanzar o retroceder). En caso de detectar un color distinto al de la mesa o bien detectar una distancia mayor a la separación con la mesa el robot deberá volver al centro de la misma
para regresar al estado inicial y luego comenzar otra vez.

==Solución==

'''Descripción'''

Obtenemos los valores de la variable COLOR_MESA, DISTANCIA_MESA, MIN_TIEMPO_RETROCESO, MAX_TIEMPO_RETROCESO, MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO de la misma forma que lo hicimos en el Ejemplo 6.

Como podemos apreciar en el ejemplo anterior, el robot tiene un comportamiento que claramente se adapta al paradigma reactivo. Esto es, SENSAR - ACTUAR. Cambiará su estado dependiendo de dos condiciones que le indican si el color sensado se corresponde con el de la mesa (COLOR_MESA) o si la distancia sensada es distinta a la distancia que hay entre el sensor y la mesa (DISTANCIA_MESA).

Distinguimos entonces tres estados posibles según las diferentes condiciones (ADELANTE_FUERA_MESA, ATRAS_FUERA_MESA, EN_LA_MESA) sean verdaderas o falsas. Si se cumple la condición ADELANTE_FUERA_MESA (ATRAS_FUERA_MESA), el robot deberá retroceder (avanzar) un tiempo aleatorio definido entre el rango MIN_TIEMPO_RETROCESO y MAX_TIEMPO_RETROCESO y luego girar de forma aleatoria también por un tiempo entre el rango MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO. En caso contrario, el robot deberá desplazarse en la mesa.

Finalmente se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se cumpla alguna de las condiciones para cambiar de estado y en tal caso, se ejecutará la función asociada al evento correspondiente

<syntaxhighlight lang="lua">
events.add(puedo_seguir, '==', ADELANTE_FUERA_MESA, volver_inicio)
events.add(puedo_seguir, '==', ADELANTE_FUERA_MESA, volver_inicio)
events.add(puedo_seguir, '==', EN_MESA, moverse)

events.go()
</syntaxhighlight>

* '''moverse'''
Esta función permite que el robot avance o retroceda dependiendo del sentido que deba tomar.

<syntaxhighlight lang="lua">
local function moverse()
local sentido = chequear_avance_o_retrocedo();
if(sentido) then
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
else
Motors.setvel2mtr(1, MOTOR_VEL, 1, MOTOR_VEL)
end
end
</syntaxhighlight>

* '''chequear_avance_o_retrocedo'''
Retorna un valor booleano que indica si el robot debe avanzar. Para desplazarse de forma aleatoria, adelante o atrás, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el desplazamiento será hacia adelante, retornando True y en caso contrario deberá desplazarse hacia atrás retornando False.

<syntaxhighlight lang="lua">
local function chequear_avance_o_retrocedo()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''puedo_avanzar'''
Retorna un valor booleano que indica si el robot se encuentra en peligro de caerse, según el valor obtenido por el sensor de grises y su comparación con la variable COLOR_MESA y el valor obtenido por el sensor de distancia y su comparación con la variable DISTANCIA_MESA. También define el valor de la variable debe_avanzar, la cual dependiendo de quién detecte que el robot se encuentra en peligro de caer definirá los valores para distinguir la acción a tomar: el valor será false si se detectó con el sensor de grises y será true si se detectó con el sensor de distancia.

<syntaxhighlight lang="lua">
local function puedo_seguir()
if Grey_2.getValue() > COLOR_MESA then
ret = ADELANTE_FUERA_MESA
else
if Distanc_6.getValue() < DISTANCIA_MESA then
ret = ATRAS_FUERA_MESA
else
ret = EN_LA_MESA
end
end
return ret
end
</syntaxhighlight>

* '''chequear_giro_izquierda'''
Retorna un valor booleano que indica si el robot debe girar hacia la izquierda. Para girar de forma aleatoria, a izquierda o derecha, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el giro será hacia la izquierda, retornando True y en caso contrario deberá girar a la derecha retornando False.

<syntaxhighlight lang="lua">
local function chequear_giro_izquierda()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''girar_aleatorio'''
Nuevamente utilizamos la función random para obtener un número aleatorio entre MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO y así definir el tiempo durante el cual el robot estará girando. Luego chequeamos con la función chequear_giro_izquierda() si el giro será en sentido izquierdo o derecho, dependiendo de ese valor se procederá entonces a girar en ese sentido con una velocidad definida por la variable VELOCIDAD_GIRO.

<syntaxhighlight lang="lua">
local function girar_aleatorio()
local tiempo_giro = math.random(MIN_TIEMPO_GIRO, MAX_TIEMPO_GIRO)
local izquierda = chequear_giro_izquierda()
if (izquierda) then
Motors.setvel2mtr(0, VELOCIDAD_GIRO, 1, VELOCIDAD_GIRO)
else
Motors.setvel2mtr(1, VELOCIDAD_GIRO, 0, VELOCIDAD_GIRO)
end
util.wait(tiempo_giro)
end
</syntaxhighlight>

* '''volver_inicio'''
Esta función se encarga de que el robot vuelva al centro de la mesa, que es su posición inicial. Para esto utiliza la variable debe_avanzar que indica si el robot debe avanzar o retroceder dependiendo su posición actual.

<syntaxhighlight lang="lua">
local function volver_inicio()
if (debe_avanzar) then
Motors.setvel2mtr(0, VELOCIDAD_RETROCESO, 0, VELOCIDAD_RETROCESO)
else
Motors.setvel2mtr(1, VELOCIDAD_RETROCESO, 1, VELOCIDAD_RETROCESO)
end
util.wait(TIEMPO_VOLVER_INICIO)
girar_aleatorio()
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano a la mesa, pero siempre sin tocarla, en la parte de adelante del Butiá. También se debe colocar un sensor de distancia en la parte trasera del Butiá, en nuestro caso a una altura de al menos 3 cm con respecto a la mesa. Esto último debe ser así pues el sensor de distancia utilizado devuelve valores incorrectos para distancias menores a 3cm.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras de la mesa.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_7.png|300px|thumb|center|Configuración]]

==Video==

<youtube>H3Ri7VNSrM8</youtube>

==Código==

[[Butialo: Ejemplo 7 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia - Código]]

Butialo: Ejemplo 6 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-15T18:12:02Z

Vacosta:

__TOC__

==Descripción==
Se desea implementar un programa que permita al robot Butiá poder desplazarse en una mesa sin caerse de la misma.

Inicialmente el robot sorteará hacia dónde desplazarse (avanzar o retroceder). En caso de detectar un color distinto al de la mesa o bien detectar una distancia mayor a la separación con la mesa el robot deberá volver al centro de la misma
para regresar al estado inicial y luego comenzar otra vez.

==Solución==

'''Descripción'''

Como fue explicado en ejemplos anteriores, el sensor de escala de grises (en este caso, se conectó el sensor al puerto 2, por eso su nombre es “Grey_2”) debe ser calibrado previamente a la ejecución del programa a desarrollar para poder obtener los respectivos valores límites a partir del cual definimos que el robot se encuentra sobre la mesa.

Calculando el valor medio, obtuvimos el valor de la variable COLOR_MESA (55000 para las pruebas realizadas).
Determinamos entonces que si el valor arrojado por el sensor es menor a 55000, el robot puede continuar avanzando sin peligro de caer de la mesa, en caso contrario se deberá evitar la caída.

Además usaremos un sensor de distancia, el cual debe ser calibrado previamente también. Para ello, colocamos el sensor sobre la mesa y utilizamos la función Distanc_6.getValue() que nos brinda el entorno Butialo (en este caso se colocó el sensor de distancia en el puerto 6, por eso su nombre es Distanc_6). Nos arrojará un valor que tendremos identificado como “DISTANCIA_MESA”.

Posteriormente, colocamos el sensor fuera de la mesa y obtenemos un nuevo valor. Con dicho valor y el anterior, calculamos el valor medio (21000 para las pruebas realizadas). De esta forma obtenemos el valor de la variable DISTANCIA_MESA que refiere a la distancia a partir de la cual el robot detecta la presencia de la mesa. Determinamos entonces que si el valor arrojado por el sensor es menor a 21000, el robot puede continuar avanzando sin peligro de caer de la mesa, en caso contrario se deberá evitar la caída.

Una vez calibrados los sensores y obtenidos los respectivos valores de tiempo máximo y mínimo de giro y retroceso, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en desplazar el robot de forma aleatoria, para adelante o para atrás, hasta tanto no se encuentre en peligro de caer de la mesa. En caso contrario, deberá retroceder o avanzar dependiendo de cuál sensor detectó que el robot se encuentra en peligro de caer de la mesa. Luego de que el robot se encuentra lo más cercano a su posición inicial, el centro de la mesa, se utiliza la función girar_aleatorio() para que el siguiente movimiento del mismo se realice en un sentido aleatorio.

<syntaxhighlight lang="lua">
while true do
moverse()
while (puedo_avanzar()) do
util.wait(INTERVALO_CHEQUEO)
end
volver_inicio()
end
</syntaxhighlight>

* '''moverse'''
Esta función permite que el robot avance o retroceda dependiendo del sentido que deba tomar.

<syntaxhighlight lang="lua">
local function moverse()
local sentido = chequear_avance_o_retrocedo();
if(sentido) then
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
else
Motors.setvel2mtr(1, MOTOR_VEL, 1, MOTOR_VEL)
end
end
</syntaxhighlight>

* '''chequear_avance_o_retrocedo'''
Retorna un valor booleano que indica si el robot debe avanzar. Para desplazarse de forma aleatoria, adelante o atrás, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el desplazamiento será hacia adelante, retornando True y en caso contrario deberá desplazarse hacia atrás retornando False.

<syntaxhighlight lang="lua">
local function chequear_avance_o_retrocedo()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''puedo_avanzar'''
Retorna un valor booleano que indica si el robot se encuentra en peligro de caerse, según el valor obtenido por el sensor de grises y su comparación con la variable COLOR_MESA y el valor obtenido por el sensor de distancia y su comparación con la variable DISTANCIA_MESA. También define el valor de la variable debe_avanzar, la cual dependiendo de quién detecte que el robot se encuentra en peligro de caer definirá los valores para distinguir la acción a tomar: el valor será false si se detectó con el sensor de grises y será true si se detectó con el sensor de distancia.

<syntaxhighlight lang="lua">
local function puedo_avanzar()
local ret
if Grey_2.getValue() < COLOR_MESA and Distanc_6.getValue() >= DISTANCIA_MESA then
ret = true
else
ret = false
end
if(not ret) then
if(Grey_2.getValue() > COLOR_MESA) then
debe_avanzar = false
else
debe_avanzar = true
end
end
return ret
end</syntaxhighlight>

* '''chequear_giro_izquierda'''
Retorna un valor booleano que indica si el robot debe girar hacia la izquierda. Para girar de forma aleatoria, a izquierda o derecha, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el giro será hacia la izquierda, retornando True y en caso contrario deberá girar a la derecha retornando False.

<syntaxhighlight lang="lua">
local function chequear_giro_izquierda()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''girar_aleatorio'''
Nuevamente utilizamos la función random para obtener un número aleatorio entre MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO y así definir el tiempo durante el cual el robot estará girando. Luego chequeamos con la función chequear_giro_izquierda() si el giro será en sentido izquierdo o derecho, dependiendo de ese valor se procederá entonces a girar en ese sentido con una velocidad definida por la variable VELOCIDAD_GIRO.

<syntaxhighlight lang="lua">
local function girar_aleatorio()
local tiempo_giro = math.random(MIN_TIEMPO_GIRO, MAX_TIEMPO_GIRO)
local izquierda = chequear_giro_izquierda()
if (izquierda) then
Motors.setvel2mtr(0, VELOCIDAD_GIRO, 1, VELOCIDAD_GIRO)
else
Motors.setvel2mtr(1, VELOCIDAD_GIRO, 0, VELOCIDAD_GIRO)
end
util.wait(tiempo_giro)
end
</syntaxhighlight>

* '''volver_inicio'''
Esta función se encarga de que el robot vuelva al centro de la mesa, que es su posición inicial.
Para esto utiliza la variable debe_avanzar que indica si el robot debe avanzar o retroceder dependiendo su posición actual.

<syntaxhighlight lang="lua">
local function volver_inicio()
if (debe_avanzar) then
Motors.setvel2mtr(0, VELOCIDAD_RETROCESO, 0, VELOCIDAD_RETROCESO)
else
Motors.setvel2mtr(1, VELOCIDAD_RETROCESO, 1, VELOCIDAD_RETROCESO)
end
util.wait(TIEMPO_VOLVER_INICIO)
girar_aleatorio()
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano a la mesa, pero siempre sin tocarla, en la parte de adelante del Butiá. También se debe colocar un sensor de distancia en la parte trasera del Butiá, en nuestro caso a una altura de al menos 3 cm con respecto a la mesa. Esto último debe ser así pues el sensor de distancia utilizado devuelve valores incorrectos para distancias menores a 3cm.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras de la mesa.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_6.png|300px|thumb|center|Configuración]]

==Video==

<youtube>H3Ri7VNSrM8</youtube>

==Código==

[[Butialo: Ejemplo 6 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises y uno de distancia - Código]]

Ejemplos de Aplicaciones en Butialo

2012-10-15T18:04:02Z

Vacosta: Ejemplos butialo 2011 trasladada a Ejemplos de Aplicaciones en Butialo

__TOC__

==Integrantes==

* Vicente Acosta
* Lourdes Cairelli
* Leticia Vilariño

==Introducción==
Butialo es un entorno fácil de usar que permite programar a Butiá en el lenguaje Lua.

Lua es un lenguaje de scripting imperativo simple pero que a la vez permite crear programas sofisticados. Es un lenguaje dinámico, con manejo de memoria automático y es extremadamente rápido.

Butialo es un IDE derivado de Pippy (el entorno para Python provisto con las XO), que simplifica la creación de programas para Butiá autodetectando la presencia de componentes Butiá conectados y ofreciendo snippets de código para accederlos.

==Objetivos==
Crear programas que sirvan de ejemplo e inspiración. Además del clásico seguidor de línea, se pueden crear ejemplos que saquen provecho de la mayor potencia y expresividad de Lua comparado con TortugArte.

==Ejemplos==

[[Butialo: Ejemplo 1 - Seguidor de líneas sin eventos, utilizando un sensor de grises|Ejemplo 1: Seguidor de líneas sin eventos, utilizando un sensor de grises]]

[[Butialo: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises|Ejemplo 2: Seguidor de líneas con eventos, utilizando un sensor de grises]]

[[Butialo: Ejemplo 3 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises|Ejemplo 3: Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises]]

[[Butialo: Ejemplo 4 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises|Ejemplo 4: Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises]]

[[Butialo: Ejemplo 5 - Seguidor de líneas con eventos, utilizando dos sensores de grises|Ejemplo 5: Seguidor de líneas con eventos, utilizando dos sensores de grises]]

[[Butialo: Ejemplo 6 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises y uno de distancia|Ejemplo 6: Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises y uno de distancia]]

[[Butialo: Ejemplo 7 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia|Ejemplo 7: Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia]]

[[Butialo: Ejemplo 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia|Ejemplo 8: Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia]]

Ejemplos butialo 2011

2012-10-15T18:04:02Z

Vacosta: Ejemplos butialo 2011 trasladada a Ejemplos de Aplicaciones en Butialo

#REDIRECCIÓN [[Ejemplos de Aplicaciones en Butialo]]

Butialo: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises

2012-10-15T18:02:27Z

Vacosta: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises trasladada a Butialo: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises

__TOC__

==Descripción==
Se desea Implementar un seguidor de líneas básico que permite al robot Butiá seguir el rastro de una línea de color negro sobre el suelo, utilizando un sensor de grises.

El robot deberá avanzar mientras se encuentre en una zona oscura y en caso de salirse de la misma, girar para poder encontrar nuevamente una zona oscura.

La programación de la solución deberá usar los eventos que provee el lenguaje Lua.

==Solución==

'''Descripción'''

Al igual que en el ejemplo 1, es necesario calibrar el sensor antes de comenzar.

Una vez calibrado el sensor, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''
Consiste en avanzar el robot hasta tanto el color de la línea sea negro, en caso contrario deberá buscar dicho color realizando un movimiento en forma de abanico.

Para esto, se agrega un evento que si detecta que el Butiá está sobre la línea negra se llama a la función "avanzar", y si el robot encuentra una sola blanca significa que se desvió de la línea negra y por tanto es necesario buscarla, usando la función "buscar_negro".

<syntaxhighlight lang="lua">
events.add(Grey_1.getValue, '>=', COLOR_NEGRO, avanzar)

evento_blanco_encontrado = events.add(Grey_1.getValue, '<', COLOR_NEGRO, buscar_negro)

events.go()
</syntaxhighlight>

* '''avanzar'''
Si se estaba buscando la línea de color negro y se invocó esta función, es porque dicha línea fue encontrada, y por tanto se remueve el evento que tenía como objetivo "hacer un abanico" hasta encontrar la línea. Además, se vuelve a agregar el evento que activa la búsqueda de la línea negra cuando se encuentra el color blanco.

La variable TIEMPO_CENTRADO tiene como objetivo hacer que el Butiá, luego de encontrar la línea negra se mueve un poco más hacia el centro de la misma, para poder hacer el recorrido de forma más eficiente.

Por último, activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
if buscando_negro then
-- Remueve el evento para que se deje de buscar el color negro
events.remove(evento_buscar_negro)
-- Vuelve a agregar el evento que la funci\u00f3n buscar_negro removi\u00f3
evento_blanco_encontrado = events.add(Grey_1.getValue, '<', COLOR_NEGRO, buscar_negro)

buscando_negro = false
tiempo = 0.5
invertir_sentido()
util.wait(TIEMPO_CENTRADO)
end

Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''buscar_negro'''
Esta función tiene como objetivo "hacer un abanico" hasta encontrar nuevamente la línea negra.

Si es la primera vez que se invoca (o sea, el Butiá iba por la línea negra y encontró una zona blanca) se deshabilita el evento "evento_blanco_encontrado" para poder realizar la rutina de búsqueda sin que ambos eventos se "pisen". Esto es necesario porque simultáneamente se estarían dando las condiciones para que se ejecuten los 2 eventos (evento_blanco_encontrado y evento_buscar_negro) pero en este caso sólo es de interés que se ejecute la rutina de búsqueda haciendo el abanico (evento_buscar_negro).

Se usa la variable "tiempo" para incrementar el tiempo en el que gira en cada uno de los sentidos el Butiá.

Nótese que para poder realizar el abanico, es necesario deshabilitar el evento anterior "evento_buscar_negro" que consideraba un tiempo determinado, y agregar uno nuevo con el mismo nombre que considere el nuevo valor de la variable "tiempo".

<syntaxhighlight lang="lua">
local function buscar_negro()
if not buscando_negro then
buscando_negro = true
-- Se deshabilita el evento de "color blanco encontrado" porque no tiene que "mezclarse" con el actual
events.remove(evento_blanco_encontrado)
else
-- Se remueve el evento anterior para agregar uno nuevo con el nuevo valor de la variable tiempo
events.remove(evento_buscar_negro)
end
last = util.get_time()
-- Lo siguiente es para que se busque s\u00f3lo un determinado tiempo en cada sentido de giro
evento_buscar_negro = events.add(get_elapsed, ">=", tiempo, buscar_negro)
invertir_sentido()
tiempo = tiempo * 2
girar()
end
</syntaxhighlight>

* '''girar'''
Gira el robot en el sentido correspondiente, el cual estará definido por la variable sentido.

<syntaxhighlight lang="lua">
local function girar()
if sentido == "I" then
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
end
invertir_sentido()
end
</syntaxhighlight>

*'''get_elapsed'''
Esta función tiene como objetivo retornar el tiempo en segundos que pasó desde la última vez que se grabó la variable "last"

<syntaxhighlight lang="lua">
local function get_elapsed()
return util.get_time() - last
end
</syntaxhighlight>

*'''invertir_sentido'''
Cambia el sentido de izquierda a derecha o viceversa.

<syntaxhighlight lang="lua">
local function invertir_sentido()
if sentido == "I" then
sentido = "D"
else
sentido = "I"
end
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano al piso posible, pero siempre sin tocarlo, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras del piso.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_2.png|300px|thumb|center|Configuración]]

==Video==

<youtube>7WrPNRNH3XM</youtube>

==Código==

[[Butialo: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises - Código]]

Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises

2012-10-15T18:02:27Z

Vacosta: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises trasladada a Butialo: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises

#REDIRECCIÓN [[Butialo: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises]]

Butialo: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises

2012-10-12T03:11:11Z

Vacosta: /* Código */

Butialo: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises - Código

2012-10-12T03:10:20Z

Vacosta: Primera versión (y la última ;) )

<syntaxhighlight lang="lua">
local COLOR_NEGRO = 35000
local MOTOR_VEL = 500
local MOTOR_GIRO_VEL = 500
local sentido = "D"
local tiempo = 0.5
local evento_blanco_encontrado
local evento_buscar_negro
local buscando_negro = false
local TIEMPO_CENTRADO = 0.2
local last

local function invertir_sentido()
if sentido == "I" then
sentido = "D"
else
sentido = "I"
end
end

local function get_elapsed()
return util.get_time() - last
end

local function girar()
if sentido == "I" then
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
end
end

local function buscar_negro()
if not buscando_negro then
buscando_negro = true
-- Se deshabilita el evento de "color blanco encontrado" porque no tiene que "mezclarse" con el actual
events.remove(evento_blanco_encontrado)
else
-- Se remueve el evento anterior para agregar uno nuevo con el nuevo valor de la variable tiempo
events.remove(evento_buscar_negro)
end
last = util.get_time()
-- Lo siguiente es para que se busque s\u00f3lo un determinado tiempo en cada sentido de giro
evento_buscar_negro = events.add(get_elapsed, ">=", tiempo, buscar_negro)
invertir_sentido()
tiempo = tiempo * 2
girar()
end

local function avanzar()
if buscando_negro then
-- Remueve el evento para que se deje de buscar el color negro
events.remove(evento_buscar_negro)
-- Vuelve a agregar el evento que la funci\u00f3n buscar_negro removi\u00f3
evento_blanco_encontrado = events.add(Grey_1.getValue, '<', COLOR_NEGRO, buscar_negro)

buscando_negro = false
tiempo = 0.5
invertir_sentido()
util.wait(TIEMPO_CENTRADO)
end

Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end

events.add(Grey_1.getValue, '>=', COLOR_NEGRO, avanzar)

evento_blanco_encontrado = events.add(Grey_1.getValue, '<', COLOR_NEGRO, buscar_negro)

events.go()
</syntaxhighlight>

Butialo: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises

2012-10-12T03:08:35Z

Vacosta: /* Video */

__TOC__

==Descripción==
Se desea Implementar un seguidor de líneas básico que permite al robot Butiá seguir el rastro de una línea de color negro sobre el suelo, utilizando un sensor de grises.

El robot deberá avanzar mientras se encuentre en una zona oscura y en caso de salirse de la misma, girar para poder encontrar nuevamente una zona oscura.

La programación de la solución deberá usar los eventos que provee el lenguaje Lua.

==Solución==

'''Descripción'''

Al igual que en el ejemplo 1, es necesario calibrar el sensor antes de comenzar.

Una vez calibrado el sensor, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''
Consiste en avanzar el robot hasta tanto el color de la línea sea negro, en caso contrario deberá buscar dicho color realizando un movimiento en forma de abanico.

Para esto, se agrega un evento que si detecta que el Butiá está sobre la línea negra se llama a la función "avanzar", y si el robot encuentra una sola blanca significa que se desvió de la línea negra y por tanto es necesario buscarla, usando la función "buscar_negro".

<syntaxhighlight lang="lua">
events.add(Grey_1.getValue, '>=', COLOR_NEGRO, avanzar)

evento_blanco_encontrado = events.add(Grey_1.getValue, '<', COLOR_NEGRO, buscar_negro)

events.go()
</syntaxhighlight>

* '''avanzar'''
Si se estaba buscando la línea de color negro y se invocó esta función, es porque dicha línea fue encontrada, y por tanto se remueve el evento que tenía como objetivo "hacer un abanico" hasta encontrar la línea. Además, se vuelve a agregar el evento que activa la búsqueda de la línea negra cuando se encuentra el color blanco.

La variable TIEMPO_CENTRADO tiene como objetivo hacer que el Butiá, luego de encontrar la línea negra se mueve un poco más hacia el centro de la misma, para poder hacer el recorrido de forma más eficiente.

Por último, activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
if buscando_negro then
-- Remueve el evento para que se deje de buscar el color negro
events.remove(evento_buscar_negro)
-- Vuelve a agregar el evento que la funci\u00f3n buscar_negro removi\u00f3
evento_blanco_encontrado = events.add(Grey_1.getValue, '<', COLOR_NEGRO, buscar_negro)

buscando_negro = false
tiempo = 0.5
invertir_sentido()
util.wait(TIEMPO_CENTRADO)
end

Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''buscar_negro'''
Esta función tiene como objetivo "hacer un abanico" hasta encontrar nuevamente la línea negra.

Si es la primera vez que se invoca (o sea, el Butiá iba por la línea negra y encontró una zona blanca) se deshabilita el evento "evento_blanco_encontrado" para poder realizar la rutina de búsqueda sin que ambos eventos se "pisen". Esto es necesario porque simultáneamente se estarían dando las condiciones para que se ejecuten los 2 eventos (evento_blanco_encontrado y evento_buscar_negro) pero en este caso sólo es de interés que se ejecute la rutina de búsqueda haciendo el abanico (evento_buscar_negro).

Se usa la variable "tiempo" para incrementar el tiempo en el que gira en cada uno de los sentidos el Butiá.

Nótese que para poder realizar el abanico, es necesario deshabilitar el evento anterior "evento_buscar_negro" que consideraba un tiempo determinado, y agregar uno nuevo con el mismo nombre que considere el nuevo valor de la variable "tiempo".

<syntaxhighlight lang="lua">
local function buscar_negro()
if not buscando_negro then
buscando_negro = true
-- Se deshabilita el evento de "color blanco encontrado" porque no tiene que "mezclarse" con el actual
events.remove(evento_blanco_encontrado)
else
-- Se remueve el evento anterior para agregar uno nuevo con el nuevo valor de la variable tiempo
events.remove(evento_buscar_negro)
end
last = util.get_time()
-- Lo siguiente es para que se busque s\u00f3lo un determinado tiempo en cada sentido de giro
evento_buscar_negro = events.add(get_elapsed, ">=", tiempo, buscar_negro)
invertir_sentido()
tiempo = tiempo * 2
girar()
end
</syntaxhighlight>

* '''girar'''
Gira el robot en el sentido correspondiente, el cual estará definido por la variable sentido.

<syntaxhighlight lang="lua">
local function girar()
if sentido == "I" then
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
end
invertir_sentido()
end
</syntaxhighlight>

*'''get_elapsed'''
Esta función tiene como objetivo retornar el tiempo en segundos que pasó desde la última vez que se grabó la variable "last"

<syntaxhighlight lang="lua">
local function get_elapsed()
return util.get_time() - last
end
</syntaxhighlight>

*'''invertir_sentido'''
Cambia el sentido de izquierda a derecha o viceversa.

<syntaxhighlight lang="lua">
local function invertir_sentido()
if sentido == "I" then
sentido = "D"
else
sentido = "I"
end
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano al piso posible, pero siempre sin tocarlo, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras del piso.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_2.png|300px|thumb|center|Configuración]]

==Video==

<youtube>7WrPNRNH3XM</youtube>

==Código==

[[Butialo: Ejemplo 1 - Seguidor de líneas sin eventos, utilizando un sensor de grises - Código]]

Butialo: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises

2012-10-12T03:07:56Z

Vacosta: /* Configuración */

__TOC__

==Descripción==
Se desea Implementar un seguidor de líneas básico que permite al robot Butiá seguir el rastro de una línea de color negro sobre el suelo, utilizando un sensor de grises.

El robot deberá avanzar mientras se encuentre en una zona oscura y en caso de salirse de la misma, girar para poder encontrar nuevamente una zona oscura.

La programación de la solución deberá usar los eventos que provee el lenguaje Lua.

==Solución==

'''Descripción'''

Al igual que en el ejemplo 1, es necesario calibrar el sensor antes de comenzar.

Una vez calibrado el sensor, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''
Consiste en avanzar el robot hasta tanto el color de la línea sea negro, en caso contrario deberá buscar dicho color realizando un movimiento en forma de abanico.

Para esto, se agrega un evento que si detecta que el Butiá está sobre la línea negra se llama a la función "avanzar", y si el robot encuentra una sola blanca significa que se desvió de la línea negra y por tanto es necesario buscarla, usando la función "buscar_negro".

<syntaxhighlight lang="lua">
events.add(Grey_1.getValue, '>=', COLOR_NEGRO, avanzar)

evento_blanco_encontrado = events.add(Grey_1.getValue, '<', COLOR_NEGRO, buscar_negro)

events.go()
</syntaxhighlight>

* '''avanzar'''
Si se estaba buscando la línea de color negro y se invocó esta función, es porque dicha línea fue encontrada, y por tanto se remueve el evento que tenía como objetivo "hacer un abanico" hasta encontrar la línea. Además, se vuelve a agregar el evento que activa la búsqueda de la línea negra cuando se encuentra el color blanco.

La variable TIEMPO_CENTRADO tiene como objetivo hacer que el Butiá, luego de encontrar la línea negra se mueve un poco más hacia el centro de la misma, para poder hacer el recorrido de forma más eficiente.

Por último, activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
if buscando_negro then
-- Remueve el evento para que se deje de buscar el color negro
events.remove(evento_buscar_negro)
-- Vuelve a agregar el evento que la funci\u00f3n buscar_negro removi\u00f3
evento_blanco_encontrado = events.add(Grey_1.getValue, '<', COLOR_NEGRO, buscar_negro)

buscando_negro = false
tiempo = 0.5
invertir_sentido()
util.wait(TIEMPO_CENTRADO)
end

Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''buscar_negro'''
Esta función tiene como objetivo "hacer un abanico" hasta encontrar nuevamente la línea negra.

Si es la primera vez que se invoca (o sea, el Butiá iba por la línea negra y encontró una zona blanca) se deshabilita el evento "evento_blanco_encontrado" para poder realizar la rutina de búsqueda sin que ambos eventos se "pisen". Esto es necesario porque simultáneamente se estarían dando las condiciones para que se ejecuten los 2 eventos (evento_blanco_encontrado y evento_buscar_negro) pero en este caso sólo es de interés que se ejecute la rutina de búsqueda haciendo el abanico (evento_buscar_negro).

Se usa la variable "tiempo" para incrementar el tiempo en el que gira en cada uno de los sentidos el Butiá.

Nótese que para poder realizar el abanico, es necesario deshabilitar el evento anterior "evento_buscar_negro" que consideraba un tiempo determinado, y agregar uno nuevo con el mismo nombre que considere el nuevo valor de la variable "tiempo".

<syntaxhighlight lang="lua">
local function buscar_negro()
if not buscando_negro then
buscando_negro = true
-- Se deshabilita el evento de "color blanco encontrado" porque no tiene que "mezclarse" con el actual
events.remove(evento_blanco_encontrado)
else
-- Se remueve el evento anterior para agregar uno nuevo con el nuevo valor de la variable tiempo
events.remove(evento_buscar_negro)
end
last = util.get_time()
-- Lo siguiente es para que se busque s\u00f3lo un determinado tiempo en cada sentido de giro
evento_buscar_negro = events.add(get_elapsed, ">=", tiempo, buscar_negro)
invertir_sentido()
tiempo = tiempo * 2
girar()
end
</syntaxhighlight>

* '''girar'''
Gira el robot en el sentido correspondiente, el cual estará definido por la variable sentido.

<syntaxhighlight lang="lua">
local function girar()
if sentido == "I" then
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
end
invertir_sentido()
end
</syntaxhighlight>

*'''get_elapsed'''
Esta función tiene como objetivo retornar el tiempo en segundos que pasó desde la última vez que se grabó la variable "last"

<syntaxhighlight lang="lua">
local function get_elapsed()
return util.get_time() - last
end
</syntaxhighlight>

*'''invertir_sentido'''
Cambia el sentido de izquierda a derecha o viceversa.

<syntaxhighlight lang="lua">
local function invertir_sentido()
if sentido == "I" then
sentido = "D"
else
sentido = "I"
end
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano al piso posible, pero siempre sin tocarlo, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras del piso.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_2.png|300px|thumb|center|Configuración]]

==Video==

<youtube>rKINEFBUZVE</youtube>

==Código==

[[Butialo: Ejemplo 1 - Seguidor de líneas sin eventos, utilizando un sensor de grises - Código]]

Archivo:Config butialo problema 2.png

2012-10-12T03:07:46Z

Vacosta:

Butialo: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises

2012-10-12T03:03:12Z

Vacosta: Mas cosas explicando el código

__TOC__

==Descripción==
Se desea Implementar un seguidor de líneas básico que permite al robot Butiá seguir el rastro de una línea de color negro sobre el suelo, utilizando un sensor de grises.

El robot deberá avanzar mientras se encuentre en una zona oscura y en caso de salirse de la misma, girar para poder encontrar nuevamente una zona oscura.

La programación de la solución deberá usar los eventos que provee el lenguaje Lua.

==Solución==

'''Descripción'''

Al igual que en el ejemplo 1, es necesario calibrar el sensor antes de comenzar.

Una vez calibrado el sensor, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''
Consiste en avanzar el robot hasta tanto el color de la línea sea negro, en caso contrario deberá buscar dicho color realizando un movimiento en forma de abanico.

Para esto, se agrega un evento que si detecta que el Butiá está sobre la línea negra se llama a la función "avanzar", y si el robot encuentra una sola blanca significa que se desvió de la línea negra y por tanto es necesario buscarla, usando la función "buscar_negro".

<syntaxhighlight lang="lua">
events.add(Grey_1.getValue, '>=', COLOR_NEGRO, avanzar)

evento_blanco_encontrado = events.add(Grey_1.getValue, '<', COLOR_NEGRO, buscar_negro)

events.go()
</syntaxhighlight>

* '''avanzar'''
Si se estaba buscando la línea de color negro y se invocó esta función, es porque dicha línea fue encontrada, y por tanto se remueve el evento que tenía como objetivo "hacer un abanico" hasta encontrar la línea. Además, se vuelve a agregar el evento que activa la búsqueda de la línea negra cuando se encuentra el color blanco.

La variable TIEMPO_CENTRADO tiene como objetivo hacer que el Butiá, luego de encontrar la línea negra se mueve un poco más hacia el centro de la misma, para poder hacer el recorrido de forma más eficiente.

Por último, activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
if buscando_negro then
-- Remueve el evento para que se deje de buscar el color negro
events.remove(evento_buscar_negro)
-- Vuelve a agregar el evento que la funci\u00f3n buscar_negro removi\u00f3
evento_blanco_encontrado = events.add(Grey_1.getValue, '<', COLOR_NEGRO, buscar_negro)

buscando_negro = false
tiempo = 0.5
invertir_sentido()
util.wait(TIEMPO_CENTRADO)
end

Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''buscar_negro'''
Esta función tiene como objetivo "hacer un abanico" hasta encontrar nuevamente la línea negra.

Si es la primera vez que se invoca (o sea, el Butiá iba por la línea negra y encontró una zona blanca) se deshabilita el evento "evento_blanco_encontrado" para poder realizar la rutina de búsqueda sin que ambos eventos se "pisen". Esto es necesario porque simultáneamente se estarían dando las condiciones para que se ejecuten los 2 eventos (evento_blanco_encontrado y evento_buscar_negro) pero en este caso sólo es de interés que se ejecute la rutina de búsqueda haciendo el abanico (evento_buscar_negro).

Se usa la variable "tiempo" para incrementar el tiempo en el que gira en cada uno de los sentidos el Butiá.

Nótese que para poder realizar el abanico, es necesario deshabilitar el evento anterior "evento_buscar_negro" que consideraba un tiempo determinado, y agregar uno nuevo con el mismo nombre que considere el nuevo valor de la variable "tiempo".

<syntaxhighlight lang="lua">
local function buscar_negro()
if not buscando_negro then
buscando_negro = true
-- Se deshabilita el evento de "color blanco encontrado" porque no tiene que "mezclarse" con el actual
events.remove(evento_blanco_encontrado)
else
-- Se remueve el evento anterior para agregar uno nuevo con el nuevo valor de la variable tiempo
events.remove(evento_buscar_negro)
end
last = util.get_time()
-- Lo siguiente es para que se busque s\u00f3lo un determinado tiempo en cada sentido de giro
evento_buscar_negro = events.add(get_elapsed, ">=", tiempo, buscar_negro)
invertir_sentido()
tiempo = tiempo * 2
girar()
end
</syntaxhighlight>

* '''girar'''
Gira el robot en el sentido correspondiente, el cual estará definido por la variable sentido.

<syntaxhighlight lang="lua">
local function girar()
if sentido == "I" then
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
end
invertir_sentido()
end
</syntaxhighlight>

*'''get_elapsed'''
Esta función tiene como objetivo retornar el tiempo en segundos que pasó desde la última vez que se grabó la variable "last"

<syntaxhighlight lang="lua">
local function get_elapsed()
return util.get_time() - last
end
</syntaxhighlight>

*'''invertir_sentido'''
Cambia el sentido de izquierda a derecha o viceversa.

<syntaxhighlight lang="lua">
local function invertir_sentido()
if sentido == "I" then
sentido = "D"
else
sentido = "I"
end
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano al piso posible, pero siempre sin tocarlo, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras del piso.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_1.png|300px|thumb|center|Configuración]]

==Video==

<youtube>rKINEFBUZVE</youtube>

==Código==

[[Butialo: Ejemplo 1 - Seguidor de líneas sin eventos, utilizando un sensor de grises - Código]]

Butialo: Ejemplo 2 - Seguidor de líneas con eventos, utilizando un sensor de grises

2012-10-12T02:57:28Z

Vacosta: Primera versión

__TOC__

==Descripción==
Se desea Implementar un seguidor de líneas básico que permite al robot Butiá seguir el rastro de una línea de color negro sobre el suelo, utilizando un sensor de grises.

El robot deberá avanzar mientras se encuentre en una zona oscura y en caso de salirse de la misma, girar para poder encontrar nuevamente una zona oscura.

La programación de la solución deberá usar los eventos que provee el lenguaje Lua.

==Solución==

'''Descripción'''

Al igual que en el ejemplo 1, es necesario calibrar el sensor antes de comenzar.

Una vez calibrado el sensor, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''
Consiste en avanzar el robot hasta tanto el color de la línea sea negro, en caso contrario deberá buscar dicho color realizando un movimiento en forma de abanico.

Para esto, se agrega un evento que si detecta que el Butiá está sobre la línea negra se llama a la función "avanzar", y si el robot encuentra una sola blanca significa que se desvió de la línea negra y por tanto es necesario buscarla, usando la función "buscar_negro".

<syntaxhighlight lang="lua">
events.add(Grey_1.getValue, '>=', COLOR_NEGRO, avanzar)

evento_blanco_encontrado = events.add(Grey_1.getValue, '<', COLOR_NEGRO, buscar_negro)

events.go()
</syntaxhighlight>

* '''avanzar'''
Si se estaba buscando la línea de color negro y se invocó esta función, es porque dicha línea fue encontrada, y por tanto se remueve el evento que tenía como objetivo "hacer un abanico" hasta encontrar la línea. Además, se vuelve a agregar el evento que activa la búsqueda de la línea negra cuando se encuentra el color blanco.

La variable TIEMPO_CENTRADO tiene como objetivo hacer que el Butiá, luego de encontrar la línea negra se mueve un poco más hacia el centro de la misma, para poder hacer el recorrido de forma más eficiente.

Por último, activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
if buscando_negro then
-- Remueve el evento para que se deje de buscar el color negro
events.remove(evento_buscar_negro)
-- Vuelve a agregar el evento que la funci\u00f3n buscar_negro removi\u00f3
evento_blanco_encontrado = events.add(Grey_1.getValue, '<', COLOR_NEGRO, buscar_negro)

buscando_negro = false
tiempo = 0.5
invertir_sentido()
util.wait(TIEMPO_CENTRADO)
end

Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''buscar_negro'''
Esta función tiene como objetivo "hacer un abanico" hasta encontrar nuevamente la línea negra.

Si es la primera vez que se invoca (o sea, el Butiá iba por la línea negra y encontró una zona blanca) se deshabilita el evento "evento_blanco_encontrado" para poder realizar la rutina de búsqueda sin que ambos eventos se "pisen". Esto es necesario porque simultáneamente se estarían dando las condiciones para que se ejecuten los 2 eventos (evento_blanco_encontrado y evento_buscar_negro) pero en este caso sólo es de interés que se ejecute la rutina de búsqueda haciendo el abanico (evento_buscar_negro).

Se usa la variable "tiempo" para incrementar el tiempo en el que gira en cada uno de los sentidos el Butiá.

Nótese que para poder realizar el abanico, es necesario deshabilitar el evento anterior "evento_buscar_negro" que consideraba un tiempo determinado, y agregar uno nuevo con el mismo nombre que considere el nuevo valor de la variable "tiempo".

<syntaxhighlight lang="lua">
local function buscar_negro()
if not buscando_negro then
buscando_negro = true
-- Se deshabilita el evento de "color blanco encontrado" porque no tiene que "mezclarse" con el actual
events.remove(evento_blanco_encontrado)
else
-- Se remueve el evento anterior para agregar uno nuevo con el nuevo valor de la variable tiempo
events.remove(evento_buscar_negro)
end
last = util.get_time()
-- Lo siguiente es para que se busque s\u00f3lo un determinado tiempo en cada sentido de giro
evento_buscar_negro = events.add(get_elapsed, ">=", tiempo, buscar_negro)
invertir_sentido()
tiempo = tiempo * 2
girar()
end
</syntaxhighlight>

*
local function girar()
if sentido == "I" then
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
end
end

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano al piso posible, pero siempre sin tocarlo, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras del piso.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_1.png|300px|thumb|center|Configuración]]

==Video==

<youtube>rKINEFBUZVE</youtube>

==Código==

[[Butialo: Ejemplo 1 - Seguidor de líneas sin eventos, utilizando un sensor de grises - Código]]

Butialo: Ejemplo 4 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises

2012-10-11T21:04:36Z

Vacosta: Agrego el video

__TOC__

==Descripción==
Se desea implementar utilizando eventos un programa que permita al robot Butiá poder desplazarse en una mesa sin caerse de la misma.

El robot deberá avanzar mientras detecte un color semejante al de la mesa. En caso de detectar un color distinto al de la mesa, procederá a retroceder por un tiempo aleatorio para luego cambiar de sentido (izquierda o derecha), y así poder avanzar nuevamente.

==Solución==

'''Descripción'''

Obtenemos los valores de la variable COLOR_MESA, MIN_TIEMPO_RETROCESO, MAX_TIEMPO_RETROCESO, MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO de la misma forma que lo hicimos en el Ejemplo 3.

Como podemos apreciar en el ejemplo anterior, el robot tiene un comportamiento que claramente se adapta al paradigma reactivo. Esto es, SENSAR - ACTUAR. Cambiará su estado dependiendo de una condición que le indica si el color sensado se corresponde con el de la mesa (COLOR_MESA).

Distinguimos entonces dos estados posibles según la condición sea verdadera o falsa. Si se cumple la condición, el robot deberá retroceder en un tiempo aleatorio definido entre el rango MIN_TIEMPO_RETROCESO y MAX_TIEMPO_RETROCESO y luego girar de forma aleatoria también por un tiempo entre el rango MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO.
En caso contrario, el robot deberá avanzar.

Finalmente se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se encuentre en peligro de caer de la mesa, en caso contrario deberá retroceder de forma aleatoria. Luego de que se retrocede aleatoriamente, por un tiempo determinado, se utiliza la función girar_aleatorio() para que la siguiente vez que se avance, se haga en un sentido aleatorio.

<syntaxhighlight lang="lua">
events.add(Grey_2.getValue, '>=', COLOR_MESA,retroceder_y_girar_aleatorio)
events.add(Grey_2.getValue, '<', COLOR_MESA, avanzar)
events.go()
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''retroceder_y_girar_aleatorio'''
Retrocede y luego gira de forma aleatoria.

<syntaxhighlight lang="lua">
local function retroceder_y_girar_aleatorio()
retroceder_aleatorio()
girar_aleatorio()
end
</syntaxhighlight>

* '''chequear_giro_izquierda'''
Retorna un valor booleano que indica si el robot debe girar hacia la izquierda. Para girar de forma aleatoria, a izquierda o derecha, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el giro será hacia la izquierda, retornando True y en caso contrario deberá girar a la derecha retornando False.

<syntaxhighlight lang="lua">
local function chequear_giro_izquierda()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''girar_aleatorio'''
Nuevamente utilizamos la función random para obtener un número aleatorio entre MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO y así definir el tiempo durante el cual el robot estará girando. Luego chequeamos con la función chequear_giro_izquierda() si el giro será en sentido izquierdo o derecho, dependiendo de ese valor se procederá entonces a girar en ese sentido con una velocidad definida por la variable VELOCIDAD_GIRO.

<syntaxhighlight lang="lua">
local function girar_aleatorio()
local tiempo_giro = math.random(MIN_TIEMPO_GIRO, MAX_TIEMPO_GIRO)
local izquierda = chequear_giro_izquierda()
if (izquierda) then
Motors.setvel2mtr(0, VELOCIDAD_GIRO, 1, VELOCIDAD_GIRO)
else
Motors.setvel2mtr(1, VELOCIDAD_GIRO, 0, VELOCIDAD_GIRO)
end
util.wait(tiempo_giro)
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano a la mesa, pero siempre sin tocarla, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras de la mesa.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_4.png|300px|thumb|center|Configuración]]

==Video==

<youtube>MmQjJZjHFgQ</youtube>

==Código==

[[Butialo: Ejemplo 4 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises - Código]]

Butialo: Ejemplo 5 - Seguidor de líneas con eventos, utilizando dos sensores de grises

2012-10-11T02:47:36Z

Vacosta: Agrego el video

__TOC__

==Descripción==

Se desea implementar utilizando eventos un programa que permita al robot Butiá seguir el rastro de una línea de color negro sobre el suelo.

El robot deberá avanzar mientras se encuentre en una zona oscura y en caso de salirse de la misma se tendrán tres alternativas posibles para poder encontrar nuevamente una zona oscura, dependiendo de cuál sensor detectó que el robot se ha salido de la zona.

==Solución==

'''Descripción'''

Obtenemos el valor de la variable COLOR_NEGRO de la misma forma que lo hicimos en el Ejemplo 1.

Como podemos apreciar en el Ejemplo 1, el robot tiene un comportamiento que claramente se adapta al paradigma reactivo. Esto es, SENSAR - ACTUAR. Cambiará su estado dependiendo de una condición que le indica para cada sensor si el color sensado se corresponde con el color negro (COLOR_NEGRO).

Distinguimos entonces tres estados posibles: NEGRO_AMBOS, NEGRO_IZQUIERDO y NEGRO_DERECHO.
Cuando ambos sensores detectan el color negro, el robot se encuentra en el estado NEGRO_AMBOS. Por lo cual el robot deberá avanzar.
Si el sensor izquierdo detecta el color negro y el sensor derecho no, entonces el robot se encuentra en el estado NEGRO_IZQUIERDO. El robot aquí deberá girar en sentido izquierdo para tratar de no salirse de la línea.
Si el sensor derecho detecta el color negro y el sensor izquierdo no, entonces el robot se encuentra en el estado NEGRO_DERECHO. Análogamente, el robot deberá girar en sentido derecho.
En caso contrario, el estado será BLANCO y al perder la línea con ambos sensores el robot se detiene.

Finalmente se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se cumpla alguna de las condiciones para cambiar de estado y en tal caso, se ejecutará la función asociada al evento correspondiente.

<syntaxhighlight lang="lua">
events.add(obtener_estado, '==', NEGRO_IZQUIERDO, girar_izquierda)
events.add(obtener_estado, '==', NEGRO_DERECHO, girar_derecha)
events.add(obtener_estado, '==', NEGRO_AMBOS, avanzar)
events.add(obtener_estado, '==', BLANCO, detener)
events.go()
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''detener'''
Detiene los motores.

<syntaxhighlight lang="lua">
local function detener()
Motors.setvel2mtr(0, 0, 0, 0)
end
</syntaxhighlight>

* '''es_negro'''
Retorna un valor booleano que indica si el robot está parado sobre la zona oscura, según el valor obtenido por el sensor de grises y su comparación con la constante COLOR_NEGRO.

<syntaxhighlight lang="lua">
local function es_negro(valor)
return (valor > COLOR_NEGRO)
end
</syntaxhighlight>

* '''girar_derecha'''
Gira el robot hacia la derecha con una velocidad definida por la variable MOTOR_GIRO_VEL.

<syntaxhighlight lang="lua">
local function girar_derecha()
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,0,0)
end
</syntaxhighlight>

* '''girar_izquierda'''
Gira el robot hacia la izquierda con una velocidad definida por la variable MOTOR_GIRO_VEL.

<syntaxhighlight lang="lua">
local function girar_izquierda()
Motors.setvel2mtr(0,0,0,MOTOR_GIRO_VEL)
end
</syntaxhighlight>

* '''obtener_estado'''
Retorna el estado correspondiente, dependiendo de los valores obtenidos en cada uno de los sensores de grises.

<syntaxhighlight lang="lua">
local function obtener_estado()
negro_izquierda = es_negro(Grey_1.getValue())
negro_derecha = es_negro(Grey_2.getValue())
if (negro_izquierda and negro_derecha) then
return NEGRO_AMBOS
elseif (negro_izquierda) then
return NEGRO_IZQUIERDO
elseif (negro_derecha) then
return NEGRO_DERECHA
else
return BLANCO
end
end
</syntaxhighlight>

==Configuración==

Se deben colocar dos sensores de escala de grises lo más cercano al suelo, pero siempre sin tocarla, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir los sensores al Butiá, quedando dichos sensores a ras del suelo.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_5.png|300px|thumb|center|Configuración]]

==Video==

<youtube>-P_puOseUMc</youtube>

==Código==

[[Butialo: Ejemplo 5 - Seguidor de líneas con eventos, utilizando dos sensores de grises - Código]]

Archivo:Config butialo problema 5.png

2012-10-11T02:42:55Z

Vacosta:

Archivo:Config butialo problema 8.png

2012-10-11T02:41:23Z

Vacosta:

Butialo: Ejemplo 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-11T02:40:54Z

Vacosta: Agrego el video

__TOC__

==Descripción==

Se desea implementar un seguidor de líneas de nivel avanzado que permita al robot Butiá seguir el rastro de una línea de color negro sobre el suelo eludiendo obstáculos.

El robot deberá avanzar mientras se encuentre en una zona oscura y no detecte la proximidad de un obstáculo. En caso de salirse de la línea, deberá girar para poder encontrar nuevamente una zona oscura y en caso de detectar un obstáculo procederá a aplicar una técnica de rodeo poder continuar avanzando por la línea de color negro.

==Solución==

'''Descripción'''

Obtenemos el valor de la variable COLOR_NEGRO de la misma forma que lo hicimos en el Ejemplo 1. Además, debemos calibrar el valor de la variable DISTANCIA_OBSTACULO que refiera a la distancia mínima a partir de la cual el robot detecta la presentacia de un obstáculo y por lo tanto deberá esquivar el mismo utilizando una técnica de rodeo.

El robot deberá seguir el rastro de la línea de color negro de la misma forma que se realizó en el Ejemplo 1, chequeando además la presencia de un obstáculo que deberá esquivar para luego regresar a línea negra.

Una vez calibrados los valores de los sensores, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se encuentre en peligro de caer de la mesa, en caso contrario deberá retroceder de forma aleatoria. Luego de que se retrocede aleatoriamente, por un tiempo determinado, se utiliza la función girar_aleatorio() para que la siguiente vez que se avance, se haga en un sentido aleatorio.

<syntaxhighlight lang="lua">
while true do
avanzar()
while (es_negro() and not hay_obstaculo()) do
util.wait(INTERVALO_CHEQUEO)
end
if hay_obstaculo() then
esquivar_obstaculo()
else
buscar_negro()
util.wait(TIEMPO_CENTRADO)
invertir_sentido()
end
end
</syntaxhighlight>

* '''invertir_sentido'''
Cambia el sentido de izquierda a derecha o viceversa.

<syntaxhighlight lang="lua">
local function invertir_sentido()
if sentido == "I" then
sentido = "D"
else
sentido = "I"
end
end
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''retroceder'''
Retrocede el Butiá haciendo que los motores giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function retroceder()
Motors.setvel2mtr(1, MOTOR_VEL, 1, MOTOR_VEL)
end
</syntaxhighlight>

* '''es_negro'''
Retorna un valor booleano que indica si el robot está parado sobre la zona oscura, según el valor obtenido por el sensor de grises y su comparación con la constante COLOR_NEGRO.

<syntaxhighlight lang="lua">
local function es_negro()
local color = Grey_1.getValue()
return (color > COLOR_NEGRO)
end
</syntaxhighlight>

* '''girar'''
Gira el robot en el sentido correspondiente, el cual estará definido por la variable sentido.

<syntaxhighlight lang="lua">
local function girar()
if sentido == "I" then
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
end
end
</syntaxhighlight>

* '''buscar_negro'''
Si el robot no encuentra color negro entonces deberá buscarlo. El robot hace un abanico, girando determinado tiempo en un sentido, para luego girar el doble de tiempo en el sentido opuesto. Esta acción culminará cuando se detecte que el robot está en una zona oscura.

<syntaxhighlight lang="lua">
local function buscar_negro()
tiempo = 0.5
local tiempo_girando
while true do
tiempo_girando = 0
girar()
invertir_sentido()
while (not es_negro() and tiempo_girando <= tiempo) do
util.wait(0.1)
tiempo_girando = tiempo_girando + 0.1
end
if es_negro() then
break
else
tiempo = tiempo * 2
end
end
end
</syntaxhighlight>

* '''hay_obstaculo'''
Retorna un valor booleano que indica si el robot ha detectado la presencia de un obstáculo, según el valor obtenido por el sensor de distancia y su comparación con la constante DISTANCIA_OBSTACULO.

<syntaxhighlight lang="lua">
local function hay_obstaculo()
local distancia = Distanc_2.getValue()
return (distancia > DISTANCIA_OBSTACULO)
end
</syntaxhighlight>

* '''esquivar_obstaculo'''
Al detectar la presencia de un obstáculo, el robot deberá actuar de la siguiente forma:
1) Retroceder un tiempo determinado hasta alejarse lo suficiente como para poder girar.
2) Girar a la derecha 90°.
3) Avanza un tiempo determinado para poder pasar el obstáculo.
4) Girar a la izquierda 90°.
5) Avanza para volver a retomar la línea.

<syntaxhighlight lang="lua">
local function esquivar_obstaculo()
local sentido_previo = sentido
retroceder()
util.wait(TIEMPO_RETROCESO)
sentido = "D"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS)
avanzar()
util.wait(TIEMPO_AVANCE)
sentido = "I"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS)
avanzar()
util.wait(TIEMPO_AVANCE * 3)
sentido = "I"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS * 4 / 3)
avanzar()
while (not es_negro()) do
util.wait(INTERVALO_CHEQUEO)
end
sentido = sentido_previo
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano al suelo, pero siempre sin tocarlo, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras del suelo.

Además se debe colocar un sensor de distancia al frente, en la parte de adelante del Butiá también encastrando piezas.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_8.png|300px|thumb|center|Configuración]]

==Video==

<youtube>maY-Xjjofp4</youtube>

==Código==

[[Butialo: Ejemplo 3 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia - Código]]

Butialo: Ejemplo 3 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises

2012-10-11T02:39:34Z

Vacosta: Agrego el video

__TOC__

==Descripción==
Se desea implementar un programa que permita al robot Butiá poder desplazarse en una mesa sin caerse de la misma.

El robot deberá avanzar mientras detecte un color semejante al de la mesa. En caso de detectar un color distinto al de la mesa, procederá a retroceder por un tiempo aleatorio para luego cambiar de sentido (izquierda o derecha), y así poder avanzar nuevamente.

==Solución==

'''Descripción'''

Como fue explicado en ejemplos anteriores, el sensor de escala de grises (en este caso, se conectó el sensor al puerto 2, por eso su nombre es “Grey_2”) debe ser calibrado previamente a la ejecución del programa a desarrollar para poder obtener los respectivos valores límites a partir del cual definimos que el robot se encuentra sobre la mesa.

Calculando el valor medio, obtuvimos el valor de la variable COLOR_MESA (43000 para las pruebas realizadas).
Determinamos entonces que si el valor arrojado por el sensor es menor a 43000, el robot puede continuar avanzando sin peligro de caer de la mesa, en caso contrario se deberá evitar la caída.

El robot deberá retroceder en un tiempo aleatorio, dicho valor deberá ser calibrado en las variables MIN_TIEMPO_RETROCESO y MAX_TIEMPO_RETROCESO de forma de contemplar que no se caiga de la mesa en caso de que el tiempo sea muy grande. Para ello el robot se colocará en el centro de la mesa. De la misma forma, se calibrará los valores de MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO, considerando aquí los posibles valores entre 1° y 90° aproximadamente.

Una vez calibrado el sensor y obtenidos los respectivos valores de tiempo máximo y mínimo de giro y retroceso, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Consiste en avanzar el robot hasta tanto no se encuentre en peligro de caer de la mesa, en caso contrario deberá retroceder de forma aleatoria. Luego de que se retrocede aleatoriamente, por un tiempo determinado, se utiliza la función girar_aleatorio() para que la siguiente vez que se avance, se haga en un sentido aleatorio.

<syntaxhighlight lang="lua">
while true do
avanzar()
while (puedo_avanzar()) do
util.wait(INTERVALO_CHEQUEO)
end
retroceder_aleatorio()
girar_aleatorio()
end
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''puedo_avanzar'''
Retorna un valor booleano que indica si el robot se encuentra en peligro de caerse, según el valor obtenido por el sensor de grises y su comparación con la variable COLOR_MESA.

<syntaxhighlight lang="lua">
local function puedo_avanzar()
return (Grey_2.getValue() < COLOR_MESA)
end</syntaxhighlight>

* '''chequear_giro_izquierda'''
Retorna un valor booleano que indica si el robot debe girar hacia la izquierda. Para girar de forma aleatoria, a izquierda o derecha, obtenemos un valor entre 0 y 1 con la función random de la bibloteca math. Si el valor randómico obtenido es mayor a 0.5 definimos que el giro será hacia la izquierda, retornando True y en caso contrario deberá girar a la derecha retornando False.

<syntaxhighlight lang="lua">
local function chequear_giro_izquierda()
local sentido = math.random (0, 1)
return sentido > 0.5
end
</syntaxhighlight>

* '''girar_aleatorio'''
Nuevamente utilizamos la función random para obtener un número aleatorio entre MIN_TIEMPO_GIRO y MAX_TIEMPO_GIRO y así definir el tiempo durante el cual el robot estará girando. Luego chequeamos con la función chequear_giro_izquierda() si el giro será en sentido izquierdo o derecho, dependiendo de ese valor se procederá entonces a girar en ese sentido con una velocidad definida por la variable VELOCIDAD_GIRO.

<syntaxhighlight lang="lua">
local function girar_aleatorio()
local tiempo_giro = math.random(MIN_TIEMPO_GIRO, MAX_TIEMPO_GIRO)
local izquierda = chequear_giro_izquierda()
if (izquierda) then
Motors.setvel2mtr(0, VELOCIDAD_GIRO, 1, VELOCIDAD_GIRO)
else
Motors.setvel2mtr(1, VELOCIDAD_GIRO, 0, VELOCIDAD_GIRO)
end
util.wait(tiempo_giro)
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano a la mesa, pero siempre sin tocarla, en la parte de adelante del Butiá.

En nuestro caso encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras de la mesa.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_3.png|300px|thumb|center|Configuración]]

==Video==

<youtube>H3Ri7VNSrM8</youtube>

==Código==

[[Butialo: Ejemplo 3 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises - Código]]

Ejemplos de Aplicaciones en Butialo

2012-10-02T03:30:42Z

Vacosta: /* Ejemplos */

__TOC__

==Integrantes==

* Vicente Acosta Ferradini
* Leticia Vilariño
* Lourdes Cairelli

==Introducción==
Butialo es un entorno fácil de usar que permite programar a Butiá en el lenguaje Lua.

Lua es un lenguaje de scripting imperativo simple pero que a la vez permite crear programas sofisticados. Es un lenguaje dinámico, con manejo de memoria automático y es extremadamente rápido.

Butialo es un IDE derivado de Pippy (el entorno para Python provisto con las XO), que simplifica la creación de programas para Butiá autodetectando la presencia de componentes Butiá conectados y ofreciendo snippets de código para accederlos.

==Objetivos==
Crear programas que sirvan de ejemplo e inspiración. Además del clásico seguidor de línea, se pueden crear ejemplos que saquen provecho de la mayor potencia y expresividad de Lua comparado con TortugArte.

==Ejemplos==

[[Butialo: Ejemplo 1 - Seguidor de líneas con un sensor sin eventos|Ejemplo 1: Seguidor de líneas con un sensor sin eventos]]

Butialo: Ejemplo 1 - Seguidor de líneas con un sensor sin eventos

2012-10-02T03:29:37Z

Vacosta:

__TOC__

==Descripción==
Se desea Implementar un seguidor de líneas básico que permite al robot Butiá seguir el rastro de una línea de color negro sobre el suelo, utilizando un sensor de grises.

El robot deberá avanzar mientras se encuentre en una zona oscura y en caso de salirse de la misma, girar para poder encontrar nuevamente una zona oscura.

==Solución==

'''Descripción'''

Antes de describir cómo es la solución, es menester decir que el sensor de escala de grises debe ser calibrado previamente a la ejecución del programa a desarrollar para poder obtener los respectivos valores límites de color negro y color blanco.

Para tomar estos valores, colocamos el sensor sobre una zona negra y utilizamos la función Grey_1.getValue() que nos brinda el entorno Butialo (en este caso, se conectó el sensor al puerto 1, por eso su nombre es “Grey_1”). Nos arrojará un valor que tendremos identificado como “valor sobre zona oscura”. Posteriormente, se hizo lo mismo sobre una zona de color blanco, mediante lo cual obtuvimos un “valor sobre zona clara”.

Con dichos valores, sabemos en forma aproximada cuál es el entorno de valores en los cuales el sensor de grises detectará el color blanco o el color negro. A partir de esto, calculamos el valor medio y así es que obtuvimos el valor de la variable COLOR_NEGRO (35000 para las pruebas realizadas). Es decir, si el valor arrojado por el sensor es mayor o igual a 35000, sabemos que nos encontramos sobre una zona oscura o negra; y si es menor a 35000 asumimos que se trata del color blanco.

Una vez calibrado el sensor, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''
Consiste en avanzar el robot hasta tanto el color de la línea sea negro, en caso contrario deberá buscar dicho color realizando un movimiento en forma de abanico. Luego de que se busca el color negro, y se encuentra, se utiliza la función invertir_sentido() para que la siguiente vez que se busque el color negro, se haga en el sentido más probable de que esté.

<syntaxhighlight lang="lua">
while true do
avanzar()
while (es_negro()) do
util.wait(0.1)
end
buscar_negro()
util.wait(TIEMPO_CENTRADO)
invertir_sentido()
end
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''es_negro'''
Retorna un valor booleano que indica si el robot está parado sobre la zona oscura, según el valor obtenido por el sensor de grises y su comparación con la constante COLOR_NEGRO.

<syntaxhighlight lang="lua">
local function es_negro()
local color = Grey_1.getValue()
return (color > COLOR_NEGRO)
end</syntaxhighlight>

* '''girar'''
Gira el robot en el sentido correspondiente, el cual estará definido por la variable sentido

<syntaxhighlight lang="lua">
local function girar()
if sentido == "I" then
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
end
invertir_sentido()
end
</syntaxhighlight>

* '''buscar_negro'''
Si el robot no encuentra color negro entonces deberá buscarlo. El robot hace un abanico, girando determinado tiempo en un sentido, para luego girar el doble de tiempo en el sentido opuesto. Esta acción culminará cuando se detecte que el robot está en una zona oscura.

<syntaxhighlight lang="lua">
local function buscar_negro()
tiempo = 0.5
local tiempo_girando
while true do
tiempo_girando = 0
girar()
while (not es_negro() and tiempo_girando <= tiempo) do
util.wait(0.1)
tiempo_girando = tiempo_girando + 0.1
end
if es_negro() then
break
else
tiempo = tiempo * 2
end
end
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano al piso posible, pero siempre sin tocarlo, en la parte de adelante del Butiá.

En nuestro encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras del piso.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_1.png|300px|thumb|center|Configuración]]

==Video==

<youtube>rKINEFBUZVE</youtube>

==Código==

[[Butialo: Ejemplo 1 - Seguidor de líneas con un sensor sin eventos - Código]]

Butialo: Ejemplo 1 - Seguidor de líneas con un sensor sin eventos - Código

2012-10-02T03:27:07Z

Vacosta: Creación de la pagina

<syntaxhighlight lang="lua">
local COLOR_NEGRO = 35000
local MOTOR_VEL = 500
local MOTOR_GIRO_VEL = 500
local TIEMPO_CENTRADO = 0.1
local sentido = "D"
local tiempo

local function invertir_sentido()
if sentido == "I" then
sentido = "D"
else
sentido = "I"
end
end

local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end

local function es_negro()
local color = Grey_1.getValue()
return (color > COLOR_NEGRO)
end

local function girar()
if sentido == "I" then
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
end
invertir_sentido()
end

local function buscar_negro()
-- Se inicializa el tiempo en 0.5 segundo
tiempo = 0.5
local tiempo_girando
while true do
tiempo_girando = 0
girar()
-- El robot gira hasta encontrar el color negro o si no por x tiempo
while (not es_negro() and tiempo_girando <= tiempo) do
util.wait(0.1)
tiempo_girando = tiempo_girando + 0.1
end
-- Si es negro no se debe seguir iterando
if es_negro() then
break
else
tiempo = tiempo * 2
end
end
end

while true do
avanzar()
while (es_negro()) do
util.wait(0.1)
end
buscar_negro()
util.wait(TIEMPO_CENTRADO)
invertir_sentido()
end
</syntaxhighlight>

Butialo: Ejemplo 1 - Seguidor de líneas con un sensor sin eventos

2012-10-02T03:24:48Z

Vacosta:

__TOC__

==Descripción==
Se desea Implementar un seguidor de líneas básico que permite al robot Butiá seguir el rastro de una línea de color negro sobre el suelo, utilizando un sensor de grises.

El robot deberá avanzar mientras se encuentre en una zona oscura y en caso de salirse de la misma, girar para poder encontrar nuevamente una zona oscura.

==Solución==

'''Descripción'''

Antes de describir cómo es la solución, es menester decir que el sensor de escala de grises debe ser calibrado previamente a la ejecución del programa a desarrollar para poder obtener los respectivos valores límites de color negro y color blanco.

Para tomar estos valores, colocamos el sensor sobre una zona negra y utilizamos la función Grey_1.getValue() que nos brinda el entorno Butialo (en este caso, se conectó el sensor al puerto 1, por eso su nombre es “Grey_1”). Nos arrojará un valor que tendremos identificado como “valor sobre zona oscura”. Posteriormente, se hizo lo mismo sobre una zona de color blanco, mediante lo cual obtuvimos un “valor sobre zona clara”.

Con dichos valores, sabemos en forma aproximada cuál es el entorno de valores en los cuales el sensor de grises detectará el color blanco o el color negro. A partir de esto, calculamos el valor medio y así es que obtuvimos el valor de la variable COLOR_NEGRO (35000 para las pruebas realizadas). Es decir, si el valor arrojado por el sensor es mayor o igual a 35000, sabemos que nos encontramos sobre una zona oscura o negra; y si es menor a 35000 asumimos que se trata del color blanco.

Una vez calibrado el sensor, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''
Consiste en avanzar el robot hasta tanto el color de la línea sea negro, en caso contrario deberá buscar dicho color realizando un movimiento en forma de abanico. Luego de que se busca el color negro, y se encuentra, se utiliza la función invertir_sentido() para que la siguiente vez que se busque el color negro, se haga en el sentido más probable de que esté.

<syntaxhighlight lang="lua">
while true do
avanzar()
while (es_negro()) do
util.wait(0.1)
end
buscar_negro()
util.wait(TIEMPO_CENTRADO)
invertir_sentido()
end
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''es_negro'''
Retorna un valor booleano que indica si el robot está parado sobre la zona oscura, según el valor obtenido por el sensor de grises y su comparación con la constante COLOR_NEGRO.

<syntaxhighlight lang="lua">
local function es_negro()
local color = Grey_1.getValue()
return (color > COLOR_NEGRO)
end</syntaxhighlight>

* '''girar'''
Gira el robot en el sentido correspondiente, el cual estará definido por la variable sentido

<syntaxhighlight lang="lua">
local function girar()
if sentido == "I" then
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
end
invertir_sentido()
end
</syntaxhighlight>

* '''buscar_negro'''
Si el robot no encuentra color negro entonces deberá buscarlo. El robot hace un abanico, girando determinado tiempo en un sentido, para luego girar el doble de tiempo en el sentido opuesto. Esta acción culminará cuando se detecte que el robot está en una zona oscura.

<syntaxhighlight lang="lua">
local function buscar_negro()
tiempo = 0.5
local tiempo_girando
while true do
tiempo_girando = 0
girar()
while (not es_negro() and tiempo_girando <= tiempo) do
util.wait(0.1)
tiempo_girando = tiempo_girando + 0.1
end
if es_negro() then
break
else
tiempo = tiempo * 2
end
end
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano al piso posible, pero siempre sin tocarlo, en la parte de adelante del Butiá.

En nuestro encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras del piso.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_1.png|300px|thumb|center|Configuración]]

==Video==

Butialo: Ejemplo 1 - Seguidor de líneas con un sensor sin eventos

2012-10-02T03:22:48Z

Vacosta: Configuración - imagen

__TOC__

==Descripción==
Se desea Implementar un seguidor de líneas básico que permite al robot Butiá seguir el rastro de una línea de color negro sobre el suelo, utilizando un sensor de grises.

El robot deberá avanzar mientras se encuentre en una zona oscura y en caso de salirse de la misma, girar para poder encontrar nuevamente una zona oscura.

==Solución==

'''Descripción'''

Antes de describir cómo es la solución, es menester decir que el sensor de escala de grises debe ser calibrado previamente a la ejecución del programa a desarrollar para poder obtener los respectivos valores límites de color negro y color blanco.

Para tomar estos valores, colocamos el sensor sobre una zona negra y utilizamos la función Grey_1.getValue() que nos brinda el entorno Butialo (en este caso, se conectó el sensor al puerto 1, por eso su nombre es “Grey_1”). Nos arrojará un valor que tendremos identificado como “valor sobre zona oscura”. Posteriormente, se hizo lo mismo sobre una zona de color blanco, mediante lo cual obtuvimos un “valor sobre zona clara”.

Con dichos valores, sabemos en forma aproximada cuál es el entorno de valores en los cuales el sensor de grises detectará el color blanco o el color negro. A partir de esto, calculamos el valor medio y así es que obtuvimos el valor de la variable COLOR_NEGRO (35000 para las pruebas realizadas). Es decir, si el valor arrojado por el sensor es mayor o igual a 35000, sabemos que nos encontramos sobre una zona oscura o negra; y si es menor a 35000 asumimos que se trata del color blanco.

Una vez calibrado el sensor, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''
Consiste en avanzar el robot hasta tanto el color de la línea sea negro, en caso contrario deberá buscar dicho color realizando un movimiento en forma de abanico. Luego de que se busca el color negro, y se encuentra, se utiliza la función invertir_sentido() para que la siguiente vez que se busque el color negro, se haga en el sentido más probable de que esté.

<syntaxhighlight lang="lua">
while true do
avanzar()
while (es_negro()) do
util.wait(0.1)
end
buscar_negro()
util.wait(TIEMPO_CENTRADO)
invertir_sentido()
end
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''es_negro'''
Retorna un valor booleano que indica si el robot está parado sobre la zona oscura, según el valor obtenido por el sensor de grises y su comparación con la constante COLOR_NEGRO.

<syntaxhighlight lang="lua">
local function es_negro()
local color = Grey_1.getValue()
return (color > COLOR_NEGRO)
end</syntaxhighlight>

* '''girar'''
Gira el robot en el sentido correspondiente, el cual estará definido por la variable sentido

<syntaxhighlight lang="lua">
local function girar()
if sentido == "I" then
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
end
invertir_sentido()
end
</syntaxhighlight>

* '''buscar_negro'''
Si el robot no encuentra color negro entonces deberá buscarlo. El robot hace un abanico, girando determinado tiempo en un sentido, para luego girar el doble de tiempo en el sentido opuesto. Esta acción culminará cuando se detecte que el robot está en una zona oscura.

<syntaxhighlight lang="lua">
local function buscar_negro()
tiempo = 0.5
local tiempo_girando
while true do
tiempo_girando = 0
girar()
while (not es_negro() and tiempo_girando <= tiempo) do
util.wait(0.1)
tiempo_girando = tiempo_girando + 0.1
end
if es_negro() then
break
else
tiempo = tiempo * 2
end
end
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano al piso posible, pero siempre sin tocarlo, en la parte de adelante del Butiá.

En nuestro encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras del piso.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

[[Archivo:config_butialo_problema_1.png|300px|thumb|left|Configuración]]

==Video==

Archivo:Config butialo problema 1.png

2012-10-02T03:19:20Z

Vacosta: Ejemplo 1 - Seguidor de líneas con un sensor sin eventos - Configuración

Ejemplo 1 - Seguidor de líneas con un sensor sin eventos - Configuración

Butialo: Ejemplo 1 - Seguidor de líneas con un sensor sin eventos

2012-10-02T03:07:13Z

Vacosta: Casi toda la documentación de este ejemplo

__TOC__

==Descripción==
Se desea Implementar un seguidor de líneas básico que permite al robot Butiá seguir el rastro de una línea de color negro sobre el suelo, utilizando un sensor de grises.

El robot deberá avanzar mientras se encuentre en una zona oscura y en caso de salirse de la misma, girar para poder encontrar nuevamente una zona oscura.

==Solución==

'''Descripción'''

Antes de describir cómo es la solución, es menester decir que el sensor de escala de grises debe ser calibrado previamente a la ejecución del programa a desarrollar para poder obtener los respectivos valores límites de color negro y color blanco.

Para tomar estos valores, colocamos el sensor sobre una zona negra y utilizamos la función Grey_1.getValue() que nos brinda el entorno Butialo (en este caso, se conectó el sensor al puerto 1, por eso su nombre es “Grey_1”). Nos arrojará un valor que tendremos identificado como “valor sobre zona oscura”. Posteriormente, se hizo lo mismo sobre una zona de color blanco, mediante lo cual obtuvimos un “valor sobre zona clara”.

Con dichos valores, sabemos en forma aproximada cuál es el entorno de valores en los cuales el sensor de grises detectará el color blanco o el color negro. A partir de esto, calculamos el valor medio y así es que obtuvimos el valor de la variable COLOR_NEGRO (35000 para las pruebas realizadas). Es decir, si el valor arrojado por el sensor es mayor o igual a 35000, sabemos que nos encontramos sobre una zona oscura o negra; y si es menor a 35000 asumimos que se trata del color blanco.

Una vez calibrado el sensor, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''
Consiste en avanzar el robot hasta tanto el color de la línea sea negro, en caso contrario deberá buscar dicho color realizando un movimiento en forma de abanico. Luego de que se busca el color negro, y se encuentra, se utiliza la función invertir_sentido() para que la siguiente vez que se busque el color negro, se haga en el sentido más probable de que esté.

<syntaxhighlight lang="lua">
while true do
avanzar()
while (es_negro()) do
util.wait(0.1)
end
buscar_negro()
util.wait(TIEMPO_CENTRADO)
invertir_sentido()
end
</syntaxhighlight>

* '''avanzar'''
Activa los motores haciendo que los mismos giren a una velocidad prefijada en la constante MOTOR_VEL.

<syntaxhighlight lang="lua">
local function avanzar()
Motors.setvel2mtr(0, MOTOR_VEL, 0, MOTOR_VEL)
end
</syntaxhighlight>

* '''es_negro'''
Retorna un valor booleano que indica si el robot está parado sobre la zona oscura, según el valor obtenido por el sensor de grises y su comparación con la constante COLOR_NEGRO.

<syntaxhighlight lang="lua">
local function es_negro()
local color = Grey_1.getValue()
return (color > COLOR_NEGRO)
end</syntaxhighlight>

* '''girar'''
Gira el robot en el sentido correspondiente, el cual estará definido por la variable sentido

<syntaxhighlight lang="lua">
local function girar()
if sentido == "I" then
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
end
invertir_sentido()
end
</syntaxhighlight>

* '''buscar_negro'''
Si el robot no encuentra color negro entonces deberá buscarlo. El robot hace un abanico, girando determinado tiempo en un sentido, para luego girar el doble de tiempo en el sentido opuesto. Esta acción culminará cuando se detecte que el robot está en una zona oscura.

<syntaxhighlight lang="lua">
local function buscar_negro()
tiempo = 0.5
local tiempo_girando
while true do
tiempo_girando = 0
girar()
while (not es_negro() and tiempo_girando <= tiempo) do
util.wait(0.1)
tiempo_girando = tiempo_girando + 0.1
end
if es_negro() then
break
else
tiempo = tiempo * 2
end
end
end
</syntaxhighlight>

==Configuración==

Se debe colocar un sensor de escala de grises lo más cercano al piso posible, pero siempre sin tocarlo, en la parte de adelante del Butiá.

En nuestro encastramos piezas de forma de generar el soporte para adherir el sensor al Butiá, quedando dicho sensor a ras del piso.

Se muestra a continuación una imagen ilustrativa de la configuración del robot vista desde arriba.

==Video==

Butialo: Ejemplo 1 - Seguidor de líneas con un sensor sin eventos

2012-10-02T02:59:16Z

Vacosta: Agrego un poco de código

Butialo: Ejemplo 1 - Seguidor de líneas con un sensor sin eventos

2012-10-02T02:56:48Z

Vacosta:

Butialo: Ejemplo 1 - Seguidor de líneas con un sensor sin eventos

2012-10-02T02:55:06Z

Vacosta: Primer ejemplo

==Descripción==
Se desea Implementar un seguidor de líneas básico que permite al robot Butiá seguir el rastro de una línea de color negro sobre el suelo, utilizando un sensor de grises.

El robot deberá avanzar mientras se encuentre en una zona oscura y en caso de salirse de la misma, girar para poder encontrar nuevamente una zona oscura.

==Solución==

'''Descripción'''

Antes de describir cómo es la solución, es menester decir que el sensor de escala de grises debe ser calibrado previamente a la ejecución del programa a desarrollar para poder obtener los respectivos valores límites de color negro y color blanco.

Para tomar estos valores, colocamos el sensor sobre una zona negra y utilizamos la función Grey_1.getValue() que nos brinda el entorno Butialo (en este caso, se conectó el sensor al puerto 1, por eso su nombre es “Grey_1”). Nos arrojará un valor que tendremos identificado como “valor sobre zona oscura”. Posteriormente, se hizo lo mismo sobre una zona de color blanco, mediante lo cual obtuvimos un “valor sobre zona clara”.

Con dichos valores, sabemos en forma aproximada cuál es el entorno de valores en los cuales el sensor de grises detectará el color blanco o el color negro. A partir de esto, calculamos el valor medio y así es que obtuvimos el valor de la variable COLOR_NEGRO (35000 para las pruebas realizadas). Es decir, si el valor arrojado por el sensor es mayor o igual a 35000, sabemos que nos encontramos sobre una zona oscura o negra; y si es menor a 35000 asumimos que se trata del color blanco.

Una vez calibrado el sensor, se organiza la estructura de la solución en diferentes funciones de forma de modularizar y distinguir fácilmente las acciones. El programa principal quedaría de la siguiente forma:

* '''programa principal'''

Ejemplos de Aplicaciones en Butialo

2012-10-02T02:51:37Z

Vacosta:

Espacio para grupos 2012

2012-07-09T23:24:13Z

Vacosta:

[http://www.fing.edu.uy/inco/proyectos/butia/mediawiki/index.php/Asignaturas_2011 Apoyo a Asignaturas]

Apoyo a Asignaturas y Actividad sugar para enseñar conceptos básicos de Robótica.

Integrantes:
Rolando Gaudin
Sebastian Cabrera
Silvina Fiorenza

Objetivos:
- Incentivar el uso del Butia en las tareas escolares, preparando material para que los docentes vean como pueden usar el Butia para enseñar distintos temas.

- Crear una actividad sugar que enseñe conceptos básicos de robótica para que los niños/jovenes tengan un primer acercamiento la disciplina.

[[Butia_roomba|Butía Roomba]]

[[Ejemplos butialo 2011|Ejemplos butialo 2011]]

Ejemplos de Aplicaciones en Butialo

2012-07-09T23:21:36Z

Vacosta: Creación de la página