Archivi tag: espressif

Compilazione, Software, Sviluppo

ESP32 – IDF Sdk con IDE Eclipse

2019-04-29 admin

Dopo aver configurato l’ambiente di sviluppo IDF nell’articolo precedente

ESP32 – IDF Sdk

vediamo ora come utilizzare Eclipe come IDE per lo sviluppo del codice. Le istruzioni sono disponibili al link

Configurazione Eclipse

Scaricare Eclipse per C/C++ per Linux

Download Eclipse

Scompattare il file e spostarlo su /opt/

tar -zxvf eclipse-cpp-2019-03-R-linux-gtk-x86_64.tar.gz
sudo mkdir /opt 
sudo mv eclipe /opt/

tar -zxvf eclipse-cpp-2019-03-R-linux-gtk-x86_64.tar.gz

sudo mkdir /opt

sudo mv eclipe /opt/

Eseguire ecplise

/opt/eclipse/ecplise

1	/opt/eclipse/ecplise

Impostare il workspace per eclipse

Una volta aperto l’IDE selezionare File–>Import–>C/C++- -> Existing Code as Makefile Project

Premere Next; alla schermata successiva selezionare la cartella contenente il Makefile di un progetto di esempio ne campo “Existing Code Location” e scegliere come “Toolchain for indexer settings” CrossGcc come ad esempio indicato di seguito

Una volta caricato il progetto con il tasto destro sul nome del progetto si sceglie l’opzione properties

Sotto C/C++ Build–>Envinronment aggiungere la variabile

BATCH_BUILD=1

1	BATCH_BUILD=1

Aggiungere sempre nella medesima sezione la variabile IDF_PATH che punta all’SDK IDF scaricato

IDF_PATH=~/Esp32/espressif/esp-idf

1	IDF_PATH=~/Esp32/espressif/esp-idf

Editare la variabile PATH ed aggiungere il path ai bin del cross compilatore /home/sviluppo/Esp32/espressif/esp/xtensa-esp32-elf/bin

Accedere sempre in “C/C++ General”–> “Preprocessor Include Paths”; scelgliere il tab Providers e cliccare su “CDT Cross GCC Built-in Compiler Settings”

Sostituire ${COMMAND}

con xtensa-esp32-elf-gcc

Accedere ora nei providers e scegliere “CDT GCC Build Output Parser”

ed inserire all’inizio del Compiler command pattern xtensa-esp32-elf-

Salvare le configurazioni.

Le impostazioni del progetto vanno fatte sempre da make menuconfig nella shell unix. Accedere nella shell ed impostare come GPIO del led da spegnere ed accendere il valore 2; questo perché nel nostro caso la scheda è una doit il cui design è illustrato nel presente documento

SchematicsforESP32

cd ~/Esp32/espressif 
export PATH=$PATH:$HOME/Esp32/espressif/esp/xtensa-esp32-elf/bin 
export IDF_PATH=~/Esp32/espressif/esp-idf 
cd projects/blink 
make menuconfig

cd ~/Esp32/espressif

export PATH=$PATH:$HOME/Esp32/espressif/esp/xtensa-esp32-elf/bin

export IDF_PATH=~/Esp32/espressif/esp-idf

cd projects/blink

make menuconfig

Accedere a Example configuration

ed impostare il valore del gpio a 2

Salvare la configurazione. Riandare su Eclipse e procedere alla pulizia con

e successiva compilazione con Project–> Build

Per eseguire il flash del firmware da eclipse, selezionare il progetto e con il tasto destro scegliere Build Targets -> Create…

Inserire nel campo target il valore flash, lasciando di default tutto il resto

A questo punto si procede al caricamento dell’immagine cliccando due volte sulla nuova voce flash all’interno dei target del progetto

Le impostazioni per eseguire il flash devono essere impostate con make menuconfig, come visto nell’articolo precedente

ESP32 – Idf Sdk

Compilazione, Software

ESP32 – IDF Sdk

2019-04-07 admin

In questo articolo si descrive come impostare l’ambiente di sviluppo per ESP32 della Espressif.

Dal link alle risorse per il soc

https://www.espressif.com/en/products/hardware/esp32/resources

si accede alla guida per la compilazione del firmware sulle piattaforme Windows, OSX e Linux

http://esp-idf.readthedocs.io/en/latest/get-started/index.html

Le operazioni elencate di seguito sono eseguite sempre su Linux Debian 9, configurato come già descritto in precedenza

MicroPython – Python su dispositivi embedded

Si utilizza l’IDF del github. Su Debian 9 con l’utenza utilizzata per collegarsi sul sistema si crea sotto la Home dell’utente la cartella Esp32 ed all’interno la cartella espressif

cd
mkdir Esp32
cd Esp32
mdkir espressif
cd espressif

mkdir Esp32

cd Esp32

mdkir espressif

cd espressif

Installare i prerequisiti

sudo apt-get install git wget make libncurses-dev flex bison gperf python python-serial

1	sudo apt-get install git wget make libncurses-dev flex bison gperf python python-serial

Scaricare il cross compilatore

wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

1	wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

Creare la cartella esp e dall’interno scompattare il toolchain

mkdir esp 
cd esp 
tar -zxvf ../xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

mkdir esp

cd esp

tar -zxvf ../xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

Aggiungere al PATH la cartella bin del cross compilatore

export PATH=$PATH:$HOME/Esp32/espressif/esp/xtensa-esp32-elf/bin

1	export PATH=$PATH:$HOME/Esp32/espressif/esp/xtensa-esp32-elf/bin

Aggiungere al gruppo dialout, l’utenza utilizzata per le operazioni

sudo usermod -a -G dialout USER

1	sudo usermod -a -G dialout USER

Clonare il repository IDF dal $HOME/Esp32/espressif

cd $HOME/Esp32/espressif
git clone --recursive https://github.com/espressif/esp-idf.git

1 2	cd $HOME/Esp32/espressif git clone --recursive https://github.com/espressif/esp-idf.git

Aggiungere la variabile di ambiente IDF_PATH

export IDF_PATH=~/Esp32/espressif/esp-idf

1	export IDF_PATH=~/Esp32/espressif/esp-idf

Creare la cartella dei progetti sotto $HOME/Esp32/espressif e copiare un esempio dalla cartella dell’IDF

cd $HOME/Esp32/espressif
mkdir projects
cd projects
cp -r $IDF_PATH/examples/get-started/hello_world . 
cd hello_world

cd $HOME/Esp32/espressif

mkdir projects

cd projects

cp -r $IDF_PATH/examples/get-started/hello_world .

cd hello_world

Eseguire la configurazione

make menuconfig

1	make menuconfig

Accedere a Serial flasher config–> ed impostare i parametri della connessione; nel nostro caso lasciamo il default

Salvare la configurazione e compilare il firmware

make

make

Per caricare il firmware sulla scheda eseguire

make flash

1	make flash

Per caricare solo la applicazione eseguire

make app-flash

1	make app-flash

mentre per compilare solo la applicazione eseguire

make app

make app

Per eseguire il monitor del programma eseguire

make monitor

1	make monitor

Gli altri esempi disponibili con sdk

https://github.com/espressif/esp-idf/tree/f586f5e/examples

Al seguente link invece sono presenti i riferimenti delle API dell’IDF

http://esp-idf.readthedocs.io/en/latest/api-reference/index.html

Si può anche generare la documentazione dai sorgenti del github. Posizionarsi in ~/Esp32/espressif/esp-idf/docs/en

cd ~/Esp32/espressif/esp-idf/docs/en

1	cd ~/Esp32/espressif/esp-idf/docs/en

Installare i prerequisiti

sudo apt-get install python-pip python-sphinx doxygen

1	sudo apt-get install python-pip python-sphinx doxygen

sudo pip install sphinx_rtd_theme breathe sphinxcontrib.blockdiag sphinxcontrib.seqdiag sphinxcontrib.actdiag sphinxcontrib.nwdiag recommonmark

1	sudo pip install sphinx_rtd_theme breathe sphinxcontrib.blockdiag sphinxcontrib.seqdiag sphinxcontrib.actdiag sphinxcontrib.nwdiag recommonmark

Generare i documenti in formato html

make html

make html

La documentazione è generata in _build/html.

Nel prossimo articolo imposteremo come IDE per la compilazione dei programmi Eclipe

ESP32 – IDF SDK con IDE Eclipse

Compilazione, Software

ESP32 – Compilazione firmware nodemcu

2018-08-17 admin

Dopo aver visto nell’articolo precedente la compilazione del firmware MicroPython per ESP32

ESP32 – Compilazione MicroPython per ESP32

In questo articolo viene mostrato come generare l’immagine Nodemcu per la scheda ESP32.

Il firmware non è ancora completo come quello esistente per ESP8266.

Le istruzioni sono reperibili sul github al link

https://github.com/nodemcu/nodemcu-firmware/tree/dev-esp32

La documentazione sulla compilazione sono elencate al link

https://nodemcu.readthedocs.io/en/dev-esp32/en/build/

Il sistema operativo è Debian 9 già incontrato in precedenza per le utility esptool ed Adafruit-ampy

MicroPython – Python su dispositivi embedded

Collegarsi con l’utenza scelta su Debian 9, sviluppo nel nostro caso; sotto la home creare la cartella Esp32 e successivamente la cartella nodemcu

cd
mkdir Esp32
cd Esp32
mkdir nodemcu
cd nodemcu

mkdir Esp32

cd Esp32

mkdir nodemcu

cd nodemcu

Clonare il repository

git clone --branch dev-esp32 --recurse-submodules https://github.com/nodemcu/nodemcu-firmware.git nodemcu-firmware-esp32

1	git clone --branch dev-esp32 --recurse-submodules https://github.com/nodemcu/nodemcu-firmware.git nodemcu-firmware-esp32

Per aggiornare il repository già clonato seguire quanto descritto al link sulla compilazione

cd nodemcu-firmware-esp32 
git pull origin dev-esp32 
git submodule init #only if repo was cloned w/o submodules init 
git submodule update --recursive

cd nodemcu-firmware-esp32

git pull origin dev-esp32

git submodule init #only if repo was cloned w/o submodules init

git submodule update --recursive

Accedere alla cartella nodemcu-firmware-esp32 ed eseguire la configurazione

cd nodemcu-firmware-esp32
make menuconfig

1 2	cd nodemcu-firmware-esp32 make menuconfig

Abilitare il bluetooth e dei moduli accedendo in

Component config–>Bluetooth ed abilitarlo

Component config–>Nodemcu modules ed abiltare i moduli che potrebbero servire

Nella configurazione per il flash lasciamo i valori di default per la nostra scheda esp32, Serial flasher config->

Salvare la configurazione ed uscire. Per compilare l’immagine eseguire

make

make

Alla fine della compilazione viene mostrato il comando da eseguire per flashare il dispositivo; la stessa operazione viene facilitata eseguendo semplicemente

make flash

1	make flash

Per informazioni sulle partizioni delle varie versioni di ESP32 fare riferimento alla documentazione

http://api-guides/partition-tables.html

Nel prossimo articolo si mostra come compilare una applicazione utilizzando sdk di Espressif

ESP32 – IDF Sdk

Compilazione, Software

ESP32 – Compilazione MicroPython per ESP32

2018-08-08 admin

Iniziamo una serie di articoli che trattano la scheda Espressif ESP32

Modulo WiFi-Bluetooth ESP32

Dopo aver analizzato negli articoli precedenti MicroPython per ESP8266, in questo incominciamo a trattare MicroPython su ESP32.

Di seguito viene mostrato come generare l’immagine MicroPython partendo dal codice sorgente per la scheda ESP32.

Il sistema operativo è Debian 9, già incontrato in precedenza per le utility esptool ed Adafruit-ampy

MicroPython – Python su dispositivi embedded

Collegarsi con l’utenza scelta su Debian 9, sviluppo nel nostro caso; sotto la home creare la cartella Micropython e successivamente la cartella esp32

mkdir Micropython
cd Micropython
mkdir esp32
cd esp32

mkdir Micropython

cd Micropython

mkdir esp32

cd esp32

Il github di MicroPython è presente al link

Github Micropython

Le istruzioni per l’ ESP32 sono presenti al link

MicroPython esp32

Clonare il repository

git clone https://github.com/micropython/micropython

1	git clone https://github.com/micropython/micropython

Accedere in micropython/ports/esp32

cd micropython/ports/esp32

1	cd micropython/ports/esp32

Eseguire

make

make

Il comando rilascia l’hash del github dell’ espidf supportato.

Al momento della nostra compilazione il risultato è il seguente

viluppo@debian9:~/Micropython/esp32/micropython/ports/esp32$ make
Use make V=1 or set BUILD_VERBOSE in your environment to increase build verbosity.
The ESPIDF variable has not been set, please set it to the root of the esp-idf repository.
See README.md for installation instructions.
Supported git hash: 3ede9f011b50999b0560683f9419538c066dd09e
Makefile:34: *** ESPIDF not set.  Stop.

viluppo@debian9:~/Micropython/esp32/micropython/ports/esp32$ make

Use make V=1 or set BUILD_VERBOSE in your environment to increase build verbosity.

The ESPIDF variable has not been set, please set it to the root of the esp-idf repository.

See README.md for installation instructions.

Supported git hash: 3ede9f011b50999b0560683f9419538c066dd09e

Makefile:34: *** ESPIDF not set. Stop.

Ritornare nella cartella /home/sviluppo/Micropython/esp32 e clonare ESPIDF

git clone https://github.com/espressif/esp-idf.git
cd esp-idf

1 2	git clone https://github.com/espressif/esp-idf.git cd esp-idf

Eseguire il checkout con l’hash ricavato sopra

git checkout 3ede9f011b50999b0560683f9419538c066dd09e

1	git checkout 3ede9f011b50999b0560683f9419538c066dd09e

Eseguire

git submodule update --init

1	git submodule update --init

Installare il cross compilatore come indicato al link

Cross compilatore

Seguendo le indicazioni del link sopra riportato, si procede quindi ad installare i prerequisiti

sudo apt-get install git wget make libncurses-dev flex bison gperf python python-serial

1	sudo apt-get install git wget make libncurses-dev flex bison gperf python python-serial

Scaricare il cross compilatore

cd /home/sviluppo/Micropython/esp32
wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

1 2	cd /home/sviluppo/Micropython/esp32 wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

Creare la cartella esp sotto /home/sviluppo/Micropython/esp32

cd /home/sviluppo/Micropython/esp32
mkdir esp
cd esp

cd /home/sviluppo/Micropython/esp32

mkdir esp

cd esp

Scompattare il cross compilatore in esp

tar -zxvf ../xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

1	tar -zxvf ../xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

Esportare nel PATH la cartella dei binari del cross compilatore

export PATH=/home/sviluppo/Micropython/esp32/esp/xtensa-esp32-elf/bin:$PATH

1	export PATH=/home/sviluppo/Micropython/esp32/esp/xtensa-esp32-elf/bin:$PATH

Accedere in

/home/sviluppo/Micropython/esp32/micropython/ports/esp32/

1	/home/sviluppo/Micropython/esp32/micropython/ports/esp32/

Creare il file makefile con all’interno

ESPIDF = /home/sviluppo/Micropython/esp32/esp-idf
#PORT = /dev/ttyUSB0
#FLASH_MODE = qio
#FLASH_SIZE = 4MB
#CROSS_COMPILE = xtensa-esp32-elf-

include Makefile

ESPIDF = /home/sviluppo/Micropython/esp32/esp-idf

#PORT = /dev/ttyUSB0

#FLASH_MODE = qio

#FLASH_SIZE = 4MB

#CROSS_COMPILE = xtensa-esp32-elf-

include Makefile

Accedere alla cartella micropython presente in /home/sviluppo/Micropython/esp32

cd micropython

1	cd micropython

Eseguire

git submodule update --init

1	git submodule update --init

per aggiungere le dipendenze esterne.

Si compila il cross compilatore MicroPython

make -C mpy-cross
git submodule init lib/berkeley-db-1.xx
git submodule update

make -C mpy-cross

git submodule init lib/berkeley-db-1.xx

git submodule update

Si compila infine l’immagine per l’esp32 con il comando

cd ports/esp32
make

1 2	cd ports/esp32 make

Il firmware è generato nella cartella ports/esp32/build con il nome firmware.bin.

Procedere al caricamento del firmware con i comandi

make erase

1	make erase

Nel nostro caso il deploy ha avuto esito positivo con il comando

make deploy

1	make deploy

E’ possible caricare l’immagine firmware.bin con i comandi

esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600 erase_flash

1	esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600 erase_flash

esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600  write_flash -z --flash_mode "dio" --flash_freq "40m" --flash_size detect 0x1000 firmware.bin

1	esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600 write_flash -z --flash_mode "dio" --flash_freq "40m" --flash_size detect 0x1000 firmware.bin

dove in /dev/ttyXXX va inserito il riferimento alla porta seriale cui è connesso l’ESP32.

Nel prossimo articolo compileremo il firmware nodemcu per ESP32

ESP32 – Compilazione firmware nodemcu

Compilazione, Software

MicroPython – Compilazione MicroPython per ESP8266 con moduli aggiuntivi

2018-07-04 admin

Dopo aver visto nel precedente articolo la compilazione del firmware MicroPython per ESP8266

MicroPython – Compilazione MicroPython per ESP8266

mostriamo ora come compilare un modulo all’interno del firmware; tale modalità ottimizza l’esecuzione del modulo e minimizza la dimensione dello stesso sul dispositivo: il modulo è congelato nel firmware.

Con il firmware compilato in modalità standard si hanno a disposizione i seguenti moduli, elencati nella consolle REPL con il comando

help('modules')

1	help('modules')

Proviamo ora a compilare il firmware con i moduli mqtt già all’interno. Per tal obiettivo si copiano i sorgenti dei moduli nella cartella umqtt sotto modules

micropython/ports/esp8266/modules/umqtt/simple.py
micropython/ports/esp8266/modules/umqtt/robust.py

1 2	micropython/ports/esp8266/modules/umqtt/simple.py micropython/ports/esp8266/modules/umqtt/robust.py

Si provvede a ricompilare il firmware, come visto nell’articolo pubblicato sull’argomento. Da micropython/ports/esp8266 si eseguono i comandi

make clean
make

1 2	make clean make

Come si può notare dal log di compilazione anche questi sorgenti vengono posti nello stato frozen

Si carica di nuovo il firmware. In questo caso nella lista dei moduli presenti nel firmware otteniamo

E’ possbile anche creare il firmware con i moduli non compilati ed ottimizzati copiando i sorgenti nella cartella scripts sotto esp8266; nel caso specifico i sorgenti vanno posti sotto la cartella scripts

micropython/ports/esp8266/scripts/umqtt/simple.py
micropython/ports/esp8266/scripts/umqtt/robust.py

1 2	micropython/ports/esp8266/scripts/umqtt/simple.py micropython/ports/esp8266/scripts/umqtt/robust.py

I moduli sono sempre visibili nel firmware, ma non ottimizzati, per cui se serve qualche modulo lo si copia sul dispositivo durante la lavorazione e nell’ultima fase del progetto si compila il firmware con i moduli congelati.

Compilazione, Software

MicroPython – Compilazione MicroPython per ESP8266

2018-06-25 admin

Dopo aver utilizzato in alcuni esempi il firmware MicroPython sulla scheda ESP8266

MicroPython – Esempi nodi con DHT11, Relé ed MQTT

in questo articolo viene mostrato come generare il firmware MicroPython per la scheda ESP8266.

Il sistema operativo è Debian 9 già incontrato in precedenza per le utility esptool

MicroPython – Python su dispositivi embedded

Collegarsi con l’utenza scelta su Debian 9, sviluppo nel nostro caso; sotto la home creare la cartella Micropython e successivamente la cartella esp8266

mkdir Micropython
cd MicroPython
mkdir esp8266
cd esp8266

mkdir Micropython

cd MicroPython

mkdir esp8266

cd esp8266

Il codice sorgente di MicroPython è presente al link

Github Micropython

Le istruzioni per compilare il firmware per l’ESP8266 sono presenti al link

MicroPython ESP8266

Clonare il repository

git clone https://github.com/micropython/micropython

1	git clone https://github.com/micropython/micropython

Scaricare il cross compilatore, come indicato qui

Cross compilatore

Come indicato al link sopra, scarichiamo i sorgenti del cross compilatore sempre dalla cartella esp8266

git clone --recursive  https://github.com/pfalcon/esp-open-sdk

1	git clone --recursive https://github.com/pfalcon/esp-open-sdk

Installare i prerequisiti per la compilazione

sudo apt-get install make unrar-free autoconf automake libtool gcc g++ gperf flex bison texinfo gawk ncurses-dev libexpat-dev python-dev python python-serial sed git unzip bash help2man wget bzip2 libtool-bin

1	sudo apt-get install make unrar-free autoconf automake libtool gcc g++ gperf flex bison texinfo gawk ncurses-dev libexpat-dev python-dev python python-serial sed git unzip bash help2man wget bzip2 libtool-bin

Procedere alla compilazione del cross compilatore

cd esp-open-sdk
make STANDALONE=y |& tee make0.log

1 2	cd esp-open-sdk make STANDALONE=y \|& tee make0.log

Dopo la compilazione esportare nel PATH la cartella dei binari del cross compilatore

export PATH=/home/sviluppo/Micropython/esp8266/esp-open-sdk/xtensa-lx106-elf/bin:$PATH

1	export PATH=/home/sviluppo/Micropython/esp8266/esp-open-sdk/xtensa-lx106-elf/bin:$PATH

Accedere alla cartella micropython presente in ~/Micropython/esp8266

cd ~/Micropython/esp8266/micropython

1	cd ~/Micropython/esp8266/micropython

Eseguire

git submodule update --init

1	git submodule update --init

per aggiungere le dipendenze esterne.

Si compila il cross compilatore MicroPython

make -C mpy-cross

1	make -C mpy-cross

Si compila infine l’immagine per l’ESP8266 con il comando

cd ports/esp8266
make axtls
make

cd ports/esp8266

make axtls

make

Il firmware è generato nella cartella ports/esp8266/build con il nome firmware_combined.bin.

Procedere al caricamento del firmware sulla scheda con il comando

esptool.py --port /dev/ttyXXX erase_flash

1	esptool.py --port /dev/ttyXXX erase_flash

dove in /dev/ttyXXX va inserito il riferimento alla porta seriale cui è connesso l’ESP8266.

Nel nostro caso il deploy ha avuto esito positivo con il comando

make PORT=/dev/ttyUSB0 deploy

1	make PORT=/dev/ttyUSB0 deploy

E’ possible caricare l’immagine firmware_combined.bin con il comando

esptool.py --port /dev/ttyUSBX --baud 460800 write_flash --flash_size=detect 0 firmware-combined.bin

1	esptool.py --port /dev/ttyUSBX --baud 460800 write_flash --flash_size=detect 0 firmware-combined.bin

Nel prossimo articolo si analizza come compilare all’interno del firmware dei moduli aggiuntivi MicroPython

MicroPython – Compilazione MicroPython per ESP8266 con moduli aggiuntivi

Software, Sviluppo

MicroPython – Struttura programma MicroPython

2018-06-02 admin

Dopo aver esaminato diversi strumenti di sviluppo per MicroPython negli articoli precedenti

MicroPython – Strumenti di sviluppo Ampy – Eric

MicroPython – IDE MicroPython uPyCraft

in questo articolo si descrivono brevemente le principali caratteristiche di MicroPython. Esaminiamo in particolare la documentazione inerente all’ESP8266, ma i concetti possono essere estesi anche alle altre schede.

La documentazione sul soc ESP8266 e MicroPython è disponibile al link

Documentazione MicproPython ESP8266

Al link si trovano tutte le informazione necessarie per implementare il proprio codice sulla scheda e le caratteristiche di MicroPython nonché le differenze rispetto a Python.

Di seguito i punti principali per la codifica in MicroPython:

MicroPython ha una consolle REPL (Read Evaluate Print Loop) attraverso la porta seriale cui è connesso il dispositivo sui cui si posso impartire i vari comandi MicroPython in modo interattivo.

Si può accedere alla consolle REPL anche tramite connessione all’indirizzo IP del dispositivo mediante l’abilitazione della consolle WEBREPL (Web Browser Interactive prompt)

Documentazione WebREPL

importando il pacchetto webrepl, abilitandolo ed avviandolo ad ogni ripartenza del dispositivo. Per accedere al dispositivo configurato si puo usare il link

Accesso WEBREPL

o localmente clonandolo da github

git clone https://github.com/micropython/webrepl

1	git clone https://github.com/micropython/webrepl

I file che vengono eseguiti all’avvio del dispositivo sono boot.py e successivamente main.py.

Le librerie disponibili per MicroPython sono presenti sul github al link

Librerie MicroPython

Pacchetti aggiuntivi

I moduli aggiuntivi possono essere scaricati dal link delle librerie presentato sopra o scaricati con la utility upip (Package Manager) dalla consolle REPL se presenti nel repository Python Package Index (PyPI)

PYPI

come descritto di seguito

upip

Di seguito un semplice esempio che si connette al router e ci permette di accedere alla consolle MicroPython con il browser e WEBREPL.

Codice boot.py

#This file is executed on every boot (including wake-boot from deepsleep)
import esp
#esp.osdebug(None)
#Connects to the wifi AP providing a hostname, AP Name and passord
def do_connect():
    import network
    
    sta_if = network.WLAN(network.STA_IF)
    if not sta_if.isconnected():
        print('connecting to network...')
        sta_if.active(True)
		#Sets the device hostname
        sta_if.config(dhcp_hostname='ESP_TEST')
        print(sta_if.config('dhcp_hostname'))
		#CHANGE THE VALUES TO YOUR ACCESSPOINT NAME AND PASSWORD
        sta_if.connect('ACCESSPOINT', 'PASSWORDACCESSPOINT')
        while not sta_if.isconnected():
            pass
    
    print('network config:', sta_if.ifconfig())
    
#Imports various modules for network, webrepl and garbage collector	
import gc
import webrepl
import network

do_connect()
webrepl.start()
gc.collect()

#This file is executed on every boot (including wake-boot from deepsleep)

import esp

#esp.osdebug(None)

#Connects to the wifi AP providing a hostname, AP Name and passord

def do_connect():

import network

sta_if = network.WLAN(network.STA_IF)

if not sta_if.isconnected():

print('connecting to network...')

sta_if.active(True)

#Sets the device hostname

sta_if.config(dhcp_hostname='ESP_TEST')

print(sta_if.config('dhcp_hostname'))

#CHANGE THE VALUES TO YOUR ACCESSPOINT NAME AND PASSWORD

sta_if.connect('ACCESSPOINT', 'PASSWORDACCESSPOINT')

while not sta_if.isconnected():

pass

print('network config:', sta_if.ifconfig())

#Imports various modules for network, webrepl and garbage collector

import gc

import webrepl

import network

do_connect()

webrepl.start()

gc.collect()

Al primo accesso viene richiesta l’abilitazione di webrepl da eseguire nella consolle REPL con il comando

import webrepl_setup

1	import webrepl_setup

e seguendo le istruzioni si abilita il servizio e si imposta la password di accesso.

La procedura genera sul dispositivo il file webrepl_cfg.py.

Dopo l’impostazione e riavvio accediamo alla consolle web aprendo il file webrepl.html clonato localmente con un browser

Premiamo connetti e dopo aver inserito la password impostata nel setup iniziale accediamo alla consolle

Installiamo ora dalla consolle WEBREPL, ad esempio, il modulo stat utilizzando upip

import upip 
upip.install("micropython-stat")

1 2	import upip upip.install("micropython-stat")

Per incollare del testo nella consolle eseguire Ctrl+A e Ctrl+V

In questo caso il pacchetto è stato prelevato dal repository PYPI, scompattato ed installato sul dispositivo.

Abbiamo notato che alcuni moduli, sebbene presenti sul repository, danno errore in fase di installazione con upip; tali moduli li installiamo direttamente senza usare la utility upip, ma scaricando la libreria dal sito elencato sopra e trasferendo il codice sul dispositivo.

Di seguito il link al codice mostrato sopra

Webreplsample

Altra opzione disponibile è compilare il firmware con i moduli richiesti.

Nel prossimo articolo esamineremo degli esempi analoghi a quanto fatto con LUA su ESP8266 in articoli precedenti

MicroPython – Esempi nodi con DHT11, Relé ed MQTT

Installazione, Software, Sviluppo

Micropython – Strumenti di sviluppo Ampy – Eric

2018-05-29 admin

Dopo aver installato uPyCraft nell’articolo precedente

MicroPython – IDE MicroPython uPyCraft

esaminiamo ora altri strumenti disponibili per lo sviluppo MicroPython su varie piattaforme.

In questo articolo si mostrano le operazioni da eseguire su Windows e Linux.

Primo pacchetto Python da installare è Ampy (Adafruit MicroPython Tool)

ampy

Il tool è presente nei repository python, per cui può essere installato mediante pip.

In Windows eseguire in una console dos

pip install adfruit-ampy

1	pip install adfruit-ampy

Analogamente in Linux eseguire in una shell

sudo pip3 install adafruit-ampy

1	sudo pip3 install adafruit-ampy

I comandi disponibili sono visibili eseguendo

ampy --help

1	ampy --help

Ampy consente il trasferimento, creazione, visualizzazione, esecuzione dei file sul dispositivo.

Per quanto concerne l’IDE si può installare Eric, IDE Python generico

Eric

Eric non consente dall’IDE la comunicazione con il dispositivo come visto con uPyCraft; tale compito è demandato ad Ampy. Per l’installazione procedere come segue:

Per Linux Debian 9 basta eseguire

sudo apt-get install eric

1	sudo apt-get install eric

Il tool è disponibile tra gli strumenti di sviluppo; alla prima esecuzione richiede delle impostazioni di default

Si definisce la posizione del workspace

e si accede all’IDE

Per Windows scaricare lo zip

Eric

Scompattare lo zip in una cartella da cui eseguirlo; installare i prerequisiti

pip install pyqt5-tools
pip install qscintilla

1 2	pip install pyqt5-tools pip install qscintilla

Eseguire a questo punto l’installazione di eric cliccando due volte su install.py

Il programma procede al controllo dei prerequisiti ed al completamento della installazione

Cliccando due volte su eric6.py o eseguendo eric6 da una finestra dos viene eseguito il programma in modo analogo a quanto visto per Linux Debian

Nel prossimo articolo esamineremo brevemente la struttura di un programma MicroPython

MicroPython – Struttura programma MicroPython

Installazione, Software, Sviluppo

Micropython – IDE MicroPython uPyCraft

2018-04-27 admin

Dopo l’installazione del firmware sul dispositivo Nodemcu esp8266 DevKit

Firmware MicroPython

passiamo ora ad esaminare uno strumento di sviluppo può essere adatto allo sviluppo di codice Python.

Uno strumento che permette sia di scrivere codice che di caricarlo sul dispositivo è uPyCraft

uPyCraft

Lo strumento al momento funziona per Windows e dalla versione 0.30 è disponibile anche per Linux; il codice sorgente è presente al link

uPyCraft Source

Di seguito i passi per Windows e Linux.

Windows

Una volta scaricato il pacchetto lo si esegue come amministratore; viene richiesta l’installazione del font Monaco

Dopo l’installazione del font si accede all’IDE

Si imposta la regione corretta in Tools->Preferences->Language Location

ed i parametri della porta seriale in Tools->Preferences->Serial

Colleghiamo a questo punto il dispositivo su una porta USB ed impostiamo la porta corretta uPyCraft

Si sceglie il dispositivo, in questo caso ESP8266

Cliccando sulla icona di connessione si accede al dispositivo ed ai file presenti sullo stesso

Con l’installazione del firmware è presente solo il file boot.py sul dispositivo

Lo strumento permette di scaricare degli esempi di codice MicroPython per la scheda in esame; scegliamo blink.py

Premendo il pulsante “Download and Run” si carica sul dispositivo il codice e lo si esegue

In questo caso il led presente sulla scheda Nodemcu DevKit lampeggia.

Linux

Il tool è analogo nella versione Linux; si scarica il pacchetto a cui si assegna il diritto di esecuzione e lo si lancia, Occorre assegnare all’utente i diritti per l’accesso sulla porta seriale con il comando, già visto in precedenza

sudo usermod -a -G dialout USER

1	sudo usermod -a -G dialout USER

Nel nostro caso, su Debian 9, si hanno le seguenti schermate analoghe a quanto visto su Windows.

Si apre l’IDE

Si imposta la regione corretta in Tools->Preferences->Language Location

ed i parametri della porta seriale in Tools->Preferences->Serial

Colleghiamo a questo punto il dispositivo su una porta USB ed impostiamo la porta corretta uPyCraft

Si sceglie il dispositivo, in questo caso ESP8266

Cliccando sulla icona di connessione si accede al dispositivo ed ai file presenti sullo stesso

Con l’installazione del firmware è presente solo il file boot.py sul dispositivo

Lo strumento permette di scaricare degli esempi di codice MicroPython per la scheda in esame; scegliamo blink.py

Premendo il pulsante “Download and Run” si carica sul dispositivo il codice e lo si esegue

Come in Windows il led presente sulla scheda Nodemcu DevKit lampeggia.

Nella versione 0.30 per Windows abbiamo notato un funzionamento non sempre corretto, per cui in tale sistema operativo abbiamo continuato ad usare la versione 0.29.

Ulteriori informazioni su uPyCraft sono reperibili sul sito dello strumento

Documentazione uPyCraft

Nel prossimo articolo tratteremo un altro strumento di sviluppo Python

MicroPython – Strumenti di sviluppo Ampy – Eric

Installazione, Software

MicroPython – Python su dispositivi embedded

2018-04-26 admin

In questo articolo iniziamo a trattare MicroPython

MicroPython

una implementazione di Python3

Python

per dispositivi embedded.

Sul sito MicroPython sono disponibili varie immagini per diversi dispositivi, tra cui i moduli esp8266 ed esp32

MicroPython Dowloads

Iniziamo i nostri test con una scheda nodemcu esp8266 DevKit

Nodemcu Devkit

Si procede a caricare il firmware su tale scheda.

Sul sito MicroPython si fa riferimento anche al caricamento del firmware sulla scheda con le informazioni disponibili al link

Tutorial MicroPython per esp8266

Per il caricamento del firmware su utilizza sempre il tool esptool, disponibile anche sul repository Python.

Per poter procedere all’utilizzo occorre installare Python3 sulla piattaforma di sviluppo utilizzata. Di seguito i passi da seguire per Windows e Linux.

Windows

Per Windows occorre innanzitutto installare l’ambiente Python3, disponibile al seguente link

Python per Windows

Nel nostro caso è stata scaricata la versione 3.6.4 per sistemi a 64 bit. Si procede alla installazione del pacchetto con diritti di amministrazione

Dopo aver proceduto ad aggiungere Python nel Path si preme “Install Now”

Dopo aver concluso l’installazione si apre una shell dos e si controlla la versione di Python installata

Sempre dalla consolle dos si procede alla installazione di esptool con il comando

pip install esptool

1	pip install esptool

Si può procedere a questo punto all’installazione del firmware MicroPython sulla scheda Nodemcu esp8266 DevKit. Occorre, naturalmente, aver installato su Windows i drivers del chip seriale-ttl presente sul proprio modello di scheda. Ci si posiziona nella cartella in cui si è scaricato il firmware e si eseguono i comandi da shell dos

esptool.py --port COMPORT erase_flash

1	esptool.py --port COMPORT erase_flash

Procedere al caricamento del firmware

esptool.py --port COMPORT --baud 460800 write_flash --flash_size=detect -fm=dio 0 firmware.bin

1	esptool.py --port COMPORT --baud 460800 write_flash --flash_size=detect -fm=dio 0 firmware.bin

Una volta installato il firmware connettiamoci sulla consolle Python utilizando, nel nostro caso con la scheda nodemcu DevKit, la stessa porta già sfruttata per il caricamento del firmware.

Su Windows si può utilizzare il programma putty

Putty

ed impostare la connessione seriale ad un baudrate di 115200

Linux

Per Linux utilizziamo la distribuzione Debian 9, ma la procedura può essere estesa ad altre distribuzioni. Dopo l’installazione di Debian 9, analoga a quanto eseguito per la versione 8

Debian 8

si procede alla installazione in Python3 e del tool esptool

sudo apt-get install python3
sudo apt-get install python3-pip

1 2	sudo apt-get install python3 sudo apt-get install python3-pip

Aggiungere l’utenza utilizzata su Debian al gruppo dialout

sudo usermod -a -G dialout USER

1	sudo usermod -a -G dialout USER

Nel nostro caso, utilizzando sviluppo come utente, il comando è il seguente

sudo usermod -a -G dialout sviluppo

1	sudo usermod -a -G dialout sviluppo

Passiamo alla installazione del pacchetto Python esptool

sudo pip3 install esptool

1	sudo pip3 install esptool

Si può quindi procedere alla installazione del firmware in modo analogo a quanto fatto su Windows.

Si controlla su che porta seriale è disponibile la scheda (ttyUSBX)

Si procede quindi alle operazioni di cancellazione e caricamento del firmware

esptool.py --port /dev/ttyUSBX erase_flash

1	esptool.py --port /dev/ttyUSBX erase_flash

esptool.py --port /dev/ttyUSBX --baud 460800 write_flash --flash_size=detect -fm=dio 0 firmware.bin

1	esptool.py --port /dev/ttyUSBX --baud 460800 write_flash --flash_size=detect -fm=dio 0 firmware.bin

Per collegarsi sulla scheda si usa screen

sudo apt-get install screen

1	sudo apt-get install screen

il cui manuale è presente al link

Manuale screen

screen /dev/ttyUSB0 115200

1	screen /dev/ttyUSB0 115200

Per eseguire il detach premere

Ctrl+a+d

Ctrl+a+d

per eseguire il resume

screen -r

screen -r

Per chiudere screen

killall screen

1	killall screen

Una volta collegato si ottiene il medesimo risultato di Windows

Nel prossimo articolo incominceremo a vedere quali IDE si possono usare per creare e caricare il nostro codice Python

IDE MicroPython uPyCraft

Micro Devices

Archivi tag: espressif

ESP32 – IDF Sdk con IDE Eclipse

ESP32 – IDF Sdk

ESP32 – Compilazione firmware nodemcu

ESP32 – Compilazione MicroPython per ESP32

MicroPython – Compilazione MicroPython per ESP8266 con moduli aggiuntivi

MicroPython – Compilazione MicroPython per ESP8266

MicroPython – Struttura programma MicroPython

Micropython – Strumenti di sviluppo Ampy – Eric

Micropython – IDE MicroPython uPyCraft

MicroPython – Python su dispositivi embedded

Blog dedicato a dispositivi embedded