Category Archives: Compilation

Compilation, Development, Software

ESP32 – IDF Sdk with Eclipse

2019-04-29 admin

After configuring the IDF development environment in the previous article

ESP32 – IDF Sdk

let’s see now how to use Eclipse as IDE for code development. Instructions are available at the link

Eclipse Setup

Download the C/C++ Eclipse for Linux

Eclipse Download

Unpack the file and move it to /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/

Run ecplise

/opt/eclipse/ecplise

1	/opt/eclipse/ecplise

Set the workspace for eclipse

Once the IDE is open, select File -> Import -> C / C ++ – -> Existing Code as Makefile Project

Press Next; on the next screen select the folder containing the Makefile of a sample project in the “Existing Code Location” field and choose CrossGcc as “Toolchain for indexer settings” as shown below

Once the project is loaded, using the mouse right button on the project name, select the properties option

Under C / C ++ Build -> Envinronment add the variable

BATCH_BUILD = 1

1	BATCH_BUILD = 1

Add the IDF_PATH variable pointing to the downloaded IDF SDK in the same section

IDF_PATH=~/Esp32/espressif/esp-idf

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

Edit the PATH variable and add the path to the bin folder of the cross compiler /home/sviluppo/Esp32/espressif/esp/xtensa-esp32-elf/bin

Access “C / C ++ General” -> “Preprocessor Include Paths”; choose the Providers tab and click on “CDT Cross GCC Built-in Compiler Settings”

Replace $ {COMMAND}

with xtensa-esp32-elf-gcc

Choose now, always in the providers section, “CDT GCC Build Output Parser”

and insert at the beginning of the “Compiler command pattern” xtensa-esp32-elf-

Save the configurations.

The project settings should always be made by make menuconfig in the unix shell. Access the shell and set the LED to be switched on/off the value 2 as GPIO; this is because in our case the card is a doit whose design is illustrated in this document

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

Access to Example configuration

and set the gpio value to 2

Save the configuration. Go back to Eclipse and proceed with cleaning with

and subsequent compilation with Project -> Build

To run firmware flash from eclipse;, select the project and with the right button choose Build Targets -> Create …

Enter flash as value in the target name field, leaving everything else as default

At this point we proceed to upload the image by double-clicking on the new flash item within the project targets

The settings to run the flash must be set with make menuconfig, as seen in the previous article

ESP32 – IDF Sdk

Compilation, Software

ESP32 – IDF Sdk

2019-04-07 admin

This article describes how to set the Espressif development environment for the ESP32.

From the link to the resources for the soc

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

we access the guide for compiling the firmware on the Windows, OSX and Linux platforms

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

In this article we use Linux Debian 9 as operating system, configured as described previously here

MicroPython – Python ib embedded devices

We use the IDF github. On Debian 9, with the user used to connect to the system, we create the Esp32 folder under the user’s Home and the espressif folder inside it

cd
mkdir Esp32
cd Esp32
mdkir espressif
cd espressif

mkdir Esp32

cd Esp32

mdkir espressif

cd espressif

Install the prerequisites

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

Download the cross compiler

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

Create the esp folder and unpack the 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

Add the bin folder of the cross compiler to the PATH

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

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

Add the user used for the operations to the dialout group

sudo usermod -a -G dialout USER

1	sudo usermod -a -G dialout USER

Clone the IDF repository from $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

Add the IDF_PATH environment variable

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

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

Create the project folder under $HOME/Esp32/espressif and copy an example from di IDF examples

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

Run the configuration

make menuconfig

1	make menuconfig

Access Serial flasher config -> and set the connection parameters; in our case we leave the default

Save the configuration and build the firmware

make

make

To upload the firmware on the device run

make flash

1	make flash

To upload only the application run

make app-flash

1	make app-flash

while to build only the application run

make app

make app

To run the program monitor run

make monitor

1	make monitor

Here are the other examples available with sdk

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

The following link contains the references of the IDF API

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

You can also generate documentation from the github source. Go into ~/Esp32/espressif/esp-idf/docs/en

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

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

Install the prerequisites

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

Generate documentantion in html format

make html

make html

The documentation is available under _build / html.

In the next article we will configure Eclipse as IDE to build our applications

ESP32 -IDF Sdk with Eclipse

Compilation, Software

ESP32 – Nodemcu firmware compiling

2018-08-17 admin

After the compilation of the MicroPython firmware for ESP32

ESP32 – MicroPython compiling for ESP32

this article shows how to generate the Nodemcu firmware for the ESP32 MCU.

The firmware is not yet complete as the one existing for ESP8266.

The instructions can be found on the github at the link

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

The compilation documentation is available at the link

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

The operating system used is Debian 9 previously encountered for the esptool and Adafruit-ampy utilities

MicroPython – Python on embedded devices

Log on with the operating system user on Debian 9, sviluppo in our case; under the home folder create the Esp32 folder and inside this folder the nodemcu folder

cd
mkdir Esp32
cd Esp32
mkdir nodemcu
cd nodemcu

mkdir Esp32

cd Esp32

mkdir nodemcu

cd nodemcu

Clone the 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

To update the cloned repository follow the description on the compilation link, i.e.

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

Go into nodemcu-firmware-esp32 folder and run

cd nodemcu-firmware-esp32
make menuconfig

1 2	cd nodemcu-firmware-esp32 make menuconfig

Enable the bluetooth in Component config–>Bluetooth

Enable various modules in Component config–>Nodemcu modules

In the flash settings we set the default values for our ESP32, Serial flasher config->

Save the configuration and exit. To build the firmware run

make

make

At the end of the compilation the command to upload the firmware is shown; the same operation is executed by simply running

make flash

1	make flash

For informations about the partitions of the various ESP32 versions, refer to the documentation

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

In the next article we’ll show how to make an application using the Espressif SDK

ESP32 – IDF Sdk

Compilation, Software

ESP32 – MicroPython compiling for ESP32

2018-08-08 admin

We begin now a series of articles about the Espressif ESP32 MCU

ESP32 Wifi-Bluetooth Module

After having analyzed in the previous articles MicroPython for ESP8266, in this we start to treat MicroPython on ESP32.

The following shows how to generate the MicroPython image from the source code for the ESP32 board.

The operating system is Debian 9, previously encountered for the esptool and Adafruit-ampy utilities

MicroPython – Python on embedded devices

Log on with the operating system user on Debian 9, sviluppo in our case; under the home folder create the Micropython folder and inside this folder the esp32 folder

mkdir Micropython
cd Micropython
mkdir esp32
cd esp32

mkdir Micropython

cd Micropython

mkdir esp32

cd esp32

The MicroPython source code is available at the following link

Github Micropython

Instructions to build the firmware for the ESP32 are available at the link

MicroPython esp32

Clone the repository

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

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

Go into micropython/ports/esp32 folder

cd micropython/ports/esp32

1	cd micropython/ports/esp32

Run

make

make

The command releases the git hash for the supported espidf

At the time of our compilation the result is as follows

sviluppo@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.

sviluppo@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.

Go into /home/sviluppo/Micropython/esp32 folder and clone 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

Checkout with the hash obtained above

git checkout 3ede9f011b50999b0560683f9419538c066dd09e

1	git checkout 3ede9f011b50999b0560683f9419538c066dd09e

Run

git submodule update --init

1	git submodule update --init

We follow the instructions at the link

Cross compiler

to install the cross compiler; install the prerequisites for building

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

Download the cross compiler

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

Create the esp folder under /home/sviluppo/Micropython/esp32

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

cd /home/sviluppo/Micropython/esp32

mkdir esp

cd esp

Unpack the cross compiler 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

Add the binary folder of the cross compiler to the PATH envinronment variable

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

Go into the following folder

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

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

and create the makefile file with the following code inside

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

Go into the micropython folder available in /home/sviluppo/Micropython/esp32

cd micropython

1	cd micropython

Run

git submodule update --init

1	git submodule update --init

to add external dependencies.

Next step is the MicroPython cross compiler build

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

Finally we can build the ESP32 firmware with the following commands

cd ports/esp32
make

1 2	cd ports/esp32 make

The firmware is generated under ports/esp32/build with the name firmware.bin.

Proceed to load the firmware with the commands

make erase

1	make erase

In our case, the firmware upload was successful with the command

make deploy

1	make deploy

It is also possible to load the firmware.bin image with the commands

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

where /dev/ttyXXX is replaced with the actual serial port to which we connect the ESP32 board.

In the next article we’ll compile the nodemcu firmware for ESP32

ESP32 – Nodemcu firmware compiling

Compilation, Software

MicroPython – MicroPython compiling for ESP8266 with additional modules

2018-07-04 admin

After the firmware build of the MicroPython firmware for esp8266 in the previous article

MicroPython – MicroPython compiling for ESP8266

we now show how build a module inside the firmware; this option optimizes the module execution and minimizes the size of the same on the device; the module is frozen into the firmware.

With the firmware compiled with the defaults, the following modules are available, listed in the REPL console with the command

help('modules')

1	help('modules')

Now let’s try to compile the firmware with the mqtt modules already inside. For this purpose, the module sources are copied to the umqtt folder under 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

We proceed to recompile the firmware. From micropython/ports/esp8266 we run the following commands

make clean
make

1 2	make clean make

We can see from the compilation log, that these modules are placed in the frozen state

After uploading this firmware we obtain the following list of modules inside the firmware

It is also possible to create the firmware with the modules not compiled and optimized, by copying the sources in the scripts folder under esp8266; in the specific case the sources must be placed as shown below

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

The modules are always visible in the firmware, but not optimized, so if you need some module it is convenient to copy it on the device during the coding and in the last phase of the project compile the firmware with the frozen modules.

Compilation, Software

MicroPython – MicroPython compiling for ESP8266

2018-06-25 admin

After using in some examples the MicroPython firmware on the ESP8266 board

MicroPython – Nodes examples with DHT11, Relay and MQTT

this article shows how to generate the MicroPython firmware for the ESP8266 board.

The operating system used for this task is Debian 9, already encountered when we analyzed the esptool utility

MicroPython – Python on embedded devices

Log on with the operating system user on Debian 9, sviluppo in our case; under the home folder create the Micropython folder and inside this folder the esp8266 folder

mkdir Micropython
cd Micropython
mkdir esp8266
cd esp8266

mkdir Micropython

cd Micropython

mkdir esp8266

cd esp8266

The MicroPython source code is available at the following link

Github Micropython

Instructions to build the firmware for the ESP8266 are available at the link

MicroPython esp8266

Clone the repository

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

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

Download the cross compiler, as described here

Cross compiler

As indicated in the link above, download the source of the cross compiler always from the folder esp8266

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

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

Install the prerequisites for building

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

Proceed to the build of the cross compiler with the following commands

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

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

At the end of the build add the binary folder of the cross compiler to the PATH envinronment variable

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

Go into the micropython folder available under ~/Micropython/esp8266

cd ~/Micropython/esp8266/micropython

1	cd ~/Micropython/esp8266/micropython

Run

git submodule update --init

1	git submodule update --init

to add external dependencies.

Next step is the MicroPython cross compiler build

make -C mpy-cross

1	make -C mpy-cross

Finally we can build the ESP8266 firmware with the following commands

cd ports/esp8266
make axtls
make

cd ports/esp8266

make axtls

make

The firmware is generated under ports/esp8266/build folder with the name firmware_combined.bin.

Proceed to load the firmware with the command

esptool.py --port /dev/ttyXXX erase_flash

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

where /dev/ttyXXX is repalced with the actual serial port to which we connect the ESP8266 board.

In our case, the firmware upload was successful with the command

make PORT=/dev/ttyUSB0 deploy

1	make PORT=/dev/ttyUSB0 deploy

It is also possible to load the firmware_combined.bin image with the command

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

In the next article we’ll analyze how to build the MicroPython firmware adding into the image additional MicroPython modules

MicroPython – MicroPython compiling for ESP8266 with additional modules

Compilation, Installation, Software

OctoPrint installation on Orange PI PC – Python package installation

2017-11-21 admin

This article describes how to enable the Orange PI PC board to work as 3d printers network server.

A software that provides this functionality is OctoPrint

OctoPrint

From the OctoPrint site we can download an image for Raspberry PI with the system already ready; in the case of the Orange PI PC we have to install and configure OctoPrint on a Linux image.

You can also use a Linux image available for Orange PI PC and run the steps related to OctoPrint package installation, but you have to check the prerequisites for Octoprint python package installation.

We instead built for this article an image using the Armban scripts.

As a first step, prepare the micro sd card with an Armbian image. In the specific case, we’ll use a Debian Jessie image created using the Armbian script, as indicated on the link

Armbian building

and described also in a previous article

Building Armbian image for Orange PI PC

We followed these steps to build the Armbian image on Ubuntu Xenial 16.04; from a Linux command shell

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

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

cd build

./compile.sh

In the building options choose

We selected the default kernel configuration

Choose an Orange PI PC board

We used the mainline kernel

and Debian Jessie as distribution

We built an image with desktop envinronment

After this option, the script proceeds to the compilation. The generated image is Armbian_5.34_Orangepipc_Debian_jessie_next_4.13.12_desktop.img. This image can be downloaded from the link

Armbian image for Orange Pi PC

Start Armbian and create the user for the Jessie image; in this case we choose octoprint/password as user.

If necessary, reconfigure the keyboard with the command

sudo dpg-reconfigure keyboard-configuration

1 2	sudo dpg-reconfigure keyboard-configuration

and proceed to upgrade the system

sudo apt-get update
sudo apt-get upgrade

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

If the system needs to be configured via a wireless connection, the connection must be active at startup. For this purpose in our case we used the Wicd daemon

Wicd Debian

Remove the network-manager package

sudo apt-get remove network-manager

1	sudo apt-get remove network-manager

This command uninstalls network-manager and network-manager-gnome.

Check that the wireless interface is not present in

/etc/network/interfaces

cat /etc/network/interfaces

1	cat /etc/network/interfaces

Proceed to Wicd installation

sudo apt-get install wicd

1	sudo apt-get install wicd

Check that the octoprint user is present in the netdev group

cat /etc/group | grep netdev

1	cat /etc/group \| grep netdev

In our case it is already present, giving as a result

If not present, add it with the command

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

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

Start wicd

sudo systemctl start wicd

1	sudo systemctl start wicd

Logon to the armbian graphic desktop and start the wireless configuration with the command

wicd-client -n

1	wicd-client -n

Configure and save the network connection from the graphical interface.

If you want the remote desktop follow the steps listed in the article

Remote desktop setup for Armbian on Orange PI PC

We can now install Octoprint. Follow the steps available at the link

OctoPrint installation on Linux

Install the prerequisites

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

Create under /opt the octoprint folder and assign the ownership to octoprint

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

sudo mkdir /opt/octoprint

sudo chown octoprint:octoprint -R /opt/octoprint

In a Linux shell command go to /opt/octoprint folder and download the software

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

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

Run

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

Create the .octoprint folder

mkdir ~/.octoprint

1	mkdir ~/.octoprint

Add octoprint to the following groups to manage the 3d printer using the USB port

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

Check the correct installation by running the command

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

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

The OctoPrint server can be reached on port 5000 at the IP address of Orange PI PC

http://ipaddress:5000

Install the Cura Engine at this point; place yourself in the octoprint user’s home and download the source package

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

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

Unpack the package

tar -zxvf 15.04.6.tar.gz

1	tar -zxvf 15.04.6.tar.gz

Go into the unpacked folder

cd CuraEngine-15.04.6/

1	cd CuraEngine-15.04.6/

Run the compilation with the command

make

make

The compiled software is located under the build folder

Create the /opt /octoprint/cura folder and copy the CuraEngine file to this folder

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/

The executable is now in the /opt/octoprint/cura folder and will be used later by OctoPrint.

In the next article we’ll treat how to configure OctoPrint’s automatic startup

OctoPrint Autostart

Compilation, Software

LEDE building for Linkit 7688 Duo

2017-07-09 admin

After OpenWrt image building using the Mediatek SDK

OpenWrt building for Linkit 7688 and 7688 Duo

this article describes how to generate a LEDE image for the Linkit 7688 Duo.

The steps on how to compile LEDE are available at the link

LEDE Building

Clone the code from the github in a shell command window, always from the Linkit folder

cd
cd Linkit

1 2	cd cd Linkit

run

git clone https://git.lede-project.org/source.git Lede

1	git clone https://git.lede-project.org/source.git Lede

Create the src folder under Linkit and extract the compressed file

Feed for Linkit

This feed was created from Mediatek one, eliminating the binary drivers dependency.

Copy the file to the src folder and uncompress it

sviluppo@debian:~/Linkit/src$ ls
linkit.tar.gz
sviluppo@debian:~/Linkit/src$ tar -zxvf linkit.tar.gz

sviluppo@debian:~/Linkit/src$ ls

linkit.tar.gz

sviluppo@debian:~/Linkit/src$ tar -zxvf linkit.tar.gz

sviluppo@debian:~/Linkit/src$ ls
linkit  linkit.tar.gz
sviluppo@debian:~/Linkit/src$

sviluppo@debian:~/Linkit/src$ ls

linkit linkit.tar.gz

sviluppo@debian:~/Linkit/src$

Go to the Lede folder and copy the feeds.conf.default file as feeds.conf

cd 
cd Linkit/Lede
cp feeds.conf.default feeds.conf

cd Linkit/Lede

cp feeds.conf.default feeds.conf

Run

echo src-cpy  linkit ~/Linkit/src/linkit >> feeds.conf

1	echo src-cpy linkit ~/Linkit/src/linkit >> feeds.conf

Update the feeds for the packages

./scripts/feeds update

1	./scripts/feeds update

Install the packages

./scripts/feeds install -a

1	./scripts/feeds install -a

Configure the kernel executing

make menuconfig

1	make menuconfig

Use the following settings

Target System: Mediatek Ralink MIPS
Subtarget: MT7688 based boards
Target Profile: Mediatek LinkIt Smart 7688

In the Base system section enable mtk-linkit

Save and exit.

Run the building

make V=s -j x

1	make V=s -j x

where x is the number of cores to use in the building.

At the end of the process the generated image is available in the bin/targets/ramips/mt7688/ folder as lede-ramips-mt7688-LinkIt7688-squashfs-sysupgrade.bin.

The built firmware is available here

Lede Image for Linkit 7688 Duo

WARNING: The image installation on the device is at your own risk. We accept no responsibility if the installation leads to malfunction or block of the device.

If you upgrade the board using an usb key, you need to rename the lede-ramips-mt7688-LinkIt7688-squashfs-sysupgrade.bin file in lks7688.img.

This firmware may have malfunctions as it is not thoroughly tested and based on drivers under development.

In the next articles we’ll upload the images to the board and configure them

Installation and configuration of the Openwrt Image on Linkit 7688 and 7688 Duo

Compilation, Software

OpenWrt building for Linkit 7688 and 7688 Duo

2017-07-09 admin

After describing the general specifications of the two boards in the previous article

Linkit 7688 and 7688 Duo Development Boards

now we build the OpenWrt image from the sources. The following link describes the steps

Building the firmware from the source code

First we have to create the folder Linkit under /home/sviluppo in a shell command window in our Debian image, already used to build OpenWrt in another article

Building OpenWrt Image

cd
mkdir Linkit
cd Linkit

mkdir Linkit

cd Linkit

Install the prerequisites

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 libxml-parser-perl
sudo apt-get install g++

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 libxml-parser-perl

sudo apt-get install g++

Clone the OpenWrt repository

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

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

In the shell command window go to the openwrt folder and copy feeds.conf.default file as feeds.conf

cd openwrt
cp feeds.conf.default feeds.conf

1 2	cd openwrt cp feeds.conf.default feeds.conf

Add the Mediatek feed for the boards

echo src-git linkit https://github.com/MediaTek-Labs/linkit-smart-7688-feed.git >> feeds.conf

1	echo src-git linkit https://github.com/MediaTek-Labs/linkit-smart-7688-feed.git >> feeds.conf

Update the feeds for the packages

./scripts/feeds update

1	./scripts/feeds update

Install the packages

./scripts/feeds install -a

1	./scripts/feeds install -a

Configure the kernel executing

make menuconfig

1	make menuconfig

Use the following settings

Target System: Ralink RT288x/RT3xxx
Subtarget: MT7688 based boards
Target Profile: LinkIt7688

Save and exit.

Run the building

make V=99

make V=99

At a certain point, the building generates an error for the wireless card libraries. Mediatek has not released the wireless card sources, but an sdk with compiled binaries for a kernel version different from the one we are using in the building; the error reported is

cp -fpR ./wifi_binary/mt_wifi.ko_3.18.45 /home/sviluppo/Linkit/openwrt/build_dir/target-mipsel_24kec+dsp_uClibc-0.9.33.2/linux-ramips_mt7688/mtk-sdk-wifi-2015-06-01/ipkg-ramips_24kec/mtk-sdk-wifi/lib/modules/3.18.45/mt_wifi.ko
cp: cannot stat './wifi_binary/mt_wifi.ko_3.18.45': No such file or directory
Makefile:93: recipe for target '/home/sviluppo/Linkit/openwrt/bin/ramips/packages/linkit/mtk-sdk-wifi_2015-06-01-ade8b1b299cbd5748db1acf80dd3e9f567938371_ramips_24kec.ipk' failed
make[3]: *** [/home/sviluppo/Linkit/openwrt/bin/ramips/packages/linkit/mtk-sdk-wifi_2015-06-01-ade8b1b299cbd5748db1acf80dd3e9f567938371_ramips_24kec.ipk] Error 1
make[3]: Leaving directory '/home/sviluppo/Linkit/openwrt/feeds/linkit/mtk-sdk-wifi'
package/Makefile:191: recipe for target 'package/feeds/linkit/mtk-sdk-wifi/compile' failed
make[2]: *** [package/feeds/linkit/mtk-sdk-wifi/compile] Error 2
make[2]: Leaving directory '/home/sviluppo/Linkit/openwrt'
package/Makefile:188: recipe for target '/home/sviluppo/Linkit/openwrt/staging_dir/target-mipsel_24kec+dsp_uClibc-0.9.33.2/stamp/.package_compile' failed
make[1]: *** [/home/sviluppo/Linkit/openwrt/staging_dir/target-mipsel_24kec+dsp_uClibc-0.9.33.2/stamp/.package_compile] Error 2
make[1]: Leaving directory '/home/sviluppo/Linkit/openwrt'
/home/sviluppo/Linkit/openwrt/include/toplevel.mk:181: recipe for target 'world' failed
make: *** [world] Error 2
sviluppo@debian:~/Linkit/openwrt$

cp -fpR ./wifi_binary/mt_wifi.ko_3.18.45 /home/sviluppo/Linkit/openwrt/build_dir/target-mipsel_24kec+dsp_uClibc-0.9.33.2/linux-ramips_mt7688/mtk-sdk-wifi-2015-06-01/ipkg-ramips_24kec/mtk-sdk-wifi/lib/modules/3.18.45/mt_wifi.ko

cp: cannot stat './wifi_binary/mt_wifi.ko_3.18.45': No such file or directory

Makefile:93: recipe for target '/home/sviluppo/Linkit/openwrt/bin/ramips/packages/linkit/mtk-sdk-wifi_2015-06-01-ade8b1b299cbd5748db1acf80dd3e9f567938371_ramips_24kec.ipk' failed

make[3]: *** [/home/sviluppo/Linkit/openwrt/bin/ramips/packages/linkit/mtk-sdk-wifi_2015-06-01-ade8b1b299cbd5748db1acf80dd3e9f567938371_ramips_24kec.ipk] Error 1

make[3]: Leaving directory '/home/sviluppo/Linkit/openwrt/feeds/linkit/mtk-sdk-wifi'

package/Makefile:191: recipe for target 'package/feeds/linkit/mtk-sdk-wifi/compile' failed

make[2]: *** [package/feeds/linkit/mtk-sdk-wifi/compile] Error 2

make[2]: Leaving directory '/home/sviluppo/Linkit/openwrt'

package/Makefile:188: recipe for target '/home/sviluppo/Linkit/openwrt/staging_dir/target-mipsel_24kec+dsp_uClibc-0.9.33.2/stamp/.package_compile' failed

make[1]: *** [/home/sviluppo/Linkit/openwrt/staging_dir/target-mipsel_24kec+dsp_uClibc-0.9.33.2/stamp/.package_compile] Error 2

make[1]: Leaving directory '/home/sviluppo/Linkit/openwrt'

/home/sviluppo/Linkit/openwrt/include/toplevel.mk:181: recipe for target 'world' failed

make: *** [world] Error 2

sviluppo@debian:~/Linkit/openwrt$

One way to fix the problem is the following.

Go to the /home/sviluppo/Linkit/openwrt/feeds/linkit/mtk-sdk-wifi/wifi_binary/ folder and copy the files for our kernel version

cp mt_wifi.ko_3.18.44 mt_wifi.ko_3.18.45
cp mt_wifi.ko_3.18.44_all  mt_wifi.ko_3.18.45_all

1 2	cp mt_wifi.ko_3.18.44 mt_wifi.ko_3.18.45 cp mt_wifi.ko_3.18.44_all mt_wifi.ko_3.18.45_all

Rerun the building. At the end of the process the generated file is available in the bin/ramips folder

The built firmware is available here

OpenWrt Linkit 7688 and 7688 Duo Image

WARNING: The image installation on the device is at your own risk. We accept no responsibility if the installation leads to malfunction or block of the device.

If you upgrade the board using an usb flah drive, you need to rename the openwrt-ramips-mt7688-LinkIt7688-squashfs-sysupgrade.bin file in lks7688.img.

The image kernel for this building is 3.18_45; If you want to use a recent kernel, you must use the opensource drivers available for the board; in the case of the Linkit 7688 Duo card, in our possession, we can rebuild the image using the Realtek rt76 drivers for the wireless network adapter and add the additional components for the Atmel MCU using LEDE, an OpenWrt fork

LEDE Project

In the next article you will build a LEDE image for the Linkit 7688 Duo board. For the Linkit 7688 board at this time, the mraa libraries, used to interface the periphals, are not yet compatible with the latest version of LEDE and the functionality of the image is limited. There may be also bugs in the wireless card opensource drivers, which hopefully are solved in the refinement of these drivers.

LEDE building for Linkit 7688 Duo

Micro Devices

Category Archives: Compilation

ESP32 – IDF Sdk with Eclipse

ESP32 – IDF Sdk

ESP32 – Nodemcu firmware compiling

ESP32 – MicroPython compiling for ESP32

MicroPython – MicroPython compiling for ESP8266 with additional modules

MicroPython – MicroPython compiling for ESP8266

OctoPrint installation on Orange PI PC – Python package installation

LEDE building for Linkit 7688 Duo

OpenWrt building for Linkit 7688 and 7688 Duo

Blog about embedded devices