micropython开发esp32sWeb小游戏

最新推荐文章于 2025-08-01 15:52:43 发布
原创 最新推荐文章于 2025-08-01 15:52:43 发布 · 158 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #开发语言

所使用的开发板：

Web端效果

代码如下

import network
import usocket as socket
import uasyncio as asyncio
import ujson
import machine
import random
import gc
import sys
import struct

# 内存监控函数
def mem_info():
    gc.collect()
    print("Free mem:", gc.mem_free())

# 初始化时释放内存
mem_info()

# ================ AP热点设置 ================
def setup_ap():
    ap = network.WLAN(network.AP_IF)
    ap.active(True)
    ap.config(essid='SnakeGame', password='12345678', authmode=3)  # WPA2加密
    ap.config(max_clients=5)
    print('AP模式已启动')
    print('SSID: SnakeGame, 密码: 12345678')
    ip = ap.ifconfig()[0]
    print('IP地址:', ip)
    return ip

# ================ DNS服务器（用于劫持所有域名） ================
class DNSServer:
    def __init__(self, ip):
        self.ip = ip
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.sock.setblocking(False)
        self.sock.bind(('0.0.0.0', 53))
        print("DNS服务器已启动 (端口 53)")
    
    async def run(self):
        while True:
            try:
                data, addr = self.sock.recvfrom(512)
                if data:
                    # 解析DNS查询
                    transaction_id = data[0:2]
                    flags = b'\x81\x80'  # 标准响应标志
                    questions = 1
                    answers = 1
                    authority_rrs = 0
                    additional_rrs = 0
                    
                    # 构建响应头
                    response = transaction_id + flags
                    response += struct.pack('>HHHH', questions, answers, authority_rrs, additional_rrs)
                    
                    # 添加查询部分
                    response += data[12:]
                    
                    # 添加答案部分
                    response += b'\xc0\x0c'  # 指向查询名的指针
                    response += b'\x00\x01'  # 类型A
                    response += b'\x00\x01'  # 类IN
                    response += b'\x00\x00\x00\x3c'  # TTL 60秒
                    response += b'\x00\x04'  # 数据长度
                    response += socket.inet_aton(self.ip)  # 我们的IP地址
                    
                    self.sock.sendto(response, addr)
                    print(f"DNS劫持请求来自: {addr[0]}")
            except Exception as e:
                # print("DNS错误:", e)
                pass
            await asyncio.sleep_ms(100)

# ================ 游戏状态 ================
class GameState:
    def __init__(self):
        self.reset()
        self.clients = []
        self.high_score = 0
        self.base_speed = 300  # 基础速度(ms)
        self.speed_factor = 1.0  # 速度因子
        
    def reset(self):
        self.snake = [(5, 5), (4, 5), (3, 5)]  # 蛇初始位置
        self.direction = 'right'
        self.food = self.generate_food()
        self.score = 0
        self.game_over = False
        
    def generate_food(self):
        # 15x15网格
        while True:
            food = (random.randint(0, 14), random.randint(0, 14))
            if food not in self.snake:
                return food
                
    def move(self):
        if self.game_over:
            return

        head_x, head_y = self.snake[0]
        if self.direction == 'up':
            new_head = (head_x, head_y - 1)
        elif self.direction == 'down':
            new_head = (head_x, head_y + 1)
        elif self.direction == 'left':
            new_head = (head_x - 1, head_y)
        elif self.direction == 'right':
            new_head = (head_x + 1, head_y)

        # 检查碰撞
        if (new_head[0] < 0 or new_head[0] > 14 or 
            new_head[1] < 0 or new_head[1] > 14 or 
            new_head in self.snake):
            self.game_over = True
            if self.score > self.high_score:
                self.high_score = self.score
            return

        # 移动蛇
        self.snake.insert(0, new_head)
        
        # 检查食物
        if new_head == self.food:
            self.score += 1
            self.food = self.generate_food()
        else:
            self.snake.pop()
                
    def get_speed(self):
        """计算当前游戏速度，考虑基础速度和速度因子"""
        return max(100, int(self.base_speed / self.speed_factor))

# ================ Web服务器 ================
class WebServer:
    def __init__(self, game_state):
        self.game_state = game_state
        self.server = None
        self.html = self.get_html()
        
    def get_html(self):
        # 包含速度滑杆的HTML界面
        return """<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>ESP32 Snake</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            margin: 0;
            background-color: #f0f0f0;
        }
        .game-container {
            text-align: center;
            background-color: white;
            padding: 20px;
            border-radius: 10px;
            box-shadow: 0 0 10px rgba(0,0,0,0.1);
        }
        canvas {
            border: 1px solid #000;
            background-color: #000;
        }
        .game-over {
            display: none;
            color: red;
            font-size: 24px;
            margin: 10px 0;
        }
        .settings {
            margin: 15px 0;
        }
        .speed-control {
            display: flex;
            align-items: center;
            justify-content: center;
            gap: 10px;
        }
        button {
            padding: 10px 20px;
            font-size: 16px;
            cursor: pointer;
        }
    </style>
</head>
<body>
    <div class="game-container">
        <h1>ESP32 Snake</h1>
        <div class="score">得分: <span id="score">0</span> | 最高分: <span id="high-score">0</span></div>
        <canvas id="gameCanvas" width="300" height="300"></canvas>
        <div id="gameOver" class="game-over">游戏结束!</div>
        
        <div class="settings">
            <h3>游戏设置</h3>
            <div class="speed-control">
                <div class="speed-label">游戏速度:</div>
                <input type="range" min="1" max="3" value="1" step="0.5" class="speed-slider" id="speedSlider">
                <div class="speed-value" id="speedValue">1.0x</div>
            </div>
            <div class="instructions">(速度设置会在新游戏生效)</div>
        </div>
        
        <button id="restartBtn">开始新游戏</button>
    </div>

    <script>
        const canvas = document.getElementById('gameCanvas');
        const ctx = canvas.getContext('2d');
        const scoreElement = document.getElementById('score');
        const highScoreElement = document.getElementById('high-score');
        const gameOverElement = document.getElementById('gameOver');
        const restartBtn = document.getElementById('restartBtn');
        const speedSlider = document.getElementById('speedSlider');
        const speedValue = document.getElementById('speedValue');
        
        let ws;
        let gridSize = 15;
        let cellSize = canvas.width / gridSize;
        
        function connectWebSocket() {
            ws = new WebSocket('ws://' + window.location.host + '/ws');
            
            ws.onopen = () => {
                console.log('WebSocket连接已建立');
            };
            
            ws.onmessage = (event) => {
                const gameState = JSON.parse(event.data);
                drawGame(gameState);
            };
            
            ws.onclose = () => {
                console.log('WebSocket连接已关闭，尝试重新连接...');
                setTimeout(connectWebSocket, 2000);
            };
            
            ws.onerror = (error) => {
                console.error('WebSocket错误:', error);
            };
        }
        
        function drawGame(gameState) {
            ctx.clearRect(0, 0, canvas.width, canvas.height);
            
            // 绘制蛇
            ctx.fillStyle = '#00FF00';
            gameState.snake.forEach(segment => {
                ctx.fillRect(segment[0] * cellSize, segment[1] * cellSize, cellSize, cellSize);
            });
            
            // 绘制食物
            ctx.fillStyle = '#FF0000';
            ctx.fillRect(gameState.food[0] * cellSize, gameState.food[1] * cellSize, cellSize, cellSize);
            
            // 更新分数
            scoreElement.textContent = gameState.score;
            highScoreElement.textContent = gameState.high_score;
            
            // 显示游戏结束
            gameOverElement.style.display = gameState.game_over ? 'block' : 'none';
        }
        
        // 键盘控制
        window.addEventListener('keydown', (e) => {
            if (!ws) return;
            
            let direction;
            switch(e.key) {
                case 'ArrowUp': direction = 'up'; break;
                case 'ArrowDown': direction = 'down'; break;
                case 'ArrowLeft': direction = 'left'; break;
                case 'ArrowRight': direction = 'right'; break;
                default: return;
            }
            
            ws.send(JSON.stringify({ action: 'direction', data: direction }));
        });
        
        // 重新开始游戏
        restartBtn.addEventListener('click', () => {
            if (ws) {
                ws.send(JSON.stringify({ action: 'restart' }));
            }
        });
        
        // 速度设置
        speedSlider.addEventListener('input', () => {
            const value = parseFloat(speedSlider.value).toFixed(1);
            speedValue.textContent = value + 'x';
            
            if (ws) {
                ws.send(JSON.stringify({ action: 'set_speed', data: value }));
            }
        });
        
        // 初始连接
        connectWebSocket();
    </script>
</body>
</html>"""
    
    async def handle_client(self, reader, writer):
        try:
            request = await reader.read(512)
            request = request.decode('utf-8')
            
            if not request:
                return
            
            # 解析请求的第一行
            first_line = request.split('\r\n')[0]
            parts = first_line.split()
            if len(parts) < 2:
                return
                
            method = parts[0]
            path = parts[1]
            
            # 检查WebSocket升级请求
            if 'Upgrade: websocket' in request and path == '/ws':
                # 解析Sec-WebSocket-Key
                key_line = [line for line in request.split('\r\n') 
                            if line.startswith('Sec-WebSocket-Key:')][0]
                key = key_line.split(': ')[1].strip()
                
                # 计算响应key
                import ubinascii, uhashlib
                accept_key = ubinascii.b2a_base64(
                    uhashlib.sha1(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11').digest()
                ).strip().decode()
                
                # 发送WebSocket握手响应
                response = (
                    "HTTP/1.1 101 Switching Protocols\r\n"
                    "Upgrade: websocket\r\n"
                    "Connection: Upgrade\r\n"
                    "Sec-WebSocket-Accept: " + accept_key + "\r\n\r\n"
                )
                await writer.awrite(response.encode())
                
                # 将客户端添加到列表
                self.game_state.clients.append(writer)
                print("新的WebSocket客户端连接")
                
                # 处理WebSocket消息
                while True:
                    try:
                        data = await reader.read(512)
                        if not data:
                            break
                            
                        # 解析WebSocket帧 (简化版)
                        opcode = data[0] & 0x0F
                        payload_len = data[1] & 0x7F
                        mask = data[2:6]
                        payload = data[6:6+payload_len]
                        
                        # 解掩码
                        decoded = bytearray()
                        for i in range(payload_len):
                            decoded.append(payload[i] ^ mask[i % 4])
                        
                        # 处理关闭帧
                        if opcode == 0x8:
                            break
                            
                        # 处理文本帧
                        if opcode == 0x1:
                            message = ujson.loads(decoded.decode())
                            if message['action'] == 'direction':
                                self.game_state.direction = message['data']
                            elif message['action'] == 'restart':
                                self.game_state.reset()
                            elif message['action'] == 'set_speed':
                                self.game_state.speed_factor = float(message['data'])
                    except Exception as e:
                        print("WebSocket错误:", e)
                        break
                
                # 客户端断开连接
                if writer in self.game_state.clients:
                    self.game_state.clients.remove(writer)
                print("WebSocket客户端断开")
                
            else:
                # 处理普通HTTP请求 - 重定向到游戏页面
                if path != '/':
                    # 如果是其他路径，重定向到首页
                    headers = "HTTP/1.1 302 Found\r\n"
                    headers += "Location: http://192.168.4.1/\r\n"
                    headers += "Connection: close\r\n\r\n"
                    await writer.awrite(headers.encode())
                else:
                    # 发送游戏页面
                    headers = "HTTP/1.1 200 OK\r\n"
                    headers += "Content-Type: text/html\r\n"
                    headers += "Connection: close\r\n\r\n"
                    await writer.awrite(headers.encode() + self.html.encode())
                
                await writer.drain()
                
        except Exception as e:
            print("处理客户端错误:", e)
        finally:
            writer.close()
            gc.collect()
    
    async def send_game_state(self, writer):
        try:
            # 准备游戏状态数据
            game_data = {
                'snake': self.game_state.snake,
                'food': self.game_state.food,
                'score': self.game_state.score,
                'high_score': self.game_state.high_score,
                'game_over': self.game_state.game_over
            }
            json_data = ujson.dumps(game_data)
            
            # 构建WebSocket帧
            frame = bytearray()
            frame.append(0x81)  # FIN + 文本帧
            if len(json_data) < 126:
                frame.append(len(json_data))
            else:
                frame.append(126)
                frame.extend(struct.pack('>H', len(json_data)))
            frame.extend(json_data.encode())
            
            # 发送数据
            await writer.awrite(frame)
        except Exception as e:
            print("发送游戏状态错误:", e)
            # 发生错误时移除客户端
            if writer in self.game_state.clients:
                self.game_state.clients.remove(writer)
    
    async def broadcast_game_state(self):
        if not self.game_state.clients:
            return
            
        # 准备游戏状态数据
        game_data = {
            'snake': self.game_state.snake,
            'food': self.game_state.food,
            'score': self.game_state.score,
            'high_score': self.game_state.high_score,
            'game_over': self.game_state.game_over
        }
        json_data = ujson.dumps(game_data)
        
        # 构建WebSocket帧
        frame = bytearray()
        frame.append(0x81)  # FIN + 文本帧
        if len(json_data) < 126:
            frame.append(len(json_data))
        else:
            frame.append(126)
            frame.extend(struct.pack('>H', len(json_data)))
        frame.extend(json_data.encode())
        
        # 向所有客户端广播
        for writer in self.game_state.clients[:]:  # 使用副本防止修改列表
            try:
                await writer.awrite(frame)
            except Exception as e:
                print("广播错误:", e)
                if writer in self.game_state.clients:
                    self.game_state.clients.remove(writer)
    
    async def run(self):
        # 修复：MicroPython的uasyncio没有serve_forever方法
        self.server = await asyncio.start_server(self.handle_client, "0.0.0.0", 80)
        print("Web服务器已启动 (端口 80)")
        
        # 创建一个任务来保持服务器运行
        while True:
            await asyncio.sleep(1)

# ================ 主循环 ================
async def main():
    try:
        # 设置AP
        ip = setup_ap()
        
        # 启动DNS服务器
        dns_server = DNSServer(ip)
        dns_task = asyncio.create_task(dns_server.run())
        
        # 初始化游戏状态
        game_state = GameState()
        
        # 启动Web服务器
        web_server = WebServer(game_state)
        server_task = asyncio.create_task(web_server.run())
        
        # 游戏主循环
        while True:
            # 更新游戏状态
            game_state.move()
            
            # 广播游戏状态
            if game_state.clients:
                await web_server.broadcast_game_state()
            
            # 控制游戏速度
            await asyncio.sleep_ms(game_state.get_speed())
            
            # 定期内存回收
            if game_state.get_speed() % 1000 == 0:
                mem_info()
                gc.collect()
                
    except Exception as e:
        sys.print_exception(e)
        print("主循环错误, 重启...")

# 启动程序
try:
    # 分配紧急异常缓冲区
    import micropython
    micropython.alloc_emergency_exception_buf(100)
    asyncio.run(main())
except Exception as e:
    sys.print_exception(e)
    print("致命错误, 重启设备...")

【雕爷学编程】MicroPython手册之 ESP8266 使用参考
雕爷学编程
09-25 2125
MicroPython的ESP8266使用参考，是一种可以在ESP8266芯片上运行的Python语言的功能，它可以用于开发物联网、智能家居、网络控制等应用。MicroPython的ESP8266使用参考的开发和调试工具是相对简单和原始的，并且需要一定的硬件和软件配置。它集成了一个32位的Tensilica处理器、标准的数字外设接口、天线开关、射频balun、功率放大器、低噪声放大器、滤波器和电源管理模块，仅需很少的外围电路，可以实现高度的集成和可靠性。非常适合各类物联网和智能硬件的开发。
物联网全栈开发实战系列文章汇总（共1261篇，持续更新-2025.08.01）
视觉与物联智能
04-27 1万+
物联网全栈开发实战专栏将涵盖各类单片机、嵌入式设备及驱动开发实例。从仿真到硬件，从单个实例到综合实例，从单个设备到多个设备的各种方式通信、联网等等。以实例为线索，从硬件到用户终端，掌握物联网全栈开发基础。.................................
ESP32s3-EYE ESP-IDF环境搭建Ubuntu18.04 Micropython环境搭建Pycharm 物联网
bale11guo的博客
05-30 3461
芯片采用ESP-WHO下的human-face-detection进行修改，将摄像机的拍摄画面实时在线传输到算法运行的终端进行心跳识别的运行，同时进行人脸识别。两者共同之下产生心跳数据和人脸识别结果。将两者合为数据库表项之后插入数据库当中。 同时，安装在使用者终端的APP能够实时获取到数据库中对应其输入ID的全部数据，根据需要进行本地的心率折线图绘制。 .....................
ESP8266—01S_联网五子棋创作
Eddie_66的博客
03-23 1067
引入ESP8266 WiFi库，用于实现WiFi连接和网络通信；定义GPIO0引脚，用于烧录模式控制。
ESP32_IDF_组件的总结
会选科技的博客
04-11 1539
所有支持ESP32-idf框架的组件，利用好可以不用再造轮子Page 1Multicast UDP service：提供本地网络服务和主机发现的多播UDP服务。Addressable LED Strip Driver：用于控制可寻址LED灯带（如WS2812等）的驱动程序。ESP Secure Cert Manager：ESP安全证书管理器，用于管理设备的安全证书。LVGL：轻量级且功能多样的图形库，适用于嵌入式系统的用户界面设计。
HTML & Web教程
热门推荐
weixin_45674624的博客
04-21 2万+
HTML & Web教程 1.HTML概述 a.网站是什么？ 举个例子： ​ 一个网站由很多网页组成，可以将多个网页放在一个文件夹中，这个文件夹还可以嵌套其它子文件夹，最终形成一个树状结构，如下图所示： ​ 如果我们给顶级目录 program 绑定一个域名 www.domain.com，那么用户就可以通过 www.domain.com 来访问 program 文件夹中的所有文件（包括子文件夹），例如： www.domain.com/demo.html www.domain.com/pyth
ESP32 单片机 MicroPython
qq_32381773的博客
05-29 1158
ESP32是一款功能强大的单片机，集成了双核处理器、Wi-Fi和蓝牙功能，适用于物联网（IoT）应用。它提供丰富的GPIO接口，支持多种通信协议，具有低功耗和高性能，广泛用于智能家居、传感器网络等项目。
ESP32 单片机 Arduino
qq_32381773的博客
05-29 2652
ESP32是一款功能强大的单片机，集成了双核处理器、Wi-Fi和蓝牙功能，适用于物联网（IoT）应用。它提供丰富的GPIO接口，支持多种通信协议，具有低功耗和高性能，广泛用于智能家居、传感器网络等项目。
仅凭一块ESP32主板，你能玩转的10个零成本创意项目（无需外设！）
GDBBader的博客
02-04 1606
即使只有一块ESP32主板，你仍然可以：✅ 学习GPIO控制✅ 掌握WiFi/蓝牙通信✅ 理解PWM/DAC原理✅ 开发微型物联网系统下一步行动任选本文中的一个项目，10分钟内完成代码烧录在评论区分享你的实验结果（如：“成功用GPIO4实现了触摸唤醒！”）当你准备好扩展时，只需一个5元的按钮或传感器，就能开启新世界！⚡ 现在就让你的ESP32结束吃灰生涯，立刻行动！资源推荐ESP32引脚速查表MicroPython文档无外设调试技巧视频。
【ESP8266_01s原理图精讲】：掌握模块内部工作机制
ESP8266_01s_Wi-Fi模块PCB图+原理图，元件库同样完整。](http://wiki.inford.net/objst/wiki/uxigzs9awq27872dnytusur4a0zvcq5m-Schematic_ESP-01_Sheet-1_20190905225312.png) # 摘要 本文详细介绍了ESP8266_01s...
ESP8266多模块协作：原理图中的通信协议深究
![ESP8266多模块协作：原理图中的通信协议深究]...ESP8266模块是一款集成了TCP/IP协议栈的Wi-Fi模块，它在物联网(IoT)领域
编程新手必看：LY-51S V2.3开发板最佳编程语言选择指南
本文介绍了LY-51S V2.3开发板及其编程环境的搭建，涵盖了支持的多种编程语言如C语言和Python，并重点阐述了这些语言在嵌入式开发中的应用。通过详细回顾C语言的基础语法、硬件操作控制、算法实现及模块化与库开发，...
Napping靶机渗透测试攻略
2301_77839771的博客
07-29 721
发现此处有个超级链接，点击后跳转到baidu.com。发现了我们输入的URL被嵌入了该页面并且作为跳转地址，而且target=_blank,表明是在新的地址跳转而且没有审核。在/var/www/html目录下放两个html文件，一个为站点首页(index.html)，一个为钓鱼界面(test.html)在kali上wget下载的网站首页文件为.php，需要重命名为.html。写好我们的钓鱼界面后我们开启监听，访问kali下的网页，需要开启http服务并在kali监听端口，监听的端口为钓鱼页面里链接的端口。
RAGFlow Agent 知识检索节点源码解析：从粗排到精排的完整流程
最新发布
澄南澄北的博客
08-01 752
文本检索：基于关键词匹配，擅长精确匹配和术语查找向量检索：基于语义相似度，擅长理解查询意图和同义词匹配Embedding 检索方法通过分别编码 Query 和 Chunk 得到向量，并用余弦相似度评估相关性。优点是可以提前计算Chunk的向量并存储，检索效率高、可大规模向量召回，适合在粗排阶段使用。但这种独立编码方式无法建模两者之间的语义交互。而 Rerank 模型会将 Query 和 Chunk 作为一个成对的输入，同时送入模型进行处理。
专业Python爬虫实战教程：逆向加密接口与验证码突破完整案例
ZTLJQ的博客
07-29 876
本文介绍了如何逆向分析并爬取一个采用JavaScript混淆和加密签名的内部测试系统API。主要步骤包括：1）分析网页结构，定位加密签名函数；2）使用Python还原JavaScript签名算法；3）实现验证码识别预处理；4）模拟登录流程获取会话；5）构造签名参数调用数据接口。案例综合运用了JavaScript逆向、加密算法还原、验证码识别等技术，通过requests.Session维护会话状态，最终实现了一个完整的自动化爬虫系统。
Redis 键值对操作详解：Python 实现指南
AI浩
07-29 1483
场景推荐操作替代方案添加小数据SETHSET（对象）添加大数据HSET/MSET分批次添加添加临时数据SETEX删除小数据DELETEUNLINK删除大数据UNLINK无批量操作管道 + MSET/UNLINK单独命令添加操作使用set()添加单个键值对使用mset()批量添加多个键值对使用setex()添加带过期时间的键值对删除操作优先使用unlink()进行删除（尤其大型数据）仅在需要立即释放内存时使用delete()批量删除时结合管道提高效率。
宝塔Python项目无法使用域名访问
少湖说
07-31 820
摘要：宝塔中部署的Flask项目无法通过IP/域名访问。排查发现：1) 阿里云安全组443端口已开放但连接被拒；2) 项目配置中host应为"0.0.0.0"而非"localhost"；3) Nginx反向代理错误地将请求转发至443端口（实际项目运行在50001端口）。解决方案：修改Nginx配置中的proxy_pass为http://127.0.0.1:50001，并确保外网映射正确对应内外端口。注意宝塔面板的端口映射功能可能不生效，需手动配置。（149字）
学习 java web 简单监听器
~
07-31 395
使用Java Servlet作为后端核心，配合监听器(Listener)实现应用生命周期管理，前端采用JSP进行动态页面渲染。核心功能包括通过Servlet处理HTTP请求，利用监听器监控ServletContext、Session和Request三种作用域对象的创建销毁及属性变更，实现资源管理和业务逻辑处理。项目中MyListener类实现了多种监听器接口，可捕获对象创建销毁事件及属性变化，为系统提供完善的监控能力。
unittest测试框架详解
xt1989288的博客
07-31 993
​ 单元测试是指，对软件中的最小可测试单元在与程序其他部分相隔离的情况下进行检查和验证的工作，这里的最小可测试单元通常是指函数或者类，一般是开发来做的，按照测试阶段来分，就是单元测试、集成测试、系统测试以及验收测试。
Micropython在ESP32上的固件开发与应用
资源摘要信息:...总之，ESP32与MicroPython的结合为嵌入式系统开发提供了一个强大而灵活的平台，使得开发过程更加简单、高效，同时也降低了嵌入式编程的门槛，使得更多的人能够参与到物联网项目的开发中来。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值