esp8266-01S学习笔记

识别不到设备

CH340SER安装

vscode 安装插件

Pymakr

安装

pip install esptool

或是用git安装

git clone https://github.com/espressif/esptool.git

将

#删除flash(COM?取决于你电脑识别的COM口来决定)(prowershell)
esptool -p COM? erase_flash

esptool --port COM? --baud 460800 write_flash --flash_size=detect 0 esp8266-1m-20210202-v1.14.bin

esp8266-1m-20210202-v1.14.bin
失效的话请看这个

查看代码是否上传

import os
os.listdir()

点亮esp8266-01s上的led

import machine
led = machine.Pin(2,machine.Pin.OUT)

led闪烁

import machine
import time

led = machine.Pin(2,machine.Pin.OUT)

def run():
    led.value(1)
    time.sleep(5)
    led.value(0)
    time.sleep(5)

import machine
import time

led = machine.Pin(2,machine.Pin.OUT)

def run():
    for i in range(5):
        led.value(1)
        time.sleep(2)
        led.value(0)
        time.sleep(2)
if __name__ == '__main__':
    # print("hello is is main")
    run()

可是使用上面的Run file on device来运行此程序

连接网络

import network
import machine

def connect():
    led = machine.Pin(2,machine.Pin.OUT)
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    # print(wlan.scan())
    print(wlan.isconnected())
    if not wlan.isconnected():
        print("connecting to network...")
        led.value(1)
        wlan.connect('your wifi name','your wifi password')
        while not wlan.isconnected():
            pass
    print("network config:",wlan.ifconfig())
    led.value(0) 

if __name__ == '__main__':
    connect()

network模块主要功能如下

import network
 
wlan = network.WLAN(network.STA_IF) # 创建一个WLAN实例  create station interface
wlan.active(True)       # 激活实例 activate the interface
wlan.scan()             # 扫描WIFI  scan for access points
wlan.isconnected()      # 判断WIFI连接否, 返回布尔值  check if the station is connected to an AP
wlan.connect('essid', 'password') # 连接WIFI  connect to an AP
wlan.config('mac')      # 获取实例的MAC地址 get the interface's MAC address
wlan.ifconfig()         # 获取实例的网络信息  get the interface's IP/netmask/gw/DNS addresses
 
ap = network.WLAN(network.AP_IF) # 创建一个AP实例 create access-point interface
ap.config(essid='ESP-AP') #  配置实例的essid参数 set the ESSID of the access point
ap.config(max_clients=10) # 设定多少个客户端可以连接它 set how many clients can connect to the network
ap.active(True)         # 激活实例 activate the interface

连接ip里的api(http形式)

import network
from machine import Pin 
import urequests

def connect():
    led = Pin(2,Pin.OUT)
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    # print(wlan.scan())
    print(wlan.isconnected())
    if not wlan.isconnected():
        print("connecting to network...")
        led.value(1)
        wlan.connect('your wifi name','your wifi password')
        while not wlan.isconnected():
            pass
    print("network config:",wlan.ifconfig())
    led.value(0) 

def linkHttpIp():
    connect()
    r = urequests.get('http://124.223.18.34:5555/')
    print(r.text)
    

if __name__ == '__main__':
    # connect()
    linkHttpIp()

ImportError: no module named ‘urequests’

urequests下载地址
如果失效或者不能访问，请复制下面的代码到自己创建的urequests.py空文件里面

#urequests.py
import usocket


class Response:
    def __init__(self, f):
        self.raw = f
        self.encoding = "utf-8"
        self._cached = None

    def close(self):
        if self.raw:
            self.raw.close()
            self.raw = None
        self._cached = None

    @property
    def content(self):
        if self._cached is None:
            try:
                self._cached = self.raw.read()
            finally:
                self.raw.close()
                self.raw = None
        return self._cached

    @property
    def text(self):
        return str(self.content, self.encoding)

    def json(self):
        import ujson

        return ujson.loads(self.content)


def request(
    method,
    url,
    data=None,
    json=None,
    headers={},
    stream=None,
    auth=None,
    timeout=None,
    parse_headers=True,
):
    redirect = None  # redirection url, None means no redirection
    chunked_data = data and getattr(data, "__iter__", None) and not getattr(data, "__len__", None)

    if auth is not None:
        import ubinascii

        username, password = auth
        formated = b"{}:{}".format(username, password)
        formated = str(ubinascii.b2a_base64(formated)[:-1], "ascii")
        headers["Authorization"] = "Basic {}".format(formated)

    try:
        proto, dummy, host, path = url.split("/", 3)
    except ValueError:
        proto, dummy, host = url.split("/", 2)
        path = ""
    if proto == "http:":
        port = 80
    elif proto == "https:":
        import ussl

        port = 443
    else:
        raise ValueError("Unsupported protocol: " + proto)

    if ":" in host:
        host, port = host.split(":", 1)
        port = int(port)

    ai = usocket.getaddrinfo(host, port, 0, usocket.SOCK_STREAM)
    ai = ai[0]

    resp_d = None
    if parse_headers is not False:
        resp_d = {}

    s = usocket.socket(ai[0], usocket.SOCK_STREAM, ai[2])

    if timeout is not None:
        # Note: settimeout is not supported on all platforms, will raise
        # an AttributeError if not available.
        s.settimeout(timeout)

    try:
        s.connect(ai[-1])
        if proto == "https:":
            s = ussl.wrap_socket(s, server_hostname=host)
        s.write(b"%s /%s HTTP/1.0\r\n" % (method, path))
        if not "Host" in headers:
            s.write(b"Host: %s\r\n" % host)
        # Iterate over keys to avoid tuple alloc
        for k in headers:
            s.write(k)
            s.write(b": ")
            s.write(headers[k])
            s.write(b"\r\n")
        if json is not None:
            assert data is None
            import ujson

            data = ujson.dumps(json)
            s.write(b"Content-Type: application/json\r\n")
        if data:
            if chunked_data:
                s.write(b"Transfer-Encoding: chunked\r\n")
            else:
                s.write(b"Content-Length: %d\r\n" % len(data))
        s.write(b"Connection: close\r\n\r\n")
        if data:
            if chunked_data:
                for chunk in data:
                    s.write(b"%x\r\n" % len(chunk))
                    s.write(chunk)
                    s.write(b"\r\n")
                s.write("0\r\n\r\n")
            else:
                s.write(data)

        l = s.readline()
        # print(l)
        l = l.split(None, 2)
        if len(l) < 2:
            # Invalid response
            raise ValueError("HTTP error: BadStatusLine:\n%s" % l)
        status = int(l[1])
        reason = ""
        if len(l) > 2:
            reason = l[2].rstrip()
        while True:
            l = s.readline()
            if not l or l == b"\r\n":
                break
            # print(l)
            if l.startswith(b"Transfer-Encoding:"):
                if b"chunked" in l:
                    raise ValueError("Unsupported " + str(l, "utf-8"))
            elif l.startswith(b"Location:") and not 200 <= status <= 299:
                if status in [301, 302, 303, 307, 308]:
                    redirect = str(l[10:-2], "utf-8")
                else:
                    raise NotImplementedError("Redirect %d not yet supported" % status)
            if parse_headers is False:
                pass
            elif parse_headers is True:
                l = str(l, "utf-8")
                k, v = l.split(":", 1)
                resp_d[k] = v.strip()
            else:
                parse_headers(l, resp_d)
    except OSError:
        s.close()
        raise

    if redirect:
        s.close()
        if status in [301, 302, 303]:
            return request("GET", redirect, None, None, headers, stream)
        else:
            return request(method, redirect, data, json, headers, stream)
    else:
        resp = Response(s)
        resp.status_code = status
        resp.reason = reason
        if resp_d is not None:
            resp.headers = resp_d
        return resp


def head(url, **kw):
    return request("HEAD", url, **kw)


def get(url, **kw):
    return request("GET", url, **kw)


def post(url, **kw):
    return request("POST", url, **kw)


def put(url, **kw):
    return request("PUT", url, **kw)


def patch(url, **kw):
    return request("PATCH", url, **kw)


def delete(url, **kw):
    return request("DELETE", url, **kw)

使用urequest(我这里urequest存放路径是根目录/urequests/urequests.py所以我这里是urequests.urequests,as是取别名，如果是与main.py同级的urequests.py就上传和引入import urequests就行)

urequests/urequests.py的取名所以是urequests.urequests调用

import network
from machine import Pin 
import urequests.urequests as request

def connect():
    led = Pin(2,Pin.OUT)
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    # print(wlan.scan())
    print(wlan.isconnected())
    if not wlan.isconnected():
        print("connecting to network...")
        led.value(1)
        wlan.connect('your wifi name','your wifi password')
        while not wlan.isconnected():
            pass
    print("network config:",wlan.ifconfig())
    led.value(0) 

def linkHttpIp():
    connect()
    r = request.get('http://124.223.18.34:5555/') #这是我自己的服务器可能会过期，这个连接输出的是'hello this is node api'是正确的(之后可能会改)
    print(r.text)
    

if __name__ == '__main__':
    # connect()
    linkHttpIp()

POST请求

以上案例都是get请求

import network  #链接网络
from machine import Pin #esp8266-01s引脚
import urequests.urequests as request#网络请求，自己移植，上面有写
import ujson #json格式

def connect():
    led = Pin(2,Pin.OUT)
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    # print(wlan.scan())
    print(wlan.isconnected())
    if not wlan.isconnected():
        print("connecting to network...")
        led.value(1)
        wlan.connect('your wifi name','your wifi password')
        while not wlan.isconnected():
            pass
    print("network config:",wlan.ifconfig())
    led.value(0) 

def linkHttpIp():
    connect()
    post_data = ujson.dumps({"name":"chen","isvip":"false"}) #定义发生json数据格式(name,isvip固定,当然之后添加其他的也不会有错)
    # r = request.get('http://124.223.18.34:5557/') 
    r = request.post('http://124.223.18.34:5557/postCookie',data=post_data)#自己的服务器，之后业务可能会没有，按照自己的服务器(电脑)来,当然不能是localhost或者127.0.0.1
    print(r.text)
    

if __name__ == '__main__':
    # connect()
    linkHttpIp()

效果如下(仅供参考):

这个字符串是我通过md5进行加密的