apo/micropython-workshop
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Lynn Ochs 2019-11-24 20:57:07 +01:00
commit 06531ce833
3 changed files with 459 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile Normal file
View File

@ -0,0 +1,2 @@
README.html: README.md template.html5
pandoc --toc -t html5 --template=template README.md > README.html

385
README.md Normal file
View File

@ -0,0 +1,385 @@
MicroPython Workshop
====================
Getting started
---------------
### Installing MicroPython
Get a recent build of Pycopy, a fork of MicroPython that we will be using for this workshop. A build of the current state as of 2019-11-24 is [here](firmware.bin).
Afterwards, get `esptool` and use it to flash your board:
``` sh
pip install esptool
esptool.py --port /dev/ttyUSB0 erase_flash
esptool.py --port /dev/ttyUSB0 --chip esp32 \
write_flash -z 0x1000 firmware.bin
```
You can now connect to your board's REPL with e.g. `screen` or `putty`:
``` sh
screen /dev/ttyUSB0 115200
```
You'll get a command prompt and be able to execute the first commands
``` python
help()
print("Hello, world")
```
A reference of all the default libraries can be found on [readthedocs.io](https://pycopy.readthedocs.io/en/latest/)
### File upload using `ampy`
You can use `ampy` to manage files from the CLI:
``` sh
pip install adafruit-ampy
export AMPY_PORT=/dev/ttyUSB0
# List files
ampy ls
# Print file contents
ampy get boot.py
# Save a file
ampy get boot.py boot.py
# Create some example file
echo "print('hello, world')" > hello.py
# Run a local file
ampy run hello.py
# Save it to the board
ampy put hello.py
# Delete it again
ampy rm hello.py
```
The contents of `boot.py` are run each time the controller resets. It may contain instructions for setting up your network connection, local time, peripherals, etc.
Hello, LED
----------
You can control the builtin LED, which is on pin 5:
``` python
from machine import Pin
led = Pin(5, Pin.OUT)
# The values are inverted, so this turns
# the LED on:
led.off()
# and this turns it off:
led.on()
# You can also use numbers or booleans:
led.value(False)
led.value(1)
```
### Brightness control with PWM
``` python
from machine import PWM
pwm = PWM(led)
# Read the frequency
pwm.freq()
# Set it
pwm.freq(20000)
# Read and set the duty cycle
pwm.duty()
pwm.duty(1023)
pwm.duty(512)
pwm.duty(0)
```
### Reserved pins
- UART: Pins 1 and 3 are TX/RX
- Flash: 6, 7, 8, 11, 16, 17. Messing with these will probably crash your program.
- 34-39 are input only and do not have pullups.
All other pins can be used for PWM.
Pins 2, 4, 12, 13, 14, 15 are connected the the micro-SD slot.
Digital and analog input
------------------------
Use `machine.Pin` for digital input
``` python
from machine import Pin
pin = Pin(4, Pin.IN)
pin.value()
# You can use pullups:
pin = Pin(4, Pin.IN, Pin.PULL_UP)
pin = Pin(4, Pin.IN, Pin.PULL_DOWN)
```
For analog input, use `machine.ADC`. By default, the ADC has an input range of 1.00 V, but this can be changed to up to 3.6 V. Available pins are 32 through 39.
``` python
from machine import Pin, ADC
pin = ADC(Pin(32, Pin.IN, None))
pin.read()
# You can set the resolution, it defaults to 12 bits
pin.width(ADC.WIDTH_10BIT)
pwm = machine.PWM(Pin(5, Pin.OUT))
while True:
pwm.duty(1023 - pin.read())
```
Timers
------
MicroPython on the ESP32 has virtual timers and 4 hardware timers. You can use a lot more virtual timers, but they are more prone to jitter. In either case, you can not allocate memory in a timer, as they are executed from an interrupt context.
Timers execute a callback, which takes the timer as an argument
``` python
from machine import Timer
import utime
# Create a virtual timer with ID -1.
# IDs >= 0 are hardware timers.
timer = Timer(-1)
data = [0] * 32
index = 0
def callback(timer):
global data, index
data[index] = utime.ticks_ms
index = (index + 1) % 32
# Run the callback once, after 100 ms
timer.init(mode = Timer.ONE_SHOT, period = 100, callback = callback)
# Run the callback every second
timer.init(period = 1000, callback = callback)
# After some time
print(data)
timer.deinit()
```
Files
-----
MicroPython has an internal filesystem that is stored after the firmware. You can access it in the usual way:
``` python
import os
os.listdir("/")
print( open("/boot.py").read() )
# Write to a file. Deletes existing content.
f = open("data.txt", "a")
f.write("Hello ")
f.close()
# Append
f = open("data.txt", "a")
f.write("world.\n")
f.close()
print(open("data.txt").read())
```
Sleep modes and power consumption
---------------------------------
When transmitting data to a WLAN, power consumption will be 160 - 260 mA (so use `WLAN.active(false)` when you don't need it). Even with a deactivated modem, the power consumption can still be up to 20 mA when the CPU is running.
### Idle
In idle mode, the CPU is paused but peripherals keep working.
``` python
import machine
# Enter idle mode indefinitely
machine.idle()
```
Execution continues when an interrupt happens, usually after a few milliseconds
### Light sleep
In light sleep, most of the microprocessor will be inactive. Power consumption will be at about 0.8 mA.
``` python
import machine
# Enter light sleep until the next interrupt
machine.lightsleep()
# Enter lightsleep until the next interrupt, but
# at most for one second
machine.lightsleep(1000)
```
### Deep sleep
In deep sleep, most of the RAM and all digital peripherals are turned off. Only the RTC and ULP co-processor stay active. Power consumption is about 10 uA. After deep sleep is exited, the ESP32 will reset.
``` python
import machine
# Same behaviour as with lightsleep
machine.deepsleep()
machine.deepsleep(10000)
# To further reduce power consumption, disable pullups:
p1 = machine.Pin(4, machine.Pin.IN, machine.Pin.PULL_HOLD)
```
After the reset, use `machine.reset_cause()` to check if we were in a deep sleep:
``` python
import machine
if machine.reset_cause() == machine.DEEPSLEEP_RESET:
print("Woke up from deep sleep")
```
### RTC
The RTC of the ESP32 is not only used to keep track of time, but can also save up to 2 kiB of data during deep sleep. This memory is still volatile, however, and will be deleted if you use the reset button or remove power
``` python
import machine
rtc = machine.RTC()
rtc.memory('some data')
rtc.memory()
```
Network
-------
To create or connect to a WLAN, we will use the `network` module.
### Creating a network
You can easily create a network with a DHCP server for any clients:
``` python
import network
wlan = network.WLAN(network.AP_IF)
wlan.config(essid = "micropython",
authmode = network.AUTH_WPA2_PSK,
password = "YELLOWSUBMARINE")
# You can look at some interface information:
# Address, subnet mask, gateway, DNS server.
# Pass in a tuple containing these values to
# set the information instead.
wlan.ifconfig()
```
### Connecting to an existing network
``` python
import network
wlan = network.WLAN(network.STA_IF)
# Activate the interface
wlan.active(True)
# Scan for visible networks
wlan.scan()
# Check connection status
wlan.isconnected()
# We are not connected. Change that
wlan.connect("micropython", "YELLOWSUBMARINE")
```
### TCP/UDP sockets
``` python
import usocket
# Create a TCP socket
tcp = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM)
# or UDP
udp = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM)
# Listen on a port and accept a connection from a client
address = usocket.getaddrinfo('0.0.0.0', 42)[0][-1]
tcp.bind(address)
tcp.listen()
conn, remote_address = tcp.accept()
# Connect to a server
address = usocket.getaddrinfo('192.168.4.1', 42)
tcp.connect(address)
# Write data
tcp.write(b"Hello\n")
# Receive data
conn.read(16)
conn.readline()
```
HTTP
----
### Requests
``` python
import urequests
urequests.get('https://hotspot.vodafone.de/api/v4/login?loginProfile=6')
```
### Server
First, we need to install `picoweb`
``` python
import upip
upip.install("picoweb")
upip.install("pycopy-ulogging")
```
This will automatically install `picoweb` and its dependencies into `/lib/` if you have an internet connection.
Now you can create simple websites.
``` python
import picoweb
app = picoweb.WebApp(__name__)
@app.route("/")
def index(request, response):
yield from picoweb.start_response(response)
yield from response.awrite("<html><body>Hello, world</body></html>")
app.run("0.0.0.0", 80, debug=True)
```
Next steps
----------
In no particular order:
- WebREPL
- Talking to peripherals with SPI, I2C, ...
- LED libraries for WS2812, APA102, ...
- Interrupt handlers
- Using the SD card
- Using `uselect` to handle multiple sockets
- Handling sensor data with `umqtt`

72
template.html5 Normal file
View File

@ -0,0 +1,72 @@
<!DOCTYPE html>
<html$if(lang)$ lang="$lang$"$endif$$if(dir)$ dir="$dir$"$endif$>
<head>
<meta charset="utf-8">
<meta name="generator" content="pandoc">
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
$for(author-meta)$
<meta name="author" content="$author-meta$">
$endfor$
$if(date-meta)$
<meta name="dcterms.date" content="$date-meta$">
$endif$
$if(keywords)$
<meta name="keywords" content="$for(keywords)$$keywords$$sep$, $endfor$">
$endif$
<title>$if(title-prefix)$$title-prefix$ – $endif$$pagetitle$</title>
<style type="text/css">code{white-space: pre;}</style>
$if(quotes)$
<style type="text/css">q { quotes: "“" "”" "‘" "’"; }</style>
$endif$
$if(highlighting-css)$
<style type="text/css">
body { background-color: white; }
div.sourceCode { background-color: #dddddd; padding: 0 0.5em; }
#content { background-color: #eeeeee; max-width: 40em; margin: auto; padding: 1em; }
$highlighting-css$
</style>
$endif$
$for(css)$
<link rel="stylesheet" href="$css$">
$endfor$
$if(math)$
$math$
$endif$
<!--[if lt IE 9]>
<script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
<![endif]-->
$for(header-includes)$
$header-includes$
$endfor$
</head>
<body>
<div id="content">
$for(include-before)$
$include-before$
$endfor$
$if(title)$
<header>
<h1 class="title">$title$</h1>
$if(subtitle)$
<p class="subtitle">$subtitle$</p>
$endif$
$for(author)$
<p class="author">$author$</p>
$endfor$
$if(date)$
<p class="date">$date$</p>
$endif$
</header>
$endif$
$if(toc)$
<nav id="$idprefix$TOC">
$toc$
</nav>
$endif$
$body$
$for(include-after)$
$include-after$
$endfor$
</div>
</body>
</html>