1 medidor POV com IOT habilitado: 3 etapas (com imagens)

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

Antes de começar a explicação sobre este projeto, gostaria de me desculpar pela baixa qualidade de imagem e vídeo, mas honestamente é realmente difícil obter uma imagem nítida e clara executando POV com uma câmera normal como a minha câmera móvel. Ela precisa de uma lente ótica de diafragma muito rápida para capturar o movimento real, mas vou fazer o upload do vídeo melhor quando finalmente puder comprar minha câmera CANON

Qual é o ponto de vista

POV significa Persistence Of Vision Globe, que está relacionado ao fenômeno da visão humana. O estímulo luminoso permanece como um efeito colateral na retina por cerca de 1/10 de segundo. Quando os estímulos de luz são sequenciados em rápida sucessão, eles se fundem em uma imagem contínua. Na verdade, é a base para dispositivos de cinema e televisão,. Os pontos de vista fazem tal ilusão (nos enganam) e criam a imagem girando a matriz de luzes LED em torno de um único ponto ou eixo

O que é inovação de projeto

Claro que o POV não é uma ideia nova e muitos projetos já existem no Instructables ou em outros sites, no entanto, esses projetos usam principalmente o templo estático predefinido ou a imagem que é lida principalmente da memória MCU ou do cartão SD, mas neste projeto usamos implantar recursos bonitos de IOT habilitado chip como ESP8266 neste assunto.

Com os recursos deste IOT, nós

1. pode facilmente fazer upload de novas imagens para a memória sem fio
2. crie o cenário desejado de exibição de imagens com qualquer sequência ou qualquer duração
3. não há necessidade de reprogramar o chip ou desconectar o cartão de memória e reconectá-lo para uma nova animação
4. IOT webhost amigável torna mais fácil para qualquer um gerenciar POV com celular ou tablet, mesmo remotamente
5. implementação de hardware de custo muito baixo com capacidade para mais de 30 imagens diferentes

Como funciona o POV

Exibições POV, uma matriz linear (unidimensional) de luzes LED gira em torno de um único ponto, como uma roda de bicicleta. Ao medir sua taxa de rotação e controlar seus flashes com precisão de milissegundos, podemos criar a ilusão de uma imagem bidimensional ou tridimensional pairando no ar. Vamos considerar o quadro único de qualquer efeito (imagem, texto, …), cada quadro consiste em muitos pixels e, portanto, muitas linhas no plano ou área esférica, o POV exibe esta imagem com uma única linha de imagem cuja posição é alterada junto com sua rotação para preencher essa imagem, então o problema é como controlar com precisão a cor do pixel do LED de acordo com o tempo e o espaço para que possa criar a imagem inteira. Os pontos de vista são categorizados com base no eixo de rotação, tipo de efeito pode ser exibido e quanta cor pode criar.

Por diferentes eixos de rotação, pode produzir exibição POV plana, cilíndrica e esférica

muitos projetos de POV usam LED de uma única cor simples ou pixels inteligentes de alta velocidade como WS2812 ou APA104 e neste projeto usamos o rápido atualizador de chip de LED APA102 com taxa de atualização de praticamente cerca de 16 MHz. este chip LED tem 2 linhas para controlar (Terra, Dados, Relógio, + 5v)

Etapa 1: como construir POV

A princípio preciso da estrutura para montar o hub POV, fazer a estrutura metálica ou não metálica depende do que você tem em mãos. Você pode fazer com qualquer material disponível para instalá-lo na parede ou adicionar pernas para fazer o suporte. Meu amigo faz o tripé simples e monta o mecanismo da correia dentada para reduzir o RPM do motor DC em torno de 500. Matemática pequenaPara termos uma imagem clara e coerente, precisamos atualizar o quadro em torno de 20 fps, é necessário ter uma imagem clara, precisamos exibi-la repetidamente em cerca de 20 vezes por segundo, como meu POV consiste em 1 faixa diagonal de LED, portanto, cada quadro completado com metade ou rotação, em outras palavras precisamos do RPM do hub Ideal em torno de 600 e com este RPM cada revolução leva cerca de 100 ms. a equação a seguir demonstra que o conceito RPM = (fps / Nb) * 60 cujo Nb é igual a Número de ramal, e neste caso temos RPM = (20/2) * 60 = 600 meu POV girar em torno de 430 rpm, portanto, meu fps é em torno de 15 fsp o que é bastante bom neste assunto. Construindo a parte mecânica

Na próxima etapa usei um pedaço de cilindro de PVC Milled para segurar a barra de LED. Para conectar o cubo com o eixo da polia, um parafuso M10 foi aparafusado na parte traseira da parte PCV Dois anel de cobertura instalado no eixo da polia para transmitir 5 volts DC para a placa e faixa de LED, então conforme as fotos a seguir, esta parte montada na polia simples sistema de transmissão de tempo que está conectado ao motor 12v DC cada parte tem sua própria fonte de alimentação e fechada em uma caixa branca anexada às pernas

Etapa 2: Implementação de Software Parte 1

A fim de demonstrar a imagem dada em fita de LED, cada imagem deve ser pixelizada, em seguida, carregada para a memória MCU e, em seguida, alimentada para fita de LED linha por linha, para fazer isso eu fiz um software para duas plataformas diferentes, uma é baseada no processamento de tempo de execução Java e outro em C ++ para MCUProcessing programa pixelizado que este programa escreveu no Processing IDE e simplesmente abre o arquivo de imagem, em seguida, gira-o em etapas para extrair linhas pixelizadas de imagem. Eu escolho 200 linhas para exibir qualquer imagem, então eu giro a imagem adjacente (360 /200=1.8 graus) 200 vezes para extrair 200 linhas. Como minha faixa de LED consiste em 144 LED com chip APA102 embutido, uma imagem inteira tem 200 * 144 = 28800 pixels. Como cada cor no chip APA102 é exibida com 4 bytes (W, RGB), portanto, cada tamanho de imagem é exatamente 200 * 144 * 4 = 115200 ou 112,5 KB após o código de processamento demonstrar a sequência de pixelização da imagem, e o resultado será um arquivo de extensão bin que pode ser carregado para a memória MCU

PImage img, black_b, image_load; saída PrintWriter; int SQL; float led_t; byte pov_data; int line_num = 200; String _OUTPUT = "";

configurações vazias ()

{selectInput ("Selecione uma imagem", "imageChosen"); noLoop (); esperar(); }

void setup ()

{output = createWriter (_OUTPUT); black_b = createImage (SQL, SQL, RGB); black_b.loadPixels (); para (int i = 0; i = line_num) {noLoop (); output.flush (); output.close ();} background (black_b); pushMatrix (); imageMode (CENTER); traduzir (SQL / 2, SQL / 2); rotate (radianos (l * 360 / line_num)); imagem (img, 0, 0); popMatrix (); pushMatrix (); para (int i = 0; i <144; i ++) {cor c = get (int (i * led_t + led_t / 2), int (SQL / 2)); output.print ((char) red (c) + "" + (char) green (c) + "" + (char) blue (c)); // print ((char) red (c) + "" + (char) green (c) + "" + (char) blue (c) + ";"); preencher (c); rect (i * led_t, (SQL / 2) - (led_t / 2), led_t, led_t); } // println (); popMatrix (); // atraso (500); l ++; }

void keyPressed ()

{output.flush (); // Grava os dados restantes no arquivo output.close (); // Conclui o arquivo exit (); // Pára o programa}

void imageChosen (Arquivo f)

{if (f == null) {println ("A janela foi fechada ou o usuário clicou em cancelar."); exit (); } else {if (f.exists ()) img = loadImage (f.getAbsolutePath ()); String s = f.getAbsolutePath (); String lista = divisão (s, '\'); int n = list.length; String arquivo = divisão (lista [n-1], '.'); println ("Abrir arquivo:" + arquivo [0]); _OUTPUT = arquivo [0] + ". Bin"; // img = loadImage ("test.jpg"); int w = img.width; int h = img.height; SQL = max (w, h); tamanho (SQL, SQL); led_t = SQL / 144.0; println ("h =" + h + "w =" + w + "max =" + SQL + "tamanho led =" + led_t); }} void mousePressed () {loop ();}

void mydata ()

{byte b = loadBytes ("algo.dat"); // Imprime cada valor, de 0 a 255 para (int i = 0; i <b.length; i ++) {// A cada décimo número, inicia uma nova linha if ((i% 10) == 0) println (); // bytes são de -128 a 127, isso se converte em 0 a 255 int a = b & 0xff; imprimir (a + ""); } println (); // Imprime uma linha em branco no final saveBytes ("numbers.dat", b); } void wait () {while (img == null) {delay (200); } ciclo(); }

Etapa 3: Implementação de software - parte 2

Programa de exibição MCU

O chip ESP8266 de alto desempenho foi selecionado por alguns motivos. Primeiro, ele desenvolveu ferramentas abertas de SDK para aproveitar os recursos WiFi junto com a memória para hospedar um servidor web para o usuário. Com esses recursos, um servidor web amigável projetado para carregar a imagem pixelizada para a memória MCU e criar um cenário definido pelo usuário para exibição. Com a série ESP-12E de 4 Mb, podemos usar 1 Mb para o programa e 3 Mb para imagens que, com tamanho de 112,5 KB para imagem pixelizada, poderíamos carregar cerca de 25 imagens no MCU e fazer qualquer sequência ou qualquer período de exibição para a imagem carregada que eu uso Implementação da base de código do Arduino para fazer o servidor da web. o código tem três funções principais em seu loop conforme a seguir

void loop () {if (! SHOW &&! TEST) server.handleClient (); if (MOSTRAR) {if ((millis () - OpenlastTime)> DURAÇÃO [índice_de_imagem] * 1000) {if (índice_de_imagem> = IMAGE_NUM) índice_de_imagem = 0; _memory_pointer = start_address_of_imagefile [image_index]; Serial.printf ("Número do arquivo =% u nome:% s endereço:% u duração:% u / n", image_index, IMAGES [image_index].c_str (), start_address_of_imagefile [image_index], DURATION [image_index]); Current_imageLine = 0; image_index ++; OpenlastTime = millis (); } if ((micros () - lastLineShow)> lineInterval) {lastLineShow = micros (); ESP.flashRead (_memory_pointer, (uint32_t *) leds, NUM_LEDS * 3); FastLED.show (); _pointer_memória + = (NUM_LEDS * 3); Current_imageLine ++; atraso (LineIntervalDelay); } if (Current_imageLine> = IMAGES_LINES) {Current_imageLine = 0; _memory_pointer = start_address_of_imagefile [image_index-1]; }} optimistic_yield (1000); }

Server Handler o server.handleClient (); responsável por processar qualquer solicitação do cliente no webhost, este site pode ser projetado arbitrariamente para fazer upload de dados, alterar a configuração do show de qualquer relatório de estado. Meu webhost consiste em três guias conforme as imagens a seguir, na primeira guia pudemos verificar o cenário atual do show com sequência e duração para cada imagem, também informações de rede, bem como POV rpm mostrado

na guia de upload de imagem, podemos fazer upload de uma imagem pixelizada para a memória MCU ou excluir uma imagem específica

na guia de rede, podemos alterar as configurações de rede, como modo wi-fi, ip estático, nome e senha da rede,..

Carregador de imagem

esta função servidor cliente solicita pelo Ajax para fazer upload da imagem pixelizada para a memória MCU e, em seguida, gravar o arquivo na memória em formato bruto para que a leitura do arquivo seja o mais rápido possível. Local de início e término da memória armazenado na tabela para exibição na faixa de LED

Função de exibição

Usei a biblioteca FastLED para mostrar pixel em faixa de LED, esta biblioteca é uma das mais bem-sucedidas e bem desenvolvidas para show de LED na plataforma AVR e ESP. Basta enviar a função FastLED, a localização do pixel LED armazenado. lemos pixels linha por linha da memória e os mostramos na faixa de LED e esperamos pelo novo sinalizador de rotação se tornar realidade. repetimos esta sequência até 200 linhas de cada imagem lidas

todo o código localizado no meu repositório git aqui

a seguir está o vídeo do ponto de vista em ação que é gravado pela câmera móvel e, como expliquei, a qualidade do vídeo não é boa devido à baixa velocidade do diafragma da câmera não profissional