Lâmpada solar recarregável alimentada por XOD: 9 etapas (com fotos)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:39

Existem lâmpadas solares de jardim / passarela de baixo custo disponíveis na maioria das lojas de artigos para casa e ferragens. Mas, como diz o velho ditado, você geralmente obtém o que pagou. Os circuitos usuais de carregamento e iluminação que eles usam são simples e baratos, mas a saída de luz que você recebe é tudo menos impressionante (e quase não chega para ninguém usar sua passarela para ver para onde estão indo!)

Esta é minha tentativa de projetar um módulo de iluminação fora da rede que é uma melhoria significativa, embora seja relativamente barato de fazer. Dando a ele alguns "cérebros". XOD.io é um novo IDE compatível com a plataforma de desenvolvimento embarcada Arduino, onde você pode "escrever" código graficamente. O ambiente transpila seu esboço gráfico para C ++ moderno, que é notavelmente eficiente na geração de código compacto e gera código-fonte totalmente compatível com o IDE do Arduino padrão sem a necessidade de dependências externas adicionais. Dessa forma, mesmo microcontroladores pequenos e baratos com programas limitados e recursos de armazenamento de dados podem ser empregados para realizar tarefas complexas.

Este projeto mostra como dois microcontroladores ATTiny85 compatíveis com Arduino trabalhando juntos podem ser usados para gerenciar os requisitos de energia da lâmpada. O primeiro processador lida com os dados do ambiente de detecção do hardware externo, e o segundo tenta colher o máximo de energia do sol que puder durante o dia e, em seguida, controlar a iluminação de um LED de alta potência enquanto uma bateria de armazenamento se descarrega à noite. O segundo processador realiza seu trabalho por meio de uma implementação compacta de controle de “lógica difusa”. O software para ambos os chips foi desenvolvido exclusivamente dentro do ambiente XOD.

Etapa 1: Materiais Necessários

Arduino IDE, versão mais recente, com extensão ATTinyCore instalada a partir do gerenciador "Boards"

Programador Sparkfun USBTinyISP ATTiny, 11801 ou página do produto Sparkfun equivalente

Conversor de reforço de baixa tensão ajustável Pololu com entrada de desligamento, U1V11A ou equivalente página do produto Pololu

LED branco ou RGB de alta potência com dissipador de calor, ânodo comum, Adafruit 2524 ou página de produto Adafruit equivalente

Microchip ATTiny85 em embalagem DIP de 8 pinos, 2 páginas de produto da Mouser

Soquetes DIP IC de 8 pinos, 2

Capacitor de armazenamento em massa, 16 v 220 uF

Capacitor de saída, 6,3v 47uF

Resistores limitadores de corrente, 50 ohm 1/4 watt

resistores pull-up i2c, 4.7k, 2

Resistores divisores de detecção de tensão do painel, 1/4 watt, 100k, 470k

Resistência de detecção de corrente, tolerância de 10 ohm 1⁄2 watt 1%

Capacitores de desvio, cerâmica 0,1uF, 2

2 bateria recarregável de íon de lítio 3,7 v 100mAh, PKCELL LP401 ou equivalente

Conector de entrada do plugue cilíndrico para painel, 1

Mini blocos de terminais de placa de solda de 3 "x3" e fio de núcleo sólido fino para fazer conexões

Um osciloscópio, multímetro e fonte de alimentação de bancada quase certamente serão necessários para o teste

Etapa 2: configuração do ambiente

O ambiente XOD não suporta a série ATTiny de processadores prontos para uso, mas usando algumas bibliotecas de terceiros do universo Arduino, é simples adicionar suporte para esta série de AVRs. A primeira etapa é instalar a biblioteca “ATTinyCore” do menu suspenso “Ferramentas → Placa → Gerenciador de placa” do IDE do Arduino. Certifique-se de que as configurações conforme mostrado na imagem incluída estão corretas - lembre-se de que você deve clicar em "Burn bootloader" para alterar os fusíveis de configuração de tensão e velocidade de clock antes de enviar qualquer código!

O código-fonte para esta biblioteca está disponível em:

Outra biblioteca útil do repositório é “FixedPoints”, que é uma implementação em tempo de compilação de matemática de ponto fixo para processadores com suporte para Arduino. O ATTiny limitou SRAM e memória de programa e ajuda muito a reduzir o tamanho do esboço final para usar um número inteiro de 2 bytes para armazenamento geral de dados, em vez de um tipo de ponto flutuante, que requer 4 bytes no AVR. A velocidade de execução também deve ser melhorada, pois o ATTiny não tem uma unidade de multiplicação de hardware, muito menos ponto flutuante de hardware!

O código-fonte está disponível em:

O tutorial sobre como criar, transpilar e implantar esboços gráficos XOD em: https://github.com/Pharap/FixedPointsArduino ajudará muito a entender como os arquivos de origem incluídos foram criados.

Etapa 3: Visão geral do projeto

Na placa, dois processadores ATTiny85 são conectados por meio de uma interface i2c e são usados trabalhando juntos para gerenciar a detecção da tensão do painel solar, a corrente fluindo para a bateria do conversor de reforço enquanto o painel está iluminado, a tensão da bateria e a bateria temperatura.

O conversor boost é um módulo de prateleira baseado em um Texas Instruments TPS6120 IC, que pode pegar uma tensão de entrada tão baixa quanto 0,5 volts e aumentá-la para qualquer lugar de 2 volts a 5 volts. O núcleo do sensor compreende vários blocos funcionais. O relógio principal começa a funcionar assim que a energia é aplicada ao conversor boost da entrada do painel solar. Isso inicia a execução do esboço e a primeira coisa é determinar se o painel está iluminado o suficiente para fornecer corrente de carga para a bateria.

A tensão do painel solar é passada por dois filtros digitais e, se estiver acima de um certo limite, o sistema determina que o painel está iluminado e conecta o relógio mestre ao monitor de detecção de corrente. Este é um canal do conversor analógico para digital do chip, configurado diferencialmente, que detecta a tensão em um resistor de tolerância de 1% de 10 ohms conectado em série entre a saída do conversor de reforço e a entrada da bateria. Quando o painel não está iluminado, este ATTiny envia um sinal para o segundo ATTiny dizendo-lhe para monitorar a energia do LED em vez de carregar a energia, e desligar o conversor boost e isolar a entrada para que a bateria não envie corrente de volta através do painel.

O segundo núcleo ATTiny é onde o controlador de LED e o sistema de monitoramento de carga da bateria são executados. Os dados de tensão do painel, tensão da bateria e corrente de carga da bateria são enviados a este núcleo para processamento por meio de uma rede de lógica difusa, que tenta gerar um sinal PWM apropriado para aplicar ao pino SHTDN, controlando assim a quantidade de corrente enviada para a bateria para carregá-lo quando iluminado - uma forma básica de rastreamento de ponto de potência máxima (MPPT). Ele também recebe um sinal do núcleo do sensor dizendo se deve ligar ou desligar o LED, dependendo da saída do dia / dia do núcleo do sensor flip-flop noturno.

Quando o LED está ativo à noite, este ATTiny monitora os dados de tensão da bateria enviados a ele por seu amigo, e seu próprio sensor de temperatura no chip, para obter uma estimativa aproximada de quanta energia está sendo empurrada para o LED (a tensão da bateria diminui e a temperatura do chip aumenta com a corrente retirada de seus pinos.) A rede de lógica difusa associada ao patch LED PWM tenta fazer um julgamento sobre a quantidade de energia da bateria ainda disponível e diminui a intensidade do LED conforme a bateria se esgota.

Etapa 4: Criação de patches personalizados da biblioteca XOD Core

Vários nós de patch personalizados foram usados para este projeto, alguns dos quais podem ser facilmente construídos inteiramente a partir de nós XOD incluídos, e alguns que foram implementados em C ++.

O primeiro dos dois nós de patch personalizados nas imagens é uma implementação de um filtro de média móvel exponencial. Este é um filtro digital passa-baixo de baixa sobrecarga usado em série no esboço, uma vez para filtrar a tensão de entrada do painel solar para o núcleo lógico e mais uma vez para alimentar o gatilho que determina a iluminação ambiente de longo prazo. Veja a entrada da Wikipedia sobre suavização exponencial.

A estrutura do nó na imagem é apenas uma representação gráfica direta da função de transferência no artigo, conectada entre si usando links das entradas apropriadas para as saídas. Há um nó defer da biblioteca que permite que um loop de feedback seja criado (o XOD irá avisá-lo se você criar um loop de feedback sem inserir um atraso no loop, conforme descrito no modelo de execução do XOD). patch funciona bem, é simples.

O segundo nó de patch customizado é uma variação do flip-flop padrão incluído no XOD, que é alimentado com a tensão do painel filtrado. Ele trava alto ou baixo, dependendo se o sinal de entrada está acima ou abaixo de um certo limite. Os nós de conversão são usados para converter valores de saída booleanos para o tipo de dados de pulso para acionar o flip-flop, conforme a transição de estado de baixo para alto. O design deste nó de patch deve ser um tanto autoexplicativo a partir da captura de tela.

Etapa 5: Criação de patches personalizados usando C ++

Para requisitos especiais em que a funcionalidade do nó necessária seria muito complexa para ser facilmente representada graficamente, ou que dependem de bibliotecas Arduino não nativas do ambiente Arduino padrão, o XOD torna mais fácil para aqueles com algum conhecimento C / C ++ escreverem pedaços pequenos de código que pode então ser integrado a um patch da mesma forma que qualquer outro nó criado pelo usuário ou de estoque. Selecionar "criar um novo patch" no menu de arquivo cria uma folha em branco para trabalhar e os nós de entrada e saída podem ser arrastados da seção de "nós" da biblioteca principal. Em seguida, o nó "não implementado no xod" pode ser arrastado e, quando clicado, abrirá um editor de texto onde a funcionalidade necessária pode ser implementada em C ++. Como lidar com o estado interno e acessar as portas de entrada e saída do código C ++ é abordado aqui.

Como um exemplo de implementação de patches personalizados em C ++, dois outros patches personalizados para o núcleo do driver são usados para fazer uma estimativa da tensão de alimentação do núcleo do driver e da temperatura central. Junto com sua rede difusa, isso permite uma estimativa aproximada da energia restante da bateria disponível para alimentar os LEDs quando está escuro.

O patch do sensor de temperatura também é alimentado com a saída do sensor de tensão de alimentação para obter uma estimativa melhor - a temperatura do núcleo de detecção nos permite obter uma estimativa aproximada de quanta energia está sendo queimada nos LEDs, e combinada com a leitura da tensão de alimentação quando esgotando a bateria, uma estimativa aproximada de quanta energia resta da bateria. Não precisa ser superpreciso; se o núcleo "sabe" que os LEDs estão consumindo muita corrente, mas a tensão da bateria está caindo rapidamente, é provavelmente seguro dizer que a energia da bateria não vai durar muito mais tempo, e é hora de desligar a lâmpada.

Etapa 6: construção

Eu construí o projeto em um pequeno pedaço de placa de prototipagem com almofadas de cobre para as peças do orifício. Usar soquetes para os ICs ajuda muito para programação / modificação / teste; o USBTiny ISP da Sparkfun tem um soquete semelhante em sua placa, de modo que a programação dos dois chips consiste apenas em conectar o programador a uma porta USB do PC, carregando o código XOD transpilado dos arquivos Arduino.ino incluídos com as configurações apropriadas da placa e do programador, e em seguida, remova cuidadosamente os chips do soquete do programador e insira-os nos soquetes do protoboard.

O módulo conversor boost baseado em Pololu TPS6120 vem em uma placa riser soldada no protoboard em cabeçotes de pinos, então é possível economizar espaço montando alguns componentes embaixo. No meu protótipo, coloquei os dois resistores pullup de 4.7k embaixo. Eles são necessários para que o barramento i2c entre os chips funcione corretamente - a comunicação não funcionará bem sem eles! No lado direito da placa está o conector de entrada para o plugue do painel solar e o capacitor de armazenamento de entrada. É melhor tentar conectar o conector e esta tampa diretamente juntos por meio de "passagens" de solda, não de fio de conexão, para obter o caminho de resistência mais baixo possível. Runs de solda sólida são então usados para conectar o terminal positivo do capacitor de armazenamento diretamente ao terminal de tensão de entrada do módulo de reforço, e o pino de aterramento do módulo de reforço diretamente ao pino de aterramento do conector.

À direita e à esquerda dos soquetes para os dois ATTinys estão capacitores de despike / deglitching de 0,1uF. Esses componentes também são importantes para não ficar de fora e devem ser conectados aos pinos de alimentação e aterramento dos ICs através de um caminho o mais curto e direto possível. O resistor de detecção de corrente de 10 ohm está à esquerda, ele é conectado em linha com a saída do conversor de reforço e cada lado é conectado a um pino de entrada do núcleo do sensor - esses pinos são configurados para funcionar como um ADC diferencial para medir indiretamente o corrente na bateria. As conexões entre os pinos IC para o barramento i2c e o pino de desligamento do conversor boost, etc. podem ser feitas usando um fio de conexão na parte inferior da placa de protótipo, um fio de conexão de núcleo sólido muito fino funciona muito bem para isso. Isso torna as mudanças mais fáceis e também parece muito mais organizado do que colocar jumpers entre os orifícios na parte superior.

O módulo de LED que usei era uma unidade RGB tricolor, meu plano era ter todos os três LEDs ativos para produzir branco quando a bateria estivesse quase totalmente carregada e lentamente diminuir o LED azul para amarelo quando a carga se esgotasse. Mas esse recurso ainda não foi implementado. Um único LED branco com um resistor limitador de corrente também funcionará bem.

Etapa 7: Teste, Parte 1

Depois de programar os dois CIs ATTiny com os arquivos de esboço incluídos por meio do programador USB do ambiente Arduino, ajuda a testar se os dois núcleos do protótipo estão funcionando corretamente antes de tentar carregar a bateria do painel solar. Idealmente, isso requer um osciloscópio básico, multímetro e fonte de alimentação de bancada.

A primeira coisa a verificar é se não há curto-circuitos em qualquer lugar da placa antes de conectar os ICs, bateria e painel em seus soquetes para evitar possíveis danos! A maneira mais fácil de fazer isso é usar uma fonte de alimentação de bancada que pode limitar sua corrente de saída a um valor seguro nesse caso. Usei minha alimentação de bancada definida em 3 volts e limite de 100 mA conectada aos terminais de entrada do painel solar para os fios positivo e negativo da fonte de alimentação. Com nada além dos componentes passivos instalados, não deve haver essencialmente nenhum consumo de corrente registrado no monitor de corrente da fonte de alimentação. Se houver fluxo de corrente significativo ou se a alimentação estiver limitando a corrente, algo está errado e a placa deve ser verificada para garantir que não haja conexões com fiação incorreta ou capacitores com polaridade invertida.

A próxima etapa é garantir que o conversor boost está funcionando corretamente. Há um potenciômetro de parafuso na placa, com a fonte de alimentação ainda conectada e quatro dos pinos do conversor conectados apropriadamente, o potenciômetro deve ser girado com uma pequena ponta de chave de fenda até que a tensão no terminal de saída do módulo leia em torno de 3,8 a 3,9 volts. Este valor DC não mudará durante a operação, o núcleo do driver controlará a tensão de saída média pulsando o pino de desligamento do módulo.

Etapa 8: Teste, Parte 2

A próxima coisa a verificar é se a comunicação i2c está funcionando bem, com a placa funcionando com a alimentação da bancada, o CI do núcleo do sensor pode ser instalado. Em um osciloscópio, deve haver sinais pulsantes nos pinos 5 e 7 do chip físico, este driver i2c no chip tentando enviar dados para seu parceiro. Depois de desligar, o núcleo do driver pode ser instalado e a conexão verificada com um osciloscópio novamente, deve haver uma sequência maior de pulsos visíveis em ambas as linhas. Isso significa que os chips estão se comunicando corretamente.

Ajuda ter a bateria ligeiramente carregada para o teste completo final. A alimentação de bancada também pode ser usada para fazer isso, com o limite de corrente definido em cerca de 50 mA e a tensão ainda em 3,8 volts, deixando a bateria LiPo conectada diretamente por alguns minutos.

A etapa final é testar o sistema completo - com tudo conectado, se o painel for coberto por dez ou 15 segundos, a luz deve acender sendo conduzida pela saída PWM do driver do núcleo. Com o painel sob luz solar intensa, a bateria deve carregar a partir da saída do conversor de reforço. A rede de lógica difusa pode ser inspecionada indiretamente para ver se está funcionando corretamente, observando a linha PWM que conduz o pino de desligamento do conversor de reforço; conforme a iluminação aumenta com a bateria com baixo estado de carga, a largura do pulso deve aumentar, mostrando que quanto mais energia se torna disponível da luz do sol, o núcleo do driver está sinalizando que mais energia deve ser enviada para a bateria!

Etapa 9: Apêndice sobre Lógica Fuzzy

A lógica difusa é uma técnica de aprendizado de máquina que pode ser usada no controle de sistemas de hardware onde há incerteza em muitos dos parâmetros do sistema sendo controlado, tornando uma entrada explícita para solução de controle de saída para o objetivo difícil de escrever matematicamente. Isso é realizado usando valores lógicos que ficam em algum lugar entre 0 (falso) e 1 (verdadeiro), expressando a incerteza em um valor mais parecido com o que um humano faria ("principalmente verdadeiro" ou "não realmente verdadeiro") e permitindo uma área cinza entre afirmações que são 100% verdadeiras e 100% falsas. A maneira como isso é feito é primeiro pegar amostras das variáveis de entrada nas quais uma decisão precisa se basear e “fuzzificá-las”.

O coração de qualquer sistema de lógica difusa é uma "memória associativa difusa". Isso é uma reminiscência de uma matriz, onde no caso do circuito de carga da bateria um conjunto 3x3 de valores variando entre 0 e 1 é armazenado. Os valores na matriz podem ser aproximadamente associados a como um humano raciocinaria sobre qual deveria ser o fator PWM que controla o pino SHTDN do conversor boost, dependendo de como a função de associação acima qualifica um determinado conjunto de entradas. Por exemplo, se a tensão de entrada do painel é alta, mas a corrente que está sendo puxada para a bateria é baixa, provavelmente significa que mais energia pode ser drenada e a configuração de PWM não é a ideal e deve ser aumentada. Por outro lado, se a tensão do painel ficar baixa, mas o carregador ainda estiver tentando empurrar uma grande corrente para a bateria, também será desperdiçada, portanto, seria melhor diminuir o sinal PWM para o conversor de reforço. Uma vez que os sinais de entrada são "fuzzificados" em um conjunto fuzzy, eles são multiplicados por esses valores, semelhante à forma como um vetor é multiplicado por uma matriz, para gerar um conjunto transformado que é representativo de quão pesadamente o "conhecimento" continha a célula da matriz deve ser fatorado na função de combinação final.

Usando o nó "não implementado em xod", que permite que nós XOD que implementam funcionalidades personalizadas muito complicadas para serem razoáveis de fazer a partir dos blocos de construção de estoque e um pouco de C ++ no estilo Arduino, a memória associativa, função de ponderação e " fuzzifier "semelhantes aos blocos descritos nesta referência: https://www.drdobbs.com/cpp/fuzzy-logic-in-c/184408940 são simples de fazer e muito mais fáceis de experimentar.