giovedì 31 dicembre 2020

MQTT publisher sistema di test del protocollo MQTT

 Chi non volesse costruire il device come trattato negli articoli precedenti, ma avesse comunque necessita' di veder funzionare il sistema basato sui pacchetti di messaggi MQTT, puo' sempre far girare un software sul pc che simula il device stesso e che fornisce messaggi sul broket MQTT necessari.

Per questi test ho scelto il broker messo a disposizione dal progetto Eclipse che potete trovare qui 

Per far questo, sempre attraverso il progetto Eclipse ho trovato un codice che con poche righe consente di inviare messaggi ad un qualsiasi broker MQTT ad intervalli regolari

Utilizzando sempre il sitema Linux su WSL in Windows, nella mia shell, sempre nella cartella mqtt_client, ho creato un nuovo file chiamato publisher.py che crea una connessione con il broker MQTT, ed invia una serie di messaggi sul topic scelto ( nel mio caso TecnoGeppetto/topic

publisher.py

import paho.mqtt.client as mqtt
import time

def on_connect(client, userdata, flags, rc):
    print(f"Connected with result code {rc}")
    
client = mqtt.Client()
client.on_connect = on_connect
client.connect("broker.emqx.io", 1883, 60)

# send a message to the TecnoGeppetto/topic every 10 second, 50 times in a row
for i in range(50):
    # the four parameters are topic, sending content, QoS and whether retaining the message respectively
    client.publish('TecnoGeppetto/topic', payload=i, qos=0, retain=False)
    print(f"send {i} to TecnoGeppetto/topic")
    time.sleep(1)

client.loop_forever()

Quindi, su un sistema sul quale gira python 3 e sul quale e' installata la libreria paho.mqtt.client bastera' chiamare python3 publisher.py per ottenere una serie di 50 messaggi ogni 10 secondi pubblicati sul broker pubblico scelto sul topic preferito (nel caso del codice in oggetto, sul topic  TecnoGeppetto/topic

Naturalmente i messaggi potranno essere ricevuto su un'altra shell sulla quale gira il software subcriber, descritto nel post precedente.


Buon divertimento 

TecnoGeppetto




Client MQTT subscriber e publisher per linux - Raspberry Pi

 A seguire gli esperimenti di questi giorni, oggi mi sono dedicato alla configurazione su linux di un sistema per leggere i messaggi inviati dal sensore. Ho cercato un client MQTT che potesse essere utilizzato da linea di comando ed ho trovato e configurato questo che adesso decrivero'.


Ho trovato il progetto Eclipse che fa al caso mio, hanno sviluppato una libreria disponibile su github per la gestione delle comunicazioni con un broker MQTT che si chiama paho che risolve la maggior parte dei problemi e consente con 4 righe di codice  di ottenere cio' di cui ho bisogno.

I passi necessari per far funzionare tutto sono questi:

su linux ( io per praticita' utilizzo una shell linux in WSL su windows, perche' in questo periodo sto usando un pc con windows) creo la mia direttory di progetto che ho chiamato mqtt_client 


quindi entro nella cartella appena creata con 


quindi creo il file che conterra' il codice del programma MQTT client subscriber


edito il contenuto del file con i dati del mio broker MQTT pubblico  scelto.

file  subscribe.py:

# subscribe.py
import paho.mqtt.client as mqtt

def on_connect(client, userdata, flags, rc):
    print(f"Connected with result code {rc}")
    # subscribe, which need to put into on_connect
    # if reconnect after losing the connection with the broker, it will continue to subscribe to the raspberry/topic topic
    client.subscribe("TecnoGeppetto/topic")

# the callback function, it will be triggered when receiving messages
def on_message(client, userdata, msg):
    print(f"{msg.topic} {msg.payload}")
    
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

# set the will message, when the system is powered off, or the network is interrupted abnormally, it will send the will message to other clients
client.will_set('TecnoGeppetto/status', b'{"status": "Off"}')

# create connection, the three parameters are broker address, broker port number, and keep-alive time respectively
client.connect("broker.emqx.io", 1883, 60)

# set the network loop blocking, it will not actively end the program before calling disconnect() or the program crash
client.loop_forever()

Naturalmente per far funzionare tutto sulla distribuzione linux che ho scelto e' presente python 3.xx, se non lo fosse e' necessario installarlo  assieme a pip3 che servira' per installare la libreria di cui si fa       l' import nel codice.

sudo apt install python3

poi

pip3 install paho-mqtt

A questo punto per far girare il client in ricezione sui topic scelti nel codice ( nel caso qui pubblicato TecnoGeppetto/topic  , basta chiamare 



Nel caso di problemi di connesisone il sistema rende un codice di errore, questa di seguito e' la legenda dei possibili codici

0: connection succeeded
1: connection failed - incorrect protocol version
2: connection failed - invalid client identifier
3: connection failed - the broker is not available
4: connection failed - wrong username or password
5: connection failed - unauthorized
6-255: undefined
If it is other issues, you can check the network situation, or check whether `paho-mqtt` has been installed.


Naturalmente il topic da scegliere deve essere lo stesso sul quale trasmette il sensore, in modo da poter regolarmente ricevere il messaggio trasmesso ogni volta dal sensore.


Buon divertimento 

TecnoGeppetto




mercoledì 30 dicembre 2020

ESP32 ESP8266 pubblica da DHT11 temperatura ed umidita' su un broker MQTT

 Conseguenza naturale degli ultimi due progetti (gli ultimi due post pubblicati!) e' quella di pubblicare su di un broker MQTT i dati rilevati da un sensore DHT11 di temperatura ed umidita' rilevata.
Il circuito e' come il precedente: 

  • Un ESP32 od un ESP8266 (il codice funziona su entrambi)
  • un sensore DHT11
  • alimentazione 3,3volt o 5 volt 
  • un broker MQTT disponibile


Collegato il sensore al Pin 14 del ESP8266 (quello contrassegnato con le lettere D5 sul circuito) (attenzione per ESP32 in pin e' diverso), non resta altro che creare la connessione con il router per l'accesso ad internet.
Creare la connessione con il broker.
Effettuare la lettura del dato dal sensore.
Inviare la lettura come contenuto del messaggio verso il broker MQTT.

Il sistema si mette in ascolto su un topic di notifica, costruito ad hoc per confermare al device la corretta lettura del dato dal lato del ricevitore ( mi immagino un sistema che pubblica su un display il valore della temperatura ricevuta, oppure una dashboard che riceve piu' sensori e ne grafica i dati ricevuti). Nel caso che la conferma di ricezione non arrivi per oltre 1 ora, il sistema si resetta e ricarica il firmware dall'inizio, ricominciando con nuove connessioni ecc....

boot.py:

# TecnoGeppetto
# Sistema MQTT con esp8266 / esp32
# Legge la temperatura da DHT11 e invia a sever Mosquitto
# 
# ESP#1
# 
import time
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp
esp.osdebug(None)
import gc
gc.collect()
import webrepl
import dht
from machine import Pin

ssid = "XXXXXXXXXXXXXXXXXXXXXX"
password = "XXXXXXXXXXXXXX"
mqtt_server = 'XXXXXXXXXXXXXXXXXXX'
#EXAMPLE IP ADDRESS
#mqtt_server = '192.168.1.144'
client_id = ubinascii.hexlify(machine.unique_id())
topic_sub = b'TecnoGeppetto/notifica'
topic_pub = b'TecnoGeppetto/temp'

sensor = dht.DHT11(Pin(14)) #il pin al quale e' collegato il sensore DHT11

last_message = 0
message_interval = 5   #intervallo tra i messaggi
last_start = time.time()
start_interval = 3600  # intervallo tra le conferme di ricezione da parte del sistema
counter = 0

station = network.WLAN(network.STA_IF)

station.active(True)
station.connect(ssid, password)

while station.isconnected() == False:
  pass

print('Connection successful')
print(station.ifconfig())
webrepl.start()


main.py:

### ESP #1

def sub_cb(topic, msg):
  print((topic, msg))
  if topic == b'TecnoGeppetto/notifica' and msg == b'OK':
    print('ESP Ha ricevuto la Temperatura!')
    last_start = time.time()                 #azzero contatore del reset

def connect_and_subscribe():
  global client_id, mqtt_server, topic_sub
  client = MQTTClient(client_id, mqtt_server)
  client.set_callback(sub_cb)
  client.connect()
  client.subscribe(topic_sub)
  print('Connected to %s MQTT broker, subscribed to %s topic' % (mqtt_server, topic_sub))
  return client

def restart_and_reconnect():
  print('Failed to connect to MQTT broker. Reconnecting...')
  time.sleep(10)
  machine.reset()
  
def get_temp():             #legge la temperatura dal sensore DHT11
  sensor.measure()
  temp = sensor.temperature()
  hum = sensor.humidity()
  return [temp,hum]


try:
  client = connect_and_subscribe()
except OSError as e:
  restart_and_reconnect()

while True:
  try:
    client.check_msg()
    if (time.time() - last_message) > message_interval:
      temp=get_temp()
      msg = b"N. "+str(counter)+" Temperatura. "+str(temp[0])+" Umidita. "+str(temp[1])
      client.publish(topic_pub, msg)
      last_message = time.time()
      counter += 1
    if (time.time() - last_start) > start_interval:     #se e' passato piu di start_interval dall ultima conferma di ricezione
      restart_and_reconnect()                             #resetto la scheda e riconnetto
  except OSError as e:
    restart_and_reconnect()



Con il codice sopra il sensore comincia a pubblicare i valori letti dal sensore DHT11 sul topic TecnoGeppetto/temp, e si mette in ascolto sul topic TecnoGeppetto/notifica 

Buon divertimento
TecnoGeppetto




martedì 29 dicembre 2020

ESP8266 e MQTT con MicroPython, connessione e primi vagiti

 Dopo aver domato i mostriciattoli ESP8266  ed ESP32 come visto nei post precedenti, oggi mi sono cimentato nella pubblicazione di dati con il protocollo MQTT.
Il sistema lo avevo testato per la prima volta durante un corso che ho fatto quest'anno, in sonstanza e' molto semplice, un server dove gira il software Mosquitto, riceve messaggi da un nodo e li "gira" a tutti i nodi che sono in ricezione su un determinato "topic".

Il sistema che ho testato si compone di due ESP8266, uno che si preoccupa di inviare un messaggio su uno specifico "topic" ed ascolta invece un topic diverso attraverso il quale ricevera' la notifica di ricezione dall'altro nodo (un suo fratello ESP8266). L'altro ovviamente, ricevera' sul canale di trasmissione del primo, e  trasmettera' su quello di ricezione del primo. in maniera di avere un sistema che trasmette un messaggio su un canale e riceve ok di ricezione su un altro. 


Quindi il codice per il primo ESP8266 sara' il seguente:

boot.py

# TecnoGeppetto
# Sistema MQTT con esp8266 / esp32
#
# ESP#1
# 
import time
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp
esp.osdebug(None)
import gc
gc.collect()
import webrepl


ssid = "XXXXXXXXXXXXXXXX"
password = "XXXXXXXXXXXXXXX"
mqtt_server = 'XXXXXXXXXXXXXXX'
#EXAMPLE IP ADDRESS
#mqtt_server = '192.168.1.144'
client_id = ubinascii.hexlify(machine.unique_id())
topic_sub = b'TecnoGeppetto/notifica'
topic_pub = b'TecnoGeppetto/ciao'

last_message = 0
message_interval = 5
counter = 0

station = network.WLAN(network.STA_IF)

station.active(True)
station.connect(ssid, password)

while station.isconnected() == False:
  pass

print('Connection successful')
print(station.ifconfig())
webrepl.start()
    

main.py

# ESP #1

def sub_cb(topic, msg):
  print((topic, msg))
  if topic == b'TecnoGeppetto/notifica' and msg == b'received':
    print('ESP received hello message')

def connect_and_subscribe():
  global client_id, mqtt_server, topic_sub
  client = MQTTClient(client_id, mqtt_server)
  client.set_callback(sub_cb)
  client.connect()
  client.subscribe(topic_sub)
  print('Connected to %s MQTT broker, subscribed to %s topic' % (mqtt_server, topic_sub))
  return client

def restart_and_reconnect():
  print('Failed to connect to MQTT broker. Reconnecting...')
  time.sleep(10)
  machine.reset()

try:
  client = connect_and_subscribe()
except OSError as e:
  restart_and_reconnect()

while True:
  try:
    client.check_msg()
    if (time.time() - last_message) > message_interval:
      msg = b'Hello #%d' % counter
      client.publish(topic_pub, msg)
      last_message = time.time()
      counter += 1
  except OSError as e:
    restart_and_reconnect()


Questi sopra sono i file di cui fare upload sul primo ESP8266 nei quali va sostituito al posto delle XXXXXX i dati per accedere al proprio router per il collegamento ad internet ed il numero IP del broker MQTT. ( in un altro progetto che pubblichero' piu' avanti, un server MQTT fatto in casa con Raspberry).
Come detto sopra, il primo device crea una connessione con il broker, sottoscrive un topic sul quale rimane in ascolto, nel caso in esempio : TecnoGeppetto/notifica 
Quando sono trascorsi 5 secondi, pubblica sul topic  TecnoGeppetto/ciao   un  saluto "Hello"

L'altro ESP8266 avra' invece questo software :


boot.py

# ESP#2

import time
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp
esp.osdebug(None)
import gc
gc.collect()

ssid = "XXXXXXXXXXXX"
password = "XXXXXXXXXX"
mqtt_server = 'xxxxxxxxxxxx'
#EXAMPLE IP ADDRESS
#mqtt_server = '192.168.1.144'
client_id = ubinascii.hexlify(machine.unique_id())
topic_sub = b'TecnoGeppetto/ciao'
topic_pub = b'TecnoGeppetto/notifica'

station = network.WLAN(network.STA_IF)

station.active(True)
station.connect(ssid, password)

while station.isconnected() == False:
  pass

print('Connection successful')
print(station.ifconfig())


main.py

# ESP#2

def sub_cb(topic, msg):
  print((topic, msg))

def connect_and_subscribe():
  global client_id, mqtt_server, topic_sub
  client = MQTTClient(client_id, mqtt_server)
  client.set_callback(sub_cb)
  client.connect()
  client.subscribe(topic_sub)
  print('Connected to %s MQTT broker, subscribed to %s topic' % (mqtt_server, topic_sub))
  return client

def restart_and_reconnect():
  print('Failed to connect to MQTT broker. Reconnecting...')
  time.sleep(10)
  machine.reset()

try:
  client = connect_and_subscribe()
except OSError as e:
  restart_and_reconnect()

while True:
  try:
    new_message = client.check_msg()
    if new_message != 'None':
      client.publish(topic_pub, b'received')
    time.sleep(1)
  except OSError as e:
    restart_and_reconnect()

Che apre una connessione ad internet via router, si connette al broker MQTT, si mette in ascolto del topic :  TecnoGeppetto/ciao      e quando riceve il "saluto" inviato dal primo, pubblica sul topic:  TecnoGeppetto/notifica       la conferma di ricezione.

Elaborato dal progetto originale che puoi trovare qui 

Buon divertimento
TecnoGeppetto

lunedì 28 dicembre 2020

DHT11 ESP8266 NEOPIXEL e Micropython

 Ho ripreso in mano il mio ESP8266 per approfondirne la conoscenza. Nell'ultimo post ho imparato a caricare il Micropython ed a collegare il mio ESP8266 da remoto con WebREPL.


In questo modo e' possibile caricare i file di programma nel file system del ESP8266, in modo da poterli poi far "girare" chiamandoli direttamente da termionale o madandoli in esecuzione direttamente al boot, utilizzando il file di sistema boot.py.

Infatti il MicroPython, gia' dalla sua istallazione prevede il file boot.py che in automatico la macchina chiama ad ogni reboot, quindi e' facile poter far partire tutti i programmi che vogliamo opportunamente impostando solamente  quest'ultimo file.


Avevo in un cassetto un ESP8266 superstite da alcuni altri passati esperimenti, al quale era gia' collegato e funzionante una barretta di 8 led Neopixel ed un sensore DHT11.

Niente di meglio per fare amicizia con il sistema Micropython.

Ho iniziato ad impostare la rete in modo fisso, in maniera che ad ogni reboot l'ESP si colleghi in automatico con il router di casa, semplicemente copiando le istruzioni necessarie nel file  boot.py (le stesse che abbiamo visto nel post di ieri).

Fatto questo e reso automatica la partenza del sistema WebREPL come visto ieri, impostando la password.

Ho iniziato a caricare tramite WebREPL il file di un semplice programma che legge la temperatura dal sensore e la stampa sulla consolle.

TEMP.PY :

#questo programma legge la temperatura e l'umidita' dal sensore DHT11 
#collegato al Pin 14 del ESP8266 (il pin contrassegnato con D5)

from machine import Pin
#from time import sleep
import dht 
#sensor = dht.DHT22(Pin(14))
sensor = dht.DHT11(Pin(14))

def get_temp():
    sensor.measure()
    temp = sensor.temperature()
    hum = sensor.humidity()
    return [temp,hum]


def leggi_temp():
    sensor.measure()
    temp = sensor.temperature()
    hum = sensor.humidity()
    print('Temperature: %3.1f C' %temp)
    print('Humidity: %3.1f %%' %hum)
    


Poi ho caricato un secondo file leds.py che gestira' i leds della barretta di Neopixel con a bordo il famoso led WS2812B.

LEDS.PY :

# questo programma scrive colori su neopixel ws2812B
# i neopixel sono collegati al Pin 5 che e' marcato D1 sulla scheda esp8266

import machine, neopixel
from time import sleep
import temp
n = 8 #numero dei pixel disponibili
p = 5 #pin sul quale sono collegati i led

np = neopixel.NeoPixel(machine.Pin(p), n)

def temp_leds():
    lista = temp.get_temp()
    if lista[0] <= 16:
        np[0] = (0,0,5)
        np[1] = (0,0,0)
        np[2] = (0,0,0)
        np[3] = (0,0,0)
        np[4] = (0,0,0)
        np[5] = (0,0,0)
        np[6] = (0,0,0)
        np[7] = (0,0,0)
        np.write()
    elif lista[0] == 17:
        np[0] = (0,0,5)
        np[1] = (0,0,5)
        np[2] = (0,0,0)
        np[3] = (0,0,0)
        np[4] = (0,0,0)
        np[5] = (0,0,0)
        np[6] = (0,0,0)
        np[7] = (0,0,0)
        np.write()
    elif lista[0] == 18:
        np[0] = (0,5,3)
        np[1] = (0,5,3)
        np[2] = (0,5,0)
        np[3] = (0,0,0)
        np[4] = (0,0,0)
        np[5] = (0,0,0)
        np[6] = (0,0,0)
        np[7] = (0,0,0)
        np.write()
    elif lista[0] == 19:
        np[0] = (0,5,3)
        np[1] = (0,5,3)
        np[2] = (0,5,0)
        np[3] = (0,5,0)
        np[4] = (0,0,0)
        np[5] = (0,0,0)
        np[6] = (0,0,0)
        np[7] = (0,0,0)
        np.write()
    elif lista[0] == 20:
        np[0] = (0,5,0)
        np[1] = (0,5,0)
        np[2] = (0,5,0)
        np[3] = (0,5,0)
        np[4] = (5,5,0)
        np[5] = (0,0,0)
        np[6] = (0,0,0)
        np[7] = (0,0,0)
        np.write()
    elif lista[0] == 21:
        np[0] = (0,5,0)
        np[1] = (0,5,0)
        np[2] = (0,5,0)
        np[3] = (0,5,0)
        np[4] = (5,5,0)
        np[5] = (5,0,0)
        np[6] = (0,0,0)
        np[7] = (0,0,0)
        np.write()
    elif lista[0] == 22:
        np[0] = (0,5,0)
        np[1] = (0,5,0)
        np[2] = (0,5,0)
        np[3] = (0,5,0)
        np[4] = (5,5,0)
        np[5] = (5,0,0)
        np[6] = (5,0,0)
        np[7] = (0,0,0)
        np.write()
    elif lista[0] == 23:
        np[0] = (0,5,0)
        np[1] = (0,5,0)
        np[2] = (0,5,0)
        np[3] = (0,5,0)
        np[4] = (5,5,0)
        np[5] = (5,0,0)
        np[6] = (5,0,0)
        np[7] = (5,0,0)
        np.write()
    else:
        np[0] = (3,0,0)
        np[1] = (3,0,0)
        np[2] = (3,0,0)
        np[3] = (3,0,0)
        np[4] = (5,0,0)
        np[5] = (5,0,0)
        np[6] = (5,0,0)
        np[7] = (5,0,0)
        np.write()
def smooth_red():
    for led in range(8):
        for i in range(50):
            np[led] = (i, 0, 0)
            np.write()
            sleep(0.025)

def spengi_leds():
    for i in range(8):
        np[i] = (0, 0, 0)
    np.write()

def smooth_green():
    for led in range(8):
        for i in range(50):
            np[led] = (0, i, 0)
            np.write()
            sleep(0.025)

def smooth_blu():
    for led in range(8):
        for i in range(50):
            np[led] = (0, i, 0)
            np.write()
            sleep(0.025)
        

Inizialmente ho fatto amicizia con i colori (attenzione a non far partire alla massima intensita' tutti i led assieme che potrebbe essere dannoso per l'alimentazione del computer al quale e' collegato l'ESP, a causa del  troppo assorbimento - circa 60 mA per ogni led)

Infine li ho inseriti nel file di boot.py per far si che possano funzionare gia' dal reboot:

Il sistema cosi impostato, legge la temperatura una sola volta all'accensione, e in funzione del valore letto, accende i led di colore blu se la temperatura e' al di sotto dei 16 - 17 gradi
di colore verde per valori tra i 17 ed i 20 gradi e di rosso se la temperatura supera i 20 gradi.
I led si accendono in modo che la scala sia "parlante" in funzione dell'aumento della temperatura.
Cioe' < 16 gradi solo il primo led - poi via via fino a 24 gradi con tutti e 8 i led accesi.

E' ovvio che il tutto e' fatto per test e per fare conoscenza! Per fare un device intelligente, la temperatura va letta ad iintervalli costanti ed aggiornata la scla dei led in conseguenza. Ma non era questo lo scopo dei miei test di oggi (comunque bastano altre due righe di codice per farlo!)


BOOT.PY


# This file is executed on every boot (including wake-boot from deepsleep)
#import esp
#esp.osdebug(None)
import uos, machine
#uos.dupterm(None, 1) # disable REPL on UART(0)
import gc
import webrepl
import network
import temp
import leds
sta_if = network.WLAN(network.STA_IF)
sta_if.connect("XXXXXXXXXXXXXXXXXX","XXXXXXXXXXX") # Connect to an AP
print("LA mia connessione e' attiva e questo e' il mio indirizzo: ", sta_if.ifconfig())
webrepl.start()
gc.collect()
temp.leggi_temp()

leds.temp_leds()


Oggi sono arrivato fino qui!
A domani (forse ) per la prossima puntata.
TecnoGeppetto

domenica 27 dicembre 2020

Programmare Esp32Cam con Python anche da remoto

La parte discorsiva la faro' in un secondo momento. 

Collegare Esp32Cam completo di modulo seriale alla USB del pc tramite cavo USB-C tenendo premuto il tasto IO0, che deve essere premuto per mettere il microcontrollore in flash mode. far partire il tools predisposto da Espressif.


Controllare tra i dispositivi di Windows che nome e' stato asseganto alla seriale, nel mio caso COM7 

Ho cancellato completamente la Flash con l'apposito tasto rifatto il boot  del device scollegandolo e ricollegandolo tenendo premuto il tasto IO0 . 
A questo punto fatto il download del firmware col tasto START.

 Se tutto e' andato a buon fine adesso ci ritroviamo con un device esp32 che risponde , se interrogato via seriale, con il prompt di python. 

Quindi collegare il device alla seriale, chiamarlo con un programma che legge i dati da seriale, per esempio putty su windows o minicom su debian, con la velocita' settata a 115200b e rispondera' il classico >>> di python.

Per poter lavorare sul nostro ESP32 senza connetterlo al pc tramite cavo vanno fatti due passi importanti: 

Collegare il device ad una rete (la stessa dove si trovera' anche il tuo pc) Abilitare la funzione WebREPL del micropython che consente di "parlare" con il prompt tramite una connessione wifi. 

Qui tutte le piu' importanti comandi per lavorare con l'interfaccia wifi :

import network

wlan = network.WLAN(network.STA_IF) # create station interface
wlan.active(True)       # activate the interface
wlan.scan()             # scan for access points
wlan.isconnected()      # check if the station is connected to an AP
wlan.connect('essid', 'password') # connect to an AP
wlan.config('mac')      # get the interface's MAC address
wlan.ifconfig()         # get the interface's IP/netmask/gw/DNS addresses

ap = network.WLAN(network.AP_IF) # create access-point interface
ap.config(essid='ESP-AP') # 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

Qui invece come attivare il WebREPL:
  import webrepl_setup
import webrepl
webrepl.start()

# or, start with a specific password
webrepl.start(password='mypass')



Attivato WebREPL andra' impostata la password che l'utente dovra' digitare all'accesso da remoto, per poter programmare il device.
Buon divertimento
TecnoGeppetto