Diferencia entre revisiones de «Seguidor de Luz»

Revisión actual del 19:42 28 jun 2020

Introducción

En la actualidad el cambio de la matriz energética es sin lugar a dudas un temas considerados en la agenda de la mayoría de los países del mundo. En el caso de Uruguay se está desarrollando un Plan de Nacional de Eficiencia Energética que culminaría en 2024 donde se considera la energía solar térmica como una de las herramientas para lograr este objetivo. En este contexto resulta importante que se promueve la educación acerca del conocimiento y uso de las fuentes renovables de energía.

Este proyecto se presenta un modelo a escala de un mecanismo capaz de orientar los paneles solares de forma que éstos permanezcan aproximadamente perpendiculares a los rayos solares optimizando el rendimiento de estos.

Está dirigido a estudiantes de últimos años de nivel escolar o primeros de secundaria.

También se podría contextualizar el modelo relacionando al movimiento de lagunas de las plantas como el girasol que poseen el comportamiento de seguir movimiento del sol al transcurrir el día.

Materiales

• Kit Robótico Butia.
• 4 sensores de luz.
• Esfera de Espuma Plast.
• Carton sueco o similares.
• Cinta Aisladora.
• Cinta doble faz
• XO/pc con TurtleBots y el Plugin de Butia.

Construcción

Paso 1: Retirar la rueda derecha del Kit butia junto a su soporte.

Paso 2: Recortar un soporte auxiliar para el motor y con cinta aisladora unirlo al la rueda izquierda del robot Butiá.

Paso 3: Tomar dos barras de encastre unidas en forma de L y con la ayuda de otra barra de encastre fijarla con dos tornillos a la rueda del segundo motor.

Paso 4: Cortar un Cuadrado de cartón de 25 cm de lado, realizarle los agujeros correspondientes y con dos tornillos unirlo a la L de barras de encastre.

Paso 5: Tomar media esfera de espuma Plast y pegarla al cuadrado de cartón.

Paso 6: Pegar con cinta doble faz los cuatro sensores de luz a la media esfera de espuma Plast.

Paso 7: Conectar los sensores a los respectivo puertos de la placa Butiá. En este ejemplo : 1 - Arriba, 3 - Abajo, 5 - Izquierda, 6 Derecha.

Paso 8: Cortar dos soportes en cartón para que el robot Butiá permanezca en forma vertical y unirlos al robot.

Implementación

La implementación del seguidor de luz fue realizada en Python utilizando la librería PyBot. El codigo comleto esta disponible en el siguiente Repositorio.

Comencemos!!!

Importamos la librería PyBot

   sys.path.insert(0, '/home/olpc/Activities/TurtleBots.activity/plugins/butia')

   sys.path.insert(0, "/usr/share/sugar/activities/TurtleBots.activity/plugins/butia")

Importamos el módulo de pybot

   from pybot import usb4butia

Generamos una instancia de la placa USB4Butia

   robot = usb4butia.USB4Butia()
   robot.refresh()

Definimos una comprador de dos números aplicando un tolerancia

   tolerance = 5000
   def isBigger(num1, num2, tolerance):
       return (num1 - tolerance)>num2

Definimos las funciones que retornan el valor de cada uno de los 4 sensores de luz.

Para eliminar las diferencias en las mediciones de los sensores provocadas por la luz ambiente almacenamos el valor inicial de cada sensor y para eliminar errores de medición de los sensores utilizamos el promedio de 10 mediciones.

   acumulateTopLight = 0
   for i in range(10):
       acumulateTopLight += robot.getLight(1) 
   topLight_init = acumulateTopLight / 10
       acumulateBottomLight = 0
   for i in range(10):
       acumulateBottomLight += robot.getLight(3)
   bottomLight_init =  acumulateBottomLight / 10
       acumulateLeftLight = 0
   for i in range(10):
       acumulateLeftLight += robot.getLight(5)
   leftLight_init = acumulateLeftLight / 10
       acumulateRightLight = 0
   for i in range(10):
       acumulateRightLight += robot.getLight(6)
   rightLight_init = acumulateRightLight /10    

   def getTopLight():
       acumulateTopLight = 0
       for i in range(10):
           acumulateTopLight += robot.getLight(1) 
       return (acumulateTopLight/10) - topLight_init

   def getBottomLight():
       acumulateBottomLight = 0
       for i in range(10):
           acumulateBottomLight += robot.getLight(3)
       return (acumulateBottomLight/10) - bottomLight_init

   def getLeftLight():
       acumulateLeftLight = 0
       for i in range(10):
           acumulateLeftLight += robot.getLight(5)
       return (acumulateLeftLight/10) - leftLight_init

   def getRightLight():
       acumulateRightLight = 0
       for i in range(10):
           acumulateRightLight += robot.getLight(6)
       return (acumulateRightLight/10) - rightLight_init

Definimos las funciones para el desplazamiento de los motores. Debido a que el movimiento hacia arriba exige mayor esfuerzo del motor aumentamos el valor de la velocidad de este

   def goRight():
       robot.set2MotorSpeed(1, 200, 0, 0)
       print("goRight")

   def goLeft():
       robot.set2MotorSpeed(0, 200, 0, 0)
       print("goLeft")

   def goUp():
       robot.set2MotorSpeed(0, 0, 0, 500)
       print("goUp")

   def goDown():
       robot.set2MotorSpeed(0, 0, 1, 200)
       print("goDown")

   def stop():
       robot.set2MotorSpeed(0, 0, 0, 0)
       print("stop")

En cada interacción comparamos las mediciones de los sensores y desplazamos los motores según corresponda Primero se realiza el movimiento vertical y cuando la ubicación vertical es las deseada se realiza el desplazamiento horizontal

• Si el valor del sensor superior es mayor al inferior se realiza un movimiento hacia arriba
• Si el valor del sensor inferior es mayor al superior se realiza un movimiento hacia abajo
• Si el valor del sensor izquierdo es mayor al derecho se realiza un movimiento hacia la izquierda
• Si el valor del sensor derecho es mayor al izquierdo se realiza un movimiento hacia la derecha

   while (True):
       topLight = getTopLight()
       print( "Top Light",topLight)
       bottomLight = getBottomLight()
       print( "Botom Light", bottomLight)
       if isBigger(topLight,bottomLight, tolerance) : 
           goUp()
       elif isBigger(bottomLight,topLight, tolerance) : 
           goDown()
       else:
           leftLight = getLeftLight()
           print( "Left Light",leftLight)
           rightLight = getRightLight()
           print( "Right Light", rightLight)
           if isBigger(leftLight,rightLight, tolerance) : 
               goLeft()
           elif isBigger(rightLight,leftLight, tolerance) : 
               goRight()
       time.sleep(1)
       stop()
       time.sleep(1)

En acción

En el siguiente video se puede ver como elrobot sigue el flash de la camara.

Posibles Fallas

El seguidor nunca llega a una posición de equilibrio

Esto puede suceder cuando la tolerancia almacenada en la variable "tolerance" es muy pequeña y nunca se considera que la luz está llegando en igual medida a los 4 sensores. La solución es aumentar el valor de la tolerancia.

El seguidor no logra realizar un desplazamiento hacia arriba

Debido a que el movimiento hacia arriba es contra la gravedad requiere más esfuerzo del motor por lo tanto una solución a este problema es aumentar la velocidad asignada al motor en la función goUp.

El desplazamiento hacia abajo es muy rápido

Debido a que el movimiento hacia abajo es en el mismo sentido que la gravedad requiere menos esfuerzo del motor por lo tanto una solución a este problema es disminuir la velocidad asignada al motor en la función goDown.