Archivi categoria: Sviluppo

Esempio lua per modulo nodemcu enduser_setup (parte1)

2016-11-21 admin

Nel precedente artciolo abbiamo mostrato un esempio di codice LUA per ESP8266 su nodemcu

Facciamo ora vedere un esempio in cui si utilizza il modulo enduser_setup.

Come prima operazione compiliamo il firmware nodemcu inserendo anche il modulo enduser_setup. Si rieseguono i passi fatti nell’articolo della compilazione

Compilare Nodemcu su linux

modificando il file app/include/user_modules.h scommentando la direttiva

#define LUA_USE_MODULES_ENDUSER_SETUP

1	#define LUA_USE_MODULES_ENDUSER_SETUP

Dopo la compilazione del firmware e caricamento sul dispositivo, utilizziamo uno switch connesso al nodemcu dev kit come indicato di seguito

Il pin D5 può essere connesso ad un tensione bassa o alta. In base all’ingresso si modifica il comportamento del sistema.

Nota: Il Pin D5 nell’esempio specifico è stato usato in modalità di Input; nel caso si vogliano usare come Output, occorre inserire una resistenza per limitare la corrente di uscita, come specificato al link

Allocazione PIN GPIO

Nel prossimo articolo caricheremo del codice LUA di esempio e si utlizzerà il modulo enduser_setup per gestire le connessioni wifi

Esempio lua per modulo nodemcu enduser_setup (parte2)

Software, Sviluppo

Esempio Codice LUA per ESP8266

2016-11-16 admin

Come accennato nel precedente articolo

Caricare il firmware nodemcu con esptool

ora siamo pronti a caricare qualche esempio di codice sul sistema ESP8266.

Seguendo la documentazione Lua per Nodemcu

Documentazione LUA Nodemcu

proviamo a caricare un semplice server http sul sistema.

Apriamo ESPlorer e carichiamo il seguente codice, esempio modificato presente sul github, inserendo i valori appropriati per i campi “SSID” e “password”.

webserver pin

wifi.setmode(wifi.STATION)
wifi.sta.config("SSID", "password")
gpio.mode(1, gpio.OUTPUT)
srv=net.createServer(net.TCP)
srv:listen(80,function(conn)
    conn:on("receive", function(client,request)
        local buf = ""
        local _, _, method, path, vars = string.find(request, "([A-Z]+) (.+)?(.+) HTTP")
        if(method == nil)then
            _, _, method, path = string.find(request, "([A-Z]+) (.+) HTTP")
        end
        local _GET = {}
        if (vars ~= nil)then
            for k, v in string.gmatch(vars, "(%w+)=(%w+)&*") do
                _GET[k] = v
            end
        end
        buf = buf.."<h1> Hello, NodeMcu.</h1><form src=\"/\">Turn PIN1 <select name=\"pin\" onchange=\"form.submit()\">"
        local _on,_off = "",""
        if(_GET.pin == "ON")then
              _on = " selected=true"
              gpio.write(1, gpio.HIGH)
        elseif(_GET.pin == "OFF")then
              _off = " selected=\"true\""
              gpio.write(1, gpio.LOW)
        end
        buf = buf.."<option".._on..">ON</opton><option".._off..">OFF</option></select></form>"
        client:send(buf)
    end)
    conn:on("sent", function (c) c:close() end)
end)

wifi.setmode(wifi.STATION)

wifi.sta.config("SSID", "password")

gpio.mode(1, gpio.OUTPUT)

srv=net.createServer(net.TCP)

srv:listen(80,function(conn)

conn:on("receive", function(client,request)

local buf = ""

local _, _, method, path, vars = string.find(request, "([A-Z]+) (.+)?(.+) HTTP")

if(method == nil)then

_, _, method, path = string.find(request, "([A-Z]+) (.+) HTTP")

end

local _GET = {}

if (vars ~= nil)then

for k, v in string.gmatch(vars, "(%w+)=(%w+)&*") do

_GET[k] = v

end

buf = buf.."<h1> Hello, NodeMcu.</h1><form src=\"/\">Turn PIN1 <select name=\"pin\" onchange=\"form.submit()\">"

local _on,_off = "",""

if(_GET.pin == "ON")then

_on = " selected=true"

gpio.write(1, gpio.HIGH)

elseif(_GET.pin == "OFF")then

_off = " selected=\"true\""

gpio.write(1, gpio.LOW)

end

buf = buf.."<option".._on..">ON</opton><option".._off..">OFF</option></select></form>"

client:send(buf)

end)

conn:on("sent", function (c) c:close() end)

end)

Salviamo il file come ipstatico.lua. Con ESPlorer carichiamo il file sul nodemcu devkit con il pulsante “Save to ESP”.

Creare un secondo file init.lua

tmr.alarm(0, 5000, 0, function() dofile("ipstatico.lua") end)

1	tmr.alarm(0, 5000, 0, function() dofile("ipstatico.lua") end)

e salvare anche questo sul device.

Facciamo ripartire il dispositivo con il comando reset sul tool ESPlorer. Dalla barra dei comandi eseguiamo

print(wifi.sta.getip())

1	print(wifi.sta.getip())

che ci fornisce l’indirizzo ip acquisito dal disposito. Con il browser accediamo all’indirizzo ip ricavato sopra e troviamo una piccola interfaccia che ci permette di attivare o meno il PIN1 in uscita

Con tale metodo però occorre conoscere l’Access Point cui ci si deve connettere. Per superare questa limitazione si può utilizzare il modulo enduser setup

Modulo enduser_setup

Con tale modulo si avvia ESP8266 come access point con un portale su cui si possono inserire le credenziali dell’access point cui ci si deve collegare.

Nel prossimo articolo compileremo il firmware con l’aggiunta del modulo enduser_setup, non presente sulla compilazione standard, e faremo lo stesso esempio con il suo utilizzo

Esempio Lua modulo Enduser_setup

Software, Sviluppo

Caricare il firmware Nodemcu con esptool

2016-10-19 admin

Nell’articolo sulla compilazione del firmware Nodemcu

Compilazione firmware Nodemcu

avevamo creato nella cartella bin i file 0x0000.bin e 0x100000.bin e copiato i file dall’SDK Espressif blank.bin e esp_init_data_default.bin.

Dalla documentazione dello strumento esptool

esptool

il comando generico da usare è il seguente

esptool.py --port <serial-port-of-ESP8266> write_flash -fm <mode> -fs <size> 0x00000 <nodemcu-firmware>.bin

1	esptool.py --port <serial-port-of-ESP8266> write_flash -fm <mode> -fs <size> 0x00000 <nodemcu-firmware>.bin

Dal momento che siamo in presenza di una scheda con 4M di flash e con una velocità di comunicazione della USB di 9600 bps dovremo usare i seguenti parametri

mode=dio
size=32m

Sempre dalla documentazione esptool, non avendo creato il firmware con docker, siamo in presenza dei due file, che avevamo già provveduto a combinare nel file nodemcu_float.bin.

Nel caso della scheda a nostra disposizione è stato necessario anche usare i file

esp_init_data_default.bin: parametri di default del firmware.
blank.bin: reset dei dati sulla scheda.

secondo la mappatura indicata al link

Guida ESP8266

Nel nostro caso gli indirizzi usati (4M di flash) sono

0x3FC000 per esp_init_data_default.bin.
0x3FE000 per blank.bin

Ci si posiziona in una command shell script nella cartella nodemcu-firmware e si impostano i path corretti

/home/sviluppo/esp8266/nodemcu-firmware
export PATH="$HOME/esp8266/esp-open-sdk/xtensa-lx106-elf/bin/:$PATH"
alias xgcc="xtensa-lx106-elf-gcc

/home/sviluppo/esp8266/nodemcu-firmware

export PATH="$HOME/esp8266/esp-open-sdk/xtensa-lx106-elf/bin/:$PATH"

alias xgcc="xtensa-lx106-elf-gcc

I comandi da eseguire sono quindi i seguenti, considerando /dev/ttyUSB0 la porta USB del dev kit

Reset della scheda

./tools/esptool.py --port /dev/ttyUSB0 --baud 9600 erase_flash 
./tools/esptool.py --port /dev/ttyUSB0  --baud 9600 write_flash -fm dio -fs 32m  0x3FE000 ./bin/blank.bin

1 2	./tools/esptool.py --port /dev/ttyUSB0 --baud 9600 erase_flash ./tools/esptool.py --port /dev/ttyUSB0 --baud 9600 write_flash -fm dio -fs 32m 0x3FE000 ./bin/blank.bin

Caricamento del firmware

./tools/esptool.py --port /dev/ttyUSB0  --baud 9600 write_flash -fm dio -fs 32m 0x00000 ./bin/nodemcu_float.bin 0x3fc000 ./bin/esp_init_data_default.bin

1	./tools/esptool.py --port /dev/ttyUSB0 --baud 9600 write_flash -fm dio -fs 32m 0x00000 ./bin/nodemcu_float.bin 0x3fc000 ./bin/esp_init_data_default.bin

Nel prossimo articolo caricheremo del nostro codice LUA scipt sul dispositivo.

Esempio codice Lua

Software, Sviluppo

Compilare nodemcu su linux

2016-10-08 admin

Trattiamo ora i passi da seguire per creare la propria immagine Nodemcu con cross compilazione su Linux.

Partiamo sempre dalla immagine Debian descritta in articolo precedente

Ambiente Debian

Seguendo quanto indicato al link

Cross compilazione

come prima operazione prepariamo l’ambiente di cross compilazione.

Colleghiamoci su Debian con la nostra utenza (sviluppo nel nostro caso) e creiamo una cartella esp8266 da riga comando

mkdir esp8266
cd esp8266

1 2	mkdir esp8266 cd esp8266

Installiamo i prerequisiti

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

sudo apt-get install make

sudo apt-get install unrar

sudo apt-get install autoconf

sudo apt-get install automake

sudo apt-get install libtool

sudo apt-get install gcc

sudo apt-get install g++

sudo apt-get install gperf

sudo apt-get install flex

sudo apt-get install bison

sudo apt-get install texinfo

sudo apt-get install gawk

sudo apt-get install ncurses-dev

sudo apt-get install libncurses5-dev

sudo apt-get install libexpat-dev

sudo apt-get install python

sudo apt-get install python-dev

sudo apt-get install python-serial

sudo apt-get install sed

sudo apt-get install git

sudo apt-get install unzip

sudo apt-get install bash

sudo apt-get install help2man

sudo apt-get install wget

sudo apt-get install bzip2

sudo apt-get install libtool-bin

sudo apt-get install srecord

sudo apt-get install python2.7-dev

Procediamo a scaricare il repository esp-open-sdk

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

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

per procedere alla sua compilazione

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

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

Al termine della compilazione abbiamo la seguente indicazione

Xtensa toolchain is built, to use it:

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

Espressif ESP8266 SDK is installed, its libraries and headers are merged with the toolchain

Xtensa toolchain is built, to use it:

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

Espressif ESP8266 SDK is installed, its libraries and headers are merged with the toolchain

Occorre inserire nel PATH quanto segue

export PATH=/home/sviluppo/esp8266/esp-open-sdk/xtensa-lx106-elf/bin:$PATH
alias xgcc="xtensa-lx106-elf-gcc"

1 2	export PATH=/home/sviluppo/esp8266/esp-open-sdk/xtensa-lx106-elf/bin:$PATH alias xgcc="xtensa-lx106-elf-gcc"

Possiamo clonare a queto punto il github del firmware Nodemcu. Sempre dalla precedente finestra di riga comandi eseguire

sviluppo@debian8:~/esp8266/esp-open-sdk$ cd ..
sviluppo@debian8:~/esp8266$ pwd
/home/sviluppo/esp8266
sviluppo@debian8:~/esp8266$

sviluppo@debian8:~/esp8266/esp-open-sdk$ cd ..

sviluppo@debian8:~/esp8266$ pwd

/home/sviluppo/esp8266

sviluppo@debian8:~/esp8266$

Una volta posizionati nella cartella esp8266 eseguire

git clone https://github.com/nodemcu/nodemcu-firmware

1	git clone https://github.com/nodemcu/nodemcu-firmware

Al termine posizionarsi in nodemcu-firmware

cd nodemcu-firmware

1	cd nodemcu-firmware

Prima di procedere alla creazione del nostro primo firmware apportiamo delle modifche sulla configurazione presente in app/include/user_config.h

Abilitiamo la direttiva per il nostro devkit 0.9 (devkit in nostro possesso)

#define DEVKIT_VERSION_0_9 1 // define this only if you use NodeMCU devkit v0.9

Modifichiamo la velocità di comunicazione sulla USB (velocità di comunicazione del nostro devkit)

//#define BIT_RATE_DEFAULT BIT_RATE_115200
#define BIT_RATE_DEFAULT BIT_RATE_9600

Modifichiamo la dimensione della flash a 4M (dimensione a nostra disposizione)

#define FLASH_4M
// #define FLASH_8M
// #define FLASH_16M
//#define FLASH_AUTOSIZE

Salviamo il file e procediamo alla creazione del firmware con il comando

make

make

Al termine sotto la cartella bin

sviluppo@debian8:~/esp8266/nodemcu-firmware$ ls ./bin
0x00000.bin 0x10000.bin

1 2	sviluppo@debian8:~/esp8266/nodemcu-firmware$ ls ./bin 0x00000.bin 0x10000.bin

troveremo due file: 0x00000.bin e 0x100000.bin. Creiamo un solo file nodemcu_float.bin con il comando

srec_cat -output ./bin/nodemcu_float.bin -binary ./bin/0x00000.bin -binary -fill 0xff 0x00000 0x10000 ./bin/0x10000.bin -binary -offset 0x10000

1	srec_cat -output ./bin/nodemcu_float.bin -binary ./bin/0x00000.bin -binary -fill 0xff 0x00000 0x10000 ./bin/0x10000.bin -binary -offset 0x10000

Aggiungiamo l’utente sviluppo al gruppo abilitato a scrivere sulla usb

sudo adduser $USER dialout

1	sudo adduser $USER dialout

Debian vede senza necessità di drivers aggiuntivi la porta USB. In presenza di macchina virtuale abilitare la periferica.

Accedere all’sdk scaricato e compilato prima; nella cartella bin copiare i file

blank.bin
esp_init_data_default.bin

nella cartella bin dove sono stati generati i file del firmware nodemcu

A questo punto siamo pronti a caricare il firmware sul dispositivo mediante lo strumento esptool. Nel prossimo articolo descriveremo come caricare il firmware sul dispositivo

Caricare il firmware con esptool

Software, Sviluppo

Caricare codice LUA su ESP8266

2016-10-06 admin

Dopo aver installato il firmware appropriato

Caricare il firmware

si può caricare il proprio codice LUA script sul nostro device. Per eseguire tale operazione esistono diversi strumenti

Caricare codice Lua

In questo articolo installeremo ESPlorer

ESPlorer

E’ una applocazione java e disponibile per i sistemi operativi Windows, Linux ed Osx. Come prerequisito richiede la presenza di Java SE ver. 7 o superiore.

Si scarica il tool dal link sotto elencato in una cartella

Scarica ESPlorer

e si lancia mediante il comando

java -jar "ESPlorer.jar"

1	java -jar "ESPlorer.jar"

o tramite script dos o unix (ESPlorer.bat o ESPlorer.sh).

A questo punto si collega il Nodemcu devkit al pc e si impostano i parametri di comunicazione e la velocità della porta COM.

Si presenta, per esempio in Windows, la seguente schermata

Si può premere Open che permette l’accesso sul dispositivo.

Si può a questo punto procedere alla creazione del proprio codice in LUA script e caricarlo sull’ESP8266 utilizzando; il codice si può generare integrandolo con i vari moduli messi a disposizione dal firmware secondo la documentazione

Nodemcu API

Nel prossimo articolo descriveremo come compilare una versione del firmware personalizzata in Linux

Compilazione Nodemcu

Software, Sviluppo

Compilazione modulo openwrt

2016-09-14 admin

Nell’articolo precedente

Compilazione Immagine OpenWrt

si è descritto come compilare il firmware OpenWrt per il router TP-Link TL-MR3420 V1. Di seguito si mostra come compilare un modulo, vsftpd, ed installarlo sul sistema da shell.

Eseguire il comando make menuconfig

make menuconfig

1	make menuconfig

ed accedere alla sezione relativa al modulo vsftpd sotto Network->File Transfer ed abilitarlo come moduloSalvare la configurazione in .config ed eseguire i comandi

make defconfig
make package/vsftpd/compile V=s

1 2	make defconfig make package/vsftpd/compile V=s

Al termine del processo il pacchetto del modulo è presente nella directory packages sotto la cartella bin della piattaforma utilizzataCopiare il file sul router come root mediante scp (su windows si può utilizzare WinScp) nella cartella /tmp. Non eseguire l’aggiornamento dei repository dei pacchetti dalla interfaccia web (se eseguito far ripartire il dispositivo) ed accedere al router mediante ssh, sempre come root, per procedere alla installazione del pacchetto

root@OpenWrt:/tmp# opkg install vsftpd_3.0.2-4.1_ar71xx.ipk
Installing vsftpd (3.0.2-4.1) to root...
Configuring vsftpd.
root@OpenWrt:/tmp#

root@OpenWrt:/tmp# opkg install vsftpd_3.0.2-4.1_ar71xx.ipk

Installing vsftpd (3.0.2-4.1) to root...

Configuring vsftpd.

root@OpenWrt:/tmp#

OpenWrt mette a disposizione tanti moduli che permettono di potenziare notevolmente le funzionalità del dispositivo; alcuni moduli sono abbastanza esosi come risorse , per cui è possibile installarli su router con hardware più potente.

Software, Sviluppo

Compilazione immagine openwrt

2016-09-14 admin

Dopo aver descritto brevemente il firmware OpenWrt nel precedente articolo

OpenWrt

si passa alla compilazione del firmware OpenWrt per il proprio dispositivo.

L’esempio sarà basato sul router TP-Link TL-MR3420 versione 1. Tale modello è presente fra la lista dei modelli supportati da OpenWrt; di seguito il link alla documentazione del modello in oggetto

TP-Link TL-MR3420

Dalla documentazione si nota che il SOC è un Atheros AR7241. Questa informazione sarà utilizzata in fase di configurazione della compilazione del firmware. Come operazione preliminare scaricare anche il firmware originale del router presente al link precedente

Firmware Originale

Nella pagina TP-Link TL-MR3420 sono presenti inoltre i link al firmware opewrt in due varianti:

Firmware per intallazione: openwrt-15.05.1-ar71xx-generic-tl-mr3420-v1-squashfs-factory.bin.
Firmware per aggiornamento: openwrt-15.05.1-ar71xx-generic-tl-mr3420-v1-squashfs-sysupgrade.bin

Partendo dal firmware originale si usa il firmware per installazione, mentre per aggiornare da openwrt si usa il secondo tipo.

Dal link di OpenWrt sulla compilazione dell’immagine

Sviluppo OpenWrt

si eseguono le seguenti operazioni su Debian preparato in precedenza

Preparazione ambiente Debian

Aperta una shell su Debian come utente normale (non root) si installano i prerequisiti

sudo apt-get install git-core 
sudo apt-get install build-essential 
sudo apt-get install libssl-dev 
sudo apt-get install libncurses5-dev 
sudo apt-get install unzip 
sudo apt-get install gawk
sudo apt-get install subversion 
sudo apt-get install mercurial

sudo apt-get install git-core

sudo apt-get install build-essential

sudo apt-get install libssl-dev

sudo apt-get install libncurses5-dev

sudo apt-get install unzip

sudo apt-get install gawk

sudo apt-get install subversion

sudo apt-get install mercurial

Creare una cartella OpenWrt e clonare il repository. Nel nostro caso scegliamo il branch stabile 15.05

mkdir OpenWrt
cd OpenWrt
git clone  https://git.openwrt.org/15.05/openwrt.git 15.05

mkdir OpenWrt

cd OpenWrt

git clone https://git.openwrt.org/15.05/openwrt.git 15.05

Al termine del processo git eseguire

cd 15.05
./scripts/feeds update -a
./scripts/feeds install -a

cd 15.05

./scripts/feeds update -a

./scripts/feeds install -a

Siamo pronti a questo punto ad eseguire la compilazione della immagine per il TP-Link TL-MR3420 V1.

Si lancia il comando

make menuconfig

1	make menuconfig

scegliendo come Target System AR7xxx/AR9xxx come indicato di seguitoCon i seguenti pulsanti si modificano le opzioni:

y: si compila.
m: si compila come modulo.
n: non viene considerato.

Fare riferimento al link

Compilazione OpenWrt

per tutte le opzioni.

Premendo Invio alla schermata successiva si sceglie la piattaforma correttaSi devono installare anche i pacchetti minimi per l’amministrazione del sistema, ossia LuCI baseAlla schermata successiva si sceglie Collectione quindi l’opzione luci che installa automaticamente i prerequisiti tra i quali anche un server httpSi installano anche i moduli crittografici del kernel accedendo ai moduli del kernelSi sceglie poi l’opzione delle api crittograficheed infine si scelgono i seguenti moduli compilati con l’immagineConviene salvare la configurazione in un file in modo da riutilizzarla in seguito. Salvare infine la configurazione nel file .config.

Uscire dal menuconfig ed eseguire il comando

make defconfig

1	make defconfig

in modo da controllare tutti i prerequisiti necessari alla compilazione.

Per avviare la compilazione eseguire il comando

make V=s

make V=s

Il comando precedente esegue la compilazione in verbose mode.

Al termine della compilazione si hanno i file dei firmware nella cartella bin piattaforma scelta. Nel nostro caso le immagini sono evidenziate nella figura seguenteSi può procedere alla installazione del firmware.

ATTENZIONE: Prima di procedere alla installazione del firmware verificate la procedura di recupero del vostro router in caso di qualche problema, quale avvio in recovery mode, flash via tftp, jtag, ecc. 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 disposivo.

Si faccia riferimento al sito di OperWrt per tutte le opzioni ed impostazioni utilizzabili per la compilazione e lo sviluppo dei moduli. Nel prossimo articolo

Compilazione modulo OpenWrt

si descrive come compilare ed installare da linea comando il server ftp vsftpd.

Software, Sviluppo

Creazione immagine Armbian per Orange PI PC

2016-09-02 admin

Passiamo ora alla creazione della immagine Armbian per Orange PI PC. Dal github dello sviluppatore

Armbian Github

sono elencati i passi da seguire.

Dal sito Armbian

Compilazione immagine Armbian

l’ambiente di compilazione testato è Ubuntu. Nel nostro test utilizzando una distribuzione Ubuntu 16.04.1 LTS x86-64

Ubuntu

lo script compile.sh installa automaticamente i pacchetti necessari alla compilazione dell’immagine. Sul sito sono presenti inoltre le varie opzioni di compilazione.

Volendo utilizzare la distribuzione Debian 8.5 come host per eseguire la procedura, si sono seguiti i seguenti passi riportati di seguito. Nel caso si riportino errori si utilizzi la distribuzione Ubuntu suggerita sul sito Armbian.

Come operazione preliminare installiamo il crosscompilatore per Debian

https://wiki.debian.org/CrossToolchains

Creare il file crosstools.list in /etc/apt/sources.list.d

sudo vi /etc/apt/sources.list.d/crosstools.list

1	sudo vi /etc/apt/sources.list.d/crosstools.list

ed inseriamo la voce

deb http://emdebian.org/tools/debian/ jessie main

1	deb http://emdebian.org/tools/debian/ jessie main

Salviamo il file ed aggiungiamo la chiave del repository

sudo apt-get install curl

1	sudo apt-get install curl

curl http://emdebian.org/tools/debian/emdebian-toolchain-archive.key | sudo apt-key add -

1	curl http://emdebian.org/tools/debian/emdebian-toolchain-archive.key \| sudo apt-key add -

Installiamo i seguenti pacchetti e l’architettura armhf

sudo dpkg --add-architecture armhf
sudo apt-get update
sudo apt-get install autoconf
sudo apt-get install ccache
sudo apt-get install git
sudo apt-get install qemu
sudo apt-get install qemu-user-static
sudo apt-get install dchroot
sudo apt-get install debootstrap
sudo apt-get install apt-cacher-ng 
sudo apt-get install pigz
sudo apt-get install pv
sudo apt-get install mpv
sudo apt-get install  u-boot-tools
sudo apt-get install ntpdate
sudo apt-get install device-tree-compiler
sudo apt-get install pkg-config
sudo apt-get install libusb-1.0-0-dev
sudo apt-get install libusb-dev
sudo apt-get install gcc-4.9-multilib
sudo apt-get install crossbuild-essential-armhf

sudo dpkg --add-architecture armhf

sudo apt-get update

sudo apt-get install autoconf

sudo apt-get install ccache

sudo apt-get install git

sudo apt-get install qemu

sudo apt-get install qemu-user-static

sudo apt-get install dchroot

sudo apt-get install debootstrap

sudo apt-get install apt-cacher-ng

sudo apt-get install pigz

sudo apt-get install pv

sudo apt-get install mpv

sudo apt-get install u-boot-tools

sudo apt-get install ntpdate

sudo apt-get install device-tree-compiler

sudo apt-get install pkg-config

sudo apt-get install libusb-1.0-0-dev

sudo apt-get install libusb-dev

sudo apt-get install gcc-4.9-multilib

sudo apt-get install crossbuild-essential-armhf

Siamo pronti ad installare l’ambiente per la compilazione sia su Ubuntu che Debian. Creaimo una cartella armbian sotto orangepi nella cartella dell’utente con cui ci si collega, che nel nostro caso è sviluppo

sviluppo@debian8:~/orangepi$ ls
openelec  sunxi
sviluppo@debian8:~/orangepi$ mkdir armbian

sviluppo@debian8:~/orangepi$ ls

openelec sunxi

sviluppo@debian8:~/orangepi$ mkdir armbian

Ci si posiziona in questa cartella e si eseguono i comandi

git clone https://github.com/igorpecovnik/lib --depth 1
cp lib/compile.sh .

1 2	git clone https://github.com/igorpecovnik/lib --depth 1 cp lib/compile.sh .

Per procedere alla compilazione eseguire

./compile.sh

1	./compile.sh

Inserire la password di root per poter proseguire. Quando richiesto selezionare come indicato nelle immagini seguenti.

Immagine completa

Scheda OrangePI PC

Scegliamo il kernel di default

Immagine Debian stabile

Immagine con Desktop Envinronment

Sotto la cartella output/images viene generata l’immagine da caricare sulla scheda micro sd come descritto in articolo precedente

Software, Sviluppo

Creazione pacchetto enigma2

2016-08-28 admin

Dopo aver compilato l’immagine enigma2

Immagine Enigma 2

mostriamo come creare un package.

Nella cartella recipes-local

~/enigma2/openatv/build-enviroment/meta-local/recipes-local

1	~/enigma2/openatv/build-enviroment/meta-local/recipes-local

creaimo una cartella per il nostro package, ad esempio testpackage, e una sottocartella files

mkdir testpackage
cd testpackage
makdir files
cd files

mkdir testpackage

cd testpackage

makdir files

cd files

Creare del codice nella cartella files, ad esempio testpackage.c

#include <stdio.h>
int main(int argc, char** argv){
printf("Test Package!\n\n");
return 0;
}

#include <stdio.h>

int main(int argc, char** argv){

printf("Test Package!\n\n");

return 0;

}

Creiamo il file Readme.txt nella cartella files e LICENSE nella cartella testpackage. Nel file Readme.txt vi sono le informazioni sulla applicazione. Per la licenza, che al momento si può lasciare anche vuoto, occorre create l’hash da inserire nel file bitbake.

Creare il file md5 per la licenza

md5sum ~/enigma2/openatv/build-enviroment/meta-local/recipes-local/testpackage/LICENCE
d41d8cd98f00b204e9800998ecf8427e

1 2	md5sum ~/enigma2/openatv/build-enviroment/meta-local/recipes-local/testpackage/LICENCE d41d8cd98f00b204e9800998ecf8427e

Creaimo il file bitbake testpackage_0.1.bb sotto la cartella testpackage per la cross compilazione

DESCRIPTION = "testpackage application"
PR = "r0"
LICENSE = "TEST"
LIC_FILES_CHKSUM = "file:///home/sviluppo/enigma2/openatv/build-enviroment/meta-local/recipes-local/testpackage/LICENSE;md5=d41d8cd98f00b204e9800998ecf8427e"

 

SRC_URI = "file://testpackage.c \
file://README.txt"
do_compile() {
${CC} ${CFLAGS} ${LDFLAGS} ${WORKDIR}/testpackage.c -o testpackage
}
do_install() {
install -m 0755 -d ${D}${bindir} ${D}${docdir}/testpackage
install -m 0755 ${S}/testpackage ${D}${bindir}
install -m 0644 ${WORKDIR}/README.txt ${D}${docdir}/testpackage
}

DESCRIPTION = "testpackage application"

PR = "r0"

LICENSE = "TEST"

LIC_FILES_CHKSUM = "file:///home/sviluppo/enigma2/openatv/build-enviroment/meta-local/recipes-local/testpackage/LICENSE;md5=d41d8cd98f00b204e9800998ecf8427e"

SRC_URI = "file://testpackage.c \

file://README.txt"

do_compile() {

${CC} ${CFLAGS} ${LDFLAGS} ${WORKDIR}/testpackage.c -o testpackage

}

do_install() {

install -m 0755 -d ${D}${bindir} ${D}${docdir}/testpackage

install -m 0755 ${S}/testpackage ${D}${bindir}

install -m 0644 ${WORKDIR}/README.txt ${D}${docdir}/testpackage

}

Compiliamo il pacchetto ad esempio per zgemma accedendo all’ambiente dedicato a tale sistema con

cd /home/sviluppo/enigma2/openatv/build-enviroment/builds/openatv/release/h3/
source env.source
bitbake testpackage

cd /home/sviluppo/enigma2/openatv/build-enviroment/builds/openatv/release/h3/

source env.source

bitbake testpackage

Il file viene generato nella seguente cartella

sviluppo@debian8:~/enigma2/openatv/build-enviroment/builds/openatv/release/h3/tmp/deploy/ipk/mips32el$ ls testpackage*
testpackage_0.1-r0_mips32el.ipk      testpackage-dev_0.1-r0_mips32el.ipk
testpackage-dbg_0.1-r0_mips32el.ipk  testpackage-doc_0.1-r0_mips32el.ipk
sviluppo@debian8:~/enigma2/openatv/build-enviroment/builds/openatv/release/h3/tmp/deploy/ipk/mips32el$

sviluppo@debian8:~/enigma2/openatv/build-enviroment/builds/openatv/release/h3/tmp/deploy/ipk/mips32el$ ls testpackage*

testpackage_0.1-r0_mips32el.ipk testpackage-dev_0.1-r0_mips32el.ipk

testpackage-dbg_0.1-r0_mips32el.ipk testpackage-doc_0.1-r0_mips32el.ipk

sviluppo@debian8:~/enigma2/openatv/build-enviroment/builds/openatv/release/h3/tmp/deploy/ipk/mips32el$

Copiare il pacchetto testpackage_0.1-r0_mips32el.ipk sullo ZGemma H3 nella cartella /tmp ed eseguire

opkg install testpackage_0.1-r0_mips32el.ipk

1	opkg install testpackage_0.1-r0_mips32el.ipk

Per forzare l’installazione senza tenere conto dei prerequisiti

opkg --nodeps install testpackage_0.1-r0_mips32el.ipk

1	opkg --nodeps install testpackage_0.1-r0_mips32el.ipk

L’eseguibile è presente nella cartella /usr/bin; la sua esecuzione ci dà l’output che ci si aspettava

root@zgemmah2h:/tmp# testpackage
Test Package!

1 2	root@zgemmah2h:/tmp# testpackage Test Package!

Software, Sviluppo

Compilazione Immagine Enigma2 OpenATV

2016-08-17 admin

In questo articolo descriviamo come preparare una immagine Enigma2 basata sulla distribuzione OpenATV

Openatv

Dopo aver installato l’ambiente di compilazione, come descritto nel blog

Preparazione ambiente Debian

si può procedere come segue.

Collegarsi sull’ambiente Debian con l’utenza da utilizzare per la compilazione; nel nostro caso l’utenza è sviluppo. Nella home directory dell’utente creare la cartella enigma2

mkdir enigma2
cd enigma2

1 2	mkdir enigma2 cd enigma2

Installare i seguenti pacchetti

sudo apt-get install autoconf
sudo apt-get install automake
sudo apt-get install bison
sudo apt-get install bzip2
sudo apt-get install cvs
sudo apt-get install diffstat
sudo apt-get install flex
sudo apt-get install g++
sudo apt-get install gawk
sudo apt-get install gcc
sudo apt-get install gettext
sudo apt-get install git-core
sudo apt-get install gzip
sudo apt-get install help2man
sudo apt-get install ncurses-bin
sudo apt-get install ncurses-dev
sudo apt-get install libc6-dev
sudo apt-get install libtool
sudo apt-get install make
sudo apt-get install texinfo
sudo apt-get install patch
sudo apt-get install perl
sudo apt-get install pkg-config
sudo apt-get install subversion
sudo apt-get install tar
sudo apt-get install texi2html
sudo apt-get install wget
sudo apt-get install zlib1g-dev
sudo apt-get install chrpath
sudo apt-get install libxml2-utils
sudo apt-get install xsltproc
sudo apt-get install libglib2.0-dev
sudo apt-get install python-setuptools
sudo apt-get install libc6-i386
sudo apt-get install genromfs
sudo apt-get install guile-1.8-libs
sudo apt-get install gparted
sudo apt-get install quilt
sudo apt-get install git
sudo apt-get install  libproc-processtable-perl

sudo apt-get install autoconf

sudo apt-get install automake

sudo apt-get install bison

sudo apt-get install bzip2

sudo apt-get install cvs

sudo apt-get install diffstat

sudo apt-get install flex

sudo apt-get install g++

sudo apt-get install gawk

sudo apt-get install gcc

sudo apt-get install gettext

sudo apt-get install git-core

sudo apt-get install gzip

sudo apt-get install help2man

sudo apt-get install ncurses-bin

sudo apt-get install ncurses-dev

sudo apt-get install libc6-dev

sudo apt-get install libtool

sudo apt-get install make

sudo apt-get install texinfo

sudo apt-get install patch

sudo apt-get install perl

sudo apt-get install pkg-config

sudo apt-get install subversion

sudo apt-get install tar

sudo apt-get install texi2html

sudo apt-get install wget

sudo apt-get install zlib1g-dev

sudo apt-get install chrpath

sudo apt-get install libxml2-utils

sudo apt-get install xsltproc

sudo apt-get install libglib2.0-dev

sudo apt-get install python-setuptools

sudo apt-get install libc6-i386

sudo apt-get install genromfs

sudo apt-get install guile-1.8-libs

sudo apt-get install gparted

sudo apt-get install quilt

sudo apt-get install git

sudo apt-get install libproc-processtable-perl

Riconfigurare la shell come segue

sudo dpkg-reconfigure dash

1	sudo dpkg-reconfigure dash

Scegliere No come opzione.

Creare la cartella openatv sotto enigma2

mkdir openatv
cd openatv

1 2	mkdir openatv cd openatv

Creare una cartella sources sotto openatv; tale cartella conterrà i sorgenti dei vari tipi di dispositivi che si vogliono compilare

mkdir sources

1	mkdir sources

Clonare in locale il repository git della oe-alliance

git clone https://github.com/oe-alliance/build-enviroment.git

1	git clone https://github.com/oe-alliance/build-enviroment.git

Al termine del download entrare nella cartella build-envinronment ed eseguire make

cd build-enviroment
make

1 2	cd build-enviroment make

Editare ora il file site.conf e modificare il parametro della cartella di download dei sorgenti da

DL_DIR = "/home/sviluppo/enigma2/openatv/build-enviroment/sources"

1	DL_DIR = "/home/sviluppo/enigma2/openatv/build-enviroment/sources"

DL_DIR = "/home/sviluppo/enigma2/openatv/sources"

1	DL_DIR = "/home/sviluppo/enigma2/openatv/sources"

Dalla cartella build-environment eseguire la compilazione della immagine; ad esempio per il decoder Airdigital Zgemma H2H

MACHINE=zgemmah2h DISTRO=openatv  make image

1	MACHINE=zgemmah2h DISTRO=openatv make image

Per il decode Xtrend et10000

MACHINE=et10000DISTRO=openatv  make image

1	MACHINE=et10000DISTRO=openatv make image

Al termine della compilazione l’immagine è presente nella cartella sotto deploy a seconda del dispositivo di cui si è compilata l’immagine: nel caso dello Zgemma H2H

/home/sviluppo/enigma2/openatv/build-enviroment/builds/openatv/release/h3/tmp/deploy/images/h3/

1	/home/sviluppo/enigma2/openatv/build-enviroment/builds/openatv/release/h3/tmp/deploy/images/h3/

L’immagine da installare sul dispositivo è lo zip che viene generato dal processo di compilazione, da scompattare in questo caso su una penna USB e caricare sullo Zgemma H2H.

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.

Micro Devices

Archivi categoria: Sviluppo

Esempio lua per modulo nodemcu enduser_setup (parte1)

Esempio Codice LUA per ESP8266

Caricare il firmware Nodemcu con esptool

Compilare nodemcu su linux

Caricare codice LUA su ESP8266

Compilazione modulo openwrt

Compilazione immagine openwrt

Creazione immagine Armbian per Orange PI PC

Creazione pacchetto enigma2

Compilazione Immagine Enigma2 OpenATV

Blog dedicato a dispositivi embedded