Arduino ESP32配置静态IP并通过网页控制GPIO引脚

最新推荐文章于 2024-04-20 12:57:21 发布
最新推荐文章于 2024-04-20 12:57:21 发布
阅读量2k 收藏 30
点赞数 4
分类专栏： Arduino ESP32 入门实例教程 文章标签： tcp/ip 网络协议 网页控制
本文为Perseverance52博主原创文章，未经博主允许，不得转载！
本文链接：https://blog.csdn.net/weixin_42880082/article/details/121055042
版权

Arduino ESP32配置静态IP并通过网页控制GPIO引脚

配置静态IP前，需要对当前要进入的wifi网络的基本信息有了解才行，必须知道wifi的网关，网段，尽量配置比较远一点的IP，防止IP相同的冲突。

实例代码

/*ESP32 配置静态IP并通过网页控制GPIO引脚*/
#include <WiFi.h>

// WIFI信息
const char* ssid = "MERCURY_D268G";
const char* password = "pba5ayzk";

// Set web server port number to 80
WiFiServer server(80);

// 变量来存储HTTP请求
String header;

// 用于存储当前输出状态的辅助变量
String output26State = "off";
String output27State = "off";

// 配置输出引脚号
const int output26 = 26;
const int output27 = 27;

// 设置静态IP信息（配置信息前需要对将要接入的wifi网段有了解）
IPAddress local_IP(192, 168, 0, 188);
// 设置静态IP网关
IPAddress gateway(192, 168, 0, 1);

IPAddress subnet(255, 255, 0, 0);
IPAddress primaryDNS(8, 8, 8, 8);   //optional
IPAddress secondaryDNS(8, 8, 4, 4); //optional

void setup() {
  Serial.begin(115200);
  // Initialize the output variables as outputs
  pinMode(output26, OUTPUT);
  pinMode(output27, OUTPUT);
  // Set outputs to LOW
  digitalWrite(output26, LOW);
  digitalWrite(output27, LOW);

  // Configures static IP address
  if (!WiFi.config(local_IP, gateway, subnet, primaryDNS, secondaryDNS)) {
    Serial.println("STA Failed to configure");
  }
  
  // Connect to Wi-Fi network with SSID and password
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  // Print local IP address and start web server
  Serial.println("");
  Serial.println("WiFi connected.");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
  server.begin();
}

void loop(){
  WiFiClient client = server.available();   // Listen for incoming clients

  if (client) {                             // If a new client connects,
    Serial.println("New Client.");          // print a message out in the serial port
    String currentLine = "";                // make a String to hold incoming data from the client
    while (client.connected()) {            // loop while the client's connected
      if (client.available()) {             // if there's bytes to read from the client,
        char c = client.read();             // read a byte, then
        Serial.write(c);                    // print it out the serial monitor
        header += c;
        if (c == '\n') {                    // if the byte is a newline character
          // if the current line is blank, you got two newline characters in a row.
          // that's the end of the client HTTP request, so send a response:
          if (currentLine.length() == 0) {
            // HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
            // and a content-type so the client knows what's coming, then a blank line:
            client.println("HTTP/1.1 200 OK");
            client.println("Content-type:text/html");
            client.println("Connection: close");
            client.println();
            
            // turns the GPIOs on and off
            if (header.indexOf("GET /26/on") >= 0) {
              Serial.println("GPIO 26 on");
              output26State = "on";
              digitalWrite(output26, HIGH);
            } else if (header.indexOf("GET /26/off") >= 0) {
              Serial.println("GPIO 26 off");
              output26State = "off";
              digitalWrite(output26, LOW);
            } else if (header.indexOf("GET /27/on") >= 0) {
              Serial.println("GPIO 27 on");
              output27State = "on";
              digitalWrite(output27, HIGH);
            } else if (header.indexOf("GET /27/off") >= 0) {
              Serial.println("GPIO 27 off");
              output27State = "off";
              digitalWrite(output27, LOW);
            }
            
            // 访问显示页面
            client.println("<!DOCTYPE html><html>");          
            client.println("<head><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">");
            client.println("<meta charset=\"UTF-8\">");
            client.println("<link rel=\"icon\" href=\"data:,\">");
            // CSS to style the on/off buttons 
            // Feel free to change the background-color and font-size attributes to fit your preferences
            client.println("<style>html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}");
            client.println(".button { background-color: #4CAF50; border: none; color: white; padding: 16px 40px;");
            client.println("text-decoration: none; font-size: 30px; margin: 2px; cursor: pointer;}");
            client.println(".button2 {background-color: #555555;}</style></head>");
            
            // Web Page Heading
            client.println("<body><h1>ESP32 Web Server</h1>");
            
            // Display current state, and ON/OFF buttons for GPIO 26  
            client.println("<p>GPIO 26 - 状态 " + output26State + "</p>");
            // If the output26State is off, it displays the ON button       
            if (output26State=="off") {
              client.println("<p><a href=\"/26/on\"><button class=\"button\">开</button></a></p>");
            } else {
              client.println("<p><a href=\"/26/off\"><button class=\"button button2\">关</button></a></p>");
            } 
               
            // Display current state, and ON/OFF buttons for GPIO 27  
            client.println("<p>GPIO 27 - 状态 " + output27State + "</p>");
            // If the output27State is off, it displays the ON button       
            if (output27State=="off") {
              client.println("<p><a href=\"/27/on\"><button class=\"button\">开</button></a></p>");
            } else {
              client.println("<p><a href=\"/27/off\"><button class=\"button button2\">关</button></a></p>");
            }
            client.println("</body></html>");
            
            // The HTTP response ends with another blank line
            client.println();
            // Break out of the while loop
            break;
          } else { // if you got a newline, then clear currentLine
            currentLine = "";
          }
        } else if (c != '\r') {  // if you got anything else but a carriage return character,
          currentLine += c;      // add it to the end of the currentLine
        }
      }
    }
    // Clear the header variable
    header = "";
    // Close the connection
    client.stop();
    Serial.println("Client disconnected.");
    Serial.println("");
  }
}
  • 串口打印信息
    在这里插入图片描述
  • 控制页面
    在这里插入图片描述
perseverance52
关注
  • 4
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ESP32-Arduino-网络开发实例-WiFi连接设置静态IP
视觉与物联智能
02-28 3824
ESP32-S 是一款通用型WiFi-BT-BLE MCU模组，功能强大，用途广泛，可以用于低功耗传感器网络和要求极高的任务，例如语音编码、音频流和MP3解码等。 此款模组的核心是ESP32芯片，具有可扩展、自适应的特点。两个CPU核可以被单独控制或上电。时钟频率的调节范围为80 MHz到240 MHz。用户可以切断CPU的电源，利用低功耗协处理器来不断
ESP_WiFiManager：这是具有后备Web配置门户的ESP32 ESP8266 WiFi连接管理器。 使用此库可配置ESP32，ESP8266模块的WiFi等。运行时的凭据。 您还可以指定静态DNS服务器，个性化主机名，固定或随机AP WiFi通道。 带有支持ArduinoJson 6.0.0+和5.13.5-的示例
02-02
ESP_WiFiManager：这是具有后备Web配置门户的ESP32 ESP8266 WiFi连接管理器。 使用此库可配置ESP32，ESP8266模块的WiFi等。运行时的凭据。 您还可以指定静态DNS服务器，个性化主机名，固定或随机AP WiFi通道。 带有支持ArduinoJson 6.0.0+和5.13.5-的示例
ESP32-CAM静态IP的设置
de221002的博客
04-05 473
静态IP Arduino IDE文件我也是在网上找的，接着打开静态IP地址的Arduino IDE文件。然后在网页里面打开固定的那个静态IP地址，非常完美，每次打开都是那个地址不会变。每次使用完关机之后打开就找不到IP地址。用静态的他就不会出现这种情况。上传成功后，按一下复位键，串口监视器里面就会有那个固定的IP地址。再打开，Arduino IDE示例里面打开ID地址上传。下次就来搞内网穿透，因为这个只能限制同一个局域网内。导入ESP32-CAM固件，先导入端口。一样的修改IP地址，子网掩码，网关。
ESP8266-AZ-Envy:esp8266
04-16
ESP8266-AZ-Envy 固件 AZ-交付，AZ-嫉妒， 案例的3D文件 编译 这是一个项目。 固件重置 接通AZ-Envy的电源（插入） 在头5秒钟内按下并按住Flash-Button WiFi LED快速开始快速闪烁时松开闪光灯按钮 固件重置在大约30秒后结束，并通过永久性WiFi LED指示灯亮起。 重新校准MQ2气体传感器 点击Flash按钮 默认设置 固件重置后，将设置以下值。 价值 描述 管理员密码 行政 设置管理员密码 WiFi模式 美联社 接入点或站模式 WiFi SSID az-envy- esp id 接入点模式下的SSID WiFi密码 12345678 默认的WiFi密码 网络模式 的DHCP 网络模式STATIC或DHCP * 1 网络IP地址 192.168.192.1 设备IP地址* 2 网络掩码 255.255.255.0 子网
esp8266 mp3
09-12
esp8266 语音播放 //Priorities of the reader and the decoder thread. Higher = higher prio. #define PRIO_READER 11 #define PRIO_MAD 1 //The mp3 read buffer size. 2106 bytes should be enough for up to 48KHz mp3s according to the sox sources. Used by libmad. #define READBUFSZ (2106) static char readBuf[READBUFSZ]; static long bufUnderrunCt; //Reformat the 16-bit mono sample to a format we can send to I2S. static int sampToI2s(short s) { //We can send a 32-bit sample to the I2S subsystem and the DAC will neatly split it up in 2 //16-bit analog values, one for left and one for right. //Duplicate 16-bit sample to both the L and R channel int samp=s; samp=(samp)&0xffff; samp=(samp<65535) samp=65535; if (samp>11]; err=(samp&0x7ff); //Save rounding error. return samp; } //2nd order delta-sigma DAC //See http://www.beis.de/Elektronik/DeltaSigma/DeltaSigma.html for a nice explanation static int sampToI2sDeltaSigma(short s) { int x; int val=0; int w; static int i1v=0, i2v=0; static int outReg=0; for (x=0; x<32; x++) { val<0) w-=32767; else w+=32767; //Difference 1 w+=i1v; i1v=w; //Integrator 1 if (outReg>0) w-=32767; else w+=32767; //Difference 2 w+=i2v; i2v=w; //Integrator 2 outReg=w; //register if (w>0) val|=1; //comparator } return val; } //Calculate the number of samples that we add or delete. Added samples means a slightly lower //playback rate, deleted samples means we increase playout speed a bit. This returns an //8.24 fixed-point number int recalcAddDelSamp(int oldVal) { int ret; long prevUdr=0; static int cnt; int i; static int minFifoFill=0; i=spiRamFifoFill(); if (i<minFifoFill) minFifoFill=i; //Do the rest of the calculations plusminus every 100mS (assuming a sample rate of 44KHz) cnt++; if (cnt<1500) return oldVal; cnt=0; if (spiRamFifoLen()<10*1024) { //The FIFO is very small. We can't do calculations on how much it's filled on average, so another //algorithm is called for. int tgt=1600; //we want an average of this amount of bytes as the average minimum buffer fill //Calculate underruns this cycle int udr=spiRamGetUnderrunCt()-prevUdr; //If we have underruns, the minimum buffer fill has been lower than 0. if (udr!=0) minFifoFill=-1; //If we're below our target decrease playback speed, and vice-versa. ret=oldVal+((minFifoFill-tgt)*ADD_DEL_BUFFPERSAMP_NOSPIRAM); prevUdr+=udr; minFifoFill=9999; } else { //We have a larger FIFO; we can adjust according to the FIFO fill rate. int tgt=spiRamFifoLen()/2; ret=(spiRamFifoFill()-tgt)*ADD_DEL_BUFFPERSAMP; } return ret; } //This routine is called by the NXP modifications of libmad. It passes us (for the mono synth) //32 16-bit samples. void render_sample_block(short *short_sample_buff, int no_samples) { //Signed 16.16 fixed point number: the amount of samples we need to add or delete //in every 32-sample static int sampAddDel=0; //Remainder of sampAddDel cumulatives static int sampErr=0; int i; int samp; #ifdef ADD_DEL_SAMPLES sampAddDel=recalcAddDelSamp(sampAddDel); #endif sampErr+=sampAddDel; for (i=0; i(1<<24)) { sampErr-=(1<<24); //...and don't output an i2s sample } else if (sampErr<-(1<<24)) { sampErr+=(1<bufend-stream->next_frame; memmove(readBuf, stream->next_frame, rem); while (rem<sizeof(readBuf)) { n=(sizeof(readBuf)-rem); //Calculate amount of bytes we need to fill buffer. i=spiRamFifoFill(); if (i<n) n=i; //If the fifo can give us less, only take that amount if (n==0) { //Can't take anything? //Wait until there is enough data in the buffer. This only happens when the data feed //rate is too low, and shouldn't normally be needed! // printf("Buf uflow, need %d bytes.\n", sizeof(readBuf)-rem); bufUnderrunCt++; //We both silence the output as well as wait a while by pushing silent samples into the i2s system. //This waits for about 200mS for (n=0; nerror, mad_stream_errorstr(stream)); return MAD_FLOW_CONTINUE; } //This is the main mp3 decoding task. It will grab data from the input buffer FIFO in the SPI ram and //output it to the I2S port. void ICACHE_FLASH_ATTR tskmad(void *pvParameters) { int r; struct mad_stream *stream; struct mad_frame *frame; struct mad_synth *synth; //Allocate structs needed for mp3 decoding stream=malloc(sizeof(struct mad_stream)); frame=malloc(sizeof(struct mad_frame)); synth=malloc(sizeof(struct mad_synth)); if (stream==NULL) { printf("MAD: malloc(stream) failed\n"); return; } if (synth==NULL) { printf("MAD: malloc(synth) failed\n"); return; } if (frame==NULL) { printf("MAD: malloc(frame) failed\n"); return; } //Initialize I2S i2sInit(); bufUnderrunCt=0; printf("MAD: Decoder start.\n"); //Initialize mp3 parts mad_stream_init(stream); mad_frame_init(frame); mad_synth_init(synth); while(1) { input(stream); //calls mad_stream_buffer internally while(1) { r=mad_frame_decode(frame, stream); if (r==-1) { if (!MAD_RECOVERABLE(stream->error)) { //We're most likely out of buffer and need to call input() again break; } error(NULL, stream, frame); continue; } mad_synth_frame(synth, frame); } } } int getIpForHost(const char *host, struct sockaddr_in *ip) { struct hostent *he; struct in_addr **addr_list; he=gethostbyname(host); if (he==NULL) return 0; addr_list=(struct in_addr **)he->h_addr_list; if (addr_list[0]==NULL) return 0; ip->sin_family=AF_INET; memcpy(&ip->sin_addr, addr_list[0], sizeof(ip->sin_addr)); return 1; } //Open a connection to a webserver and request an URL. Yes, this possibly is one of the worst ways to do this, //but RAM is at a premium here, and this works for most of the cases. int ICACHE_FLASH_ATTR openConn(const char *streamHost, const char *streamPath) { int n, i; while(1) { struct sockaddr_in remote_ip; bzero(&remote_ip, sizeof(struct sockaddr_in)); if (!getIpForHost(streamHost, &remote_ip)) { vTaskDelay(1000/portTICK_RATE_MS); continue; } int sock=socket(PF_INET, SOCK_STREAM, 0); if (sock==-1) { continue; } remote_ip.sin_port = htons(streamPort); printf("Connecting to server %s...\n", ipaddr_ntoa((const ip_addr_t*)&remote_ip.sin_addr.s_addr)); if (connect(sock, (struct sockaddr *)(&remote_ip), sizeof(struct sockaddr))!=00) { close(sock); printf("Conn err.\n"); vTaskDelay(1000/portTICK_RATE_MS); continue; } //Cobble together HTTP request write(sock, "GET ", 4); write(sock, streamPath, strlen(streamPath)); write(sock, " HTTP/1.0\r\nHost: ", 17); write(sock, streamHost, strlen(streamHost)); write(sock, "\r\n\r\n", 4); //We ignore the headers that the server sends back... it's pretty dirty in general to do that, //but it works here because the MP3 decoder skips it because it isn't valid MP3 data. return sock; } } //Reader task. This will try to read data from a TCP socket into the SPI fifo buffer. void ICACHE_FLASH_ATTR tskreader(void *pvParameters) { int madRunning=0; char wbuf[64]; int n, l, inBuf; int t; int fd; int c=0; while(1) { fd=openConn(streamHost, streamPath); printf("Reading into SPI RAM FIFO...\n"); do { n=read(fd, wbuf, sizeof(wbuf)); if (n>0) spiRamFifoWrite(wbuf, n); c+=n; if ((!madRunning) && (spiRamFifoFree()0); close(fd); printf("Connection closed.\n"); } } //Simple task to connect to an access point, initialize i2s and fire up the reader task. void ICACHE_FLASH_ATTR tskconnect(void *pvParameters) { //Wait a few secs for the stack to settle down vTaskDelay(3000/portTICK_RATE_MS); //Go to station mode wifi_station_disconnect(); if (wifi_get_opmode() != STATION_MODE) { wifi_set_opmode(STATION_MODE); } //Connect to the defined access point. struct station_config *config=malloc(sizeof(struct station_config)); memset(config, 0x00, sizeof(struct station_config)); sprintf(config->ssid, AP_NAME); sprintf(config->password, AP_PASS); wifi_station_set_config(config); wifi_station_connect(); free(config); //Fire up the reader task. The reader task will fire up the MP3 decoder as soon //as it has read enough MP3 data. if (xTaskCreate(tskreader, "tskreader", 230, NULL, PRIO_READER, NULL)!=pdPASS) printf("Error creating reader task!\n"); //We're done. Delete this task. vTaskDelete(NULL); } //We need this to tell the OS we're running at a higher clock frequency. extern void os_update_cpu_frequency(int mhz); void ICACHE_FLASH_ATTR user_init(void) { //Tell hardware to run at 160MHz instead of 80MHz //This actually is not needed in normal situations... the hardware is quick enough to do //MP3 decoding at 80MHz. It, however, seems to help with receiving data over long and/or unstable //links, so you may want to turn it on. Also, the delta-sigma code seems to need a bit more speed //than the other solutions to keep up with the output samples, so it's also enabled there. #if defined(DELTA_SIGMA_HACK) SET_PERI_REG_MASK(0x3ff00014, BIT(0)); os_update_cpu_frequency(160); #endif //Set the UART to 115200 baud UART_SetBaudrate(0, 115200); //Initialize the SPI RAM chip communications and see if it actually retains some bytes. If it //doesn't, warn user. if (!spiRamFifoInit()) { printf("\n\nSPI RAM chip fail!\n"); while(1); } printf("\n\nHardware initialized. Waiting for network.\n"); xTaskCreate(tskconnect, "tskconnect", 200, NULL, 3, NULL); }
通过网页控制Arduino的GPIO引脚-电路方案
04-20
现在，让我们继续学习如何控制GPIO引脚。在本教程中，我们将切换可访问的网页上的LED。 硬件部件: Arduino UNO和Genuino UNO×1个 ESP8266 ESP-01×1个 面包板（通用）×1个 电阻1k欧姆×1个 电阻10k欧姆×1个 跳线（通用）×1个 LED（通用）×1个 电阻2.21k欧姆×1个 软件应用程序和在线服务: Arduino IDE 在本教程中，我将向您展示如何控制GPIO引脚。在本教程中，我们将切换网页上的LED，可以从任何具有Internet连接的设备访问该LED。 使用跳线连接各部件，如下所示: 就像以前一样，我们将使用Arduino UNO对ESP-01模块进行编程。为此，我们将RESET引脚连接到GND，以禁用UNO的板载芯片。然后，将通用ESP8266模块设置为Arduino IDE中的开发板。 要将ESP-01模块设置为编程模式，请将GPIO0引脚连接到GND。同样，上传之前，请将ESP-01的RESET引脚连接到GND并断开连接。
ESP32Arduino学习（一）.设置静态IP
小白学编程
04-22 7889
ESP32Arduino学习（一）.设置静态IP连接
ESP32——WIFI静态IP设置方法（官方）
tsliuch的专栏
10-22 3654
WIFI静态IP设置方法（官方）
ESP32静态ip配置
fatCatLA的博客
10-26 1129
3.1以station例程为模板，定义网络参数结构体指针，获取指针地址，作为参数传入回调函数。3.2在回调函数中，加入静态ip设置，先停止DHCP，再设置。1.参考官方例程：examples\protocols\static_ip。2.1动态获取ip的例程中，没有传递指针。2.对比动态ip获取的关键点，网络参数结构体指针的传递。2.2注册的回调函数中，添加多一次判断。3.3复制静态设置函数。
ESP32——WIFI静态IP设置方法（非官方）
tsliuch的专栏
08-05 3380
基于ESP32的WIFI静态IP设置方法
【ESP32-S3的开发】| 3.ESP32S3 设置DNS、静态IP实现域名解析
热门推荐
你看的代码还不够多
03-03 1万+
ESP32S3 设置DNS、静态IP实现域名解析
Arduino中esp32和esp8266离线芯片安装包
05-10
还在为Arduino中连接不上外网下载不到芯片而担心吗，这里一件简单安装；通常如果没有安装芯片包会在编译的时候报错；这是因为芯片选择错误 里面总共2个离线安装包，选择需要的进行安装 下载之后安装教程 1.选择需要...
配置arduino esp32环境，方法亲测有效
01-06
2.arduino esp32环境的配置，主要有四种方法：一种是通过下载git,通过git clone去克隆对应的文件，这种方法较麻烦，且尝试过，经常克隆失败，所以不具体讲述； 第二种是直接去github官网下载esp32包，对应地址： ...
矩阵灯控制系统Arduino ESP32 FastLED
07-13
ESP32写好蓝牙透传代码，将从手机收到的数据通过串口传送给Arduino 2560主板，2560主板解析命令，驱动LED矩阵，矩阵为512个点；16*32矩阵，芯片为单总线，WS2813芯片；内含协议说明文档如想商业化本设计，请联系本人...
esp32 通过WiFi联网控制摄像头采集图像并通过oled屏幕显示
07-13
esp32 通过WiFi联网控制摄像头采集图像并通过oled屏幕显示
esp32s3中设置静态IP地址
最新发布
weixin_44470384的博客
04-20 193
将esp32s3单片机作为AP热点，需要配置网关和静态IP地址，系统默认是192.168.4.1，为了实现自定义可以如下配置，并且根据MAC地址自定义SSID。
ESP32学习笔记（14）——HTTP服务器
Leung的博客
05-09 1万+
一、HTTP简介 HTTP（Hyper Text Transfer Protocol） 超文本传输协议，是一种建立在 TCP 上的无状态连接，整个基本的工作流程是客户端发送一个 HTTP 请求，说明客户端想要访问的资源和请求的动作，服务端收到请求之后，服务端开始处理请求，并根据请求做出相应的动作访问服务器资源，最后通过发送 HTTP 响应把结果返回给客户端。其中一个请求的开始到一个响应的结束称为事务，当一个事务结束后还会在服务端添加一条日志条目。 1.1 HTTP请求 HTTP 请求是客户端往服务端发送请
IDF4.4 ESP32-S2给以太网接口设置静态IP
weichushun的专栏
02-19 2927
需求： 实际Lora网关需要可让用户通过WEB配置以太网接口的静态IP，如果是空的，就自动启动DHCP，否则用静态IP。 先看到网上有这个，看样子是比较老版本的SDK了，我现在是IDF4.4，不用他的函数了。 Esp32-Ethernet-kit_A_1.2以太网设置静态ip，windows与板子ping通_Linux_zhicheng的博客-CSDN博客_esp32静态ip 接着找，发现了这个 How to assign Ethernet Static IP address - ESP32 For
ESP32接入网络后，循环扫描服务器IP及端口状态信息（ESP-IDF）
weixin_49337111的博客
01-09 1442
在嵌入式物联网这一类的项目开发中，硬件设备常作为客户端，通过固定的或非固定的服务器IP地址和端口号向服务器进行通信，上传本地数据到服务器中或接收来自服务器的请求数据。本文主要解决当服务器IP地址并未固定或者因某种原因导致服务器的IP地址发生变动，而硬件设备产品可能已经上市交付等其它因素，并不能及时的通过OTA升级更新客户端的MCU硬件程序，但硬件产品依然需要连接服务器的端口，进行数据交互。ESP32扫描到在线的IP地址，但未扫描到对应的端口，如果服务器未开启，则ESP32会一直循环扫描服务器的IP及端口。
arduino esp32 网页wifi控制
06-28
4. 接收请求并控制硬件：在网页上点击按钮时，会向服务器发送请求，此时ESP32的服务器就会调用相应的函数进行处理。例如，当请求路径是/ledon时，就可以使用digitalWrite()函数将某个数字管脚的电平设置为高电平，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值