Brinque com Fire Over Wi-Fi (ESP8266, NeoPixels e aplicativo Android)

Componentes e suprimentos

ElectroPeak ESP8266 Serial WIFI Witty Cloud Board

Neopixels Smart LED Strip (60LED / m strip)

ElectroPeak Logic Level Converter

ElectroPeak 21 cm 40P Macho para Fêmea Jumper Wire

Tubo de PVC de 60 cm tamanho 2 ”

Papel vegetal

Cilindro de vidro

Fonte de alimentação 5V (pelo menos 9A)

Arduino Nano R3

Ferramentas e máquinas necessárias

Pistola de cola quente (genérica)

Ferro de soldar (genérico)

Aplicativos e serviços online

Arduino IDE

Sobre este projeto

Você pode ler este e outros tutoriais incríveis em Site oficial do ElectroPeak

Crie um efeito de simulação de fogo legal com controle sem fio Wi-Fi. Um aplicativo móvel (para smartphones Android) com uma interface bonita está pronto para instalar e brincar com sua criação! Também usaremos Arduino e ESP8266 para controlar a chama. Ao final deste projeto, você aprenderá:

Como funcionam os NeoPixels.
Como programar ESP8266 e controlar variáveis por Wi-Fi
Como criar um efeito de fogo legal com NeoPixels

Uma introdução aos NeoPixels

LEDs endereçáveis individualmente ou freqüentemente chamados de NeoPixels já existem há algum tempo e você provavelmente os conhece, mas, se não, eles são como LEDs RGB normais, mas como o nome sugere, a cor de cada um deles pode ser endereçada individualmente , permitindo que padrões e animações infinitamente legais sejam feitos. Para WS2812b, você só precisa de 3 fios, 2 para alimentação e 1 para dados. Isso significa que você só precisa de um pino Arduino livre para controlar uma tonelada de LEDs!

Neste projeto, vamos usar esses LEDs inteligentes para criar um efeito de fogo. Para controlar os LEDs, usaremos a incrível biblioteca FastLED. Usaremos o exemplo de esboço Fire2012 da biblioteca escrita por Mark Kriegsman. Usamos 6 tiras de LEDs, cada uma com 30 LEDs (um total de 180 LEDs), colocamos esses LEDs em um pedaço de tubo de PVC e os colocamos em um cilindro de vidro (esses cilindros de vidro são normalmente usados como vasos). Temos que difundir a luz dos LEDs para que pareçam contínuos, para isso usamos papel vegetal que deixa a luz passar e difunde a luz.

Construção

Primeiro, pegue um cilindro de vidro adequado, nosso cilindro tem um comprimento de 60 cm e um diâmetro de 12 cm.

Se você puder encontrar um cilindro de vidro fosco, isso será bom, mas se for um vidro transparente, você pode usar papel vegetal para cobrir a superfície do cilindro (tanto a superfície interna quanto a externa), o papel vegetal faz um bom trabalho de difusão da luz e produz bons resultados.

Após obter um cilindro de vidro, meça seu comprimento interno e, em seguida, corte o tubo de PVC para que ele caiba dentro do cilindro. Nosso cilindro de vidro tem uma altura de 60cm (excluindo a base, ele tem um comprimento interno de 59cm), então cortamos nosso tubo de PVC para 59cm. Você vai colar fitas de LED neste cachimbo, um cachimbo com diâmetro de 4cm seria perfeito.

Em seguida, temos que cortar nossa faixa de led em 6 partes iguais aqui usamos faixa de densidade 60LEDs / m (você pode usar densidades maiores para melhores efeitos se quiser) usamos seis comprimentos de 50 cm, o que significa que precisamos de 3 metros. Espace os seis comprimentos igualmente em torno do tubo de PVC e cole as tiras no tubo. É assim que deve ser.

Para as tiras de LED juntas, você pode soldar os fios diretamente na tira de acordo com o desenho a seguir ou primeiro soldar os cabeçotes dos pinos nas tiras e, em seguida, usar os fios da placa de ensaio para conectá-los.

Quando todas as conexões de tiras de LED estiverem concluídas, você deve colocar o tubo dentro do cilindro. Para centralizar o tubo dentro do cilindro, você pode usar espuma para cortar um círculo que tem um diâmetro externo igual ao diâmetro interno do cilindro de vidro e um diâmetro interno igual ao diâmetro externo do tubo de PVC. Prepare dois deles para cada lado do tubo. Prenda essas peças nas pontas e coloque cuidadosamente o tubo dentro do cilindro.

Código

Usamos Arduino IDE para codificação e upload para ESP8266. Você deve usar uma placa que tenha um ESP8266 com 3 MB de SPIFFS se quiser fazer o upload dos arquivos do software do controlador no SPIFFS. SPIFFS é a abreviação de “Sistema de arquivos Flash de interface periférica serial”, você pode carregar os arquivos do controlador para esta memória para servir os arquivos daquele local. Ao fazer isso, você pode abrir seu navegador (no telefone ou notebook) e ir para o endereço de seu ESP (o padrão é 192.168.4.1) e você obterá a interface do controlador em seu navegador sem ter que instalar o aplicativo, se você ter um iPhone ou iPad esta é sua única opção.

Carregue o seguinte esboço em sua placa ESP. Precisamos da biblioteca FastLED, então primeiro adicione-a ao seu IDE do Arduino, se ainda não o fez (você pode baixá-lo aqui). O código de simulação de incêndio é o esboço fire2012 de Mark Kriegsman, que você pode encontrar nos exemplos. Esse exemplo é para uma faixa de led, mas aqui modificamos o código para usar um número variável de faixas. Quanto maior o número de tiras / leds, maior será o efeito.

A lógica da simulação de incêndio é claramente descrita no arquivo de exemplo. Se você quiser saber como funciona, leia o código-fonte do exemplo.

  #include  #include  #include "FastLED.h" #include "EEPROM.h" #include "FS.h" // necessário para SPIFFS # define DATA_PIN 5 # define LED_TYPE WS2811 # define COLOR_ORDER GRB # define NUM_LEDS 30 # define NUM_STRIPS 6 # define CHIPSET WS2812B // endereços para salvar dados em EEPROM para preservar o estado de simulação de incêndio # define cs0Adr 0 # define cs1Adr 3 # define cs2Adr 6 # define cs3Adr 9 # define BriAdr 15 # define FpsAdr 16 # define SparkingAdr 17 # define CoolingAdr 18 # define EEPROMCheckAdr 20 // se este valor for 250, assumimos que salvamos anteriormente na EEPROM e carregamos os dados daquele CRGB leds [NUM_STRIPS * NUM_LEDS]; String inData; uint8_t FPS =100; // FRAMES_PER_SECONDuint8_t SPARKING =150; uint8_t COOLING =90; uint8_t BRIGHTNESS =100; uint8_t csRGB [4] [3] ={{0, 0, 0}, {255, 0, 0}, {255, 127, 0}, {255, 255, 255}}; sem sinal longo anteriorMillis =0; alteração do bool =falso; // se verdadeiro, vamos salvar em EEprom.unsigned long changeMillis =0; // as alterações serão salvas 1 minuto após nenhuma alteração ser aplicada para evitar desgaste EEPROM.bool initSetup =true; CRGBPalette16 gPal; ESP8266WebServer server (80); // Objeto de servidor da Web. Estará escutando na porta 80 (padrão para HTTP) void setup () {EEPROM.begin (200); cWiFi (); setupFastLED (); loadConfig (); gPal =CRGBPalette16 (CRGB (csRGB [0] [0], csRGB [0] [1], csRGB [0] [2]), CRGB (csRGB [1] [0], csRGB [1] [1], csRGB [1] [2]), CRGB (csRGB [2] [0], csRGB [2] [1], csRGB [2] [2]), CRGB (csRGB [3] [0], csRGB [3] [ 1], csRGB [3] [2]));} inline void setupFastLED () {delay (1000); // atraso de sanidade FastLED.addLeds  (leds, NUM_STRIPS * NUM_LEDS) .setCorrection (TypicalLEDStrip); FastLED.setBrightness (BRIGHTNESS);} void loop () {server.handleClient (); // Tratamento de solicitações de entrada if (change) {if (millis () - changeMillis> 60000) {change =false; saveToEEPROM (); } } fogo(); FastLED.show (); FastLED.delay (1000 / FPS);} void Fire2012WithPalette (int stripNo) {calor de byte estático [NUM_STRIPS] [NUM_LEDS]; // Etapa 1. Resfrie um pouco cada célula para (int i =0; i  =2; k--) {calor [stripNo] [k] =(calor [stripNo] [k - 1] + aquecimento [tiraNo] [k - 2] + aquecimento [tiraNo] [k - 2]) / 3; } // Etapa 3. Acender aleatoriamente novas 'faíscas' de calor perto do fundo if (random8 ()  =period * 1000) {// salvar a última vez que você piscou o LED previousMillis =currentMillis; return true; } else {return false; }} void EEPROMupdate (endereço de byte, valor de byte) {if (EEPROM.read (endereço)! =valor) {EEPROM.write (endereço, valor); EEPROM.commit (); } return;} void saveToEEPROM () {EEPROMupdate (BriAdr, BRIGHTNESS); EEPROMupdate (FpsAdr, FPS); EEPROMupdate (SparkingAdr, SPARKING); EEPROMupdate (CoolingAdr, COOLING); for (uint8_t i =0; i <4; i ++) {for (uint8_t j =0; j <3; j ++) {EEPROMupdate ((i * 3 + j), csRGB [i] [j]); }}} void handleCS0Change () {csRGB [0] [0] =str2int (server.arg ("R")); csRGB [0] [1] =str2int (server.arg ("G")); csRGB [0] [2] =str2int (server.arg ("B")); gPal =CRGBPalette16 (CRGB (csRGB [0] [0], csRGB [0] [1], csRGB [0] [2]), CRGB (csRGB [1] [0], csRGB [1] [1], csRGB [1] [2]), CRGB (csRGB [2] [0], csRGB [2] [1], csRGB [2] [2]), CRGB (csRGB [3] [0], csRGB [3] [ 1], csRGB [3] [2])); changeMillis =millis (); alterar =verdadeiro;} void handleCS1Change () {csRGB [1] [0] =str2int (server.arg ("R")); csRGB [1] [1] =str2int (server.arg ("G")); csRGB [1] [2] =str2int (server.arg ("B")); gPal =CRGBPalette16 (CRGB (csRGB [0] [0], csRGB [0] [1], csRGB [0] [2]), CRGB (csRGB [1] [0], csRGB [1] [1], csRGB [1] [2]), CRGB (csRGB [2] [0], csRGB [2] [1], csRGB [2] [2]), CRGB (csRGB [3] [0], csRGB [3] [ 1], csRGB [3] [2])); changeMillis =millis (); alterar =verdadeiro;} void handleCS2Change () {csRGB [2] [0] =str2int (server.arg ("R")); csRGB [2] [1] =str2int (server.arg ("G")); csRGB [2] [2] =str2int (server.arg ("B")); gPal =CRGBPalette16 (CRGB (csRGB [0] [0], csRGB [0] [1], csRGB [0] [2]), CRGB (csRGB [1] [0], csRGB [1] [1], csRGB [1] [2]), CRGB (csRGB [2] [0], csRGB [2] [1], csRGB [2] [2]), CRGB (csRGB [3] [0], csRGB [3] [ 1], csRGB [3] [2])); changeMillis =millis (); alterar =verdadeiro;} void handleCS3Change () {csRGB [3] [0] =str2int (server.arg ("R")); csRGB [3] [1] =str2int (server.arg ("G")); csRGB [3] [2] =str2int (server.arg ("B")); gPal =CRGBPalette16 (CRGB (csRGB [0] [0], csRGB [0] [1], csRGB [0] [2]), CRGB (csRGB [1] [0], csRGB [1] [1], csRGB [1] [2]), CRGB (csRGB [2] [0], csRGB [2] [1], csRGB [2] [2]), CRGB (csRGB [3] [0], csRGB [3] [ 1], csRGB [3] [2])); changeMillis =millis (); alterar =true;} void handleConf () {if (server.arg ("brilho")! ="") {BRILHO =str2int (server.arg ("brilho")); FastLED.setBrightness (BRIGHTNESS); changeMillis =millis (); mudança =verdadeiro; } if (server.arg ("fps")! ="") {FPS =str2int (server.arg ("fps")); changeMillis =millis (); mudança =verdadeiro; } if (server.arg ("sparking")! ="") {SPARKING =str2int (server.arg ("sparking")); changeMillis =millis (); mudança =verdadeiro; } if (server.arg ("resfriamento")! ="") {COOLING =str2int (server.arg ("resfriamento")); changeMillis =millis (); mudança =verdadeiro; } server.sendHeader ("Conexão", "fechar"); server.sendHeader ("Access-Control-Allow-Origin", "*"); server.send (200, "text / plain", ""); // Retorna a resposta HTTP} void loadConfig () {if (EEPROM.read (EEPROMCheckAdr) ==250) {BRIGHTNESS =EEPROM.read (BriAdr); SPARKING =EEPROM.read (SparkingAdr); COOLING =EEPROM.read (CoolingAdr); FPS =EEPROM.read (FpsAdr); se (FPS ==0) FPS =100; for (uint8_t i =0; i <4; i ++) {for (uint8_t j =0; j <3; j ++) {csRGB [i] [j] =EEPROM.read (i * 3 + j); }}} else {EEPROMupdate (BriAdr, BRIGHTNESS); EEPROMupdate (FpsAdr, FPS); EEPROMupdate (CoolingAdr, COOLING); EEPROMupdate (SparkingAdr, SPARKING); for (uint8_t i =0; i <4; i ++) {for (uint8_t j =0; j <3; j ++) {EEPROMupdate ((i * 3 + j), csRGB [i] [j]); }} Atualização de EEPROM (EEPROMCheckAdr, 250); }} void cWiFi () {WiFi.softAP ("ElectroPeak's Flame", ""); // defina uma senha aqui se desejar, por exemplo, WiFi.softAP ("ElectroPeak's Flame", "12345678"); IPAddress myIP =WiFi.softAPIP (); server.on ("/ cs0", handleCS0Change); server.on ("/ cs1", handleCS1Change); server.on ("/ cs2", handleCS2Change); server.on ("/ cs3", handleCS3Change); server.on ("/ conf", handleConf); server.serveStatic ("/", SPIFFS, "/", "max-age =86400"); server.begin (); // Inicie o servidor}

Para controlar a “aparência e sensação” do fogo, há duas variáveis para jogar:SPARKING e COOLING, que você pode controlar dinamicamente no software do controlador carregado no SPIFFS ou no aplicativo Android que você pode baixar. Você também pode controlar o FPS aqui.

A cor do fogo é controlada por uma paleta de cores que também pode ser alterada através do software do controlador (através de 4 interruptores de cor). Basta clicar / tocar em cada círculo de cor que representa uma interrupção de cor para definir a cor, após definir a cor atingida perto para fechar a caixa de diálogo e ver a mudança.

Como fazer upload para SPIFFS?

Para fazer o upload dos arquivos para a memória SPIFFS usando o Arduino IDE, primeiro você precisa criar uma pasta chamada "dados" dentro da pasta do esboço e colocar todos os arquivos que deseja carregar nessa pasta. O arquivo carregado aqui contém o esboço e esta pasta.

Em seguida, você precisa do plugin de upload do sistema de arquivos Arduino ESP8266 para Arduino. Siga as instruções em sua página Github e instale o plugin. Quando instalado, você encontrará ESP8266 Sketch Data Upload em ferramentas cardápio. Coloque seu ESP no modo de programação e clique nele. Seja paciente e deixe os arquivos subirem, isso pode demorar um pouco. Nota:defina a “velocidade de upload” para 921600 para torná-lo mais rápido.

Como funciona?

O esboço carregado na placa ESP8266 cria um servidor web, que responde às solicitações enviadas do aplicativo. O aplicativo simplesmente envia solicitações GET ao servidor (ESP8266). Os dados de cor para criar a paleta são enviados como argumentos na solicitação get, o mesmo é verdadeiro para outros parâmetros como Sparking e Cooling.

Por exemplo, para definir o brilho, a seguinte solicitação é enviada pelo aplicativo

http://192.168.4.1/conf?brightness=224

existe um manipulador para esta solicitação no sketch que quando obtém esta solicitação define o brilho. Revise o código para saber mais.

Aplicativo Android

O aplicativo Android é criado usando Phonegap. É uma tecnologia que permite criar aplicativos móveis multiplataforma usando tecnologias web (HTML, CSS, Javascript). Você pode obter o código-fonte visitando esta página

Você pode ler este e outros tutoriais incríveis em Site oficial do ElectroPeak

Código

Código de efeito de fogo
Sketch and Data folder

Código de efeito de fogo Arduino

 #include #include #include "FastLED.h" #include "EEPROM.h" #include "FS.h" // necessário para SPIFFS # define DATA_PIN 5 # define LED_TYPE WS2811 # define COLOR_ORDER GRB # define NUM_LEDS 30 # define NUM_STRIPS 6 # define CHIPSET WS2812B // endereços para salvar dados em EEPROM para preservar o estado de simulação de incêndio # define cs0Adr 0 # define cs1Adr 3 # define cs2Adr 6 # define cs3Adr 9 # define BriAdr 15 # define FpsAdr 16 # define SparkingAdr 17 #define CoolingAdr 18 # define EEPROMCheckAdr 20 // se este valor for 250 assumimos que salvamos anteriormente na EEPROM e carregamos os dados daquele CRGB leds [NUM_STRIPS * NUM_LEDS]; String inData; uint8_t FPS =100; // FRAMES_PER_SECONDuint8_t SPARKING =150; uint8_t COOLING =90; uint8_t BRIGHTNESS =100; uint8_t csRGB [4] [3] ={{0, 0, 0}, {255, 0, 0}, {255, 127, 0}, {255, 255, 255}}; sem sinal longo anteriorMillis =0; alteração do bool =falso; // se verdadeiro, vamos salvar em EEprom.unsigned long changeMillis =0; // as alterações serão salvas 1 minuto após nenhuma alteração ser aplicada para evitar desgaste EEPROM.bool initSetup =true; CRGBPalette16 gPal; ESP8266WebServer server (80); // Objeto de servidor da Web. Estará escutando na porta 80 (padrão para HTTP) void setup () {EEPROM.begin (200); cWiFi (); setupFastLED (); loadConfig (); gPal =CRGBPalette16 (CRGB (csRGB [0] [0], csRGB [0] [1], csRGB [0] [2]), CRGB (csRGB [1] [0], csRGB [1] [1], csRGB [1] [2]), CRGB (csRGB [2] [0], csRGB [2] [1], csRGB [2] [2]), CRGB (csRGB [3] [0], csRGB [3] [ 1], csRGB [3] [2])); } inline void setupFastLED () {delay (1000); // atraso de sanidade FastLED.addLeds  (leds, NUM_STRIPS * NUM_LEDS) .setCorrection (TypicalLEDStrip); FastLED.setBrightness (BRIGHTNESS);} void loop () {server.handleClient (); // Tratamento de solicitações de entrada if (change) {if (millis () - changeMillis> 60000) {change =false; saveToEEPROM (); } } fogo(); FastLED.show (); FastLED.delay (1000 / FPS);} void Fire2012WithPalette (int stripNo) {calor de byte estático [NUM_STRIPS] [NUM_LEDS]; // Etapa 1. Resfrie um pouco cada célula para (int i =0; i  =2; k--) {calor [stripNo] [k] =(calor [stripNo] [k - 1] + aquecimento [tiraNo] [k - 2] + aquecimento [tiraNo] [k - 2]) / 3; } // Etapa 3. Acender aleatoriamente novas 'faíscas' de calor perto do fundo if (random8 ()  =period * 1000) {// salvar a última vez que você piscou o LED previousMillis =currentMillis; return true; } else {return false; }} void EEPROMupdate (endereço de byte, valor de byte) {if (EEPROM.read (endereço)! =valor) {EEPROM.write (endereço, valor); EEPROM.commit (); } return;} void saveToEEPROM () {EEPROMupdate (BriAdr, BRIGHTNESS); EEPROMupdate (FpsAdr, FPS); EEPROMupdate (SparkingAdr, SPARKING); EEPROMupdate (CoolingAdr, COOLING); for (uint8_t i =0; i <4; i ++) {for (uint8_t j =0; j <3; j ++) {EEPROMupdate ((i * 3 + j), csRGB [i] [j]); }}} void handleCS0Change () {csRGB [0] [0] =str2int (server.arg ("R")); csRGB [0] [1] =str2int (server.arg ("G")); csRGB [0] [2] =str2int (server.arg ("B")); gPal =CRGBPalette16 (CRGB (csRGB [0] [0], csRGB [0] [1], csRGB [0] [2]), CRGB (csRGB [1] [0], csRGB [1] [1], csRGB [1] [2]), CRGB (csRGB [2] [0], csRGB [2] [1], csRGB [2] [2]), CRGB (csRGB [3] [0], csRGB [3] [ 1], csRGB [3] [2])); changeMillis =millis (); alterar =verdadeiro;} void handleCS1Change () {csRGB [1] [0] =str2int (server.arg ("R")); csRGB [1] [1] =str2int (server.arg ("G")); csRGB [1] [2] =str2int (server.arg ("B")); gPal =CRGBPalette16 (CRGB (csRGB [0] [0], csRGB [0] [1], csRGB [0] [2]), CRGB (csRGB [1] [0], csRGB [1] [1], csRGB [1] [2]), CRGB (csRGB [2] [0], csRGB [2] [1], csRGB [2] [2]), CRGB (csRGB [3] [0], csRGB [3] [ 1], csRGB [3] [2])); changeMillis =millis (); alterar =verdadeiro;} void handleCS2Change () {csRGB [2] [0] =str2int (server.arg ("R")); csRGB [2] [1] =str2int (server.arg ("G")); csRGB [2] [2] =str2int (server.arg ("B")); gPal =CRGBPalette16 (CRGB (csRGB [0] [0], csRGB [0] [1], csRGB [0] [2]), CRGB (csRGB [1] [0], csRGB [1] [1], csRGB [1] [2]), CRGB (csRGB [2] [0], csRGB [2] [1], csRGB [2] [2]), CRGB (csRGB [3] [0], csRGB [3] [ 1], csRGB [3] [2])); changeMillis =millis (); alterar =verdadeiro;} void handleCS3Change () {csRGB [3] [0] =str2int (server.arg ("R")); csRGB [3] [1] =str2int (server.arg ("G")); csRGB [3] [2] =str2int (server.arg ("B")); gPal =CRGBPalette16 (CRGB (csRGB [0] [0], csRGB [0] [1], csRGB [0] [2]), CRGB (csRGB [1] [0], csRGB [1] [1], csRGB [1] [2]), CRGB (csRGB [2] [0], csRGB [2] [1], csRGB [2] [2]), CRGB (csRGB [3] [0], csRGB [3] [ 1], csRGB [3] [2])); changeMillis =millis (); alterar =true;} void handleConf () {if (server.arg ("brilho")! ="") {BRILHO =str2int (server.arg ("brilho")); FastLED.setBrightness (BRIGHTNESS); changeMillis =millis (); mudança =verdadeiro; } if (server.arg ("fps")! ="") {FPS =str2int (server.arg ("fps")); changeMillis =millis (); mudança =verdadeiro; } if (server.arg ("sparking")! ="") {SPARKING =str2int (server.arg ("sparking")); changeMillis =millis (); mudança =verdadeiro; } if (server.arg ("resfriamento")! ="") {COOLING =str2int (server.arg ("resfriamento")); changeMillis =millis (); mudança =verdadeiro; } server.sendHeader ("Conexão", "fechar"); server.sendHeader ("Access-Control-Allow-Origin", "*"); server.send (200, "text / plain", ""); // Retorna a resposta HTTP} void loadConfig () {if (EEPROM.read (EEPROMCheckAdr) ==250) {BRIGHTNESS =EEPROM.read (BriAdr); SPARKING =EEPROM.read (SparkingAdr); COOLING =EEPROM.read (CoolingAdr); FPS =EEPROM.read (FpsAdr); se (FPS ==0) FPS =100; for (uint8_t i =0; i <4; i ++) {for (uint8_t j =0; j <3; j ++) {csRGB [i] [j] =EEPROM.read (i * 3 + j); }}} else {EEPROMupdate (BriAdr, BRIGHTNESS); EEPROMupdate (FpsAdr, FPS); EEPROMupdate (CoolingAdr, COOLING); EEPROMupdate (SparkingAdr, SPARKING); for (uint8_t i =0; i <4; i ++) {for (uint8_t j =0; j <3; j ++) {EEPROMupdate ((i * 3 + j), csRGB [i] [j]); }} Atualização de EEPROM (EEPROMCheckAdr, 250); }} void cWiFi () {WiFi.softAP ("ElectroPeak's Flame", ""); // defina uma senha aqui se desejar, por exemplo, WiFi.softAP ("ElectroPeak's Flame", "12345678"); IPAddress myIP =WiFi.softAPIP (); server.on ("/ cs0", handleCS0Change); server.on ("/ cs1", handleCS1Change); server.on ("/ cs2", handleCS2Change); server.on ("/ cs3", handleCS3Change); server.on ("/ conf", handleConf); server.serveStatic ("/", SPIFFS, "/", "max-age =86400"); server.begin (); // Inicie o servidor}

Sketch and Data folder Arduino

Este arquivo zip contém o arquivo de esboço e a pasta de dados (upload SPIFFS)

 Sem visualização (apenas download).

Peças personalizadas e gabinetes

eps_flame_android_u5Zy5Bksvp.apk

Crie um contador de pessoas controlado por um aplicativo Android Desinfecção do robô com luz ultravioleta

Processo de manufatura

impressao 3D

Sistema de controle de automação

Tecnologia industrial