Robo Taller

Taller de Robótica

Dr. Gildardo Sánchez Ante

Departamento de Cs. Computacionales

ITESM-Campus Guadalajara

Contenido

SESION I Introducción. Enfoques para programación en robótica

móvil. Robótica móvil en la práctica: Ejemplos. Lego Mindstorms: Hardware. Lego Mindstorms: Software. Proyecto 1: Detección y seguimiento de una

fuente luminosa Proyecto 2: Seguimiento de líneas. Proyecto 3: Robot Merodeador.

Instructor

Gildardo Sánchez AnteDoctorado en Cs. ComputacionalesITESM-Cuernavaca/Stanford Univ.

Área de especialidad: Planeación de movimientos en robótica.

Oficina: DIA-3, 3er Piso, Edificio Administrativo Tel. (33) 3669-3000 x 3130 [email protected] http://academia.gda.itesm.mx/~gsanchez

¿Qué es un robot?

“Máquina reprogramable, multifuncional diseñada para manipular materiales, partes, herramientas o dispositivos especializados a través de movimientos programables para el desarrollo de una variedad de tareas”

Robotics Industries Association

Robots

Investigación

Industrial(Desplazamiento)

¿Juguete?

Industrial(Soldadura)

Exploración

Contenido

SESION I Introducción. Enfoques para programación en robótica móvil. Robótica móvil en la práctica: Ejemplos. Lego Mindstorms: Hardware. Lego Mindstorms: Software. Proyecto 1: Detección y seguimiento de una fuente

luminosa Proyecto 2: Seguimiento de líneas. Proyecto 3: Robot Merodeador.

Enfoques para robótica móvil

Enfoque Deliberativo o de Planificación.Suponiendo que el robot “conoce” su entorno

perfectamente y que éste cambia solamente por la acción del mismo robot o que en su defecto el robot puede predecir esos cambios.

Entonces es posible que el robot genere un plan de movimientos en un proceso fuera de línea y que una vez obtenido éste, lo ejecute.


Enfoque Reactivo: Para casos en que el robot no conoce la dinámica

del entorno, es posible inducir en él una serie de comportamientos simples cuya combinación crea en un momento determinado la posibilidad de lidiar con ciertos problemas.

En este caso el robot no planifica de antemano sus movimientos, los va decidiendo de acuerdo con la información que los sensores le proporcionan y las reglas que le han sido programadas.


Ambas propuestas son interesantes y pueden ser complementarias. Mientras que en el enfoque deliberativo puro el lazo de control no se cierra, evitando la posibilidad de manejar errores, en el caso de la robótica reactiva, es muy difícil reproducir acciones complejas en el robot. Casi siempre se limita a imitar en un cierto grado acciones simples de insectos.

Contenido



Algunos ejemplos prácticos

La intención de presentar estos casos es dar ideas de cómo se han abordado algunos de los problemas clásicos en planeación de movimientos de robots móviles.

Caso 1

Misión: Construir un mapa de un entorno inicialmente desconocido.

Equipo:Robot Super Scout equipado con un Sick

Laser, y acceso inalámbrico a una computadora.

El robot

El proceso

Hacer un barrido del entorno con el láser. Generar polilíneas. Alinear el mapa actual con la versión

anterior de éste. Marcar “free-edges”. Determinar siguiente posición de barrido

(next-best view algorithm).

Resultado de un barrido con el Sick Laser

Estrategia de Next-best view

Un ejemplo

1122

44 66

Caso 2: Target Tracking

Misión: Identificar un objetivo (target) y mantenerlo siempre dentro del campo de visión del robot (autonomous observer).

Equipo:Robot SuperScout con dos cámaras de video,

frame grabber y acceso inalámbrico a otra computadora.

Robot Nomad 200 guiado mediante un humano.

Target

Observador

Campo visualdel observador

Una mejor estrategia

Target

Observador

¿Cuál es la mejor posición?

Target

Observador

Menor tiempo de escape

Target

Observador

Un ejemplo

En un entorno complejo

Videos

Empleo de Simuladores

Los simuladores son herramientas sumamente poderosas que aunque no suplen la utilización de un robot real, sí ayudan a optimizar su uso, especialmente en las etapas de depuración.

KepheraMobs

Caso: Navegación simple

Misión: Moverse por ahí tratando de evitar colisiones.

Equipo: Plataforma de Lego con dos sensores de contacto y uno de luz infrarroja.

Pero mejor....

¡Pongamos manos a la obra!

Contenido



Introducción

El RCX es el cerebro del sistema ROBOTICS INVENTION, el RCX se programa mediante una PC, además tiene pre-cargados algunos programas.

Introducción

El RCX tiene puertos para tomar lecturas de los sensores, un procesador para realizar cálculos y salidas con las cuales controla los motores.

Introducción

Para construir un robot se utilizan el RCX y las piezas LEGO.

Introducción

Mediante un lenguaje de programación visual para PC y el puerto serial, es posible programar y posteriormente descargar el código que ejecutará el RCX.

Hardware El RXC

5 programas precargados, que se ejecutan mediante los botones Prgm y Run. Es posible borrarlos para introducir programas propios.

Opera con 6 baterías AA ó con eliminador de baterías

Si el RCX no está ejecutando ningún programa, el sistema se apagará después de 15 minutos, este valor se puede modificar utilizando el software de programación incluido con el sistema

Hardware

Características del RXC3 puertos de entrada3 puertos de salida4 botones de control1 display LCD1 conector para

eliminador de baterías1 emisor/receptor

infrarrojo

El “cerebro” del Lego (RCX)

Imágenes de http://graphics.stanford.edu/~kekoa/rcx/Imágenes de http://graphics.stanford.edu/~kekoa/rcx/

Circuit Board

VISTA FRONTAL

VISTA POSTERIOR

Hardware

Puertos entrada salidaLos puertos de entrada son

puntos de conexión para sensores (luz, contacto, temperatura y rotación)

Los puertos de salida son puntos de conexión para motores y otro tipo de dispositivos como lámparas

Hardware

Botones de control Rojo (ON-OFF): encendido y apagado

del sistema RCX Negro (View), permite seleccionar la

función que se desea monitorear para mostrarla en pantalla. Ejem: visualizar la lectura de un sensor en los puertos de entrada 1,2 o 3 o la velocidad de un motor en los puertos A, B o C

Gris(Prgm o program) permite seleccionar alguno de los programas precargados en el PCX

Verde (Run) ejecuta y detiene el programa seleccionado con el boton Prgm

Hardware

Display del RCX Indicador de batería baja Indicador de puerto infrarrojo, se enciende

cuando se está programando el dispositivo Barra Indicadora de descarga de programas, se

enciende cuando se está bajando un programa de una PC al RCX

Flechas indicadoras para puertos de salida, se activan para indicar actividad en un puerto de salida

Flecha indicadora de puerto de entrada, indican actividad en un puerto de entrada

Icono de persona, cuando está corriendo indica que el RCX está ejecutando un programa

Hardware Transmisor IR

Establece enlace inalámbrico entre una PC y el RCX mediante el puerto serial de la computadora para bajar programas a la unidad RCX

Es necesario tener un campo de visión abierto para establecer comunicación. Se tienen dos rangos de comunicación seleccionables corto/largo mediante un interruptor

Típicamente la distancia para bajar un programa al RCX varía de 4-6 pulgadas, aunque bajo condiciones adecuadas puede establecer comunicación hasta unos 90 pies

El transmisor utiliza una batería de 9 volts

Contenido



Software Menú Principal

Cuando se ejecuta por primera vez, el software se activa en modo guiado. Este modo consta de las siguientes etapas: Login, Main Menu, Getting Started, Tour, Set up: Part 1, Set up: Part2, Set up Options, Training Center Introduction and Missions 1-6

El Menú Principal permite accesar a cualquiera de los siguientes submenús: Getting Started, Program RCX, Help y WWW

Software

Getting Started Contiene los submenus: Tour, Set Up:

Part 1 y Set Up Part 2 Tour

Introducción al producto MINDSTORMS y sus conceptos

Set Up: Part 1 Instrucciones paso a paso que explican

cómo cambiar baterías, cómo usar los botones, cómo girar los motores y leer los sensores y cómo utilizar los programas precargados

Software

Set Up: Part 2 Instrucciones paso a paso que

explican cómo preparar el transmisor infrarrojo IR para usarlo y conectarlo a la computadora. Además, tiene instrucciones para bajar el software al sistema RCX

Set Up Options Esta pantalla permite verificar o

cambiar los valores del sistema RCX y del transmisor IR sin necesidad de pasar por los submenus Set Up: Part 1 y Set Up: Part 2

Software

Program RCXIncluye los submenús: Training Center

programming instructions y RCX Code programming environment

Software

TRAINING CENTER Guía a los siguientes

submenús:• explicación de RCX Code

• creación de programas en RCX Code

• cargando un programa al RCX

• guardando un programa en el Program Vault y

• Otras funciones

Software

RCX CODE Es un ambiente de programación

gráfico para construir programas. Cada bloque en la pantalla es una instrucción

Permite generar programas que serán descargados en el RCX con acciones o comportamientos

La programación se realiza en el área de trabajo del RCX Code. El espacio de trabajo variará dependiendo del programa

Software

PROGRAM VAULT Permite almancenar los

programas generados con el RCX Code en el disco duro o en unidades de diskette. Existen opciones como: New, Import, Export o Delete. En el centro existen contenedores que indican los programas almacenados y se opera con las flechas arriba y abajo

I/O

Tres salidas – A, B y CPara manejar motores

Tres entradas– 1, 2 y 3InterruptoresSensor de luzContador de revolucionesOtros (temperatura, etc)

Introducción a Not Quite C (NQC)

Introducción

NQC quiere decir Not Quite C, que es el nombre de un lenguaje de programación desarrollado por Dave Baum y otras personas.

NQC tiene una sintaxis similar a la que posee el lenguaje C.

Sin embargo, NQC es un lenguaje de propósito específico para programar varios de los productos de Lego Mindstorms.

Existen otras alternativas, como es el caso de legOS y pbFORTH.

Reglas léxicas de NQC

Comentarios:/* Esto es un comentario*/

// Esto también lo es

Constantes NuméricasX = 10;

Estructura de un programa en NQC

Un programa en NQC se compone por bloques de código y variables globales.

Existen tres tipos diferentes de bloques de código:Tareas (tasks), Funciones en línea (inline) ySubrutinas (subroutine).

Tasks

El RCX soporta implícitamente el multi-tasking (cuando se comparte un procesador en múltiples procesos).

Los tasks se definen mediante:task nombre(){ // codigo de la tarea}

Un programa debe tener siempre al menos un task, llamado main. El número máximo de tasks depende del hardware en que se correrá. Para el caso del RCX se trata de 10.

Tasks

Los tasks pueden activarse o detenerse mediante las sentencias start y stop. Start task_name;

Stop task_name

Funciones

A veces es conveniente agrupar conjuntos de sentencias en una función, la cual puede ser llamada después cuando sea necesario.

Las funciones en NQC se definen:void name(argument_list){

// body of the function}

Funciones

void proviene de C. En el caso de las funciones de NQC, no es posible regresar valores, de ahí que se les defina con void.

La lista de argumentos puede ser vacía o puede contener variables, separadas por comas e indicando su tipo. NQC soporta cuatro tipos para los argumentos.

Argumentos para las funcionesType Meaning Restriction

int pass by value none

const int pass by value only constants may be used

int& pass by reference only variables may be used

const int & pass by reference function cannot modify argument

Paso de parámetros por valor

void foo(int x){

x = 2;

}

task main(){

int y = 1; // y is now equal to 1

foo(y); // y is still equal to 1!

}

Paso de parámetros const int

void foo(const int x){

PlaySound(x); // okx = 1; // error - cannot modify argument

}task main(){

foo(2); // okfoo(4*5); // ok - expression is still constantfoo(x); // error - x is not a constant

} Esto es particularmente útil ya que hay algunas funciones

del RCX que solamente aceptan argumentos constantes.

Paso de parámetros por referencia

void foo(int &x){

x = 2;}task main(){

int y = 1; // y is equal to 1foo(y); // y is now equal to 2foo(2); // error - only variables allowed

} En este caso es posible que la función modifique

los valores de los argumentos que se le pasan

Funciones

Las funciones en NQC siempre son expandidas como inline.

Esto significa que cada llamada a la función resulta en una copia del código de la función que se incluye en el programa. Si no se les usa de manera cuidadosa, pueden producir códigos de tamaño excesivo.

Subrutinas

A diferencia de las funciones, las subrutinas permiten que una sola copia del mismo código sea compartida por diferentes usuarios.

Esto las hace ser más eficientes en cuanto al uso de espacio, sin embargo, por limitaciones en el RCX, existen algunas restricciones en su uso: No pueden usar argumentos. Una subrutina no puede llamar a otra. El número máximo de ellas está limitado a 8 en el

caso del RCX. Estas restricciones las hacen menos deseables

que las funciones.

Subrutinas

La sintaxis para una subrutina es la siguiente:sub name()

{

// body of subroutine}

Variables

Todas las variables en NQC son del mismo tipo (enteros con signo de 16 bits).

Se les declara empleando int x; // declare x

int y,z; // declare y and z

int a=1,b; // declare a and b, initialize a to 1

Variables

GlobalesSe les declara fuera del alcance de

cualquiera de las funciones. Locales

Se les declara dentro de las tareas, funciones o subrutinas.

Ejemplos de variablesint x; // x is globaltask main(){

int y; // y is local to task mainx = y; // ok{ // begin compound statement

int z; // local z declaredy = z; // ok

}y = z; // error - z no longer in scope

}task foo()

{x = 1; // oky = 2; // error - y is not global

}

Estructuras de Control

Como cualquier lenguaje estructurado, NQC posee las siguientes estructuras de control:SecuenciaTomas de decisiónRepetición

Secuencia

{

x = 1;

y = 2;

} Simplemente, una sentencia se

ejecuta después de la otra. Se pueden agrupar mediante llaves.

Tomas de decisión

if (condition) consequence if (condition) consequence else alternative

if (x==1) y = 2; if (x==1) y = 3; else y = 4; if (x==1) { y = 1; z = 2; }

Tomas de decisión

switch (expression) body

case constant_expression :

default :

Ejemplo:switch(x){

case 1:// do something when X is 1break;

case 2:case 3:

// do something else when x is 2 or 3

break;default:

// do this when x is not 1, 2, or 3break;

}

ExpresionesOperator Description Associativity Restriction Example

abs()sign()

Absolute valueSign of operand

n/an/a

abs(x)sign(x)

++, -- Increment, decrement left variables only x++ or ++x

-~!

Unary minusBitwise negation (unary)Logical negation

rightrightright

constant only -x~123!x

*, /, % Multiplication, division, modulo left x * y

+, - Addition, subtraction left x + y

<<, >> Left and right shift left shift amount must constant

x << 4

<, >, <=, >=

relational operators left x < y

==, != equal to, not equal to left x == 1

& Bitwise AND left x & y

^ Bitwise XOR left x ^ y

| Bitwise OR left x | y

&& Logical AND left x && y

|| Logical OR left x || y

? : conditional value n/a x==1 ? y : z

Condiciones

Condition Meaning

true always true

false always false

expr true if expr is not equal to 0

expr1 == expr2 true if expr1 equals expr2

expr1 != expr2 true if expr1 is not equal to expr2

expr1 < expr2 true if one expr1 is less than expr2

expr1 <= expr2 true if expr1 is less than or equal to expr2

expr1 > expr2 true if expr1 is greater than expr2

expr1 >= expr2 true if expr1 is greater than or equal to expr2

! condition logical negation of a condition - true if condition is false

cond1 && cond2 logical AND of two conditions (true if and only if both conditions are true)

cond1 || cond2 logical OR of two conditions (true if and only if at least one of the conditions are true)

Ciclos

while (condition) body

while(x < 10)

{

x = x+1;

y = y*2;

}

Ciclos

do body while (condition)

for(stmt1 ; condition ; stmt2) body

repeat (expression) body

until()

Esta es nuestra primera construcción de control.

Hasta ahora nuestros códigos habían sido lineales o secuenciales.

Algunas sentencias de NQC permiten controlar el flujo del programa.

Observe while().

While

Sintaxiswhile( condicion )

cuerpo

La condición es una expresión que evalúa a falso o verdadero

Pueden ser también condiciones simples, tales como true, false

Algunas más complejas empleando sensores un poco más adelante…

Until

El opuesto del while El ciclo se ejecuta hasta que la condición sea

verdadera.Mientras sea falsa

Es común usarla sin un cuerpountil(false);

Y su uso completo es until( condicion ) {

sentencias;

}

Programando para el robot Hemos hablado ya de algunos de los elementos fundamentales del

lenguaje. Ahora veamos cómo emplearlos en problemas con el robot.

Ejemplo

task main()

{

OnFwd(OUT_A);

OnFwd(OUT_C);

Wait(400);

OnRev(OUT_A+OUT_C);

Wait(400);

Off(OUT_A+OUT_C);

}

Task y “main”

Por ahora, solamente lo usaremos, más adelante explicaremos con más detalle.

“main” indica dónde es que inicia el programa

Las llaves delimitan bloques, en este caso al programa mismo.

task main()

{

OnFwd(OUT_A);

OnFwd(OUT_C);

Wait(400);

OnRev(OUT_A+OUT_C);

Wait(400);

Off(OUT_A+OUT_C);

}

Wait

Detiene la ejecución del programa durante un cierto tiempo.

El tiempo está dado como centésimas de segundo.

Ejemplo: cuatro segundos.

task main()

{

OnFwd(OUT_A);

OnFwd(OUT_C);

Wait(400);

OnRev(OUT_A+OUT_C);

Wait(400);

Off(OUT_A+OUT_C);

}

Reverse y Off

Similar a Fwd() Note que se controlan

dos salidas.

task main()

{

OnFwd(OUT_A);

OnFwd(OUT_C);

Wait(400);

OnRev(OUT_A+OUT_C);

Wait(400);

Off(OUT_A+OUT_C);

}

Sensores

Se usan los nombre SENSOR_1, SENSOR_2, y SENSOR_3 para identificar los puertos de sensores del RCX. Un sensor tiene dos componentes: su tipo y modo. El tipo determina cómo se lee el sensor, y el modo determina cómo se interpreta el valor. Estos se fijan empleando

SetSensorType(sensor, tipo) y SetSensorMode(sensor, modo). SetSensorType(SENSOR_1,SENSOR_TYPE_LIGHT); SetSensorMode(SENSOR_1, SENSOR_MODE_PERCENT);

Por conveniencia también puede usarse: SetSensor(sensor, configuracion)

SetSensor(SENSOR_1, SENSOR_LIGHT); SetSensor(SENSOR_2, SENSOR_TOUCH);

Sensores

Sensor Type Meaning

SENSOR_TYPE_TOUCH a touch sensor

SENSOR_TYPE_TEMPERATURE a temperature sensor

SENSOR_TYPE_LIGHT a light sensor

SENSOR_TYPE_ROTATION a rotation sensor

Sensor Mode Meaning

SENSOR_MODE_RAW raw value from 0 to 1023

SENSOR_MODE_BOOL boolean value (0 or 1)

SENSOR_MODE_EDGE counts number of boolean transitions

SENSOR_MODE_PULSE counts number of boolean periods

SENSOR_MODE_PERCENT value from 0 to 100

SENSOR_MODE_FAHRENHEIT degrees F

SENSOR_MODE_CELSIUS degrees C

SENSOR_MODE_ROTATION rotation (16 ticks per revolution)

Sensores

Sensores

Sensor Configuration Type Mode

SENSOR_TOUCH SENSOR_TYPE_TOUCH SENSOR_MODE_BOOL

SENSOR_LIGHT SENSOR_TYPE_LIGHT SENSOR_MODE_PERCENT

SENSOR_ROTATION SENSOR_TYPE_ROTATION SENSOR_MODE_ROTATION

SENSOR_CELSIUS SENSOR_TYPE_TEMPERATURE SENSOR_MODE_CELSIUS

SENSOR_FAHRENHEIT SENSOR_TYPE_TEMPERATURE SENSOR_MODE_FAHRENHEIT

SENSOR_PULSE SENSOR_TYPE_TOUCH SENSOR_MODE_PULSE

SENSOR_EDGE SENSOR_TYPE_TOUCH SENSOR_MODE_EDGE

Salidas Los nombres OUT_A, OUT_B, y OUT_C se emplean para

identificar las salidas del RCX. Todos los comandos para controlar salidas pueden trabajar con varias salidas a la vez. Pro ejemplo: "OUT_A + OUT_B".

Cada salida tiene tres atributos distintos: modo, dirección, y nivel de potencia. El modo se especifica de acuerdo con:

Output Mode Meaning

OUT_OFF output is off (motor is prevented from turning)

OUT_ON output is on (motor will be powered)

OUT_FLOAT motor can "coast"

Salidas

La dirección se fija mediante SetDirection(salidas, direccion). La dirección puede ser:

La potencia va de 0 (menor) a 7 (mayor). Se fijan mediante

SetPower(salidas, potencia).

Direction Meaning

OUT_FWD Set to forward direction

OUT_REV Set to reverse direction

OUT_TOGGLE Switch direction to the opposite of what it is presently

Salidas

Command Action

On(outputs) turns motors on

Off(outputs) turns motors off

Float(outputs) makes outputs "float"

Fwd(outputs) sets outputs to forward direction

Rev(outputs) sets outputs to reverse direction

Toggle(outputs) toggles direction of outputs

OnFwd(outputs) sets direction to forward, then turns on

OnRev(outputs) sets direction to reverse, then turns on

OnFor(outputs, time) turns outputs on for specified amount of time (in 100ths of a second)

Salidas

Algunos ejemplos son:

OnFwd(OUT_A); // turn on A in the forward direction

OnRev(OUT_B); // turn on B in the reverse direction

Toggle(OUT_A + OUT_B); // flip directions of A and B

Off(OUT_A + OUT_B); // turn off A and B OnFor(OUT_C, 100); // turn on C for 1 second

Motores

OUT_A es el dispositivo (motor) en la salida A

OnFwd( ) enciende el motor hacia adelante

Más adelante: POWER

task main()

{

OnFwd(OUT_A);

OnFwd(OUT_C);

Wait(400);

OnRev(OUT_A+OUT_C);

Wait(400);

Off(OUT_A+OUT_C);

}

Instalando RxcCC

Las instrucciones dicen que se instale primero el sofware de LEGO.

RcxCC necesita que se instale Acrobat 4 Finalmente, corra el ejecutable para hacer

la instalación. Vea la página de web:

http://www.cs.unc.edu/~lastra/comp006/Notes/notes_8_28_01.html

El RCX cc

RcxCC

Integrated Development Environment

Diagnóstico

Controlador

El Joystick

Un piano

Un programa simple

Corra 1_simple.nqc Mostrar cómo compilar y bajar el programa

Pruebe en diferentes slots de programa Uso de Start y Stop Herramientas

Firmware, Direct Control, Joysticks, etc.

Sintaxis

Los comandos terminan con punto y coma( ; )

Las llaves encierran bloques de código.

¡La sintaxis es importante! Mostrar un ejemplo de error de sintaxis

Es diferente de un error lógico

Salidas

Tres salidas: OUT_A, OUT_B, OUT_C

AtributosModo (off, on, float)Dirección (fwd, rev)Nivel de potencia

Modo

Float significa que un motor puede moverseNo lo detiene

Ejemplo (Corra – 8_float.nqc)task main()

{

SetOutput(OUT_A, OUT_FLOAT);

}

Dirección

Veamos estoMain llama

SetDirection(OUT_B, OUT_FWD);o OUT_REV o OUT_TOGGLE

También Fwd(), Rev(), Toggle(), OnFwd(), OnRev(), etc.

También OnFor(salidas, tiempo)

Potencia

SetPower(OUT_C, x)Donde x va de 0 a 7.0 es la mínima potencia.7 es el máximo.

Util para movernos despacio mientras depuramos el código.

Inicialmente la potencia se fija en 7.

Programa Tankbot 1

Dos cosas nuevas#defineuntil()

Y los comentarios

// tankbot1.nqc - …

#define LEFT OUT_A

#define RIGHT OUT_C

task main()

{

On(LEFT+RIGHT);

until(false);

}

#define

Es sólo una sustitución directa Ejemplo

#define LEFT OUT_A

Simplemente reemplaza LEFT con OUT_A

•OnFwd(LEFT); OnFwd(LEFT); OnFwd(OUT_A); OnFwd(OUT_A);•OnFwd(LEFT); OnFwd(LEFT); OnFwd(OUT_A); OnFwd(OUT_A);

• ¡Note que #define no termina con punto y ¡Note que #define no termina con punto y coma!coma!

• ¡Note que #define no termina con punto y ¡Note que #define no termina con punto y coma!coma!

Regresando a Tankbot 1

Note que dado que false nunca puede ser trueEl programa estará en until(false)

¡por siempre!

¿Qué ciclo while() podríamos haber usado en lugar de éste?

Tankbot 2

Abra el programa Tankbot2 Observe el #define

Es más fácil leer y modificar el programa.

On ( )Por omisión – potencia máxima, hacia

adelante Wait – lo veremos en la siguiente lámina

Wait

Muy simpleSimplemente haz nada hasta que el

tiempo haya transcurrido.Wait(x)

Donde x es el tiempo en centésimas de segundo

#define TURN_TIME 200

Wait(TURN_TIME)

¿Cuánto es eso?

Tankbot 2

Veamos qué ocurre cuando cambiamos algunos valores.

Bumpbot

Iniciemos con el uso de sensores.Configurar los sensoresMuestrear los sensores

Sensores

Los sensores son llamadosSENSOR_1, SENSOR_2, SENSOR_3

ConfigurándolosNQC nos permite definir el tipo y modo

de los sensoresEl modo permite hacer diversas

interpretaciones del valor de un sensor.Por ahora, ignoraremos eso.

Sensor

Simplemente usaremos la subrutinaSetSensor(SENSOR_1, SENSOR_TOUCH);

Con ello, podemos reer valores tanto procesados como sin procesar.

Por ahora, le usaremos como en este caso:while(SENSOR_1 == 0)

owhile(SENSOR_1 == 1)

Contenido




Proyecto 1Sigue la luz

Diseñar un robot que sea capaz de detectar una fuente de luz y dirigirse a ella.

Contenido




Proyecto 2Seguimiento de líneas

Diseñar un robot que sea capaz de identificar una línea de color negro en el piso y seguirla.

Contenido




Proyecto 3Robot merodeador

Diseñar un robot que sea capaz de moverse aleatoriamente en el entorno sin colisionar con obstáculos.

Robo Taller

Education

Transcript of Robo Taller