ESP32 Networking

1. ESP32 Networking
ESP32 se poate conecta la alte dispozitive fără fir, folosind Wi-Fi cu standardele IEEE 802.11
b/g/n (2.4 GHz) și Bluetooth , și aici este modul de lucru pentru Wi-Fi :
• STA (Stație)
• AP (Punct de Acces)
• Soft-AP ( ambele STA și AP )
Dar dacă acesta este conectat cu Ethernet ar necesita circuit Ethernet PHY de Emisie-recepție (
RMII Interface ) fi adăugate, cum ar fi LAN8720 sau TLK110 (10/100 Mbps) , etc. proba de
Bord ESP32 cu Ethernet/LAN Port , inclusiv
• ( ESP32-WROVER-B + IP101GRI de Emisie-recepție )
• (ESP32-WROOM + LAN8720A de Emisie-recepție)
• (ESP32 bazate pe WT32-S1 Wi-SoC + LAN8720A de emisie-recepție)

Pentru ESP32 legătură cu Wi-Fi ar fi mai simplu și mai convenabil, și apoi vom programa
aparatul ESP32 rulează în modul STA și conectat la echipament, Wi-Fi Punct de Acces sau Router
în rețea, WLAN , și, astfel, poate fi conectat la Internet.
Dacă ESP32 lucra în modul de AP , sau Soft-AP , acesta permite altor dispozitive să se conecteze
prin Wi-Fi în ESP32 , am putea vedea exemple de utilizare, ESP32 de lucru într-un asemenea mod
și servește ca o Lumină-greutate Server Web built-in cu a face, alte calculatoare pot fi conectate
prin Wi-Fi pentru a ESP32 și utilizatorul poate deschide un Browser Web pentru a introduce pe
pagina web a ESP32 , așa cum este folosit în setările dispozitivului, prin intermediul web, sau
pentru a vizualiza starea anumit sistem, etc.
O altă opțiune atractivă pentru ESP32 este o comunicare fără fir într-un format numit , fără a fi
nevoie de a utiliza Wi-Fi Infrastructura , dar utilizați un Peer-to-Peer și în prezent, putem folosi
pur micro-Python.

2. ESP32 Wi-Fi de Scanare

Începe prima probă cu scanarea pentru echipamente sau rețea fără fir, Wi-Fi fără a fi nevoie pentru
a face ESP32 activat în modul STA înainte și poate folosi comanda de la biblioteca network
Urmează de scanare repetate la nesfârșit, și, dacă doriți pentru a opri sau a ieși, apăsați Ctrl+C în
fereastra Shell Interactiv de REPL

import network
import utime as time

# open WiFi interface in STA mode

wifi = network.WLAN( network.STA_IF )

# activate the WiFi interface (if_up)

wifi.active( True )

print ('Press Ctrl+C to stop WiFi scanning...')

try:
 while True:
# scan WiFi
scan_results = wifi.scan()
# print scan results (a list of tuples)
print(60*'=')
for ap in scan_results:
print( ap )
print(60*'-')
except KeyboardInterrupt:
print('Terminated...')
# deactivate the WiFi interface
wifi.active(False)

Când scanarea în rețea, Wi-Fi gratuit informații pentru fiecare dintre dispozitive a fost găsit va
include nume de referință în legătură ( SSID ), numărul de dispozitive ( adresa MAC ), canal,
frecvență ( Canal ), valorile măsura puterea semnalului recepționat ( RSSI ), modul de criptare
pentru securitate ( Modul de Autentificare ), și nu ascunde numele de SSID-ul ( Ascunse ),
respectiv.
Să vedem un exemplu de cod scris micro Python este folosit pentru scanarea în rețea Wi-Fi din
apropiere, și apoi converti rezultatul la un format de date JSON , cum ar fi numele de afișare, SSID
cod mașină (Adresa MAC) modul de setări de securitate ( Modul de Autentificare ), și un canal,
etc.

import network
import ujson as json

param_names = ['essid','mac','channel','rssi','authmode','hidden']

authmodes = ['OPEN','WEP','WPA-PSK',
'WPA2-PSK','WPA/WPA2-PSK','MAX']

def mac_bytes_to_hex_str( mac_bytes ):

return ':'.join(['%02X' % x for x in mac_bytes])

def convert_to_json( found_list ):

results = {'count': len(found_list), 'found_list': []}
for ap in found_list:
pairs = dict(zip(param_names,ap))
for name in pairs:
value = pairs.get(name)
if type(value)==bytes:
if name=='mac' and len(value)==6:
value = mac_bytes_to_hex_str( value )
else:
value = value.decode('ascii')
else:
try:
value = int(value)
if name=='authmode' and 0 <= value <= 5:
 value = authmodes[value]
except (ValueError, TypeError):
pass
pairs[name] = value
results['found_list'].append( pairs )
return results# open WiFi interface in STA mode

# activate the WiFi interface

wifi = network.WLAN( network.STA_IF )
wifi.active(True)
# scan WiFi and get the results as a list of tuples
scan_results = wifi.scan()
# deactivate the WiFi interface
wifi.active(False)
# convert a list of tuples to json data
results = convert_to_json( scan_results )

if results.get('count') > 0:
for item in results.get('found_list'):
print( json.dumps(item) ) # show JSON string
else:
print( 'No WiFi found')

3. Conexiune Wi-Fi în Modul STA

Pentru a vă conecta la rețeaua Wi-Fi modul STA , va trebui să specificați numele SSID și parola (
Password ) pentru conectarea la dispozitive wireless cum ar fi Punctul de Acces fără Fir / Ruter
exemplu următorul cod
În acest exemplu, sunt create function nume connect_wifi() Pentru utilizarea în conexiune
Wi-Fi (STA Mode) , atunci când a alerga, va trebui să specificați argumentul este o structură de
date dicționar referit de variabila WIFI_CFG Celebrul membrii ‘ssid’ Și ‘pwd’ Respectiv,
deci setați valoarea corect atunci când sunt instalate
Când a apela această funcție și se poate conecta cu succes pentru a avea valoarea returnată este un
obiect care nu este None และเราก็สามารถใชค ้ ำสั ่ง wifi.ifconfig() Pentru a vizualiza informații
despre conexiunile la rețea, cum ar fi numărul de IP-primirea ( adresa IP ) numărul de adresa IP a
dispozitivului, Gateway , etc.

import network
import utime as time

# Specify the SSID and password of your WiFi network

WIFI_CFG = { 'ssid': "XXXXXX", 'pwd': "XXXXXXXXX" }

def connect_wifi( wifi_cfg, max_retries=10 ):

# use WiFi in station mode (not AP)
wifi_sta = network.WLAN( network.STA_IF )
# activate the WiFi interface (up)
wifi_sta.active(True)
 # connect to the specified WiFi AP
wifi_sta.connect( wifi_cfg['ssid'], wifi_cfg['pwd'] )
retries = 0
while not wifi_sta.isconnected():
retries = retries + 1
if retries >= max_retries:
return None
time.sleep_ms(500)
return wifi_sta

# try to connect the network

wifi = connect_wifi( WIFI_CFG )

if wifi is None:
print( 'WiFi connection failed' )
else:
ipaddr, netmask, gateway, dns = wifi.ifconfig()
print("============================")
print("IP address :", ipaddr)
print("Net mask :", netmask)
print("Gateway :", gateway)
print("DNS server :", dns)
print("----------------------------")

4. Wi-Fi în Modul AP + Simplu HTTP Server

Următorul exemplu demo pentru a activa Wi-Fi mode, AP stil , Deschis (fără protecție cu parolă),
pentru a construi și rula funcția start_wifi_ap() Apoi, când ESP32 funcționează ca un Wi-Fi
AP , apoi (nu va fi adresa IP meci 192.168.4.1 Și alegeți canalul numărul 11) a fost de
asemenea creat, și a alerga funcția. start_web_server() Să fie capabil să lucreze ca un
Server Web ( protocol HTTP ) ușor de arată mesaj ca o pagină web.
În acest exemplu, dacă se dorește, se termina lucrarea de Server Web , vom folosi cum să verificați
apăsând butonul, așa că trebuie să fie pe ciclu, apăsați externe Active-Low și selectați pin de
utilizare GPIO23 ca date de intrare pentru buton

import network
import utime as time
import usocket as socket
from machine import Pin

AP_CFG = { 'essid': 'MyAP', # SSID for your AP

'authmode': network.AUTH_OPEN, 'channel': 11, }

def start_wifi_ap( ap_cfg ):

# open WiFi in AP mode
ap = network.WLAN( network.AP_IF )
# activate AP interface (up)
ap.active(True)
# configure the AP interface
 try:
ap.config( **ap_cfg )
except Exception as ex:
print ( 'Cannot set AP configuration...' )
if ap.active():
return ap
else:
return False

def start_web_server( btn=None ):

global sock
# create a socket (STREAM TCP socket) for network connection
sock = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
# set socket option: reuse address
sock.setsockopt( socket.SOL_SOCKET, socket.SO_REUSEADDR, 1 )
# use socket in non-blocking mode
sock.setblocking( False )
# get the server address (localhost)
addr = socket.getaddrinfo('0.0.0.0',80)[0][-1]
# bind the socket to port 80 (HTTP)
sock.bind( addr )
# listen for an incoming connection
sock.listen(1)
while True:
try:
# waiting for connection
conn,addr = sock.accept()
except OSError:
if btn and btn.value()==0: # check button
sock.close() # close socket
break # break the loop
else:
continue
# read incoming request data
request = conn.recv(1024)
print( 'Content = %s' % str(request) )
# send HTML as response
html = '<html><head></head><body>'
html += '<h1>Welcome to ESP32...</h1><br>'
html += '<b>Client from {}<b><br>'.format(str(addr))
html += '</body></html>'
conn.send( html ) # send HTML response
conn.close() # close HTTP connection
time.sleep_ms(10)

sock = None
ap = start_wifi_ap( AP_CFG )
ipaddr = ap.ifconfig()[0]
print ( 'IP address:', ipaddr ) # 192.168.4.1

BTN_GPIO = const(23) # use GPIO23 for push button

btn = Pin( BTN_GPIO, Pin.IN, Pin.PULL_UP )
try:
start_web_server( btn ) # start web server
except KeyboardInterrupt:
pass
finally:
if sock:
sock.close()
ap.active(False) # turn off WiFi AP

Dacă se va schimba de la Open a fost stabilit de codul de protecție cum să WPA2-PSK este
configurat pentru Configurare după cum se arată după cum urmează:
AP_CFG = { 'essid': 'MyAP', 'password': 'YOUR_STRONG_PASSWORD',
'authmode': network.AUTH_WPA2_PSK, 'channel':11, }

5. Obtinerea Data și Ora De pe Server NTP

Următorul exemplu demo de activare ESP32 modul STA și să vă conectați la Wi-Fi AP poate fi
conectat la Internet și de a folosi comanda ntptime.settime() Să se conecteze la un
calculator de pe Internet, care acționează ca Server NTP și actualizare ora curentă pentru
performanța circuitului de la RTC (Ceas de Timp Real) a ESP32

import network
import utime as time
import ntptime
import machine

# Specify the SSID and password of your WiFi network

WIFI_CFG = { 'ssid': "XXXX", 'pwd': "XXXXXXX" }

def connect_wifi( wifi_cfg ):

wifi_sta = network.WLAN( network.STA_IF )
wifi_sta.active(True)
wifi_sta.connect( wifi_cfg['ssid'], wifi_cfg['pwd'] )
while not wifi_sta.isconnected():
time.sleep(1.0)
print(wifi_sta.ifconfig())

def sync_ntp():
while True:
try:
# synchronize RTC with NTP server
ntptime.settime()
break
except OSError:
print('NTP server: connection timeout...')
connect_wifi( WIFI_CFG )
sync_ntp()

rtc = machine.RTC()
tm = rtc.datetime() # get current RTC datetime (now)
tz_offset = +7 # timezone offset (GMT+7)
hh, mm, ss = (tm[4]+tz_offset) % 24, tm[5], tm[6]
print( 'Time: {}:{}:{}'.format( hh, mm, ss ) )
y, m, d = tm[0], tm[1], tm[2]
print( 'Date: {}-{:02d}-{:02d}'.format( y, m, d ) )

6. HTTP GET: Obtinerea Datetime Folosind API WorldTime

Următorul exemplu demo de activare ESP32 modul STA și să vă conectați la Wi-Fi AP poate fi
conectat la Internet și solicită informații Cerere HTTP / Metoda GET pentru
, care este un furnizor de informații despre data și ora curentă time zone ( fus Orar ), care figurează
informațiile primite înapoi va fi în formă de Șir JSON

import network
import utime as time
import ujson as json
import urequests as requests

URL = "http://worldtimeapi.org/api/timezone/Asia/Bangkok"

# Specify the SSID and password of your WiFi network

WIFI_CFG = { 'ssid': "XXXX", 'pwd': "XXXXXXX" }

def connect_wifi( wifi_cfg, max_retries=10 ):

# use WiFi in station mode (not AP)
wifi_sta = network.WLAN( network.STA_IF )
# activate the WiFi interface (up)
wifi_sta.active(True)
# connect to the specified WiFi AP
wifi_sta.connect( wifi_cfg['ssid'], wifi_cfg['pwd'] )
retries = 0
while not wifi_sta.isconnected():
retries = retries + 1
if retries >= max_retries:
return None
time.sleep_ms(500)
return wifi_sta

def get_worldtime_data( url ):

resp = requests.get( url )
if resp.status_code==200: # request ok
try:
data = json.loads(resp.text)
except Exception as ex:
print ('JSON data error...' )
 return
print( 'Timezone:', data['timezone'] )
print( 'Epoch time (Jan 1, 1970):', int(data['unixtime']) )
print( 'UTC datetime:', data['utc_datetime'] )
print( 'Local datetime:', data['datetime'] )
print( 'UTC offset (hours):', data['utc_offset'] )
print( 'UTC offset (seconds):', int(data['raw_offset']) )
else:
print ('HTTP request error...')

# try to connect the network

wifi = connect_wifi( WIFI_CFG )
if wifi is not None:
get_worldtime_data( URL )
else:
print('No WiFi connection')

Eșantionul de ieșire.
Timezone: Asia/Bangkok Epoch time (Jan 1, 1970): 1609939805 UTC
datetime: 2021-01-06T13:30:05.138524+00:00 Local datetime: 2021-
01-06T20:30:05.138524+07:00 UTC offset (hours): +07:00 UTC offset
(seconds): 25200

7. HTTPS OBȚINE: Thailanda COVID-19 Actualizare de Stare

Următorul exemplu de demonstrație pentru a prelua informații despre un pacient COVID-19 în

Thailanda cu cât HTTPS OBȚINE de la API-ul de web.
informațiile vor fi sub formă de Șir JSON

import network
import utime as time
import urequests as requests

URL = "https://covid19.th-stat.com/api/open/today"

# Specify the SSID and password of your WiFi network

WIFI_CFG = { 'ssid': "XXXX", 'pwd': "XXXXXXX" }
WIFI_CFG = { 'ssid': "esl_ap", 'pwd': "cnch2687" }

COVID19_NAMES = [
('Confirmed', u'ยอดผูป ้ ่ วยสะสม'),
('Recovered', u'ผูป ้ ่ วยรักษาหายแลว้ '),
('Hospitalized', u'ผูป ้ ่ วยรักษาตัวในโรงพยาบาล'),
('Deaths', u'ผูเ้ สียชีวต ิ สะสม'),
('NewConfirmed', u'ผูป ้ ่ วยตรวจพบเพิ่มวันนี้ '),
('NewRecovered', u'ผูป ้ ่ วยรักษาหาย'),
('NewDeaths', u'ผูเ้ สียชีวต ิ วันนี้ '),
 ('UpdateDate', u'อัปเดตลา่ สุด') ]

def get_covid19_data( url ):

data = None
try:
resp = requests.get( url )
data = resp.json()
for name in COVID19_NAMES[:-1]:
if name[0] in data:
value = str(data[name[0]])
print('{}:\t\t\t\t{}'.format(name[1],value) )
name = COVID19_NAMES[-1]
update = data[ name[0] ]
print( '{}: {}'.format(name[1], update) )
except Exception as ex:
print('error:', ex)
return data

def connect_wifi( wifi_cfg ):

wifi_sta = network.WLAN( network.STA_IF )
wifi_sta.active(True)
wifi_sta.connect( wifi_cfg['ssid'], wifi_cfg['pwd'] )
while not wifi_sta.isconnected():
time.sleep(1.0)
print(wifi_sta.ifconfig())

connect_wifi( WIFI_CFG )
import gc
gc.collect()
get_covid19_data( URL )

Exemplu de text de ieșire.

ยอดผูป
้ ่ วยสะสม: 9331 ผูป ้ ่ วยรักษาหายแล้ว: 4418 ผูป ้ ่ วยรักษาตัวในโรงพยาบาล: 4847 ผูเ้ สียชีวต ิ
สะสม: 66 ผูป ่ ้
้ ่ วยตรวจพบเพิมวันนี : 365 ผูป ้ ่ วยรักษาหาย: 21 ผูเ้ สียชีวต ้
ิ วันนี : 1 อัปเดตลา่ สุด:
06/01/2021 12:25

8. Obtinerea de Aer de Calitate și Date Meteorologice din AirVisual

Următorul exemplu afișează informații despre vreme și indicele de calitate a aerului din , care
folosesc cum să comunice cu HTTPS tema de , compania va trebui date înapoi ca Date JSON
Pentru a rula REST API, în acest caz, va trebui să aibă Cheia API , va trebui să se înregistreze
pentru a utiliza prin selectarea gratuit ( Comunitate ) și specificați un loc sau Locație (în acest
exemplu, este Mueang Nonthaburi, Thailanda)

import sys
import network
import ujson as json
import utime as time
import urequests as requests

JSON_CONFIG_FILE = 'config.json'
AIRVISUAL_URL = 'https://api.airvisual.com/v2/city'

config = {}
try:
with open( JSON_CONFIG_FILE ) as json_file:
config = json.load(json_file)
except OSError as ex:
print('Cannot open JSON file')
sys.exit(-1)

sta_if = network.WLAN( network.STA_IF )

sta_if.active( True )

sta_if.connect( config['ssid'], config['pwd'] )

while not sta_if.isconnected():
time.sleep(1.0)
# show IP address assigned by DHCP server
#print( 'Connected:', sta_if.ifconfig()[0] )

# Fetch JSON data by using the AirVisual API

url_template = AIRVISUAL_URL + '?city={}&state={}&country={}&key={}'
url = url_template.format(
'Mueang%20Nonthaburi',
'Nonthaburi',
'Thailand',
config['airvisual_api_key'] )

resp = None
try:
resp = requests.get( url )
except OSError:
print('Cannot fetch data')

if resp and resp.status_code == 200: # OK

json_data = resp.json()
if json_data['status'] == 'success':
data = json_data['data']
location = (data['state'],data['city'],data['country'])
polution = data['current']['pollution']
us_aqi = polution['aqius']
ts = polution['ts'] # '2020-05-19T02:00:00.000Z'
weather = data['current']['weather']
tp = weather['tp'] # temperature (deg.C)
hu = weather['hu'] # humidity (%)
pr = weather['pr'] # pressure (mBar or hPa)
print('Location: {}, {}, {}'.format(*location) )
print( 'US AQI : {}'.format(us_aqi) )
 print(('Temperature : {} deg.C\n' +
'Humidity : {} %RH\n' +
'Pressure : {} mBar').format(tp,hu,pr))
else:
print (resp.reason)

În lucrările de acest cod trebuie să aibă un fișier config.json Care a salvat în MicroPython de
Stocare Flash , și cu text, JSON , în funcție de caracteristicile după cum urmează:
{ "ssid": "XXXXXXX", "pwd": "XXXXXXXXX", "airvisual_api_key":
"XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" }

Exemplu de text de ieșire sunt după cum urmează:

Location: Nonthaburi, Mueang Nonthaburi, Thailand US AQI : 126
Temperature : 29 deg.C Humidity : 55 %RH Pressure : 1011 mBar

9. Obtinerea Datelor Meteorologice de la OpenWeatherMap

OpenWeatherMap ( ) oferă API pentru a trage de date cu Protocolul HTTP/HTTPS (

previzualizare folosind API și date eșantion în formă de un JSON de la
https://openweathermap.org/current)

Utilizatorii vor trebui să mă abonez înainte de a îl puteți folosi gratuit (dar există restricții și condiții
de utilizare), pentru a obține APPID care este un text cu număr hexazecimal de 32 de cifre
În acest exemplu, vom prelua date climatice și selectați aduce arata doar temperatura (
Temperatura ), umiditatea relativă a aerului ( Umiditate Relativă ) și de presiune a aerului (
Presiune ) și selectați un oraș, o provincie, Nonthaburi, Thailanda ( Nonthaburi, RO ), apoi să fie
redat ca o ieșire de text prin intermediul REPL

import sys
import network
import ujson as json
import utime as time
import urequests as requests

# URL for openweathermap

API_URL = 'https://api.openweathermap.org/data/2.5/weather'

JSON_CONFIG_FILE = 'config.json'

config = {}
try:
with open( JSON_CONFIG_FILE ) as json_file:
config = json.load(json_file)
except OSError as ex:
print('Cannot open JSON file')
sys.exit(-1)

sta_if = network.WLAN( network.STA_IF )

sta_if.active( True )
sta_if.connect( config['ssid'], config['pwd'] )
while not sta_if.isconnected():
time.sleep(1.0)

#########################################################

def get_weather_data( APPID, city ):

results = {}
url = API_URL+'?units=metric&APPID='+APPID+'&q='+city
try:
data = requests.get(url).json()
except OSError:
print ('Cannot get data from OpenWeatherMap..')
return results
code = data.get('cod')
#print( json.dumps(data) )
if code == 200: # response OK
city = data['name']
results['p'] = data['main']['pressure'] # hPa
results['t'] = data['main']['temp'] # deg.C
results['h'] = data['main']['humidity'] # %
elif code == 401:
print('Error Code:', code)
print( data['message'] )
return results

city_name = 'Mueang Nonthaburi, TH'

weather_data = {
't': (' - Temperature :','deg.C'),
'h': (' - Humidity :','%RH'),
'p': (' - Pressure :','hPa'), }

appid = config['openweather_appid']
results = get_weather_data( appid, city_name )
print( city_name ) # show city name
for key in weather_data:
name, unit = weather_data[key]
value = results[key]
print('{} {} {}'.format(name,value,unit) )

În lucrările de acest cod trebuie să aibă un fișier config.json Care a salvat în MicroPython de
Stocare Flash , și cu text, JSON , în funcție de caracteristicile după cum urmează:
{ "ssid": "XXXXXXX", "pwd": "XXXXXXXXX", "openweather_appid":
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" }
Exemplu de text de ieșire sunt după cum urmează:
Mueang Nonthaburi, TH - Temperature : 29.53 deg.C - Pressure :
1011 hPa - Humidity : 54 %RH
10. Obtinerea de Date privind Calitatea Aerului din Air4Thai

Următorul exemplu demo-ul pentru a trage de informații despre calitatea aerului din Bangkok, de la
web eu folosesc HTTP GET , apoi aduce unele date care este de Date JSON face ca text de ieșire
pentru a REPL . În acest exemplu, selectate de stații de monitorizare cu ID-ul Stației meci
bkp95t Care este Bang sue distinct al Bangkok.

import sys
import network
import ujson as json
import utime as time
import urequests as requests

STATION_ID = 'bkp95t'
API_URL = 'http://air4thai.pcd.go.th/services/getNewAQI_JSON.php'

JSON_CONFIG_FILE = 'config.json'

config = {}
try:
with open( JSON_CONFIG_FILE ) as json_file:
config = json.load(json_file)
except OSError as ex:
print('Cannot open JSON file')
sys.exit(-1)

sta_if = network.WLAN( network.STA_IF )

sta_if.active( True )
sta_if.connect( config['ssid'], config['pwd'] )
while not sta_if.isconnected():
time.sleep(1.0)

#########################################################
def get_air4thai_data( url, station_id ):
try:
api_url = url + '?stationID=' + station_id
json_data = requests.get(api_url).json()
except OSError:
print ('Cannot get data from air4thai...')
return results
#print( json.dumps(data) )
station = json_data['areaEN']
print( 'Station: {}'.format(station) )
data = json_data['LastUpdate']
print( 'Last update:', data['date'], data['time'] )
print( 'PM25:', data['PM25']['value'], data['PM25']['unit'] )
print( 'AQI:', data['AQI']['aqi'] )

get_air4thai_data( API_URL, STATION_ID )

Exemplu de text de ieșire sunt după cum urmează:
Station: Bang Sue, Bangkok Last update: 2021-01-06 00:00 PM25: 41
µg/m³ AQI: 63

11. Trimiterea mesajelor notificate via LINIE Notifica API

Un alt exemplu de văzut este de a oferi un dispozitiv de tip microcontroler pentru IoT poate trimite
un mesaj de notificare sau Chat Mesaj pentru utilizator LINIA App folosind un serviciu numit
, care a început de la anul. Fri 2016
Dacă să-l folosească, utilizatorul va trebui să mergeți la setări aplicații prin intermediul paginii web
pentru a obține Token de Acces și de a folosi
• Fac pas Autentifici folosind adresa de email și parola , și apoi confirmați prin LINIA App
pe Smartphone-ul
Du-te la meniu
•
• Apăsați Genera Token în secțiunea numită " a Genera un jeton de acces (Pentru
dezvoltatori)"
• Atunci nu va fi o fereastră Pop-up , introduceți informațiile de care au nevoie pentru a
specifica Token Nume (numele care apare atunci când trimiterea de date la LINIE ) și
alegeți dacă doriți să trimiteți mesaje de Chat de grup, LINIE care utilizatorul le-a creat,
sau sunt într-un grup, sau de a trimite proprii de a selecta "1-la-1 de chat cu LINIE
notifica" , apoi apăsați Genera Token
5. Atunci când există o potrivire, și de a crea un Token , apoi, în pagina Pagina în secțiunea
numită " servicii conexe " va lista o conexiune La (nume, Simbol Nume , în funcție de
setul), La (numele grupului de linie selectat, sau numele de cont de utilizator în sine).
Pentru a trimite un mesaj la LINIA Notifica API va folosi HTTPS POST Metodă prin
specificarea URL-ul ca
și, în parte, HTTPS Antet va trebui să specificați 'Authorization' Cu 'Bearer '
Împreună cu Token de Acces
Mostre de cod pentru micro Python proces cu ESP32 sunt după cum urmează, și ca un experiment
pentru a trimite mesaje ca valoare este specificată, temperatura și umiditatea în casă (ca un exemplu
RPG)

import utime as time

import ujson as json
import usocket as socket
import ussl as ussl
import network
import urllib.parse

JSON_CONFIG_FILE = 'config.json'

config = {}
try:
with open( JSON_CONFIG_FILE ) as json_file:
config = json.load(json_file)
except OSError as ex:
print('Cannot open JSON file')
sys.exit(-1)

sta_if = network.WLAN( network.STA_IF )

sta_if.active( True )

sta_if.connect( config['ssid'], config['pwd'] )

while not sta_if.isconnected():
print('waiting for Wi-Fi connection')
time.sleep(1.0)

#########################################################
def https_post( url, headers={}, data='' ):
proto, _, host, path = url.split("/", 3)
assert( proto == 'https:' )
port = 443

if headers is None:
headers = {}
required_headers = {
'Host' : host,
'User-Agent' : 'MicroPython',
'Cache-Control' : 'no-cache',
'User-Agent' : 'MicroPython',
'Content-Type' : 'application/x-www-form-urlencoded' }
for key in required_headers.keys():
if key not in headers:
headers[key] = required_headers[key]

# get address info of the host machine

ai = socket.getaddrinfo( host, port, 0, socket.SOCK_STREAM )[0]
# create a secure socket
s = socket.socket( ai[0], ai[1], ai[2] )
s.connect(ai[-1])
s.settimeout(2.0)
s = ussl.wrap_socket(s, server_hostname=host)
# write header lines
s.write(b'POST /%s HTTP/1.1\r\n' % path)
for k in headers:
s.write(k)
s.write(b': ')
s.write(headers[k])
s.write(b'\r\n' )
s.write( b'Content-Length: %d\r\n' % (len(data)) )
s.write( b'\r\n' )
# write data
s.write(data)

# receive the response from the server

status_code = 0
eof_count = 0
 resp_text = ''
while True:
try:
line = s.readline().decode().strip()
if line == '':
eof_count += 1
if eof_count >= 2:
break
if line.startswith( 'HTTP' ):
status_code = line.split(' ')[1]
elif line.startswith('{') and eof_count==1:
resp_text += line
except OSError:
break
s.close()
return (status_code, resp_text)

#########################################################

token = config['line_notify_token']
msg = {'message': u'ในบา้ น อุณหภูมิ 27.5 °C ความชื้น 55.7%'}
headers = {'Authorization' : 'Bearer %s' % token}
data = '{}={}'.format( 'message', urllib.parse.quote(msg['message']) )
url = 'https://notify-api.line.me/api/notify'
status_code, resp_text = https_post( url, headers, data )
if status_code == '200':
print( resp_text )

Datele utilizate pentru configurarea Wi-Fi gratuit și Acces la LINIA de Token-ul este stocat în
fișier config.json În Fișier Flash de Stocare a dispozitivului micro-Python exemplu
{ "ssid": "my_wifi_ssid", "pwd": "my_wifi_password",
"line_notify_token":
"sSVjJ3qoX17pdw5UETGfi3EhLxaCzTxxxxxxxxxxxx" }
Când trimiteți un mesaj la LINIA Notifica Serviciul va mesajul de răspuns este un Șir JSON , dacă
funcționează corect, va primi un text
{"status":200,"message":"ok"}
Imagine: exemplu de mesaj primit pe telefon inteligent
Dar dacă se blochează sunt au un mesaj, ca în cazul în care nu este specificat, Autorizația în
secțiunea Antet de HTTPS POST
{"status":401,"message":"Missing authorization header"}
Sau dacă se specifică Token de Acces nu este valid, acesta va avea un mesaj
{"status":401,"message":"Invalid access token"}
Notat: în primul rând, utilizarea textului este în limba engleză,
care este salvat ca UTF-8 și când va fi exportat folosind HTTPS
POST , deci trebuie să convertiți datele înainte de a utiliza
comanda urllib.parse.quote()
Așa că va trebui să se instaleze biblioteca urllib.parse Of
se poate face cu ușurință în MicroPython REPL folosind comanda
upip Următoarele (și munca de MicroPython în ESP32 trebuie să se
conecteze vreodată la Wi-Fi cu succes).
>>> import upip
>>> upip.install('urllib.parse')
Și va trebui să descărcați fișierele ( . tar.gz ) aferente de pe
web micropython.org apoi să le puneți în /lib
Se găsește o problemă: dar folosiți biblioteca urllib.parse Va
găsi o modalitate de a rezolva o este de a șterge fișierul. re.py
Și ffilib.py Apoi, apăsați Ctrl+D pentru a începe din nou
activitatea de MicroPython.

Instalarea de bibliotecă
prin intermediul REPL de
Thonny IDE
Ne putem folosi de
biblioteca
Care este un modul cu
built-in pentru micro-
Python și de a folosi
comanda
urequests.post()
Pentru trimiterea de date
cu POST , dar din
încercați să utilizați
LINIA Notifica API a constatat că a comis o greșeală în a primi date de reacție ( Răspuns ), dar a
primit un mesaj pe LINIA App
import network
import sys
import ujson as json
import urllib.parse
import urequests as requests

JSON_CONFIG_FILE = 'config.json'

config = {}
try:
with open( JSON_CONFIG_FILE ) as json_file:
config = json.load(json_file)
except OSError as ex:
print('Cannot open JSON file')
sys.exit(-1)

sta_if = network.WLAN( network.STA_IF )

sta_if.active( True )

sta_if.connect( config['ssid'], config['pwd'] )

while not sta_if.isconnected():
print('waiting for Wi-Fi connection')
time.sleep(1.0)

#########################################################

token = config['line_notify_token']
url = 'https://notify-api.line.me/api/notify'
msg = {'message': u'ในบา้ น อุณหภูมิ 29.8 °C ความชื้น 69.0%' }
headers = {'Authorization' : 'Bearer %s' % token,
'Content-Type' : 'application/x-www-form-urlencoded' }
data = '{}={}'.format( 'message', urllib.parse.quote(msg['message']) )
try:
resp = requests.post( url, headers=headers, data=data )
print(resp.status_code, resp.text)
except Exception as ex:
print(ex)

12. Verificați conexiunile în rețea cu Ping

Următorul exemplu demonstrativ, verificați conexiunea cu un calculator sau un dispozitiv din
rețea folosind comanda ping , care trimite un pachet bazat pe tipare ICMP (Internet Control
Message Protocol)
Imagini: structura, IPv4 Pachete ICMP (Sursa: Wikipedia)
Următorul exemplu de cod adaptate la codul ( Micro-Ping pentru MicroPython ), care au
împărțit-o în https://gist.github.com/shawwwn/91cc8979e33e82af6d99ec34c38195fb

import network
import utime as time
import ujson as json

########################################################

def checksum(data): # CRC16

if len(data) % 2 == 1:
data += b'\x00'
chksum = 0
for pos in range(0, len(data), 2):
hi_byte = data[pos]
lo_byte = data[pos + 1]
chksum += (hi_byte << 8) + lo_byte
while chksum >= 0x10000:
chksum = (chksum & 0xffff) + (chksum >> 16)
chksum = ~chksum & 0xffff
return chksum

def ping(host, count=4, timeout=5000,

interval=10, quiet=False, size=64):
import utime
import uselect
import uctypes
import usocket
import ustruct
import urandom

# prepare packet
assert( (size >= 16), "packet size too small")
assert( (size <= 1000), "packet size too big")
pkt = b'Q'*(size)
pkt_desc = {
"type" : uctypes.UINT8 | 0,
"code" : uctypes.UINT8 | 1,
"checksum" : uctypes.UINT16 | 2,
"id" : uctypes.UINT16 | 4,
"seq" : uctypes.INT16 | 6,
"timestamp": uctypes.UINT64 | 8,
} # packet header descriptor
h = uctypes.struct( uctypes.addressof(pkt),
pkt_desc, uctypes.BIG_ENDIAN )
h.type = 8 # ICMP_ECHO_REQUEST
h.code = 0
h.checksum = 0
h.id = urandom.getrandbits(16)
h.seq = 1
# init socket
sock = usocket.socket(usocket.AF_INET, usocket.SOCK_RAW, 1)
sock.setblocking(0)
sock.settimeout(timeout/1000.0)
addr = usocket.getaddrinfo(host, 1)[0][-1][0] # ip address
sock.connect((addr, 1))
if not quiet:
print("PING %s (%s): %u data bytes" % (host, addr, len(pkt)))
seqs = list(range(1, count+1))
c=1
t=0
n_trans = 0
n_recv = 0
finish = False
while t < timeout:
if t==interval and c<=count:
# send packet
h.checksum = 0
h.seq = c
 h.timestamp = utime.ticks_us()
h.checksum = checksum(pkt)
if sock.send(pkt) == size:
n_trans += 1
t = 0 # reset timeout
else:
seqs.remove(c)
c += 1

# recv packet
while True:
socks,_,_ = uselect.select([sock],[],[],0)
if socks:
# receive incoming packet as response
resp = socks[0].recv(1024)
# create a memoryview object
resp_mv = memoryview(resp)
h2 = uctypes.struct(uctypes.addressof(resp_mv[20:]),
pkt_desc, uctypes.BIG_ENDIAN)
# validate checksum
calc_chksum = checksum(bytes(resp_mv[24:]))
chksum = ustruct.unpack("!H", resp_mv[22:24])[0]
chksum_ok = chksum == calc_chksum
assert chksum_ok, 'Checksum failed...'

seq = h2.seq
if h2.type==0 and h2.id==h.id and (seq in seqs): # 0: ICMP_ECHO_REPLY
t_elasped = (utime.ticks_us()-h2.timestamp) / 1000
ttl = ustruct.unpack('!B', resp_mv[8:9])[0] # time-to-live
n_recv += 1
if not quiet:
args = (len(resp), addr, seq, ttl, t_elasped)
print("{} bytes from {}: icmp_seq={}, ttl={}, time={:.1f} ms".format(*args))
seqs.remove(seq)
if len(seqs) == 0:
finish = True
break
else:
break
if finish:
break
utime.sleep_ms(1)
t += 1
# close
sock.close()
 ret = (n_trans, n_recv)
if not quiet:
args = (n_trans, n_recv)
print("{} packets transmitted, {} packets received".format(*args))
return (n_trans, n_recv)

########################################################
JSON_CONFIG_FILE = 'config.json'

config = {}
try:
with open( JSON_CONFIG_FILE ) as json_file:
config = json.load(json_file)
except OSError as ex:
print('Cannot open JSON file')
sys.exit(-1)

sta_if = network.WLAN( network.STA_IF )

sta_if.active( True )

sta_if.connect( config['ssid'], config['pwd'] )

while not sta_if.isconnected():
print('waiting for Wi-Fi connection')
time.sleep(1.0)

ping('8.8.8.8',count=5, timeout=5000, interval=200,

quiet=False, size=44)
########################################################
Exemplu de text de ieșire
PING 8.8.8.8 (8.8.8.8): 44 data bytes 64 bytes from 8.8.8.8:
icmp_seq=1, ttl=112, time=139.7 ms 64 bytes from 8.8.8.8:
icmp_seq=2, ttl=112, time=64.4 ms 64 bytes from 8.8.8.8:
icmp_seq=3, ttl=112, time=150.3 ms 64 bytes from 8.8.8.8:
icmp_seq=4, ttl=112, time=61.7 ms 64 bytes from 8.8.8.8:
icmp_seq=5, ttl=112, time=158.2 ms 5 packets transmitted, 5
packets received

Încheiat
Am văzut exemple de limbaj de codificare, micro-Python pentru ESP32 să se conecteze la o rețea
fără fir prin Wi-Fi și poate utiliza un Protocol, cum ar fi HTTP/HTTPS .