有了Python，还在学51？来看看MicroPython + ESP8266

本帖最后由 云贤 于 2017-7-19 15:08 编辑

开发MCU不止可以使用C，也可以使用Python，首先，需要到淘宝上花不到20元买一块ESP2866板，我在https://detail.tmall.com/item.htm?id=45493669633&spm=a1z09.2.0.0.1f30a53fFdBXTE&_u=foa0qq9def这家买的，可随意选择，哪家便宜买哪家。接着，需要会Python，如果不会，到网上找找教程，易上手。另外，MicroPython开源。
正文：
MicroPython ESP8266 development
1.硬件配置
到https://github.com/nodemcu/nodemcu-flasher中有烧录软件源代码，使用delphi编写，有兴趣可以看看，到Win32/Release中下载烧录软件ESP8266Flasher.exe，启动烧写程序，按照说明烧录esp8266-20170612-v1.9.1.bin
2. 软件配置安装完成后打开cmd终端，输入pip，然后输入pip install esptool3.调试按照官方说明，打开串口调试工具即可使用。http://docs.micropython.org/en/latest/esp8266/esp8266/quickref.html


General board control

The MicroPython REPL is on UART0 (GPIO1=TX, GPIO3=RX) at baudrate 115200. Tab-completion is useful to find out what methods an object has. Paste mode (ctrl-E) is useful to paste a large slab of Python code into the REPL.

The machine module:

import machinemachine.freq()          # get the current frequency of the CPUmachine.freq(160000000) # set the CPU frequency to 160 MHz

The esp module:

import espesp.osdebug(None)       # turn off vendor O/S debugging messagesesp.osdebug(0)          # redirect vendor O/S debugging messages to UART(0)


Networking

The network module:

import networkwlan = network.WLAN(network.STA_IF) # create station interfacewlan.active(True)       # activate the interfacewlan.scan()             # scan for access pointswlan.isconnected()      # check if the station is connected to an APwlan.connect('essid', 'password') # connect to an APwlan.config('mac')      # get the interface's MAC adddresswlan.ifconfig()         # get the interface's IP/netmask/gw/DNS addressesap = network.WLAN(network.AP_IF) # create access-point interfaceap.active(True)         # activate the interfaceap.config(essid='ESP-AP') # set the ESSID of the access point

A useful function for connecting to your local WiFi network is:

def do_connect():    import network    wlan = network.WLAN(network.STA_IF)    wlan.active(True)    if not wlan.isconnected():        print('connecting to network...')        wlan.connect('essid', 'password')        while not wlan.isconnected():            pass    print('network config:', wlan.ifconfig())

Once the network is established the socket module can be used to create and use TCP/UDP sockets as usual.

Delay and timing

Use the time module:

import timetime.sleep(1)           # sleep for 1 secondtime.sleep_ms(500)      # sleep for 500 millisecondstime.sleep_us(10)       # sleep for 10 microsecondsstart = time.ticks_ms() # get millisecond counterdelta = time.ticks_diff(time.ticks_ms(), start) # compute time difference


Timers

Virtual (RTOS-based) timers are supported. Use the machine.Timer class with timer ID of -1:

from machine import Timertim = Timer(-1)tim.init(period=5000, mode=Timer.ONE_SHOT, callback=lambda t:print(1))tim.init(period=2000, mode=Timer.PERIODIC, callback=lambda t:print(2))

The period is in milliseconds.

Pins and GPIO

Use the machine.Pin class:

from machine import Pinp0 = Pin(0, Pin.OUT)    # create output pin on GPIO0p0.on()                 # set pin to "on" (high) levelp0.off()                # set pin to "off" (low) levelp0.value(1)             # set pin to on/highp2 = Pin(2, Pin.IN)     # create input pin on GPIO2print(p2.value())       # get value, 0 or 1p4 = Pin(4, Pin.IN, Pin.PULL_UP) # enable internal pull-up resistorp5 = Pin(5, Pin.OUT, value=1) # set pin high on creation

Available pins are: 0, 1, 2, 3, 4, 5, 12, 13, 14, 15, 16, which correspond to the actual GPIO pin numbers of ESP8266 chip. Note that many end-user boards use their own adhoc pin numbering (marked e.g. D0, D1, ...). As MicroPython supports different boards and modules, physical pin numbering was chosen as the lowest common denominator. For mapping between board logical pins and physical chip pins, consult your board documentation.

Note that Pin(1) and Pin(3) are REPL UART TX and RX respectively. Also note that Pin(16) is a special pin (used for wakeup from deepsleep mode) and may be not available for use with higher-level classes like Neopixel.

PWM (pulse width modulation)

PWM can be enabled on all pins except Pin(16). There is a single frequency for all channels, with range between 1 and 1000 (measured in Hz). The duty cycle is between 0 and 1023 inclusive.

Use the machine.PWM class:

from machine import Pin, PWMpwm0 = PWM(Pin(0))      # create PWM object from a pinpwm0.freq()             # get current frequencypwm0.freq(1000)         # set frequencypwm0.duty()             # get current duty cyclepwm0.duty(200)          # set duty cyclepwm0.deinit()           # turn off PWM on the pinpwm2 = PWM(Pin(2), freq=500, duty=512) # create and configure in one go


ADC (analog to digital conversion)

ADC is available on a dedicated pin. Note that input voltages on the ADC pin must be between 0v and 1.0v.

Use the machine.ADC class:

from machine import ADCadc = ADC(0)            # create ADC object on ADC pinadc.read()              # read value, 0-1024


Software SPI bus

There are two SPI drivers. One is implemented in software (bit-banging) and works on all pins, and is accessed via the machine.SPI class:

from machine import Pin, SPI# construct an SPI bus on the given pins# polarity is the idle state of SCK# phase=0 means sample on the first edge of SCK, phase=1 means the secondspi = SPI(-1, baudrate=100000, polarity=1, phase=0, sck=Pin(0), mosi=Pin(2), miso=Pin(4))spi.init(baudrate=200000) # set the baudratespi.read(10)            # read 10 bytes on MISOspi.read(10, 0xff)      # read 10 bytes while outputing 0xff on MOSIbuf = bytearray(50)     # create a bufferspi.readinto(buf)       # read into the given buffer (reads 50 bytes in this case)spi.readinto(buf, 0xff) # read into the given buffer and output 0xff on MOSIspi.write(b'12345')     # write 5 bytes on MOSIbuf = bytearray(4)      # create a bufferspi.write_readinto(b'1234', buf) # write to MOSI and read from MISO into the bufferspi.write_readinto(buf, buf) # write buf to MOSI and read MISO back into buf


Hardware SPI bus

The hardware SPI is faster (up to 80Mhz), but only works on following pins: MISO is GPIO12, MOSI is GPIO13, and SCK is GPIO14. It has the same methods as the bitbanging SPI class above, except for the pin parameters for the constructor and init (as those are fixed):

from machine import Pin, SPIhspi = SPI(1, baudrate=80000000, polarity=0, phase=0)

(SPI(0) is used for FlashROM and not available to users.)

I2C bus

The I2C driver is implemented in software and works on all pins, and is accessed via the machine.I2Cclass:

from machine import Pin, I2C# construct an I2C busi2c = I2C(scl=Pin(5), sda=Pin(4), freq=100000)i2c.readfrom(0x3a, 4)   # read 4 bytes from slave device with address 0x3ai2c.writeto(0x3a, '12') # write '12' to slave device with address 0x3abuf = bytearray(10)     # create a buffer with 10 bytesi2c.writeto(0x3a, buf)  # write the given buffer to the slave


Deep-sleep mode

Connect GPIO16 to the reset pin (RST on HUZZAH). Then the following code can be used to sleep, wake and check the reset cause:

import machine# configure RTC.ALARM0 to be able to wake the devicertc = machine.RTC()rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP)# check if the device woke from a deep sleepif machine.reset_cause() == machine.DEEPSLEEP_RESET:    print('woke from a deep sleep')# set RTC.ALARM0 to fire after 10 seconds (waking the device)rtc.alarm(rtc.ALARM0, 10000)# put the device to sleepmachine.deepsleep()


OneWire driver

The OneWire driver is implemented in software and works on all pins:

from machine import Pinimport onewireow = onewire.OneWire(Pin(12)) # create a OneWire bus on GPIO12ow.scan()               # return a list of devices on the busow.reset()              # reset the busow.readbyte()           # read a byteow.writebyte(0x12)      # write a byte on the busow.write('123')         # write bytes on the busow.select_rom(b'12345678') # select a specific device by its ROM code

There is a specific driver for DS18S20 and DS18B20 devices:

import time, ds18x20ds = ds18x20.DS18X20(ow)roms = ds.scan()ds.convert_temp()time.sleep_ms(750)for rom in roms:    print(ds.read_temp(rom))

Be sure to put a 4.7k pull-up resistor on the data line. Note that the convert_temp() method must be called each time you want to sample the temperature.

NeoPixel driver

Use the neopixel module:

from machine import Pinfrom neopixel import NeoPixelpin = Pin(0, Pin.OUT)   # set GPIO0 to output to drive NeoPixelsnp = NeoPixel(pin, 8)   # create NeoPixel driver on GPIO0 for 8 pixelsnp[0] = (255, 255, 255) # set the first pixel to whitenp.write()              # write data to all pixelsr, g, b = np[0]         # get first pixel colour

For low-level driving of a NeoPixel:

import espesp.neopixel_write(pin, grb_buf, is800khz)


APA102 driver

Use the apa102 module:

from machine import Pinfrom apa102 import APA102clock = Pin(14, Pin.OUT)     # set GPIO14 to output to drive the clockdata = Pin(13, Pin.OUT)      # set GPIO13 to output to drive the dataapa = APA102(clock, data, 8) # create APA102 driver on the clock and the data pin for 8 pixelsapa[0] = (255, 255, 255, 31) # set the first pixel to white with a maximum brightness of 31apa.write()                  # write data to all pixelsr, g, b, brightness = apa[0] # get first pixel colour

For low-level driving of an APA102:

import espesp.apa102_write(clock_pin, data_pin, rgbi_buf)


DHT driver

The DHT driver is implemented in software and works on all pins:

import dhtimport machined = dht.DHT11(machine.Pin(4))d.measure()d.temperature() # eg. 23 (°C)d.humidity()    # eg. 41 (% RH)d = dht.DHT22(machine.Pin(4))d.measure()d.temperature() # eg. 23.6 (°C)d.humidity()    # eg. 41.3 (% RH)


WebREPL (web browser interactive prompt)

WebREPL (REPL over WebSockets, accessible via a web browser) is an experimental feature available in ESP8266 port. Download web client from https://github.com/micropython/webrepl (hosted version available at http://micropython.org/webrepl), and configure it by executing:

import webrepl_setup

and following on-screen instructions. After reboot, it will be available for connection. If you disabled automatic start-up on boot, you may run configured daemon on demand using:

import webreplwebrepl.start()

The supported way to use WebREPL is by connecting to ESP8266 access point, but the daemon is also started on STA interface if it is active, so if your router is set up and works correctly, you may also use WebREPL while connected to your normal Internet access point (use the ESP8266 AP connection method if you face any issues).

Besides terminal/command prompt access, WebREPL also has provision for file transfer (both upload and download). Web client has buttons for the corresponding functions, or you can use command-line client webrepl_cli.py from the repository above.