Proyecto Butiá - Contribuciones del usuario [es]

Ejemplos de Aplicaciones en Butialo

2012-10-15T15:30:35Z

Leticiavp: /* Ejemplos */

__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 de Aplicaciones en Butialo

2012-10-15T15:30:15Z

Leticiavp: /* Ejemplos */

__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 conn 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-15T15:28:17Z

Leticiavp: /* Integrantes */

__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 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 - Código

2012-10-15T15:26:02Z

Leticiavp: Página creada con '<syntaxhighlight lang="lua"> local COLOR_NEGRO = 20000 local MOTOR_VEL = 500 local MOTOR_GIRO_VEL = 500 local TIEMPO_CENTRADO = 0.1 local INTERVALO_CHEQUEO = 0.1 local DISTANCIA...'

<syntaxhighlight lang="lua">
local COLOR_NEGRO = 20000
local MOTOR_VEL = 500
local MOTOR_GIRO_VEL = 500
local TIEMPO_CENTRADO = 0.1
local INTERVALO_CHEQUEO = 0.1
local DISTANCIA_OBSTACULO = 34000
local TIEMPO_RETROCESO = 0.1
local TIEMPO_AVANCE = 1.7
local TIEMPO_GIRO_90_GRADOS = 1.7
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 retroceder()
Motors.setvel2mtr(1, MOTOR_VEL, 1, 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(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
end
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()
invertir_sentido()
-- 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

local function hay_obstaculo()
local distancia = Distanc_2.getValue()
return (distancia > DISTANCIA_OBSTACULO)
end

local function esquivar_obstaculo()
local sentido_previo = sentido
-- Retroceder unos centímetros
retroceder()
util.wait(TIEMPO_RETROCESO)
-- Girar 90 grados hacia la derecha
sentido = "D"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS)
-- Avanzar unos centímetros
avanzar()
util.wait(TIEMPO_AVANCE)
-- Girar 90 grados a la izquierda
sentido = "I"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS)
-- Avanzar el doble de centímetros
avanzar()
util.wait(TIEMPO_AVANCE * 3)
-- Girar 120 grados a la izquierda
sentido = "I"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS * 4 / 3)
-- Avanzar hasta encontrar el negro
avanzar()
while (not es_negro()) do
util.wait(INTERVALO_CHEQUEO)
end
-- Fin: restaurar el sentido al estado previo
sentido = sentido_previo
end

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>

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

2012-10-15T15:25:37Z

Leticiavp: /* Código */

__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 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia - 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

2012-10-15T15:23:32Z

Leticiavp:

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

2012-10-15T15:22:20Z

Leticiavp: Página creada con 'local COLOR_NEGRO = 20000 local MOTOR_VEL = 500 local MOTOR_GIRO_VEL = 500 local TIEMPO_CENTRADO = 0.1 local INTERVALO_CHEQUEO = 0.1 local DISTANCIA_OBSTACULO = 34000 local TIEM...'

local COLOR_NEGRO = 20000
local MOTOR_VEL = 500
local MOTOR_GIRO_VEL = 500
local TIEMPO_CENTRADO = 0.1
local INTERVALO_CHEQUEO = 0.1
local DISTANCIA_OBSTACULO = 34000
local TIEMPO_RETROCESO = 0.1
local TIEMPO_AVANCE = 1.7
local TIEMPO_GIRO_90_GRADOS = 1.7
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 retroceder()
Motors.setvel2mtr(1, MOTOR_VEL, 1, 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(0,MOTOR_GIRO_VEL,1,MOTOR_GIRO_VEL)
else
Motors.setvel2mtr(1,MOTOR_GIRO_VEL,0,MOTOR_GIRO_VEL)
end
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()
invertir_sentido()
-- 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

local function hay_obstaculo()
local distancia = Distanc_2.getValue()
return (distancia > DISTANCIA_OBSTACULO)
end

local function esquivar_obstaculo()
local sentido_previo = sentido
-- Retroceder unos centímetros
retroceder()
util.wait(TIEMPO_RETROCESO)
-- Girar 90 grados hacia la derecha
sentido = "D"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS)
-- Avanzar unos centímetros
avanzar()
util.wait(TIEMPO_AVANCE)
-- Girar 90 grados a la izquierda
sentido = "I"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS)
-- Avanzar el doble de centímetros
avanzar()
util.wait(TIEMPO_AVANCE * 3)
-- Girar 120 grados a la izquierda
sentido = "I"
girar()
util.wait(TIEMPO_GIRO_90_GRADOS * 4 / 3)
-- Avanzar hasta encontrar el negro
avanzar()
while (not es_negro()) do
util.wait(INTERVALO_CHEQUEO)
end
-- Fin: restaurar el sentido al estado previo
sentido = sentido_previo
end

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

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

2012-10-15T15:16:33Z

Leticiavp: /* 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 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>

* '''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 7 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia

2012-10-15T15:11:08Z

Leticiavp: /* 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, '==', 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 debemos colocar un sensor de distancia a una distancia de la mesa mayor a 3cm pero no mucho más, debido que a una distancia menor el sensor no sensa correctamente.

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 5 - Seguidor de líneas con eventos, utilizando dos sensores de grises - Código

2012-10-15T15:09:22Z

Leticiavp:

<syntaxhighlight lang="lua">
local COLOR_NEGRO = 35000
local MOTOR_VEL = 500
local MOTOR_GIRO_VEL = 500
local NEGRO_IZQUIERDO, NEGRO_DERECHO, NEGRO_AMBOS, BLANCO = 0, 1, 2, 3
local negro_izquierda
local negro_derecha

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

local function detener()
Motors.setvel2mtr(0, 0, 0, 0)
end

local function es_negro(valor)
return (valor > COLOR_NEGRO)
end

local function girar_derecha()
Motors.setvel2mtr(0,MOTOR_GIRO_VEL,0,0)
end

local function girar_izquierda()
Motors.setvel2mtr(0,0,0,MOTOR_GIRO_VEL)
end

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

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>

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

2012-10-15T15:01:48Z

Leticiavp: /* 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 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>

* '''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 1 - Seguidor de líneas sin eventos, utilizando un sensor de grises

2012-10-15T14:38:27Z

Leticiavp: /* Solució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.

==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>

* '''invertir_sentido'''
Invierte el valor de la variable global sentido, de izquierda a derecha y 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 6 - Robot que no se caiga de la mesa sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-15T14:23:03Z

Leticiavp: /* 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 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 debemos colocar un sensor de distancia a una distancia de la mesa mayor a 3cm pero no mucho más, debido que a una distancia menor el sensor no sensa correctamente.

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]]

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

2012-10-15T14:22:55Z

Leticiavp: /* Solución */

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

2012-10-15T14:14:46Z

Leticiavp: /* 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, '==', ADELANTE_FUERA_MESA, volver_inicio)
events.add(puedo_seguir, '==', EN_MESA, moverse)

events.go()
</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 debemos colocar un sensor de distancia a una distancia de la mesa mayor a 3cm pero no mucho más, debido que a una distancia menor el sensor no sensa correctamente.

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 7 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia

2012-10-15T14:13:26Z

Leticiavp: /* 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, '==', ADELANTE_FUERA_MESA, volver_inicio)
events.add(puedo_seguir, '==', EN_MESA, moverse)

events.go()
</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 debemos colocar un sensor de distancia a una distancia de la mesa mayor a 3cm pero no mucho más, debido que a una distancia menor el sensor no sensa correctamente.

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 7 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia

2012-10-15T14:09:36Z

Leticiavp: /* 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, '==', ADELANTE_FUERA_MESA, volver_inicio)
events.add(puedo_seguir, '==', EN_MESA, moverse)

events.go()
</syntaxhighlight>

* '''chequear_avance_o_retrocedo'''
Retorna un valor booleano que indica si el robot debe avanzar. Para desplazarse de forma aleatoria, a adelante o atras, 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 hacia adelante, retornando True y en caso contrario deberá dsplazarse hacia atras 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 la 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 retoceder 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 debemos colocar un sensor de distancia a una distancia de la mesa mayor a 3cm pero no mucho más, debido que a una distancia menor el sensor no sensa correctamente.

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-15T14:08:15Z

Leticiavp: /* 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 un sentido aleatorio.

<syntaxhighlight lang="lua">
while true do
moverse()
while (puedo_avanzar()) do
util.wait(INTERVALO_CHEQUEO)
end
volver_inicio()
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 debemos colocar un sensor de distancia a una distancia de la mesa mayor a 3cm pero no mucho más, debido que a una distancia menor el sensor no sensa correctamente.

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]]

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

2012-10-15T13:53:36Z

Leticiavp: /* 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, '==', ADELANTE_FUERA_MESA, volver_inicio)
events.add(puedo_seguir, '==', EN_MESA, moverse)

events.go()
</syntaxhighlight>

* '''chequear_avance_o_retrocedo'''
Retorna un valor booleano que indica si el robot debe avanzar. Para desplazarse de forma aleatoria, a adelante o atras, 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 hacia adelante, retornando True y en caso contrario deberá dsplazarse hacia atras retornando False.

<syntaxhighlight lang="lua">
local function chequear_avance_o_retrocedo()
-- Avanzar = true, Retroceder = false
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. Define el valor de la variable debe_avanzar que será false si se detectó con el sensor de grises (sensor se encuentra en la parte de adelante del robot) peligro de caerse de la mesa, entonces este debera retroceder o en caso de que detectó peligro de caerse con el sensor de distancia (sensor se encuentra en la parte de atras del robot), este debe avanzar.

<syntaxhighlight lang="lua">
local function puedo_seguir()

if Grey_2.getValue() > COLOR_MESA then
--retroceder
ret = ADELANTE_FUERA_MESA
else
if Distanc_6.getValue() < DISTANCIA_MESA then
--avanzar
ret = ATRAS_FUERA_MESA
else
--puedo seguir
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 la 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 retoceder 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 debemos colocar un sensor de distancia a una distancia de la mesa mayor a 3cm pero no mucho más, debido que a una distancia menor el sensor no sensa correctamente.

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 7 - Robot que no se caiga de la mesa con eventos, utilizando un sensor de grises y uno de distancia

2012-10-15T13:44:49Z

Leticiavp: /* Descripció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 indica si el color sensado se corresponde con el de la mesa (COLOR_MESA)o si la distncia sensada es distinta a la distancia que que hay entre el sensor y la mesa (DISTANCIA_MESA) .
Distinguimos entonces tres estados posibles según (ADELANTE_FUERA_MESA, ATRAS_FUERA_MESA, EN_LA_MESA). Si se cumple la condiciones ADELANTE_FUERA_MESA o ATRAS_FUERA_MESA, el robot deberá retroceder o 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>

* '''chequear_avance_o_retrocedo'''
Retorna un valor booleano que indica si el robot debe avanzar. Para desplazarse de forma aleatoria, a adelante o atras, 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 hacia adelante, retornando True y en caso contrario deberá dsplazarse hacia atras retornando False.

<syntaxhighlight lang="lua">
local function chequear_avance_o_retrocedo()
-- Avanzar = true, Retroceder = false
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. Define el valor de la variable debe_avanzar que será false si se detectó con el sensor de grises (sensor se encuentra en la parte de adelante del robot) peligro de caerse de la mesa, entonces este debera retroceder o en caso de que detectó peligro de caerse con el sensor de distancia (sensor se encuentra en la parte de atras del robot), este debe avanzar.

<syntaxhighlight lang="lua">
local function puedo_seguir()

if Grey_2.getValue() > COLOR_MESA then
--retroceder
ret = ADELANTE_FUERA_MESA
else
if Distanc_6.getValue() < DISTANCIA_MESA then
--avanzar
ret = ATRAS_FUERA_MESA
else
--puedo seguir
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 la 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 retoceder 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 debemos colocar un sensor de distancia a una distancia de la mesa mayor a 3cm pero no mucho más, debido que a una distancia menor el sensor no sensa correctamente.

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-15T13:40:08Z

Leticiavp: /* Configuració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 un sentido aleatorio.

<syntaxhighlight lang="lua">
while true do
moverse()
while (puedo_avanzar()) do
util.wait(INTERVALO_CHEQUEO)
end
volver_inicio()
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
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 debemos colocar un sensor de distancia a una distancia de la mesa mayor a 3cm pero no mucho más, debido que a una distancia menor el sensor no sensa correctamente.

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]]

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

2012-10-15T13:37:32Z

Leticiavp: /* 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 un sentido aleatorio.

<syntaxhighlight lang="lua">
while true do
moverse()
while (puedo_avanzar()) do
util.wait(INTERVALO_CHEQUEO)
end
volver_inicio()
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
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 debemos colocar un sensor de distancia a una distancia de la mesa mayor a 3cm pero no mucho más, debido que a una distancia menor el sensor no sensa correctamente.

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]]

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

2012-10-15T13:34:19Z

Leticiavp: /* 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 un sentido aleatorio.

<syntaxhighlight lang="lua">
while true do
moverse()
while (puedo_avanzar()) do
util.wait(INTERVALO_CHEQUEO)
end
volver_inicio()
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
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 la 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 retoceder 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 debemos colocar un sensor de distancia a una distancia de la mesa mayor a 3cm pero no mucho más, debido que a una distancia menor el sensor no sensa correctamente.

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]]

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

2012-10-15T13:26:09Z

Leticiavp: /* 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 un sentido aleatorio.

<syntaxhighlight lang="lua">
while true do
moverse()
while (puedo_avanzar()) do
util.wait(INTERVALO_CHEQUEO)
end
volver_inicio()
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. Define el valor de la variable debe_avanzar que será false si se detectó con el sensor de grises (sensor se encuentra en la parte de adelante del robot) peligro de caerse de la mesa, entonces este debera retroceder o en caso de que detectó peligro de caerse con el sensor de distancia (sensor se encuentra en la parte de atras del robot), este debe avanzar.

<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
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 la 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 retoceder 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 debemos colocar un sensor de distancia a una distancia de la mesa mayor a 3cm pero no mucho más, debido que a una distancia menor el sensor no sensa correctamente.

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]]

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

2012-10-15T13:20:54Z

Leticiavp: /* 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 un sentido aleatorio.

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

* '''chequear_avance_o_retrocedo'''
Retorna un valor booleano que indica si el robot debe avanzar. Para desplazarse de forma aleatoria, para adelante o atras, 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 hacia adelante, retornando True y en caso contrario deberá dsplazarse hacia atras retornando False.

<syntaxhighlight lang="lua">
local function chequear_avance_o_retrocedo()
-- Avanzar = true, Retroceder = false
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. Define el valor de la variable debe_avanzar que será false si se detectó con el sensor de grises (sensor se encuentra en la parte de adelante del robot) peligro de caerse de la mesa, entonces este debera retroceder o en caso de que detectó peligro de caerse con el sensor de distancia (sensor se encuentra en la parte de atras del robot), este debe avanzar.

<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
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 la 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 retoceder 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 debemos colocar un sensor de distancia a una distancia de la mesa mayor a 3cm pero no mucho más, debido que a una distancia menor el sensor no sensa correctamente.

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]]

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

2012-10-15T13:06:37Z

Leticiavp: /* 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 desplazarse el robot de forma aleatoria, para adelante o para atras, hasta tanto no se encuentre en peligro de caer de la mesa, en caso contrario deberá retroceder o avanzar, dependiendo de con cual sensor se detecto que el robot se esta por salir 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 el siguiente movimiento de este, se haga en un sentido aleatorio.

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

* '''chequear_avance_o_retrocedo'''
Retorna un valor booleano que indica si el robot debe avanzar. Para desplazarse de forma aleatoria, para adelante o atras, 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 hacia adelante, retornando True y en caso contrario deberá dsplazarse hacia atras retornando False.

<syntaxhighlight lang="lua">
local function chequear_avance_o_retrocedo()
-- Avanzar = true, Retroceder = false
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. Define el valor de la variable debe_avanzar que será false si se detectó con el sensor de grises (sensor se encuentra en la parte de adelante del robot) peligro de caerse de la mesa, entonces este debera retroceder o en caso de que detectó peligro de caerse con el sensor de distancia (sensor se encuentra en la parte de atras del robot), este debe avanzar.

<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
--se esta por caer desde la parte de adelante
debe_avanzar = false
else
debe_avanzar = true
end
end
return ret
end
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 la 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 retoceder 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 debemos colocar un sensor de distancia a una distancia de la mesa mayor a 3cm pero no mucho más, debido que a una distancia menor el sensor no sensa correctamente.

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]]

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

2012-10-15T12:47:47Z

Leticiavp: /* 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.

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.

Vamos a explicar como realizamos esto, para calibrar 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 el nombre es Distanc_6). Nos arrojará un valor que tendremos identificado como “DISTANCIA_MESA”. Posteriormente, se hizo lo mismo con el sensor fuera de la mesa, comparamos estos dos valores, obtenemos cual es la relación de estos.

De esta forma obtenemos el valor de la variable DISTANCIA_MESA que se refiere a la distancia a partir de la cual el robot detecta la presentacia de la mesa y la relación con respecto a esta, con lo cual el robot detecta que esta por caerse de le mesa, entonces deberá evitar la caida .

El robot deberá desplazarse por la mesa, de forma aleatoria para adelante o para atras, cuando este detecte que esta por caerse de la mesa, deberá avanzar o retroceder dependiendo de con cual de los sensores lo detecte, por un tiempo determinado. 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 y tratando de volver siempre al centro de la misma, que es su estado inicial. 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 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 desplazarse el robot de forma aleatoria, para adelante o para atras, hasta tanto no se encuentre en peligro de caer de la mesa, en caso contrario deberá retroceder o avanzar, dependiendo de con cual sensor se detecto que el robot se esta por salir 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 el siguiente movimiento de este, se haga en un sentido aleatorio.

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

* '''chequear_avance_o_retrocedo'''
Retorna un valor booleano que indica si el robot debe avanzar. Para desplazarse de forma aleatoria, para adelante o atras, 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 hacia adelante, retornando True y en caso contrario deberá dsplazarse hacia atras retornando False.

<syntaxhighlight lang="lua">
local function chequear_avance_o_retrocedo()
-- Avanzar = true, Retroceder = false
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. Define el valor de la variable debe_avanzar que será false si se detectó con el sensor de grises (sensor se encuentra en la parte de adelante del robot) peligro de caerse de la mesa, entonces este debera retroceder o en caso de que detectó peligro de caerse con el sensor de distancia (sensor se encuentra en la parte de atras del robot), este debe avanzar.

<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
--se esta por caer desde la parte de adelante
debe_avanzar = false
else
debe_avanzar = true
end
end
return ret
end
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 la 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 retoceder 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 debemos colocar un sensor de distancia a una distancia de la mesa mayor a 3cm pero no mucho más, debido que a una distancia menor el sensor no sensa correctamente.

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]]

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

2012-10-11T01:43:45Z

Leticiavp: /* 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 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==

==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 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-11T01:41:23Z

Leticiavp: /* 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 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 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_8.png|300px|thumb|center|Configuración]]

==Video==

==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 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-11T01:04:43Z

Leticiavp: /* 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 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 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 hay_obstaculo()
local distancia = Distanc_2.getValue()
return (distancia > DISTANCIA_OBSTACULO)
end
</syntaxhighlight>

* '''esquivar_obstaculo'''
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 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 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_8.png|300px|thumb|center|Configuración]]

==Video==

==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 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-11T01:04:00Z

Leticiavp: /* 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 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 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 hay_obstaculo()
local distancia = Distanc_2.getValue()
return (distancia > DISTANCIA_OBSTACULO)
end
</syntaxhighlight>

* '''esquivar_obstaculo'''
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 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 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_8.png|300px|thumb|center|Configuración]]

==Video==

==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 1 - Seguidor de líneas sin eventos, utilizando un sensor de grises

2012-10-11T00:58:34Z

Leticiavp: /* Solució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.

==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 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 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-11T00:52:45Z

Leticiavp: /* Solución */

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

2012-10-11T00:44:56Z

Leticiavp: /* 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 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 (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_8.png|300px|thumb|center|Configuración]]

==Video==

==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 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-11T00:34:53Z

Leticiavp:

__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'''

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_8.png|300px|thumb|center|Configuración]]

==Video==

==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 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-11T00:32:56Z

Leticiavp: /* Configuració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 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_8.png|300px|thumb|center|Configuración]]

==Video==

==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 8 - Seguidor de líneas con obstáculos, sin eventos, utilizando un sensor de grises y uno de distancia

2012-10-11T00:32:37Z

Leticiavp: Página creada con '__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 ...'

__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==

==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]]

Ejemplos de Aplicaciones en Butialo

2012-10-11T00:30:58Z

Leticiavp: /* 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 sin eventos, utilizando un sensor de grises|Ejemplo 1: Seguidor de líneas sin 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 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-11T00:29:23Z

Leticiavp: /* Ejemplos */

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

2012-10-11T00:26:08Z

Leticiavp: Página creada con '<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 funct...'

<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 5 - Seguidor de líneas con eventos, utilizando dos sensores de grises

2012-10-11T00:24:23Z

Leticiavp: Página creada con '__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 rob...'

__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==

==Código==

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

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

2012-10-11T00:23:38Z

Leticiavp: /* Código */

__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==

==Código==

[[Butialo: Ejemplo 4 - Robot que no se caiga de la mesa con 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-11T00:22:49Z

Leticiavp: Página creada con '__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...'

__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==

==Código==

[[Butialo: Ejemplo 4 - Butiá que no se cae de la mesa con un sensor con eventos - Código]]

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

2012-10-11T00:21:21Z

__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==

==Código==

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

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

2012-10-11T00:20:13Z

Leticiavp: Página creada con '__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, utilizand...'

__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 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]]

Ejemplos de Aplicaciones en Butialo

2012-10-11T00:19:22Z

Leticiavp: /* 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 3 - Butiá que no se cae de la mesa con un sensor sin eventos|Ejemplo 3: Butiá que no se cae de la mesa con un sensor sin eventos]]

[[Butialo: Ejemplo 4 - Butiá que no se cae de la mesa con un sensor con eventos|Ejemplo 4: Butiá que no se cae de la mesa con un sensor con eventos]]

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

[[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 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 5 - Seguidor de líneas con dos sensores con eventos

2012-10-11T00:07:09Z

Leticiavp: /* 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 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==

==Código==

[[Butialo: Ejemplo 4 - Butiá que no se cae de la mesa con un sensor sin eventos - Código]]

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

2012-10-10T23:59:38Z

Leticiavp: /* 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 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 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_5.png|300px|thumb|center|Configuración]]

==Video==

==Código==

[[Butialo: Ejemplo 4 - Butiá que no se cae de la mesa con un sensor sin eventos - Código]]

Archivo:Config butialo problema 4.png

2012-10-10T23:58:37Z

Leticiavp:

Butialo: Ejemplo 4 - Butiá que no se cae de la mesa con un sensor con eventos

2012-10-10T23:57:58Z

Leticiavp: /* Configuració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 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==

==Código==

[[Butialo: Ejemplo 4 - Butiá que no se cae de la mesa con un sensor sin eventos - Código]]