Documentos de Académico
Documentos de Profesional
Documentos de Cultura
3. MATERIALES. Los siguientes materiales se utilizaron en el Proyecto: Nro. 1 ITEM PIC 16F877A CARACT. 5v, 25mA por cada pin. CANTID. 1 OBSERV. Se puede usar otro PIC pero debe tener similares caractersticas de memoria. Motor de juguete. Se usa dos fuentes de alimentacin debido al ruido, uno para circuito de control y otra para la parte de potencia. Conversor Serial (RS232) a bus USB.
2 3
Varios 2 2
Chip FT 232RL
4. MARCO TEORICO. Este documento, as como el algoritmo y cdigo fuente base, fue en parte extrada del proyecto del seor Xabier Ugarte Pedrero. Copyright (c) 2007, para mayor referencia sobre la lgica usada y toda la teora necesaria sobre este proyecto, se debe de consultar la bibliografa y documentacin referida a este proyecto (proy_xabier_laberinto.pdf).
b) Algoritmo implementado en el microBot: El firmware fue escrito en lenguaje Basic desde el compilador PICBASIC pro 2.50b en el IDE de MicroCode Studio v3.0.0.5 de mecanique.
'**************************************************************** '* Name: LABERINTO.BAS * '* Author: [YORCY A. DIAZ VIEW EDITOR UPEA] * '* Notice: Copyright (c) 2013 BETOX * '* : All Rights Reserved * '* through licenses creative common * '* of Xabier Ugarte pedrero. * '* Date : 24/11/2013 * '* Versin: 1.0 * '* Notes : Robot laberinto guiado por mapeado del rea * '* entradas iniciales ORIGEN y DESTINO * '****************************************************************
'Declaration de fusible
@ __CONFIG _HS_OSC & _WDT_OFF & _PWRTE_ON & _BODEN_ON & _LVP_OFF & _CPD_OFF & _WRT_OFF & _DEBUG_OFF & _CP_OFF DEFINE OSC 10 'Oscilador de 10Mhz
'**** Debug - serial ***** DEFINE DEBUG_REG PORTB DEFINE DEBUG_BIT 0 DEFINE DEBUG_BAUD 9600 DEFINE DEBUG_MODE 0 '************************* ADCON1=7 'Puerto A como I/O digital
'Informacin del mapeado del rea en la eeprom acerca del laberinto DATA @$00, $00, $04, $AC, $00 DATA @$04, $00, $09, $AD, $02 DATA @$08, $80, $16, $AE, $10, $10, $07 DATA @$10, $00, $FF, $FF, $0A DATA @$14, $00, $1A, $AE, $08 DATA @$18, $00, $1F, $AF, $14 DATA @$1C, $00, $23, $AF, $19 DATA @$20, $00, $27, $AF, $1D DATA @$24, $00, $2A, $AE, $21 DATA @$28, $00, $2E, $AE, $24 DATA @$2C, $81, $35, $49, $53, $AF, $28 DATA @$34, $01, $38, $4C, $2F DATA @$38, $01, $3D, $4D, $36 DATA @$3C, $81, $45, $45, $4A, $4E, $3B DATA @$44, $01, $FF, $FF, $3F DATA @$48, $01, $4D, $4D, $3C DATA @$4C, $01, $FF, $FF, $4B DATA @$50, $81, $60, $AC, $5B, $5F, $2D DATA @$58, $01, $5C, $5C, $51 DATA @$5C, $01, $FF, $FF, $5A DATA @$60, $01, $64, $AC, $52 DATA @$64, $81, $70, $AC, $6F, $6F, $62 DATA @$6C, $01, $FF, $FF, $65 DATA @$70, $81, $88, $AC, $79, $85, $66 DATA @$78, $01, $7D, $85, $73 DATA @$7C, $01, $80, $84, $7B DATA @$80, $01, $87, $87, $7E DATA @$84, $01, $FF, $FF, $81 DATA @$88, $81, $90, $9C, $A3, $AF, $72 DATA @$90, $01, $95, $9D, $8A DATA @$94, $01, $99, $9D, $93
DATA @$98, $01, $9D, $9D, $97 DATA @$9C, $01, $FF, $FF, $9B DATA @$A0, $81, $A8, $A8, $AE, $AE, $89 DATA @$A8, $01, $FF, $FF, $A2 DATA @$AC, $01, $FF, $FF, $A0 '******************************************************************** 'Constantes del programa para los movimientos 'bits definidos en funcin al L293D AVANZAR CON %0101 'Valor forward en L293 RETROCEDER CON %1010 IZQ CON %1001 DER CON %0110 QUIETO CON %0000 '******************************************************************** 'Constantes del programa para tiempos de los movimientos pause en ms() PAUSA_AVANZAR CON 4500 'PAUSA_AVANZAR CON 1290 PAUSA_CO CON 5 'PAUSA_CO CON 6 PAUSA_IZQ CON 1200 'PAUSA_IZQ CON 445 PAUSA_DER CON 1200 'PAUSA_DER CON 445 '******************************************************************** 'Variables del programa ********************************************** ORIENTACION VAR BYTE 'NIBLE ORI VAR BYTE 'NIBLE OJO estudiarlo' ORIENT VAR BYTE ORIGEN VAR Byte DESTINO VAR Byte NODO VAR Byte INFO VAR Byte LIM1A VAR Byte LIM1B VAR Byte LIM2A VAR Byte LIM2B VAR Byte PADRE VAR Byte AUX1 VAR Byte AUX2 VAR Byte AUX3 VAR Byte AUX4 VAR Byte
OBJETO VAR Byte SIGUIENTE VAR Byte 'OJO '********************************************************************** 'Configuracin de salidas *************** TRISD = $00 'Salida * 'PORTD=$00 'TODO EN CERO * '************************************ '======================================== '===***Inicializacin de variables***==== 'para la localizacin de puntos en * 'el laberinto ms info en PDF * ' ORIGEN = $10 'Nodo de inicio $60 $9C ' OBJETO = $1C 'Nodo final/meta $90 $00 ' ' OJO ' READ origen+1,ORIENT ' ORIENT.7 = 0 ' ORIENT.6 = 0 ' ORIENT.5 = 0 ' ORIENT.4 = 0 ' ORIENT.3 = 0 ' ORIENT.2 = 0 ' ORIENTACION=ORIENT ' '===************< >*****************======== '========================================
'******************************************************************************* '====================================================================== '======================< Inicio del programa principal >======================== '******************************************************************************* INICIO: PORTD=$00 ' Portd se pone a 0 pause 2000 'VARIABLE INICIAL DESTINO = OBJETO ' IR A 0h90 PAUSE 2000 '*** El nodo en curso es igual al origen ***** NODO = ORIGEN ' ESTA EN 0h60 PAUSE 1000
'================< RUTINA LECTURA >================================== LECTURA: 'Lectura del primer byte de info sobre el nodo en curso READ NODO,INFO 'lee nodo= address 0h60 y Almacena en info 'Enva la variable INFO al debug serial en formato hex, ascii 10 13=> Enter *********** DEBUG "Address_Nodo,Byte1=",HEX NODO,",",HEX INFO,10,13 'ASCII 32 SPACE
'===================================================================== '==================< RUTINA HIJOS >==================================== HIJOS: 'Evaluamos el nmero de hijos que tiene el nodo (INFO.BIT7) DEBUG "Info.7=", HEX INFO.7, 10,13 IF (INFO.7 == 0) THEN GOTO UNHIJO ELSE GOTO DOSHIJOS ENDIF 'INFO.BIT7 = 0 Cuantos hijos tiene?
'===================================================================== '=================< RUTINA UN HIJO >================================== UNHIJO: ; 'Leemos 3 bytes ya que tiene un hijo ; READ NODO+1,LIM1A READ NODO+2,LIM1B READ NODO+3,PADRE DEBUG "LIM1A=",HEX LIM1A,10,13 DEBUG "LIM1B=",HEX LIM1B,10,13 DEBUG "PADRE=",HEX PADRE,10,13 'Depuramos la informacin sobre los limites de sus descendientes AUX1 = LIM1A AUX2 = LIM1B AUX1.0 = 0 ' borra la orientacion AUX2.0 = 0 AUX1.1 = 0 ' borra la orientacion AUX2.1 = 0 DEBUG "AUX1=",HEX AUX1,10,13 DEBUG "AUX2=",HEX AUX2,10,13 ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;
; IF (AUX1 <= DESTINO) AND (AUX2 >= DESTINO) THEN ' DESTINO=0h90 SIGUIENTE = LIM1A ELSE SIGUIENTE = PADRE ENDIF DEBUG "SIGUIENTE=",HEX SIGUIENTE,10,13 'DEBUG 10,13 ; ; ; ; ; ;
GOTO MOVIMIENTO ; '==============================================0=============== '=============< FIN UN HIJO >==================================== '================================================================ '=============< RUTINA DOS HIJOS >================================ DOSHIJOS: ' 'Leemos 5 bytes ya que tiene dos hijos ' READ NODO+1,LIM1A ' READ NODO+2,LIM1B ' READ NODO+3,LIM2A ' READ NODO+4,LIM2B ' READ NODO+5,PADRE ' ' DEBUG "LIM1A=",HEX LIM1A,10,13 ' DEBUG "LIM1B=",HEX LIM1B,10,13 ' DEBUG "LIM2A=",HEX LIM2A,10,13 ' DEBUG "LIM2B=",HEX LIM2B,10,13 ' DEBUG "PADRE=",HEX PADRE,10,13 ' ' 'Depuramos la informacin sobre los limites de sus descendientes ' AUX1 = LIM1A ' AUX2 = LIM1B ' ' AUX1.0 = 0 ' AUX2.0 = 0 ' AUX1.1 = 0 ' AUX2.1 = 0 ' ' AUX3 = LIM2A ' AUX4 = LIM2B ' ' AUX3.0 = 0 ' AUX4.0 = 0 ' AUX3.1 = 0 ' AUX4.1 = 0 ' DEBUG "AUX1=",HEX AUX1,10,13 '
IF (AUX1 <= DESTINO) AND (AUX2 >= DESTINO) THEN ' SIGUIENTE = LIM1A ' ' 'Si se encuentra entre los limites (el destino es descendiente del nodo (primer hijo)) ELSE ' SIGUIENTE = PADRE ' 'Si no se encuentra entre los limites (el destino es ascendente del nodo) ' ENDIF ' ' IF (AUX3 <= DESTINO) AND (AUX4 >= DESTINO) THEN ' SIGUIENTE = LIM2A ' 'Si se encuentra entre los limites (el destino es descendiente del nodo) (segundo hijo)) ENDIF ' ' DEBUG "SIGUIENTE=",HEX SIGUIENTE,10,13 ' ' GOTO MOVIMIENTO ' '============================================================= '=============< FIN DOS HIJOS >=================================
'============================================================= '=====< RUTINA MOVIMIENTO >================================== MOVIMIENTO: ' 'Si no se encuentra entre los limites (el destino es ascendente del nodo) ' 'Capturamos la orientacion ' ORI.0 = SIGUIENTE.0 'borramos la orientacion ' ORI.1 = SIGUIENTE.1 ' SIGUIENTE.0 = 0 ' SIGUIENTE.1 = 0 ' ' DEBUG "Nodo_Siguente=",HEX SIGUIENTE,10,13 ' 'Si el siguiente nodo al que nos dirigimos es nuestro destino (objeto o salida) ' IF (SIGUIENTE == DESTINO) THEN ' 'Entraremos dos veces en este bucle, cuando estemos en el nodo anterior al objeto (elegiremos la salida 'ms cercana como destino), y cuando estemos en el nodo anterior a la salida (iniciaremos una serie 'de movimientos que nos llevarn a la salida ' GOSUB OBJETO_SALIDA ' ENDIF ' ' 'Si hemos elegido la salida $9C, pero el objeto nos bloquea la salida, cambiamos de salida IF (SIGUIENTE == OBJETO) AND (DESTINO == $9C) THEN ' DESTINO = $10 '
GOTO LECTURA 'Reinicia la lectura si actualizar (NODO = SIGUIENTE) ' ENDIF 'NODO se queda con el anterior siguente=(88) ' ' 'Si hemos elegido la salida $10, pero el objeto nos bloquea la salida, cambiamos de salida IF (SIGUIENTE == OBJETO) AND (DESTINO == $10) THEN ' DESTINO = $9C ' GOTO LECTURA ' ENDIF ' ' 'Actualizamos el valor del nodo en curso ' NODO = SIGUIENTE ' 'Llevamos a cabo el movimiento para situarnos sobre el ' 'Primero orientamos el robot ' GOSUB SITUAR ' 'Despues avanzamos 20 cm ' GOSUB DELANTE ' 'una vez realizado el movimiento, repite el bucle de lectura ' 'de datos el nodo ' GOTO LECTURA ' '========================================================== '=========< FIN MOVIMIENTO >===============================
'========================================================== '========< RUTINA SITUAR >================================== SITUAR: ' 'Rutina para que el robot se coloque en la orientacion que deseamos, saltando a DERECHA e IZQUIERDA, y realizando 'los movimientos 'Borramos los bits de ms peso (inutiles) de la orientacion actual (ORIENTACION) y la orientacion que deseamos (ORI) ORIENTACION.7 = 0 ORIENTACION.6 = 0 ORIENTACION.5 = 0 ORIENTACION.4 = 0 ORIENTACION.3 = 0 ORIENTACION.2 = 0 ' ORI.7 = 0 ORI.6 = 0 ORI.5 = 0 ORI.4 = 0 ORI.3 = 0 ORI.2 = 0 ' ' ' ' ' ' ' ' ' ' ' '
'
10
IF (ORIENTACION == ORI) THEN RETURN 'Si hemos alcanzado la orientacion deseada... endif ' ' IF ((ORI - ORIENTACION) == 1) OR (ORI == $00) AND (ORIENTACION == $3) THEN 'Si ORI es una unidad mayor que ORIENTACION GOTO DERECHA 'o si el robot mira al este y debe avanzar al norte ELSE ' GOTO IZQUIERDA 'En el resto de los casos giramos a la izquierda ' ENDIF ' '================================================================ '===================< FIN SITUAR >================================
'=============================================================== '==============< RUTINA DERECHA >=============================== DERECHA: ' PORTD = DER ' PAUSE PAUSA_DER ' PORTD = QUIETO ' ORIENTACION = ORIENTACION + 1 ' GOTO SITUAR ' '============================================================== '================< FIN DERECHA >===============================
'============================================================== '=============< RUTINA IZQUIERDA >============================= IZQUIERDA: ' PORTD = IZQ ' PAUSE PAUSA_IZQ ' PORTD = QUIETO ' ORIENTACION = ORIENTACION - 1 ' GOTO SITUAR ' '============================================================== '==============< FIN IZQUIERDA >================================
'============================================================== '===========< RUTINA DELANTE >============================== DELANTE: ' PORTD = AVANZAR ' PAUSE PAUSA_AVANZAR/2 ' PORTD = DER '
11
PAUSE PAUSA_CO ' PORTD = AVANZAR ' PAUSE PAUSA_AVANZAR/2 ' PORTD = QUIETO ' RETURN ' '============================================================== '==============< FIN DELANTE >==================================
'================================================================ '==========< RUTINA OBJETO DE SALIDA >============================ OBJETO_SALIDA: ' 'Encaramos el objeto o la salida ' GOSUB SITUAR ' 'Si el destino es la salida $9C, estamos en el nodo anterior a esta, y el objeto ya 'est encontrado, asi que iniciamos una secuencia de movimientos que nos sacan del laberinto IF (DESTINO == $9C) THEN ' PORTD = AVANZAR ' PAUSE PAUSA_AVANZAR/2 ' PORTD = DER ' PAUSE PAUSA_CO ' PORTD = AVANZAR ' PAUSE PAUSA_AVANZAR/2 ' PORTD = IZQ ' PAUSE PAUSA_IZQ ' PORTD = AVANZAR ' PAUSE PAUSA_AVANZAR ' GOTO FIN ' ENDIF ' ' 'Si el destino es la salida $10, estamos en el nodo anterior a esta, y el objeto ya 'est encontrado, asi que iniciamos una secuencia de movimientos que nos sacan del laberinto IF (DESTINO == $10) THEN ' PORTD = AVANZAR ' PAUSE PAUSA_AVANZAR/2 ' PORTD = DER ' PAUSE PAUSA_CO PORTD = AVANZAR ' PAUSE PAUSA_AVANZAR/2 ' GOTO FIN ' ENDIF ' ' 'Si llegamos aqui, significa que el destino es el objeto, y acabamos de encontrarlo, 'estamos en el nodo anterior y lo hemos encarado, asi que ahora actualizamos el destino 'con la salida ma s cercana ' IF (INFO.0 == 0) THEN 'INFO=Byte1=> bit.0/ para out4=(0)/ para out33=(1) '
12
DESTINO = $10 ' salida 4 ' ELSE ' DESTINO = $9C ' salida 33 ' ENDIF ' 'Repetimos todo el proceso ' RETURN ' '============================================================== '========< FIN OBJETO DE SALIDA >============================= FIN: ' Bucle final PORTD = QUIETO END
5. CONCLUSIONES Y OBSERVACIONES: MicroBot laberinto: Se pudo implementar todo el sistema de control y potencia. Se tuvo algunos inconvenientes debido a que el circuito fue armado en un ProtoBoard tenindose dificultades como ruido e inestabilidad en el sistema de control. Se usa constantes de tiempos para avanzar de nodo en nodo y para girar se debe calcular los tiempos exactos para no tener problemas al momento de avanzar y girar en un nodo, se considera que el algoritmo se lo debe hacer ms mejoras. Con este proyecto se puede observar una aplicacin real de algoritmos avanzados de control en lenguajes estructurados y su uso en micro-controladores, se considera que este proyecto es la base fundamental para desarrollar Bots-laberintos de competencia ya que se emplea mapeado del rea (laberinto), Para un proyecto futuro se recomienda usar sensores como ultrasonidos para medir profundidad en los nodos y as no encontrarse con nodos ciegos y algn mtodo de reconocimiento de nodos, En competencias el mapa de laberinto es desconocido, se podra hacer que el Bot- laberinto pueda realizar su propio mapeado en su memoria EEprom mediantes sensores utilizando el mismo mtodo descrito en este proyecto logrndose as tener un sistema de control inteligente ya que el robot una vez hecho el reconocimiento sabr exactamente donde est ubicada la entrada y salida del laberinto.
13