Archivi tag: firmware

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

Compilazione, Installazione, Software

Installazione OctoPrint su Orange PI PC – Installazione pacchetto python

2017-11-21 admin

In questo articolo si descrive come abilitare la scheda Orange PI PC a server di rete per stampanti 3d.

Un sofware che fornisce tale funzionalità è OctoPrint

OctoPrint

Dal sito OctoPrint è possibile scaricare una immagine per Raspberry PI con il sistema già pronto; nel caso dell’Orange PI PC occorre procedere alla installazione del sistema OctoPrint su una immagine Linux.

E’ possibile anche usare una immagine Linux per Orange PI PC e seguire i passi relativi alla installazione di OctoPrint, ma è necessario verificare i prerequisiti del pacchetto python di OctoPrint.

Noi invece per questo articolo abbiamo compilato una immagine Debian mediante gli scripts Armbian.

Come prima operazione occorre preparare la scheda sd con una immagine Armbian. Nel caso specifico è stata creata una immagine Debian Jessie utilizzando lo script di Armbian, come indicato al link

Compilazione Armbian

e descritto in un precedente articolo

Creazione immagine Armbian per Orange PI PC

Abbiamo seguito i seguenti passi per la compilazione dell’ immagine Armbian su Ubuntu Xenial 16.04 ; da shell linux

git clone https://github.com/armbian/build
cd build
./compile.sh

git clone https://github.com/armbian/build

cd build

./compile.sh

Nelle opzioni di compilazione scegliere quanto segue

Non si cambia la configurazione di default del kernel

Scegliere come scheda Orange PI PC

Scegliere il mainline kernel

Scegliere Jessie come distribuzione

Abbiamo scelto come opzione il Desktop Envinronment

Dopo tale opzione lo script procede alla compilazione. L’immagine da noi generata è Armbian_5.34_Orangepipc_Debian_jessie_next_4.13.12_desktop.img. Tale immagine può essere scaricata al link

Immagine Armbian per Orange PI PC

Si avvia Armbian e si crea l’utenza per l’utenza; in questo caso è stato scelta come utenza octoprint/password.

Se necessario riconfigurare la tastiera con il comando

sudo dpg-reconfigure keyboard-configuration

1 2	sudo dpg-reconfigure keyboard-configuration

e procedere all’aggiornamento del sistema

sudo apt-get update
sudo apt-get upgrade

1 2	sudo apt-get update sudo apt-get upgrade

Se il sistema deve essere configurato tramite connessione wireless occorre che la connessione sia attiva all’avvio; per tale scopo nel nostro caso abbiamo utilizzato il demone wicd

Wicd Debian

Si rimuove il network-manager presente

sudo apt-get remove network-manager

1	sudo apt-get remove network-manager

che rimuove i pacchetti network-manager e network-manager-gnome.

Si controlla che l’interfaccia wireless non sia presente in /etc/network/interfaces

cat /etc/network/interfaces

1	cat /etc/network/interfaces

Si procede alla installazione di wicd

sudo apt-get install wicd

1	sudo apt-get install wicd

Si controlla che l’utenza octoprint sia presente nel gruppo netdev

cat /etc/group | grep netdev

1	cat /etc/group \| grep netdev

Nel nostro caso è già presente, dando come risultato

Nel caso non fosse presente aggiungerlo con il comando

sudo adduser octoprint netdev
sudo /etc/init.d/dbus reload

1 2	sudo adduser octoprint netdev sudo /etc/init.d/dbus reload

Far partire wicd

sudo systemctl start wicd

1	sudo systemctl start wicd

Collegarsi sul desktop grafico di Armbian e configurare la connessione wireless con il comando

wicd-client -n

1	wicd-client -n

Configurare e salvare la connessione di rete dall’interfaccia grafica.

Se si desidera il remote desktop si eseguono le operazioni già elencante all’articolo

Abilitazione Desktop Remoto su Armbian in Orange PI PC

Si può a questo punto procedere alla installazione di OctoPrint. Si seguono le indicazioni presenti al link

Installazione OctoPrint su Linux

Si installano i prerequisiti

sudo apt-get update
sudo apt-get install python-pip python-dev python-setuptools virtualenv python-virtualenv git libyaml-dev build-essential

1 2	sudo apt-get update sudo apt-get install python-pip python-dev python-setuptools virtualenv python-virtualenv git libyaml-dev build-essential

Creare sotto /opt la cartella octoprint ed assegnare l’ownership ad octoprint

sudo mkdir /opt/octoprint
sudo chown octoprint:octoprint -R /opt/octoprint

sudo mkdir /opt/octoprint

sudo chown octoprint:octoprint -R /opt/octoprint

Posizionarsi in /opt/octoprint e scaricare il sofware

cd /opt/octoprint
git clone https://github.com/foosel/OctoPrint.git

1 2	cd /opt/octoprint git clone https://github.com/foosel/OctoPrint.git

Eseguire quindi

cd OctoPrint
virtualenv venv
./venv/bin/pip install pip --upgrade
./venv/bin/python setup.py install

cd OctoPrint

virtualenv venv

./venv/bin/pip install pip --upgrade

./venv/bin/python setup.py install

Creare la cartella .octoprint

mkdir ~/.octoprint

1	mkdir ~/.octoprint

Assegnare i permessi all’utenza octoprint per gestire la porta della stampante 3d

sudo usermod -a -G tty octoprint
sudo usermod -a -G dialout octoprint

1 2	sudo usermod -a -G tty octoprint sudo usermod -a -G dialout octoprint

Si testa la corretta installazione eseguendo il comando

/opt/octoprint/OctoPrint/venv/bin/octoprint

1	/opt/octoprint/OctoPrint/venv/bin/octoprint

Il server OctoPrint è raggiungibile sulla porta 5000 all’indirizzo ip del Orange PI PC

http://indirizzoip:5000

Installare a questo punto la Cura Engine; posizionarsi nella home dell’utente octoprint e scaricare il pacchetto dei sorgenti

<code class="highlighter-rouge"></code>cd
wget https://github.com/Ultimaker/CuraEngine/archive/15.04.6.tar.gz

<code class="highlighter-rouge"></code>cd

wget https://github.com/Ultimaker/CuraEngine/archive/15.04.6.tar.gz

Scompattare il pacchetto

tar -zxvf 15.04.6.tar.gz

1	tar -zxvf 15.04.6.tar.gz

Entrare nella cartella scompattata

cd CuraEngine-15.04.6/

1	cd CuraEngine-15.04.6/

Eseguire la compilazione con il comando

make

make

Il software compilato è presente sotto la cartella build

Creare la cartella /opt/octoprint/cura e copiare il file CuraEngine in questa cartella

mkdir /opt/octoprint/cura
cd ~/CuraEngine-15.04.6/build
cp CuraEngine /opt/octoprint/cura/

mkdir /opt/octoprint/cura

cd ~/CuraEngine-15.04.6/build

cp CuraEngine /opt/octoprint/cura/

L’eseguibile è ora presente nella cartella /opt/octoprint/cura e sarà utilizzato in seguito da OctoPrint.

Nel prossimo articolo si descrive come configurare l’avvio automatico di OctoPrint

Avvio Automatico OctoPrint

Configurazione, Software

Enigma 2 – Come leggere il contenuto di una immagine

2017-08-20 admin

Nell’articolo

Compilazione Immagine Enigma2 OpenATV

abbiamo visto come compilare l’immagine Enigma 2.

Nel presente si mostra come visionare il contenuto dei file di una immagine Enigma2.

Come esempio useremo sempre l’immagine per lo Zgemma H2H.

In un ambiente Linux, Debian 8 nel nostro caso, scaricare l’immagine in una cartella, ad esempio enigma2

Scompattarla con il comando

unzip imagename.zip

1	unzip imagename.zip

Nella cartella scompattata abbiamo vari file

Quello di nostro interesse è rootfs.bin.

Il comando

file filename

1	file filename

ci dà indicazioni sulla natura del file. Nel caso di rootfs.bin

ci indica che si tratta di una immagine con ubi filesystem.

A questo punto installare come prima operazione le utility per memory technology device

sudo apt-get install mtd-utils

1	sudo apt-get install mtd-utils

Eseguire

sudo modprobe nandsim first_id_byte=0x2c second_id_byte=0xda third_id_byte=0x90 fourth_id_byte=0x95
sudo flash_erase /dev/mtd0 0 0
sudo ubiformat /dev/mtd0 -O 2048 -f ./rootfs.bin
sudo modprobe ubi
sudo ubiattach -p /dev/mtd0  -O 2048
sudo mkdir /mnt/ubifs
sudo mount -t ubifs /dev/ubi0_0 /mnt/ubifs

sudo modprobe nandsim first_id_byte=0x2c second_id_byte=0xda third_id_byte=0x90 fourth_id_byte=0x95

sudo flash_erase /dev/mtd0 0 0

sudo ubiformat /dev/mtd0 -O 2048 -f ./rootfs.bin

sudo modprobe ubi

sudo ubiattach -p /dev/mtd0 -O 2048

sudo mkdir /mnt/ubifs

sudo mount -t ubifs /dev/ubi0_0 /mnt/ubifs

Il contenuto del file è ora visibile sotto /mnt/ubifs

Per smontare il filesystem

sudo umount /mnt/ubifs

1	sudo umount /mnt/ubifs

Infine per eseguire il detach di UBI dal dispositivo mtd

sudo ubidetach /dev/ubi_ctrl -m 0

1	sudo ubidetach /dev/ubi_ctrl -m 0

Di seguito dei link per reperire ulteriori informazioni su mtd ed ubi

UBIFS

Linux MTD UBIFS

Software, Sviluppo

Compilazione addon Libreelec8 per Orange PI PC

2017-04-30 admin

Nell’articolo sulla compilazione di Libreelec 8 per Orange PI PC

Libreelec8 su Orange PI PC

avevamo creato l’ambiente e compilato l’immagine Libreelec 8 per la nostra scheda di sviluppo. Integriamo quanto detto nel precedente articolo mostrando come compilare gli addons per Libreelec 8.

Procediamo ora a compilare degli addon. I packages che si possono compilare sono presenti nelle cartelle kodi-binary-addons

e nella cartella packages/addons

Compiliamo per esempio il modulo pvr.iptvsimple con il seguente comando da shell dalla cartella /home/sviluppo/orangepi/libreelec/libreelec-8.0

PROJECT=H3 ARCH=arm scripts/create_addon pvr.iptvsimple

1	PROJECT=H3 ARCH=arm scripts/create_addon pvr.iptvsimple

Compiliamo l’addon proftpd, tra quelli presenti in packages/addons, con il comando

PROJECT=H3 ARCH=arm scripts/create_addon proftpd

1	PROJECT=H3 ARCH=arm scripts/create_addon proftpd

Gli addon risultanti sono presenti nelle relative cartelle in

/home/sviluppo/orangepi/libreelec/libreelec-8.0/target/addons/8.1/H3/arm/

1	/home/sviluppo/orangepi/libreelec/libreelec-8.0/target/addons/8.1/H3/arm/

Di seguito i link per scaricare alcuni addons compilati

PVR addon

Service Addons

Software, Sviluppo

Libreelec8 su OrangePI PC

2017-04-13 admin

In questo articolo si descrivono i passi che ho eseguito per preparare una prima versione di Libreelec 8 su Orange PI PC e altre schede con soc H3.

Partendo dall’ambiente di sviluppo Debian, con i relativi pacchetti installati, già utilizzato per la compilazione di Openelec 7

Compilazione immagine Openelec per Orange PI PC

si procede alla generazione della immagine per Libreelec 8.

E’ stato utilizzato come base il lavoro fatto per Openelec 7 e Libreelec 7 presenti sui due repository github

Github H3 Openelec 7

Github H3 Libreelec 7

Collegandosi sulla shell come sviluppo operiamo in modo analogo a quanto fatto per Openelec. Creaiamo una cartella libreelec sotto orangepi e spostiamoci in essa

sviluppo@debian8:~/orangepi$ mkdir libreelec
sviluppo@debian8:~/orangepi$ cd libreelec
sviluppo@debian8:~/orangepi/libreelec$

sviluppo@debian8:~/orangepi$ mkdir libreelec

sviluppo@debian8:~/orangepi$ cd libreelec

sviluppo@debian8:~/orangepi/libreelec$

Cloniamo il github di Libreelec con il comando

git clone -b libreelec-8.0 https://github.com/LibreELEC/LibreELEC.tv.git libreelec-8.0

1	git clone -b libreelec-8.0 https://github.com/LibreELEC/LibreELEC.tv.git libreelec-8.0

Le patch sono state create per una versione specifica del commit, per cui allineiamo il nostro clone github a quella versione

cd libreelec-8.0
git checkout 745f6790ec0456aa8478fff5360107c148ea5204

1 2	cd libreelec-8.0 git checkout 745f6790ec0456aa8478fff5360107c148ea5204

Scarichiamo dal link le patch ed il progetto per H3

H3 Libreelec 8

e scompattarlo in /home/sviluppo/orangepi/libreelec

Eseguire le seguenti operazioni

1)Copiare in /home/sviluppo/orangepi/libreelec/libreelec-8.0/projects la cartella

2) Copiare in /home/sviluppo/orangepi/libreelec/libreelec-8.0/packages/multimedia le cartelle

cedarx
libmpeg2

3) Copiare in /home/sviluppo/orangepi/libreelec/libreelec-8.0/packages/tools la cartella

sunxi-tools

4) Copiare in /home/sviluppo/orangepi/libreelec/libreelec-8.0/packages/sysutils la cartella

sunxi-sys-utils

5) Copiare in /home/sviluppo/orangepi/libreelec/libreelec-8.0/packages/graphics la cartella

sunxi-mali

6) Copiare in /home/sviluppo/orangepi/libreelec/libreelec-8.0/packages/linux-drivers la cartella

mt7601u

7) Le patch sono presenti in /home/sviluppo/orangepi/libreelec/H3LE8/patches

linux.patch

image.patch

mkimage.patch

kodi.patch

libcec.patch

u-boot.patch

u-boot-release.patch

u-boot-update.patch

Patchare il codice posizionandosi in /home/sviluppo/orangepi/libreelec ed eseguendo i comandi

patch  libreelec-8.0/packages/linux/package.mk < H3LE8/patches/linux.patch
patch  libreelec-8.0/scripts/image < H3LE8/patches/image.patch
patch  libreelec-8.0/scripts/mkimage < H3LE8/patches/mkimage.patch
patch libreelec-8.0/packages/mediacenter/kodi/package.mk < H3LE8/patches/kodi.patch 
patch  libreelec-8.0/packages/devel/libcec/package.mk < H3LE8/patches/libcec.patch
patch libreelec-8.0/packages/tools/u-boot/package.mk < H3LE8/patches/u-boot.patch
patch libreelec-8.0/packages/tools/u-boot/release < H3LE8/patches/u-boot-release.patch
patch libreelec-8.0/packages/tools/u-boot/scripts/update.sh < H3LE8/patches/u-boot-update.patch

patch libreelec-8.0/packages/linux/package.mk < H3LE8/patches/linux.patch

patch libreelec-8.0/scripts/image < H3LE8/patches/image.patch

patch libreelec-8.0/scripts/mkimage < H3LE8/patches/mkimage.patch

patch libreelec-8.0/packages/mediacenter/kodi/package.mk < H3LE8/patches/kodi.patch

patch libreelec-8.0/packages/devel/libcec/package.mk < H3LE8/patches/libcec.patch

patch libreelec-8.0/packages/tools/u-boot/package.mk < H3LE8/patches/u-boot.patch

patch libreelec-8.0/packages/tools/u-boot/release < H3LE8/patches/u-boot-release.patch

patch libreelec-8.0/packages/tools/u-boot/scripts/update.sh < H3LE8/patches/u-boot-update.patch

Procedere alla compilazione della immagine per OrangePI PC dalla cartella /home/sviluppo/orangepi/libreelec/libreelec-8.0 con il comando

ARCH=arm PROJECT=H3 SYSTEM=opipc  make image

1	ARCH=arm PROJECT=H3 SYSTEM=opipc make image

L’immagine viene generata nella cartella /home/sviluppo/orangepi/libreelec/libreelec-8.0/target

Dal link

Openelec 7 H3 FAQ

sono elencati le schede che si possono compilare modificando il parametro SYSTEM nel comando di compilazione

SYSTEM=opi2
SYSTEM=opione
SYSTEM=opipc
SYSTEM=opiplus
SYSTEM=opilite
SYSTEM=opipcplus
SYSTEM=opiplus2e
SYSTEM=bpim2p
SYSTEM=bx2

ARCH=arm PROJECT=H3 SYSTEM=SCHEDA  make image

1	ARCH=arm PROJECT=H3 SYSTEM=SCHEDA make image

Tale immagine è un primo tentativo di porting di H3 su Libreelec 8. L’immagine è stata installata su Orange PI PC e il sistema ha funzionato bene, ma sono possibili comunque bug e malfunzionamenti.

Qui è presente l’immagine Libreelec 8 compilata per Orange PI PC

Immagine Libreelec 8 Orange PI PC

Tale immagine è stata testata su Orange Pi PC.

Di seguito altre immagini non testate sui vari dispositivi

Immagine Libreelec 8 Orange Pi2

Immagine Libreelec 8 Orange Pi Lite

Immagine Libreelec 8 Orange Pi One

Immagine Libreelec 8 Orange Pi PC Plus

Immagine Libreelec 8 Orange Pi Plus

Immagine Libreelec 8 Orange Pi Plus 2e

ATTENZIONE: L’installazione dell’immagine generata sul dispositivo è a vostro rischio e pericolo. Non ci assumiamo alcuna responsabilità nel caso tale installazione generi malfunzionamento o blocco del dispositivo.

Nel seguente articolo si mostra come compilare gli addon

Compilazione addon Libreelec8 per Orange PI PC

Micro Devices

Archivi tag: firmware

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

Installazione OctoPrint su Orange PI PC – Installazione pacchetto python

Enigma 2 – Come leggere il contenuto di una immagine

Compilazione addon Libreelec8 per Orange PI PC

Libreelec8 su OrangePI PC

Blog dedicato a dispositivi embedded