Lámpara solar recargable alimentada por XOD: 9 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:44

En la mayoría de las ferreterías y tiendas de artículos para el hogar hay lámparas solares económicas para jardines y pasillos. Pero como dice el viejo refrán, normalmente obtienes lo que pagas. Los circuitos habituales de carga e iluminación que usan son simples y baratos, pero la salida de luz que obtiene es cualquier cosa menos impresionante (¡y apenas lo suficiente para que cualquiera que use su pasarela vea hacia dónde van!)

Este es mi intento de diseñar un módulo de iluminación fuera de la red que es una mejora significativa, aunque sigue siendo relativamente económico de fabricar. Dándole un poco de "cerebro". XOD.io es un nuevo IDE compatible con la plataforma de desarrollo integrada Arduino, donde puede "escribir" código gráficamente. El entorno transpila su boceto gráfico a C ++ moderno, que es notablemente eficiente en la generación de código compacto, y genera una fuente totalmente compatible con el IDE de Arduino sin requerir más dependencias externas. De esa manera, incluso los microcontroladores pequeños y económicos con recursos limitados de almacenamiento de datos y programas pueden emplearse para realizar tareas complejas.

Este proyecto muestra cómo dos microcontroladores ATTiny85 compatibles con Arduino que trabajan juntos pueden usarse para administrar los requisitos de energía de la lámpara. El primer procesador maneja los datos ambientales de detección del hardware externo, y el segundo intenta recolectar la mayor cantidad de energía posible del sol durante el día, y luego controla la iluminación de un LED de alta potencia mientras una batería de almacenamiento se descarga por la noche. El segundo procesador realiza su trabajo mediante una implementación compacta de control de "lógica difusa". El software para ambos chips se desarrolló exclusivamente en el entorno XOD.

Paso 1: Materiales necesarios

Arduino IDE, última versión, con la extensión ATTinyCore instalada desde el administrador "Boards"

Programador Sparkfun USBTinyISP ATTiny, página de producto 11801 o equivalente Sparkfun

Convertidor elevador de voltaje de bajo voltaje ajustable Pololu con entrada de apagado, U1V11A o página de producto de Pololu equivalente

LED blanco o RGB de alta potencia con disipador de calor, ánodo común, Adafruit 2524 o página de producto Adafruit equivalente

Microchip ATTiny85 en paquete DIP de 8 pines, 2 página de producto de Mouser

Zócalos DIP IC de 8 pines, 2

Condensador de almacenamiento a granel, 16 v 220 uF

Condensador de salida, 6.3v 47uF

Resistencias limitadoras de corriente, 50 ohmios 1/4 vatios

resistencias pull-up i2c, 4.7k, 2

Resistencias divisoras de detección de voltaje en panel, 1/4 vatio, 100 k, 470 k

Resistencia de detección de corriente, 10 ohmios 1⁄2 vatio 1% de tolerancia

Condensadores de derivación, cerámica 0.1uF, 2

2 baterías recargables de iones de litio de 3,7 v 100 mAh, PKCELL LP401 o equivalente

Conector de entrada de enchufe cilíndrico para panel, 1

Mini bloques de terminales de placa de almohadilla de soldadura de 3 "x3" y alambre delgado de núcleo sólido para hacer conexiones

Es casi seguro que se necesitará un osciloscopio, un multímetro y una fuente de alimentación de banco para realizar las pruebas

Paso 2: configuración del entorno

El entorno XOD no es compatible con la serie de procesadores ATTiny listos para usar, pero con un par de bibliotecas de terceros del universo Arduino es sencillo agregar compatibilidad con esta serie de AVR. El primer paso es instalar la biblioteca "ATTinyCore" del menú desplegable "Herramientas → Tablero → Administrador de tablero" del IDE de Arduino. Asegúrese de que la configuración que se muestra en la imagen incluida sea correcta; recuerde que debe presionar "Grabar cargador de arranque" para cambiar los fusibles de ajuste de voltaje y velocidad del reloj antes de cargar cualquier código.

El código fuente de esta biblioteca está disponible en:

Otra biblioteca útil del repositorio es “FixedPoints”, que es una implementación en tiempo de compilación de matemáticas de punto fijo para procesadores compatibles con Arduino. El ATTiny tiene memoria SRAM y de programa limitada, y ayuda mucho a reducir el tamaño del boceto final para usar un entero de 2 bytes para el almacenamiento de datos generales, en lugar de un tipo de punto flotante, que requiere 4 bytes en el AVR. La velocidad de ejecución también debería mejorarse, ya que ATTiny no tiene una unidad de multiplicación de hardware, ¡y mucho menos un punto flotante de hardware!

El código fuente está disponible en:

El tutorial sobre cómo crear, transpilar e implementar bocetos gráficos XOD en: https://github.com/Pharap/FixedPointsArduino ayudará mucho a comprender cómo se crearon los archivos fuente incluidos.

Paso 3: descripción general del diseño

En la placa, dos procesadores ATTiny85 están conectados a través de una interfaz i2c, y se usan trabajando juntos para administrar la detección del voltaje del panel solar, la corriente que fluye hacia la batería desde el convertidor elevador mientras el panel está iluminado, el voltaje de la batería y la batería temperatura.

El convertidor elevador es un módulo estándar basado en un circuito integrado TPS6120 de Texas Instruments, que puede tomar un voltaje de entrada tan bajo como 0.5 voltios y aumentarlo a cualquier lugar de 2 voltios a 5 voltios. El núcleo del sensor comprende varios bloques funcionales. El reloj maestro comienza a funcionar tan pronto como se aplica energía al convertidor elevador desde la entrada del panel solar. Esto inicia la ejecución del boceto, y lo primero es determinar si el panel está lo suficientemente iluminado para proporcionar corriente de carga a la batería.

El voltaje del panel solar pasa a través de dos filtros digitales, y si está por encima de cierto umbral, el sistema determina que el panel está iluminado y conecta el reloj maestro al monitor de detección de corriente. Este es un canal convertidor analógico a digital del chip, configurado diferencialmente, que detecta el voltaje a través de una resistencia de tolerancia del 1% de 10 ohmios conectada en serie entre la salida del convertidor elevador y la entrada de la batería. Cuando el panel no está iluminado, este ATTiny envía una señal al segundo ATTiny diciéndole que monitoree la energía del LED en lugar de cargar la energía, y apague el convertidor elevador y aísle la entrada para que la batería no envíe corriente a través del panel..

El segundo núcleo ATTiny es donde se ejecuta el controlador LED y el sistema de monitoreo de carga de la batería. El voltaje del panel, el voltaje de la batería y los datos de corriente de carga de la batería se envían a este núcleo para su procesamiento a través de una red de lógica difusa, que intenta generar una señal PWM adecuada para aplicar al pin SHTDN, controlando así la cantidad de corriente enviada a la batería. para cargarlo cuando está iluminado: una forma básica de seguimiento del punto de máxima potencia (MPPT). También recibe una señal del núcleo del sensor que le indica si debe encender o apagar el LED, dependiendo de la salida del día del núcleo del sensor / chanclas de noche.

Cuando el LED está activo por la noche, este ATTiny monitorea los datos de voltaje de la batería que le envía su amigo, y su propio sensor de temperatura en el chip, para obtener una estimación aproximada de cuánta energía se está introduciendo en el LED (el voltaje de la batería disminuye y la temperatura del chip aumenta con la corriente extraída de sus pines). La red de lógica difusa asociada con el parche LED PWM intenta juzgar la cantidad de energía de la batería disponible y disminuir la intensidad del LED a medida que la batería se agota.

Paso 4: creación de parches personalizados desde la biblioteca principal de XOD

Se utilizaron varios nodos de parche personalizados para este diseño, algunos de los cuales se pueden construir fácilmente por completo a partir de los nodos XOD incluidos, y otros se implementaron en C ++.

El primero de los dos nodos de parche personalizados en las imágenes es una implementación de un filtro de promedio móvil exponencial. Este es un filtro digital de paso bajo de baja sobrecarga que se usa en serie en el boceto, una vez para filtrar el voltaje entrante del panel solar para el núcleo lógico y una vez más para alimentar el disparador que determina la iluminación ambiental a largo plazo. Consulte la entrada de Wikipedia sobre suavizado exponencial.

La estructura del nodo en la imagen es solo una representación gráfica directa de la función de transferencia en el artículo, conectadas entre sí mediante enlaces de las entradas apropiadas a las salidas. Hay un nodo diferido de la biblioteca que permite crear un bucle de retroalimentación (XOD le advertirá si crea un bucle de retroalimentación sin insertar un retraso en el bucle, como se describe en el modelo de ejecución de XOD). El parche funciona bien, es simple.

El segundo nodo de parche personalizado es una variación del flip-flop estándar incluido con XOD, que se alimenta con el voltaje del panel filtrado. Se bloquea alto o bajo dependiendo de si la señal de entrada está por encima o por debajo de un cierto umbral. Los nodos de conversión se utilizan para convertir los valores de salida booleanos al tipo de datos de pulso para activar el flip flop, a medida que el estado cambia de bajo a alto. Es de esperar que el diseño de este nodo de parche sea algo autoexplicativo a partir de la captura de pantalla.

Paso 5: creación de parches personalizados con C ++

Para requisitos especiales donde la funcionalidad del nodo necesaria sería demasiado compleja para representarla gráficamente, o que se basan en bibliotecas Arduino que no son nativas del entorno Arduino estándar, XOD facilita que aquellos con algunos conocimientos de C / C ++ escriban trozos pequeños de código que luego se puede integrar en un parche al igual que cualquier otro nodo creado por el usuario o en stock. Al seleccionar "crear un nuevo parche" en el menú de archivo, se crea una hoja en blanco para trabajar, y los nodos de entrada y salida se pueden arrastrar desde la sección de "nodos" de la biblioteca principal. Luego, el nodo "no implementado en xod" se puede arrastrar y, cuando se hace clic, se abrirá un editor de texto donde la funcionalidad requerida se puede implementar en C ++. Aquí se explica cómo manejar el estado interno y acceder a los puertos de entrada y salida desde el código C ++.

Como ejemplo de implementación de parches personalizados en C ++, se utilizan dos parches personalizados adicionales para el núcleo del controlador para generar una estimación del voltaje de suministro y la temperatura del núcleo del controlador. Junto con su red difusa, esto permite una estimación aproximada de la energía restante de la batería disponible para alimentar los LED cuando está oscuro.

El parche del sensor de temperatura también se alimenta con la salida del sensor de voltaje de suministro para obtener una mejor estimación: la detección de la temperatura del núcleo nos permite obtener una estimación aproximada de la cantidad de energía que se quema en los LED, y se combina con la lectura del voltaje de suministro cuando agotar la batería una estimación más aproximada de la cantidad de energía restante de la batería. No tiene que ser superpreciso; Si el núcleo "sabe" que los LED están consumiendo mucha corriente, pero el voltaje de la batería está disminuyendo rápidamente, probablemente sea seguro decir que la energía de la batería no va a durar mucho más y es hora de apagar la lámpara.

Paso 6: Construcción

Construí el proyecto en una pequeña pieza de placa de creación de prototipos con almohadillas de cobre para las piezas de los orificios pasantes. El uso de sockets para los circuitos integrados ayuda mucho para la programación / modificación / prueba; el USBTiny ISP de Sparkfun tiene un enchufe similar en su placa, por lo que programar los dos chips solo consiste en conectar el programador a un puerto USB de la PC, cargar el código XOD transpilado de los archivos Arduino.ino incluidos con la placa y la configuración del programador adecuadas, y a continuación, extraiga suavemente los chips del zócalo del programador e insértelos en los zócalos del protoboard.

El módulo convertidor elevador basado en Pololu TPS6120 viene en una placa vertical soldada al protoboard en los encabezados de los pines, por lo que es posible ahorrar espacio montando algunos componentes debajo. En mi prototipo puse las dos resistencias pullup de 4.7k debajo. Estos son necesarios para que el bus i2c entre los chips funcione correctamente; ¡la comunicación no funcionará bien sin ellos! En el lado derecho de la placa está el conector de entrada para el enchufe del panel solar y el condensador de almacenamiento de entrada. Es mejor intentar conectar el conector y esta tapa directamente a través de "tramos" de soldadura, no cable de conexión, para obtener una ruta de resistencia lo más baja posible. Luego, se utilizan tramos de soldadura sólida para conectar el terminal positivo del condensador de almacenamiento directamente al terminal de voltaje de entrada del módulo de refuerzo, y el pin de tierra del módulo de refuerzo directamente al pin de tierra del conector.

A la derecha e izquierda de los enchufes para los dos ATTinys hay condensadores despike / deglitching de 0.1uF. También es importante no omitir estos componentes, y deben conectarse a los pines de tierra y de alimentación de los circuitos integrados a través de una ruta lo más corta y directa posible. La resistencia de detección de corriente de 10 ohmios está a la izquierda, está conectada en línea con la salida del convertidor elevador y cada lado está conectado a un pin de entrada del núcleo del sensor; estos pines están configurados para funcionar como un ADC diferencial para medir indirectamente el corriente en la batería. Las conexiones entre los pines IC para el bus i2c y el pin de apagado del convertidor elevador, etc. se pueden hacer usando un cable de conexión en la parte inferior del protoboard, un cable de conexión de núcleo sólido muy delgado funciona muy bien para esto. Facilita los cambios y también se ve mucho más ordenado que correr puentes entre los agujeros en la parte superior.

El módulo LED que utilicé era una unidad RGB tricolor, mi plan era tener los tres LED activos para producir blanco cuando la batería estaba casi cargada por completo, y atenuar lentamente el LED azul en amarillo a medida que se agotaba la carga. Pero esta característica aún no se ha implementado. Un solo LED blanco con una resistencia limitadora de corriente también funcionará bien.

Paso 7: Prueba, Parte 1

Después de programar ambos ATTiny IC con los archivos de boceto incluidos a través del programador USB del entorno Arduino, ayuda a probar que los dos núcleos del prototipo funcionan correctamente antes de intentar cargar la batería del panel solar. Idealmente, esto requiere un osciloscopio básico, un multímetro y una fuente de alimentación de banco.

Lo primero que debe verificar es que no haya cortocircuitos en ninguna parte de la placa antes de enchufar los circuitos integrados, la batería y el panel en sus enchufes para evitar posibles daños. La forma más sencilla de hacerlo es utilizar una fuente de alimentación de banco que pueda limitar su corriente de salida a un valor seguro en caso de esa situación. Usé mi suministro de banco establecido en 3 voltios y límite de 100 mA conectado a los terminales del conector de entrada del panel solar a los cables de suministro de energía positivo y negativo. Sin nada más que los componentes pasivos instalados, esencialmente no debería haber un consumo de corriente registrado en el monitor de corriente de la fuente de alimentación para hablar. Si hay un flujo de corriente significativo, o el suministro entra en limitación de corriente, algo salió mal y se debe verificar la placa para asegurarse de que no haya conexiones mal cableadas o capacitores con polaridad invertida.

El siguiente paso es asegurarse de que el convertidor elevador funcione correctamente. Hay un potenciómetro de tornillo en la placa, con la fuente de alimentación aún conectada y cuatro de los pines del convertidor conectados adecuadamente, el potenciómetro debe girarse con la punta de un destornillador pequeño hasta que el voltaje en el terminal de salida del módulo lea alrededor de 3.8 a 3.9 voltios. Este valor de CC no cambiará durante la operación, el núcleo del controlador controlará el voltaje de salida promedio pulsando el pin de apagado del módulo.

Paso 8: Prueba, Parte 2

Lo siguiente que debe verificar es que la comunicación i2c esté funcionando bien, con la placa funcionando con energía de banco, se puede instalar el IC del núcleo del sensor. En un osciloscopio debería haber señales pulsantes tanto en el pin 5 como en el pin 7 del chip físico, este controlador i2c en el chip intenta enviar datos a su amigo. Después de apagar el controlador, se puede instalar el núcleo y verificar la conexión con un osciloscopio nuevamente, debe haber una secuencia más grande de pulsos visibles en ambas líneas. Esto significa que los chips se comunican correctamente.

Es útil tener la batería ligeramente cargada para la prueba final completa. El suministro de banco también se puede usar para lograr esto, con el límite de corriente establecido en aproximadamente 50 mA y el voltaje aún en 3.8 voltios, dejando la batería LiPo conectada directamente durante unos minutos.

El último paso es probar el sistema completo: con todo conectado, si el panel está cubierto durante diez o 15 segundos, la luz debe encenderse a través de la salida PWM del núcleo del controlador. Con el panel a la luz del sol, la batería debe cargarse desde la salida del convertidor elevador. La red de lógica difusa se puede inspeccionar indirectamente para ver si está funcionando correctamente mirando la línea PWM que controla el pin de apagado del convertidor elevador; A medida que aumenta la iluminación con la batería con un estado de carga bajo, el ancho del pulso debe aumentar, lo que muestra que a medida que se obtiene más energía de la luz solar, el núcleo del controlador indica que se debe enviar más energía a la batería.

Paso 9: Apéndice sobre lógica difusa

La lógica difusa es una técnica de aprendizaje automático que se puede utilizar en el control de sistemas de hardware donde hay incertidumbre en muchos de los parámetros del sistema que se está controlando, lo que hace que una solución explícita de control de entrada a salida para el objetivo sea difícil de escribir matemáticamente. Esto se logra mediante el uso de valores lógicos que se encuentran en algún lugar entre 0 (falso) y 1 (verdadero), expresando la incertidumbre en un valor más parecido a como lo haría un humano ("mayormente verdadero" o "no realmente cierto") y permitiendo un área gris entre declaraciones que son 100% verdaderas y 100% falsas. La forma en que esto se logra es tomando primero muestras de las variables de entrada en las que se debe basar una decisión y "difuminando".

El corazón de cualquier sistema de lógica difusa es una "memoria asociativa difusa". Esto recuerda a una matriz, donde en el caso del circuito de carga de la batería se almacena un conjunto 3x3 de valores que oscilan entre 0 y 1. Los valores en la matriz se pueden asociar aproximadamente con cómo un humano razonaría sobre cuál debería ser el factor PWM que controla el pin SHTDN del convertidor elevador, dependiendo de cómo la función de membresía anterior califica un conjunto dado de entradas. Por ejemplo, si el voltaje de entrada del panel es alto, pero la corriente que ingresa a la batería es baja, probablemente significa que se puede consumir más energía y la configuración de PWM no es óptima y debe aumentarse. Por el contrario, si el voltaje del panel es bajo pero el cargador todavía está intentando impulsar una gran corriente a la batería, la energía también se desperdiciará, por lo que sería mejor disminuir la señal PWM al convertidor elevador. Una vez que las señales de entrada se "difuminan" en un conjunto difuso, se multiplican por estos valores, de forma similar a la forma en que un vector se multiplica por una matriz, para generar un conjunto transformado que es representativo de la cantidad de "conocimiento" que contiene la celda de la matriz debe tenerse en cuenta en la función de combinación final.

Usando el nodo "no implementado en xod" que permite que los nodos XOD que implementan una funcionalidad personalizada sean demasiado complicados para ser razonables de hacer a partir de los bloques de construcción de stock, y un poco de C ++ al estilo Arduino, la memoria asociativa, la función de ponderación y " fuzzifier "similar a los bloques descritos en esta referencia: https://www.drdobbs.com/cpp/fuzzy-logic-in-c/184408940 son sencillos de hacer y mucho más fáciles de experimentar.