Hi all. As you know the Omegas don't have any internal Real Time Clock (RTC) device. Without Internet connection after startup you can see 1970 year. Many devices don't need Internet, but most of them need correctly clock and calendar i.e. it can be SQL server. Software clock is not convenient.

To connect external RTC you have to install special driver (kernel module), but it may not be compatibly with Omega's OS or you can catch fatal error on loading. Kernel models are very difficult things for us (simple users). Look at below of my external RTC device PCF8563.

Fortunately, you can fix it without kernel module - user-space driver will be enough. I make it and named as liburtc. Follow the project in my repository.

The project consists with liburtc.so library (shared object) and urtcdate utility. The library provide API for your own application and also to urtcdate too. Urtcdate works similar with date utility in a Linux. After installation urtcdate utility it set self-running into the file /usr/sbin/ntpd-hotplug and will run after every NTP-client synchronizations including on startup. If you haven't Internet connection and incorrect Software clock, utility will correct it from external RTC device.

This project out of official application repository, but you can install it manually, see this below:

wget https://bitbucket.org/hlorka/liburtc/downloads/liburtc_1.0-1_mipsel_24kc.ipk
wget https://bitbucket.org/hlorka/liburtc/downloads/urtcdate_1.0-1_mipsel_24kc.ipk
opkg install ./liburtc_1.0-1_mipsel_24kc.ipk ./urtcdate_1.0-1_mipsel_24kc.ipk

Version 1.0 now supports only one RTC chip PCF8563, but you can append another to the library sources or contact me to get help. Everyone can join to the project and make your own pull-requests (Git).

How to optimize using battery power

As you see my external RTC-module was upgrade. To use Battery power more effective I recommend change Silicon rectifier (1N4148) to a Ge-rectifier with less forward drop voltage. I'm using old Russian diodes Д9[Б|Д|Е] they have very low forward voltage and they widely distributed in The Russian Federation, Belarus Republic, Ukraine, etc.

In the photo below you can see Voltage measurement before and after this rectifier.

I fixed it! The library libugpio with bugs. Below is 100% work code GPIO (sysfs) preudo-IRQ + libgpio. See and analyze.

!#c++

#include <iostream>
#include <ugpio.h>

// For gpio (sysfs) test pseudo-IRQs control only
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <poll.h>


using namespace std;


#define DEFAULT_GPIO_TEST_PIN 11
#define GPIO_EDGE_RISING "rising"
#define GPIO_EDGE_FALLING "falling"
#define GPIO_EDGE_BOTH "both"


/*
 * The function below copied from project https://github.com/OnionIoT/gpioIrqTrigger/blob/master/gpioIrqTrigger.c
 * It's correct setting edge in "gpio - sysfs".
 * WARNING! The libugpio's function equivalent "ugpio_set_edge()" doesn't work (Bug)!
*/
static int my_gpio_set_edge(const unsigned int gpio, const char *edge)
{
	int fd, len;
	char buf[255];
	memset(buf, 0, sizeof(buf));

	len = snprintf(buf, sizeof(buf), "/sys/class/gpio/gpio%d/edge", gpio);

	fd = open(buf, O_WRONLY | O_NONBLOCK);
	if (fd < 0) {
		cerr << "Error open file file " << buf << " result code #" << fd << endl;
		return fd;
	}

	write(fd, edge, strlen(edge) + 1);
	close(fd);
	return 0;
}


static int test_ugpioIrq_pin(unsigned int pinNum, const char * edge) {

	int result;

	// Initializations for poll()'function using
	struct pollfd fds[1];
	int length;
	char buf[255];
	char d;

	/* Запрашиваем номер вывода */
	ugpio_t *pMyPin = ugpio_request_one(pinNum, GPIOF_DIR_IN, "MyTestPin");
	if (pMyPin == NULL) {
		cerr << "Error: Pin #" << pinNum << " cannot be requested." << endl;
		return -1;
	}

	/* 
	* Устанавливаем направление - вход 
	* ATTENTION! We are using low-level API of libugpio, because function "ugpio_direction_input()" doesn't work (Bug) and already returns value -1.
	*/
	result = gpio_direction_input(pinNum);
	if (result < 0) {
		cerr << "Error: Cannot assign direction, function ugpio_direction_input()." << endl;
		goto err_exit;
	}

	/* Устанавливаем триггер срабатывания [ "rising" | "falling" | "both" ] */
	if (result = my_gpio_set_edge(pinNum, edge) < 0) { 
		cerr << "Error: set edge fail" << endl;
		goto err_exit;
	}

	/* Открытие вывода для дальнейших операций */
	result = ugpio_open(pMyPin);
	if (result < 0) {
		cerr << "Error open file pin in sysfs" << endl;
		goto err_exit;
	}

	// Пятикратный опрос poll() 
	for (int i = 0; i < 5; i++) {

		memset((void*)fds, 0, sizeof(fds));
		fds[0].fd = ugpio_fd(pMyPin);			// File descriptor number of opened file: /sysfs/class/gpio/gpio[N]/value
		fds[0].events = POLLPRI;				// By official manual from https://www.kernel.org/doc/Documentation/gpio/sysfs.txt

		if (result = poll(fds, (sizeof(fds) / sizeof(struct pollfd)), 10000) < 0) {   // Wait change pin state while 10 seconds.
			cerr << "Error: Poll function call failed" << endl;
			goto err_exit2;
		}

		/* Event analyze block --begin */
		if (fds[0].revents & POLLPRI) {

			/*
			* [options] Чтение значения состояния пина
			*/
			memset(buf, 0, sizeof(buf));				// Очистка буфера для стабильности

			lseek(fds[0].fd, 0, SEEK_SET);				// Становка указателя в начало
			length = read(fds[0].fd, buf, sizeof(buf));	// Читаем значение файлового дескриптора

			cout << "GPIO current state is " << buf << endl;

		}
		/* Event analyze block --end */
	}

	result = 0;

err_exit2:
	ugpio_close(pMyPin);

err_exit:
	ugpio_free(pMyPin);
	return result;

}

@supczinskib, thank you for the answer. Your UI looks like production factory device.

Your idea has interes in general. I think main controller need a bigger display for monitoring parameters. All its configurations must be declared via web-intetface or any cloud server.

Also this device need a big hardware part (pums, valves, sensors including remoted). I think it needs a big database about botany as help-part for users.

By the way... sensors you can power by solar sells, to trsnsfer data you can get LoRa net.

@supczinskib, please tell us how did you make splash boot screen with a progress bar?

Also how use third-party touch input device in the Omega?

Step 3.2. Cross-compilation (Omega OS)

The most interesting for us is a case of cross-compiling the application. This step provides an example of configuring and compiling this project via a third-party SDK using the Linux OpenWRT SDK for a single-board minicomputer Onion Omega2+.

The Omega 2 single-board computer provided with pre-installed its own Linux Onion OS operating system, which has a lot of limitations and unfortunately the vendor does not provide a convenient ready-to-use SDK.

To use it we need to compile Onion SDK from sources. Docker's variant is not working on Windows 10 Home Edition. In this step it is no need!

Onion OS is based on another operating system OpenWRT 18.06 which has the SDK (it already compiled for MIPS architecture and processor Mediatek MT7688 as our Omega2 builded). It ready to run on a x86-x64 host architecture. Therefore, the fastest way to create cross-platform user space applications is download OpenWRT 18.06 SDK x86_x64 MIPS MT76x8

Now let's begin cross-compiling.

1. Select a convenient SDK installation directory in the host (x86/x64) and go to it. By the known link OpenWRT SDK x86_x64 MIPS MT76x8 we find the archive file .tar.xz with the text "-sdk-", download, unpack; example below:

     wget https://downloads.openwrt.org/releases/18.06.2/targets/ramips/mt76x8/openwrt-sdk-18.06.2-ramips-mt76x8_gcc-7.3.0_musl.Linux-x86_64.tar.xz
     tar -xf ./openwrt-sdk-18.06.2-ramips-mt76x8_gcc-7.3.0_musl.Linux-x86_64.tar.xz
     mv ./openwrt-sdk-18.06.2-ramips-mt76x8_gcc-7.3.0_musl.Linux-x86_64 ./openwrt-sdk-mt76x8
   

2. Go back to the folder with the template project (hello world). You need to edit file configure-mips-openwrt.sh and write your own SDK paths. Below are the lines from my file that will need to be changed.

     # define the pathes (by default) to the buildroot
     BUILDROOT_PATH="/home/vladimir/OpenWRT-sdk"
   
     # define the toolchain and target names
     ...
     TOOLCHAIN_DIR="$STAGING_DIR/toolchain-mipsel_24kc_gcc-7.3.0_musl"
     TARGET_DIR="$STAGING_DIR/target-mipsel_24kc_musl"
   

   Once properly edited this file it can be applied to other projects with the same SDK's paths without changes.

3. Now you need to run configure script, through the previously edited script configure-mips-openwrt.sh. It's important!

     ./configure-mips-openwrt.sh
   

   If all paths are correct, there should be no errors, working files will appear from the blank files with the suffix .in.
   In the cross-compilation case (using SDK), you will find script file xmake.sh (see details below).

   NOTICE: The configure script (configure-mips-openwrt.sh) can accept arguments, for more details see the relevant documentation

   WARNING: In cross-compilation case the configure script incorrectly sets the installation paths, set it by hand via command-line arguments, type key --help for help.

4. Cross-compilation via SDK. The last thing is running the make utility through the script xmake.sh.

     ./xmake.sh
   

   NOTICE: xmake.sh supports command-line arguments that are passed to the make utility.

That's all!

And last you can easy switch compilation of your application between Linux host x86/x64 and Onion OS by run configure or configure-mips-openwrt.sh at any time.

Step 3.1. General compilation on the target machine

To compile, in the target machine you have to install C/C++ compiler before with all the friendly utilities and standard libraries.

Compiling and installing an application is not different from the usual (familiar in Linux) build applications from source code. First, you need to configure the project for a specific OS and architecture. Typical set of commands for configuring, compiling, and installing into the system are below:

./configure && make && make install

After the configure script will successful done, from .in-files (special blanks) the script will generated full-fledged ready-to-use files, such as Makefile, config.h.

NOTICE: The configuration Script also checks the system for all necessary project files (packages, libraries, headers, utilities, etc.), if they are not present, the configuration will fail. Satisfying dependencies is a user's task to do it manually. All developers usually accompany a project with a small installation guide that includes all the dependencies.

Step 2. Creating Autotools working files

The Autotools set utilities help us to create large files from short special templates like configure.ac, Makefile.am, etc. it is necessary to generate a script known to everyone (in Linux) ./configure.

To do this, you need to run autoconfig command in the directory with mytemplate's files, but stop! I think base file configure.ac later you will change and the most convenient way to execute another command every time after change autotools' files:

autoreconf -iv

Then you will see the executable bash-script configure, as well as many auxiliary files and a directory. All these files are distributive (portable and independent of the target platform), i.e. they must be copied together with the source code of the program for its configuration, compilation, installation on the target platform (without Autotools).

This is a necessary action before the first compilation.

NOTE: The Automake utility always generates a set of dist, distdir, distclean targets for automatically creating/deleting archived file (by default .tar.gz) - distribution of the project.

Step 1. Setup host environment, copy template's files into host

1. Before using the template, you have to install the software tools GNU Autotools, build-essential. If none, the commands below are for automatically downloading and installing them into Debian, Ubuntu.

     apt-get install -y autoconf libtool
     apt-get install -y build-essential
   

NOTICE: Dependent packages automake, autotools-dev, autoheader etc. will be also installed.

1. Then, go to any convenient directory of your own C/C++ projects and copy (clone) all the template's files from the repository there. Below is the default clone command.

     git clone https://bitbucket.org/hlorka/myapptemplate.git [<my-app-dir-name>]
   

   If your project will use the Automake utility (see below for details), you must clone special Automake git-branch using another command:

     git clone --single-branch --branch Automake https://bitbucket.org/hlorka/myapptemplate.git [<my-app-dir-name>]
   

   NOTICE: The root directory of the template myapptemplate will be created automatically, after cloning is complete, it is recommended to rename and give a more appropriate name to your own application, or you can do it immediately when cloning, by adding the name to the end of cloning command [<my-app-dir-name>].

2. The link to this repository is no longer needed and you have to delete it by delete the hidden subdirectory .git. See next command to do it.

     rm -rf ./.git

Hello all. I decided translate my README.md file to all from Russian. The file is large and I will translate it in parts. And sorry if my translation will be not good.

How it use. Step-by-step guide.

This guide is intended for the start Linux embedded programmer. If any steps and actions are familiar to You, you can skip it.

For my cross-compiling template , the steps applicable for Linux-based OS, such as Debian, Ubuntu, for other one it may be differences.

It is assumed that you already have a dedicated or virtual machine (host) with this OS installed. All actions below are performed on the host via a standard Linux terminal.

Let's begin...

These are many pieces of manuals to do it. But it's not convenient at all. I suggest to show all of us the simplest way to start coding the native applications via OpenWRT 18.06 SDK and GNU Autotools.

I studied many documentation about and make my own "template" for it (see below). First, let's figure out what we need:

• cross-compilation. Why? Cross-compile runs on powerful fast machine (Virtual Machine) to make our applications.

  • If you will compile on the Omega directly, it does not have sufficient memory resources to run a C/C++ build tool chain - only a simple applications.
  • Second problem in third-party libraries - Omega; opkg manager doesn't install -dev files of libraries and it's will be a problem in your application.

  PLEASE FORGET DIRECT COMPILATION FOREVER !

• Using GNU Autotools build system. You should adjust write platform-independent application. May be in future you want use application in other Linux-based machine. Why Autotools such an old system?

  The Autotools is the most convenient way for embedded systems. You will have usual command to compile and install the application, like ./configure && make && make install.

  • Autotools is more flexible to embedded systems. This build system works with make utility. It's very simple way to start coding in any IDE. I'm using Visual Studio 2017 for Makefile-solutions.

  • You can make your own Makefile or use Automake friend utility.

  • Autotools has simple mechanism to cross-compilation via third-party toolchain.

About C/C++ template for native applications

I created my own template to start any native application for Linux. Here is repo link:
https://bitbucket.org/hlorka/myapptemplate/

This template is simple Hello World application with next features:

• You can compile/install/uninstall it on the any Linux;

• You can compile application via Onion SDK or OpenWRT 18.06 SDK for x86_64 machines (Virtual Machines);

• You can remotely install/uninstall your application on Onion Omega (rsync, ssh utilities).

• It's using Autotools and generate bash-scripts to manage application. You no need install any other build system, such CMake.

Thus I can have coding in my favorite IDE, do sync sources to Virtual Machine and compile it there, remote or normally install. But first I usually write and test application for virtual machine except case application touches hardware peripherals.

The detailed manual about my template you can see in the README.md from repo. Unfortunately the document is still only in Russian; please use auto translation.

Oh, it's simple issue as I remember. I wrote manual about CMake using.
Don't build application on Omega, it's not works like the Raspberry, use only cross-compiling.

Manual. How to make native C/C++ application step by step.

@bigdogsb, you have to know it's a home-based device and OpenSource OS. Also you must be a very good Linux-user or admin to get maximum abilities from device. OS is very good and stable, there are many network's features.

You listed several bugs, but it's for home using.

• Web-interface as for me - no need at all;
• AP doesn't turn off - many users know that, it the bug;
• Not stable Wi-Fi connection - we all know it. For example my MIUI router from time to time no want to connect Omega2 then I reboot him (router).
• You have serial UART terminal to tune device if be able any problems with SSH.

@luckycometdaft said in Cross Compiling OpenWrt Package:

... I have installed MQTT on board and there is a .so file in Board. Now, how do I cross-compile with this library?

Look through my first post in the manual [Manual] How to make native C/C++ application step by step. There is part of it:

... Second problem in third-party libraries - Omega; opkg manager doesn't install -dev files of libraries and it's will be a problem in your application.

You have to know OpenWRT it's a minimal disk-size system. It have no .h-files to build anything in. I think you compiled your application into the Omega board (direct compilation). In this case you had install GCC build system with common h-files, but you need append your third-party h-file for special .so library.

You have to find this and append manually. You can find your h-file from so-library repository.
But I recommend you compile via SDK. You will need it in future if touch to build native applications.

I don't see real feature to change OnionOS, I hoped to see OpenWRT 19.07. To place battle software internal 32MB is enough. Database and other data files can be placed to the external disks (USB, MMC) with no problems.

@supczinskib, thank you for the answer. Your UI looks like production factory device.

Your idea has interes in general. I think main controller need a bigger display for monitoring parameters. All its configurations must be declared via web-intetface or any cloud server.

Also this device need a big hardware part (pums, valves, sensors including remoted). I think it needs a big database about botany as help-part for users.

By the way... sensors you can power by solar sells, to trsnsfer data you can get LoRa net.

@supczinskib, please tell us how did you make splash boot screen with a progress bar?

Also how use third-party touch input device in the Omega?

@crispyoz said in Cross Compiling:

I'm currently building the the LEDE system on the docker image running on my Surface 4, i7, 16GB, Windows 10 Pro 64Bit the build has been running for about 18 hours and still has not completed. The same build on the same machine but running Ubuntu 17 on VMWare Workstation Pro 15, builds in about 2 hours.

I'm using Oracle VirtualBox with a Debian i386 CLI without GUI (3GB RAM, 4 core of processor). VM runs on the host Windows 10 Home, AMD Phenom II X6 16GB RAM.

make clean
make -j4

The building takes in about 45 minutes.

@crispyoz said in Project "liburtc" the library to operate external RTC devices:

Not sure where I would buy old Russian diodes here on Australia though

You can try 1N34A that's Germanium Diode too and say us result.

Hi all. Yesterday I've connected my TFT display (3.2" controller ILI9341 320x240) and Omega2. Look at the photo below.

I don't have Dash board, but I re-compiled firmware with drivers (kernel objects).
If someone else wants to do it, I post here my experience.

Hardware connection

Let's see connection diagram below.

It's item named "LCD TFT 320x240 Graphic Color Touch Display ILI9341 Mega2560 Arduino Compatible" from AliExpress.

Software setup.

1. You must select the next components (via make menuconfig to in-built firmware: kmod-fb kmod-fbtft-support kmod-fbtft-ili9341, dejavu-fonts-ttf-DejaVuSans.

   Then you have to append initial script (filename files/08-fbtft-device) from Omega2 Dash Package repository

2. Or select omega2-dash-base in make menuconfig menu.

3. Or select the board Omega2 Dash in the same menu.

4. Or download and force upgrade firmware (filename omega2dash-vX.X.X-bXXX.bin) via util sysupgrade from repo.onioniot.com. DIDN'T TESTED!

See next useful links about it:

• Omega2 Dash Guide
• Dash на GitHub.
• Omega2 Dash Base Package
• Using fbtft_device on notro/GitHub wiki

@Moonshiner, I figured out in part of this and appended kmod-rtc-pcf8563.ko; NXP PCF8563 based address 0x51. First I've got next kernel message, please compare below:

 root@Omega-D913:/# dmesg | grep rtc
[    0.615614] hctosys: unable to open rtc device (rtc0)

Next I appended device manually:

echo pcf8563 0x51 > /sys/class/i2c-dev/i2c-0/device/new_device

Then you will see /dev/rtc0 device.

Next creating default RTC symlink:

cd /dev
ln -s rtc0 rtc

and...

hwclock -r
Sun Jul  5 19:50:44 2020  0.000000 seconds

It's works!
But this procedure we must do for each loading.

Driver works well, we have errors in OMEGA2[P].dts file, something wrong there.