FriendlyARM

New videos

2011-12-27T03:39:00.000-08:00

Finally I succeeded setting up the development environment for building QtEmbedded 4.6.3 application using QtCreator. My intention was to make complete video tutorial on all the process from installing the tools to compiling a "hello world" application and running it on FriendlyARM. Lack of time doesn't allow me to complete it. That's why I decided to publish my video "notes". They have been on YouTube for some time. They are just record of my desktop with no comment. Also here are my text notes I made during the installation process. Hope somebody might find them usefull.

Here are the videos:
How to install the cross-copiler for mini2440 on host PC (Video 1)

How to compile QtEmbedded 4.6.3 for mini2440 (Video 2)

Install QtCreator and set it up for QtEmbedded. (Video 3)

-------------------------------------------------------------------------
**** PC Installation ****
1. Install the cross-compiler to /usr/local/arm/4.3.2
In PATH variable add folder /usr/local/arm/4.3.2/bin

2. Compile QtEmbedded 4.6.3 on PC. The result of the compilation are the libraries for ARM (libQtCore.so.4.6.3, libQtGui.so.4.6.3 и т.н) and tools for PC like qmake, uic, moc etc. Do it as root
    3.1 Unzip arm-qte-463-20100802tar.gz
    3.2 Enter the arm-qte-4.6.3 folder and run configuration script (config-options file shown in Video 2):

./configure -prefix /qtbuild/ -release -shared -fast -pch -no-qt3support -qt-sql-sqlite -no-libtiff -no-libmng -qt-libjpeg -qt-zlib -qt-libpng -qt-freetype -no-openssl -nomake examples -nomake demos -nomake tools -optimized-qmake -no-phonon -no-nis -no-opengl -no-cups -no-xcursor -no-xfixes -no-xrandr -no-xrender -no-xkb -no-sm -no-xinerama -no-xshape -no-separate-debug-info -xplatform qws/linux-arm-g++ -embedded arm -depths 16 -no-qvfb -qt-gfx-linuxfb -no-gfx-qvfb -no-kbd-qvfb -no-mouse-qvfb-qt-kbd-usb -confirm-license -qt-mouse-tslib

    The -prefix option determines location of the compiled files. I this case it is /qtbuild
Important: Use exactly this version!

    3.3 Compile (takes more than an hour):
        $ make (or gmake)
        $ make install (or gmake install)

3. Install IDE QtCreator
Make qt-sdk-linux-x86-opensource-2009.05.bin executable:

    LinuxHost>chmod +x qt-sdk-linux-x86-opensource-2009.05.bin
    LinuxHost>./qt-sdk-linux-x86-opensource-2009.05.bin

4. Configure QtCreator with path to qmake. The qmake tool uses the project file .pro to generate Makefile
    From Tools-Options in QMake location add path /qtbuild/bin/qmake and click rebuild

5. Examples - in folder arm-qte-4.6.3/qt-everywhere-opensource-src-4.6.3 there is en example. Open the .pro file in QtCreator and build it.

------------------------------------------------------------
*** Configure FriendlyARM ***
The last FriendlyARM came with QtEmbedded 4.6.3 и tslib. If the board is older instead just install the file system rootfs_qtopia_qt4_20110305.img (option "y" in DWN) Doing this you don't have to upload the libraries to FriendlyARM.

This is done in Windows. Next step is to configure IP address and password with passwd command from console.
------------------------------------------------------------
*** GLOBAL VARIABLES ***

For applications to be abble to access the libraries global variables have to be set. Set them to use already installed in the file system libraries so you do not have to upload compiled QtEmbedded and tslib libraries. That's why using exactly 4.6.3 version is important.

Remark: check the fluidlauncher to see how you can make variables set on start

export USER LOGNAME PS1 PATH
export QTDIR=/usr/local/Trolltech/QtEmbedded-4.6.3-arm
export LD_LIBRARY_PATH=$QTDIR/lib
export TSLIB_CONSOLEDEVICE=none
export TSLIB_FBDEVICE=/dev/fb0
export TSLIB_TSDEVICE=/dev/input/event0
export TSLIB_CALIBFILE=/etc/pointercal
export TSLIB_CONFFILE=/usr/local/etc/ts.conf
export QWS_SIZE=800x480
export QWS_DISPLAY="LinuxFb:mmWidth135:mmHeight155"
export QWS_MOUSE_PROTO="Tslib:/dev/input/event0"
export TSLIB_PLUGINDIR=/usr/local/lib/ts

Remark:Change the display size if necessary. This settings is for 7".
------------------------------------------------------------
*** fonts **
transfer from PC from /qtbuild/lib/fonts/ fonts to
FriendlyARM /usr/local/Trolltech/QtEmbedded-4.6.3-arm/lib/fonts
------------------------------------------------------------
*** TSLIB ***
When try to run Qt4 application from console if there is no link to tslibrary an error mesage is shown:
error while loading shared libraries: libts-0.0.so.0: cannot open shared object file: No such file or directory

Make symbol link:
ln -s /usr/local/lib/libts-0.0.so.0 /usr/local/Trolltech/QtEmbedded-4.6.3-arm/lib/libts-0.0.so.0

------------------------------------------------------------
*** Screen Calibration ***
/usr/local/bin/ts_calibrate - this is the application for calibration
//it can be run from qtopia
------------------------------------------------------------
*** runnin the application ***
Diasble the Qtopia and run the application with qws option. It makes the application responsible for writing to the frame buffer.
/myapp -qws

------------------------------------------------------------

The display turns white

2011-09-14T11:17:00.000-07:00

I had problem with my FriendlyARM board. The display turned bright white occasionally.
The problem started to occure more and more often. It appeared that the problem is in the ribbon cable between the board and the display. About 0.8V are lost along the way. After connecting the display directly to the power from CON8 on the board there are no more display troubles.

HowTo videos

2011-08-30T02:31:00.000-07:00

I found two very good videos on YouTube:

How to install qtopia on the mini2440

Guide to compile and install programs on the mini2440

Enjoy :-)

Creating web interface (part 2)

2011-06-17T08:12:00.000-07:00

This Example shows how to access GPIO pins via web interface.

First you need to install on mini2440 linux kernel with GPIO support.
Unfortunately FriendlyARM comes with kernel without GPIO and SPI support.
If you decide to try to compile kernel take a look at "Kernel Tweaking" link below. There is a good explanation how to do it.
The other option is to download already compiled kernel from
http://rapidshare.com/files/409529369/zImage-2.6.32.2-mini2440_gpio_spi.html
It is for 7" display but for this example only network access to mini2440 is needed.
I'm not going to explain how to upload the kernel image. It's shown in the board's manual.

HOW TO CONTROL GPIO FROM THE COMMAND LINE:
When the new kernel is uploaded let's first check the access to GPIO from the command line.
Telnet to mini2440 and go to sys/class/gpio folder:

$ telnet 192.168.1.230
[root@FriendlyARM /]# cd sys/class/gpio/
[root@FriendlyARM gpio]# ls
export       gpiochip0    gpiochip128 gpiochip160 gpiochip192 gpiochip224 gpiochip32   gpiochip64   gpiochip96   unexport

Folders gpiochip0 , gpiochip128 .... represent GPIO drivers for each port. Ports are named A,B,C....
Check the port for each gpiochipX:

[root@FriendlyARM gpio]# cat gpiochip0/label
GPIOA
[root@FriendlyARM gpio]# cat gpiochip32/label
GPIOB
[root@FriendlyARM gpio]# cat gpiochip192/label
GPIOG

Each pin has it's corresponding access number. For example buzzer is connected to GPB0 ( Port B pin 0) and port B is accessible from gpiochip32 so the number to access the buzzer is 32.
Led1 is connected go GPB5. It's access number is 32+5 = 37
Buttons are connected to port G - gpiochip192

Function    Port    Access number
Buzzer        GPB0    32
Led1           GPB5    37
Led2           GPB6    38
Led3           GPB7    39
Led4           GPB8    40
Btn1           GPG0    192
Btn2           GPG3    195
Btn3           GPG5    197
Btn4           GPG6    198
Btn5           GPG7    199
Btn6           GPG11    203

Now open access to the buzzer. :

[root@FriendlyARM gpio]# echo 32 > export
[root@FriendlyARM gpio]# ls
export       gpio32       gpiochip0    gpiochip128 gpiochip160 gpiochip192 gpiochip224 gpiochip32   gpiochip64   gpiochip96   unexport

A new link gpio32 appeared now. Let's check the current direction and make it an output:

[root@FriendlyARM gpio]# cat gpio32/direction
in

[root@FriendlyARM gpio]# echo "high" > gpio32/direction
[root@FriendlyARM gpio]# cat gpio32/direction
out

Turn the buzzer on and off:
[root@FriendlyARM gpio]# echo "1" > gpio32/value
[root@FriendlyARM gpio]# echo "0" > gpio32/value

Close the access:
[root@FriendlyARM gpio]# echo 32 > unexport

CONTROL GPIO FROM WEB INTERFACE:
First stop the Led player as shown on one of previous posts.

The project consists from the following files:
access_num.h     -    definitions of GPIO driver access numbers

gpio.h gpio.cpp -     class for control of GPIO. Each instance is for control of one pin

readbtn.cpp    -     CGI program that reads the state of the six board buttons and shows
            it in table on a web page. The page is automatically refreshed each
            two seconds.

ledbuzz.cpp    -     CGI program that reads the query string sent to the web server and
            turns on/off the LEDs and the Buzzer.Then the state of the four board
            leds and the buzzer are shown on a web page as checkboxes.
            The user can change the    checkboxes. When submit button is pressed
            the new states are sent to the web server using GET method and the
            same program is called again.
download the project folder from:
https://rapidshare.com/files/3267170017/webcontrol.zip
https://rapidshare.com/#!download|560tg|3267170017|webcontrol.zip|16

compile with command:
$ arm-linux-g++ gpio.cpp ledbuzz.cpp -o ledbuzz.cgi
$ arm-linux-g++ gpio.cpp readbtn.cpp -o readbtn.cgi

Note: In the project folder there are already compiled binaries ledbuzz.cgi and readbtn.cgi

upload ledbuzz.cgi and readbtn.cgi to the board to /www/cgi-bin folder and give them executable attribute
# chmod a+x ledbuzz.cgi
# chmod a+x readbtn.cgi

Run them from the command line. You should get HTML output

There is no index.html. Open CGIs from PC web browser directly:
http://192.168.1.230/cgi-bin/ledbuzz.cgi
http://192.168.1.230/cgi-bin/readbtn.cgi

LINKS:
Access to GPIO pins explained
http://www.avrfreaks.net/wiki/index.php/Documentation:Linux/GPIO

Kernel Tweaking
http://members.cox.net/ebrombaugh1/embedded/mini2440/index.html

P.S. If you find this articles useful please pay some attention to the ads.
Some of them might be interresting to you too. Thanks.

Creating web interface

2011-06-11T05:32:00.000-07:00

FriendlyARM comes with installed Boa web server.
Web interface can be very useful feature for real life applications.
It might be used for editing and storing settings to a file or to access the real world - ADC, GPIO, SPI, Serial.

The purpose of this tutorial is to show the basics of creating a simple web interface using CGI in C.

All that you need is mini2440 board with or without LCD and PC with GCC cross-compiler
http://www.friendlyarm.net/dl.php?file=arm-linux-gcc-4.4.3.tgz
On my mini2440 I have SD card installed. If you do not have any you have to make some changes to the code.

Example 1:

The example consists of the following files:

index.html

template.html

savefile.c

showfile.c

This web interface opens example.txt text file from the flash and shows it on a web page.
The user can edit it and store it back.

The first file is index.html. When you type the IP address of the FriendlyARM board into a web browser Boa
searches for index.html in /www

index.html:
<HTML>
<HEAD>
    <TITLE>REDIRECTING...</TITLE>
    <meta http-equiv="Refresh" content="3;url=./cgi-bin/showfile.cgi">
</HEAD>

<BODY>
    redirecting in 3 seconds...
</BODY>
</HTML>

The only purpose of this web page is to redirect the browser to another URL and in particular this is the showfile.cgi

What is CGI? This is a program. It might be a script file or an executable written in no matter what programming language.
You can write CGI in C,Basic or even Assembler. This executable is called by the web server.
CGI program captures data reading environment variables and the output data is sent to the console.
The web server captures this output and sends it back to the client's browser.

Two CGI programs are used in this example - showfile.cgi and savefile.cgi
When the web server calls showfile.cgi it reads file template.html from flash and sends it's contents to the console.
The contents of example.txt are sent between </TEXTAREA> and </TEXTAREA> tags.

template.html
<HTML>
<HEAD>
    <TITLE>EDIT TEXT FILE</TITLE>
</HEAD>

<BODY>
    <FORM name="input" action="./savefile.cgi" method= "get">
        <TEXTAREA NAME=textarea ROWS=10 COLS=60>

    <BR><BR>
    <INPUT type="submit" value="Submit" />       <INPUT type="reset" value="Undo changes" />
    </FORM>
</BODY>
</HTML>

showfile.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main()
{
//Open template.html file. If unable to open show error web page and return
    FILE * htmlTemplate;
        htmlTemplate = fopen("/sdcard/html/template.html","r");
    if(htmlTemplate == NULL)
    {
        printf("%s%c%c\n",    "Content-Type:text/html;charset=iso-8859-1",13,10);
        printf("<HTML><HEAD><TITLE>ERROR!</TITLE></HEAD>\n");
        printf("<BODY>\n");
        printf("<H3>ERROR: Unable to open template.html!</H3>\n");
        printf("</BODY></HTML>\n");
        return 0;
    }
//Open example.txt file. If it doesn't exist a new empty file will be created.
    FILE * textFile;
        textFile = fopen("/sdcard/example.txt","a+");

//start sending template.html to the console
    char row[1000];
    printf("Set-Cookie:MY_COOKIE=ThisIsCookieJustForFun\n"); //This line is only to demonstrate how to set cookie
    printf("%s%c%c\n",    "Content-Type:text/html;charset=iso-8859-1",13,10);

    while(fgets(row,999,htmlTemplate))
    {
        printf(row);
        if(strstr(row,"<TEXTAREA") != NULL)
        {
            if(textFile != NULL)
            {//send example.txt to the console
                while(fgets(row,999,textFile))
                {
                    printf(row);
                }
            }
            printf("</TEXTAREA>\n");
        }
    }
    fclose(htmlTemplate);
    fclose(textFile);
    return 0;
}


savefile.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main()
{
//Open example.txt file.
    FILE * textFile;
        textFile = fopen("/sdcard/example.txt","w");

    char * query;
    query = getenv("QUERY_STRING");

    printf("%s%c%c\n",    "Content-Type:text/html;charset=iso-8859-1",13,10);
    printf("<HTML><HEAD><TITLE>FILE SAVED</TITLE></HEAD>\n");
    printf("<BODY>\n");
    if(textFile != NULL)
    {// save file to disk
        //cut the beginning if it starts with "textarea="
        if(strstr(query,"textarea=") != NULL) fprintf(textFile,&query[9]);
        else fprintf(textFile,query);
        printf("<H3>File example.txt was saved to SD card</H3>\n");
    }
    else printf("<H3>Failed to save example.txt. Reason - unable to open file for writing.</H3>\n");

    printf("<BR><BR>\n");
    printf("QUERY_STRING:%s<BR><BR>\n",query);
    printf("<a href=\"./showfile.cgi\">Return to edit example.txt</a>\n");

//Nex code is just for fun.
    printf("<HR><BR><BR> Now let's read some environment variables just for fun<BR>");
    char *envvar;
    envvar=getenv("HTTP_COOKIE");
    printf("<BR>HTTP_COOKIE=%s",envvar);
    envvar=getenv("SERVER_SOFTWARE");
    printf("<BR>SERVER_SOFTWARE=%s",envvar);
    envvar=getenv("SERVER_NAME");
    printf("<BR>SERVER_NAME=%s",envvar);
    envvar=getenv("GATEWAY_INTERFACE");
    printf("<BR>GATEWAY_INTERFACE=%s",envvar);
    envvar=getenv("SERVER_PROTOCOL");
    printf("<BR>SERVER_PROTOCOL=%s",envvar);
    envvar=getenv("SERVER_PORT");
    printf("<BR>SERVER_PORT=%s",envvar);
    envvar=getenv("REQUEST_METHOD");
    printf("<BR>REQUEST_METHOD=%s",envvar);
    envvar=getenv("SCRIPT_NAME");
    printf("<BR>SCRIPT_NAME=%s",envvar);
    envvar=getenv("REMOTE_ADDR");
    printf("<BR>REMOTE_ADDR=%s",envvar);
    envvar=getenv("CONTENT_TYPE");
    printf("<BR>CONTENT_TYPE=%s",envvar);
    envvar=getenv("CONTENT_LENGTH");
    printf("<BR>CONTENT_LENGTH=%s",envvar);
    envvar=getenv("HTTP_USER_AGENT");
    printf("<BR>HTTP_USER_AGENT=%s",envvar);
    envvar=getenv("HTTP_REFERER");
    printf("<BR>HTTP_REFERER=%s",envvar);

    printf("</BODY></HTML>\n");

    fclose(textFile);
    return 0;
}

Compile it with command
arm-linux-gcc showfile.c -o showfile.cgi
arm-linux-gcc savefile.c -o savefile.cgi

When "Submit" is clicked on the web page content of the text area is sent back to the web server
and savefile.cgi is called. (Note the FORM tag in template.html)
Used method is "GET" and data is retrieved from the environment variable QUERY_STRING.
If "POST" method is used reading data is read from stdin.
NOTE: When data is sent back to server some special characters are encoded to %XX format. They have to be decoded before saving them to file. To keep this example simple I omitted this step.

Only for demonstration a cookie MY_COOKIE is set and reading some environment variables is implemented.

Upload files to the board:
index.html    -- /www
showfile.cgi -- /www/cgi-bin
savefile.cgi -- /www/cgi-bin
template.html -- /sdcard/html

change permissions to execute cgi files with:
[root@FriendlyARM cgi-bin]# chmod a+x showfile.cgi
[root@FriendlyARM cgi-bin]# chmod a+x savefile.cgi

If you miss to do it you will get error

502 Bad Gateway
The CGI was not CGI/1.1 compliant.

LINKS:

HTML Tutorial
http://www.w3schools.com/html/default.asp

More on CGI
http://www.jmarshall.com/easy/cgi/

cgic: an ANSI C library for CGI Programming
http://www.boutell.com/cgic/
Excellent library that can save you a lot of typing.

iniParser: stand-alone ini parser library in ANSI C
http://ndevilla.free.fr/iniparser/
This is excellent library if you have to save and retrieve data from ini files.

Uploading new font

2010-12-20T00:22:00.000-08:00

It is possible to upload True Type Font to the FriendlyARM

1. Upload the ttf file to /opt/Qtopia/lib/fonts

2. Edit the file fontdir which is text file and on a new board is empty.
Add a line with format:

name file renderer italic weight size flags

Field	Description
name	The name of the font format, e.g.,`Helvetica`, `Times`, etc.
file	The name of the file containing the font, e.g., `helvR0810.bdf`, `verdana.ttf`, etc.
renderer	Specifies the font engine that should be used to render the font, currently only the FreeType font engine (`FT`) is supported.
italic	Specifies whether the font is italic or not; the accepted values are `y` or `n`.
weight	Specifies the font's weight: `50` is normal, `75` is bold, etc.
size	Specifies the font size, i.e., point size * 10. For example, a value of 120 means 12pt. A value of 0 means that the font is scalable.
flags	The following flag is supported: `s`: smooth (anti-aliased) All other flags are ignored.

For example to use Hebar for applications with cyrillic interface I add:
hebar hen.ttf FT n 50 0

Now without restart the font is accessible from Settings-Appearance-Font

Stop the LED player!

2010-12-19T23:49:00.000-08:00

If you need to use those GPIO pins connected to onboard LEDs the LED player should be stopped. To do this telnet to the board and with vi open this script file /etc/init.d/rcS

[root@FriendlyARM init.d]# vi rcS
(The beginning of the file omitted)
....
....
....
-------------------------------------------------------------------------------------------------------------------
syslogd
/etc/rc.d/init.d/netd start
echo "                        " > /dev/tty1
echo "Starting networking..." > /dev/tty1
sleep 1
/etc/rc.d/init.d/httpd start
echo "                        " > /dev/tty1
echo "Starting web server..." > /dev/tty1
sleep 1
#/etc/rc.d/init.d/leds start                                        Comment out these lines!
#echo "                        " > /dev/tty1
#echo "Starting leds service..." > /dev/tty1
#echo "                        "
#sleep 1

/sbin/ifconfig lo 127.0.0.1
/etc/init.d/ifconfig-eth0

/bin/qtopia &
echo "                                  " > /dev/tty1
echo "Starting Qtopia, please waiting..." > /dev/tty1
-------------------------------------------------------------------------------------------------------------------

Thats it. You can also remove "sleep 1" and win two seconds faster boot time.

Demo application - serial port and GPIO control.

2010-07-28T01:21:00.000-07:00

These days I've made a project for my FriendlyARM 7" board.
It demonstrates RS232 data transmission/reception and access to the GPIO pins. To test the serial port I used a serial-to-usb cable. The project seems to work as intended so I decided to share it:
http://rapidshare.com/files/409529027/stivlib_serial_gpio_demo_25JUL2010.zip.html
It can be used as starting point for learning. The code may be modified and used freely without any waranty.

The whole working folder is included in the archive. Here are the files:

stivlib.pro - the Project file. This is a text file. Source and header files are described in it. If new files have to be added to the project they must be described in this file

stivlib.png - image file used for icone of the desktop launcher
stivlib.desktop - text file. This is the desktop launcher.
stivlib - binary file. Compiled execteable.
In the previous post was described how to upload these files to the board.

serialport.h serialport.cpp - SerialPort class. It allows sending and recieving serial data and also control of RTS,CTS,DSR,DTR,DCD and RI pins.
gpio.h gpio.cpp - GPIO class. Each instance of this class controls one pin of the GPIO header. Refer to the documentation for the pin functions. For example pin 31 controls the buzzer.

MainWindow.ui - xml file generated by Qt Creator. May be modified with text editor.

MainWindow.h MainWindow.cpp - here is defined the class of the main form dialog frmMainWindow. Connection between the SIGNALS and SLOTS are implemented here. These files are automaticaly generated with formuic script. Do not modify them.

MainWindowImp.h MainWindowImp.cpp - In these files frmMainWindowImplementation class inherits frmMainWindow. The functionalyty of the application is implemented in this class.

main.cpp - it contains macroses for generating the application.

formuic - this script runs uic - user interface compiler. This script should be run each time modifications to MainForm.ui are made. New MainWindow.h MainWindow.cpp will be generated

build - this script runs the compiler and bilds the application

Makefile - the Mkefile is automaticaly generated. Do not modify it.

To have access to the GPIO the driver must be included to the linux kernel.
This is a link to compiled image with included drivers for GPIO and SPI. I have not tested the SPI yet. It's for 7" display!
http://rapidshare.com/files/409529369/zImage-2.6.32.2-mini2440_gpio_spi.html
Great thanks to Eric Brombaugh for his page which helped me to compile and upload the kernel.

http://members.cox.net/ebrombaugh1/embedded/mini2440/index.html

Uploading the application and creating the launcher

2010-07-18T04:20:00.000-07:00

Qtopia file system:
/opt/Qtopia/
           |--apps/
           |    |-Application/ --each folder is a desktop tab.
           |    |-FriendlyARM/    in these folders are .desktop files
           |    |-Games/
           |    |-Settings/
           |
           |--pics/   -applications icone folder
           |--bin/    -applications executables
           |--help/

1.Preparation
Prepare a .png file for desktop icon of your application.
Place it into the project folder and give it the same name as the binary file:stivlib.png
Create the stivlib.desctop file. This is a text file with the following content:

[Desktop Entry]
Version=1.0
Encoding=UTF-8
Name=StivLib
Comment=An Example Program
Exec=stivlib
Icon=stivlib
Type=Application
GenericName[en_US]=

2. Connect your PC to FriendlyARM witn network cable, and open a terminal.
FriendlyARM board comes with preset IP 192.168.1.230.
Set your IP address, telnet to FriendlyARM and set root password:

# su
# ifconfig eth0 192.168.1.1 netmask 255.255.255.0
# telnet 192.168.1.230
Trying 192.168.1.230...
Connected to 192.168.1.230.
Escape character is '^]'.

Kernel 2.6.32.2-FriendlyARM on (/dev/pts/0)
FriendlyARM login: root
[root@FriendlyARM /]# passwd
Changing password for root
New password:
Retype password:
Password for root changed by root
[root@FriendlyARM /]#

3. Make a folder into /opt/Qtopia/apps for your applications.
These folders appear like desktop tabs.

[root@FriendlyARM /]# cd /opt/Qtopia/apps
[root@FriendlyARM apps]# ls
Applications FriendlyARM   Games         Settings
[root@FriendlyARM apps]# mkdir STIV
[root@FriendlyARM apps]# ls
Applications FriendlyARM   Games         STIV          Settings
[root@FriendlyARM apps]# exit

4. Upload binary file to FriendlyARM using ftp. Upload the icone file and the .desktop file
Go to your project folder where is your binary file.

# ftp 192.168.1.230
Connected to 192.168.1.230.
220 FriendlyARM FTP server (Version 6.4/OpenBSD/Linux-ftpd-0.17) ready.
Name (192.168.1.230:svilen): root
331 Password required for root.
Password:
230 User root logged in.
Remote system type is UNIX.
Using binary mode to transfer files.
ftp> cd opt/Qtopia/bin
250 CWD command successful.
ftp> send stivlib
local: stivlib remote: stivlib
200 PORT command successful.
150 Opening BINARY mode data connection for 'stivlib'.
226 Transfer complete.
41481 bytes sent in 0.25 secs (162.7 kB/s)
ftp> cd ..
250 CWD command successful.
ftp> cd pics
250 CWD command successful.
ftp> send stivlib.png
local: stivlib.png remote: stivlib.png
200 PORT command successful.
150 Opening BINARY mode data connection for 'stivlib.png'.
226 Transfer complete.
2743 bytes sent in 0.00 secs (62295.6 kB/s)
ftp> cd ..
250 CWD command successful.
ftp> cd apps/STIV
250 CWD command successful.
ftp> send stivlib.desktop
local: stivlib.desktop remote: stivlib.desktop
200 PORT command successful.
150 Opening BINARY mode data connection for 'stivlib.desktop'.
226 Transfer complete.
146 bytes sent in 0.00 secs (9505.2 kB/s)
ftp> bye
221 Goodbye.
#

5.Now telnet again to FriendlyARM to change the attributes of the uploaded file.
It shoul become executable

# telnet 192.168.1.230
Trying 192.168.1.230...
Connected to 192.168.1.230.
Escape character is '^]'.

Kernel 2.6.32.2-FriendlyARM on (/dev/pts/0)
FriendlyARM login: root
Password:
[root@FriendlyARM /]# cd /opt/Qtopia/bin/
[root@FriendlyARM bin]# chmod a+x stivlib
[root@FriendlyARM bin]# ls

Restart the board.

Useful links:
Read about Qtopia filesystem standarts on http://doc.trolltech.com/qtopia2.2/html/files.html
vi editor quick refference http://www.digilife.be/quickreferences/QRC/vi%20Quick%20Reference.pdf

Hello World with GUI application for FrienndlyARM Tutorial

2010-07-12T01:14:00.000-07:00

Here are the steps of creating a simple "Hello world" GUI application for FriendlyARM board. You should have development tools ARM-Linux GCC 4.3.2 and ARM-Qtopia 2.2.0 already installed. If you don't have them yet you can download them from here: http://www.friendlyarm.net/downloads
My PC is working under Ubuntu 8.04. and the path of Qtopia installation is /usr/local. I know that my environment is not quite correctly set.That's why I do some steps as root and source some environment variables from file setQpeEnv. But it works.

Here are the steps:
1. With Qt Designer create the main form.

Remark:

Qt Designer comes with the "ARM-Qtopia 2.2.0". It's executable is:

/usr/local/arm-qtopia/qtopia-2.2.0-FriendlyARM/qt2/bin/designer

The screenshot above is from this tool.

Do not try newer versions of Qt Creator. They are not compatible.

From File-New select "Dialog" template. Change the "name" property to frmMainWindow. This will be the name of the form class. Save it as MainWindow.ui. This is an XML file. You can view and edit it's contents with text editor. For example if you want to add tabs to TabWidget this is the only option.

2. Create a script file "build" for building the application with following content:

#!/bin/bash
source /usr/local/arm-qtopia/qtopia-2.2.0-FriendlyARM/setQpeEnv
qmake -spec /usr/local/arm-qtopia/qtopia-2.2.0-FriendlyARM/qtopia/mkspecs/qws/linux-arm-g++ -o Makefile *.pro
make clean
make

3.Create a script file "formuic" for compiling the .ui form file with the following content

echo MAIN FORM
echo HEADER
/usr/local/arm-qtopia/qtopia-2.2.0-FriendlyARM/qt2/bin/uic -o MainWindow.h MainWindow.ui
echo CLASS
/usr/local/arm-qtopia/qtopia-2.2.0-FriendlyARM/qt2/bin/uic -i MainWindow.h -o MainWindow.cpp MainWindow.ui

Open a terminal window and go to the project folder. Run the script:
#./formuic
The uic tool (user interface compiler) takes the .ui file.
When MainWindow.ui is compiled two source files are created - a header and cpp. They content the form class "frmMainWindow".

4. Create two files main.cpp , MainWindowImp.h and MainWindowImp.cpp with the following contents:
main.cpp

#include <qtopia/qpeapplication.h>
#include "MainWindowImp.h"

QTOPIA_ADD_APPLICATION("stivlib",frmMainWindowImplementation)
QTOPIA_MAIN

QTOPIA_ADD_APPLICATION macro takes two parameters. The first is "stivlib" - the name of the project. The second frmMainWindowImplementation is the name of the class from MainWindowImp.h

MainWindowImp.h
In this file a new class frmMainWindowImplementation is defined which inherits the form class frmMainWindow. This is done because each time you make changes to you form with Qt Designer and the .ui file is compiled any changes made in MainWindow.h and MainWindow.cpp will be lost. All the functional implementations like new variables definitions and new methods should be done in this new class.

/****************************************************************************
** Created: Sun Jul 11 18:05:02 2010
**      by: Svilen Stavrev
** Implementation Class for the main form
****************************************************************************/
#ifndef FRMMAINWINDOWIMP_H
#define FRMMAINWINDOWIMP_H

#include "MainWindow.h"

class frmMainWindowImplementation : public frmMainWindow
{
    Q_OBJECT

public:
    frmMainWindowImplementation( QWidget* parent = 0, const char* name = 0, bool modal = FALSE, WFlags fl = 0 )
    : frmMainWindow(parent,name,modal,fl)
    {
        //Constructor
    }
};
#endif // FRMMAINWINDOW_H

MainWindowImp.cpp
/************************************************
** Created: Sun Jul 11 18:05:02 2010
** by: Svilen Stavrev
** Implementation Class for the main form
************************************************/
#include "MainWindowImp.h"

5. Generate the .pro (project) file using the qmake tool:

    $su
    #source /usr/local/arm-qtopia/qtopia-2.2.0-FriendlyARM/setQpeEnv
    #qmake -project

A project file stivlib.pro has been created.
Open it with the text editor and add these lines:

TARGET=stivlib <-- This is the exact name of the target executable file. No extension .bin will be added
CONFIG += qtopiaapp
CONFIG -= buildQuicklaunch

5. Build the application

#./build

Voila! The binary file stivlib is now in the project folder.
On my next post I'll show how to upload it to the FriendlyARM board and how to create a desktop launcher.

Test

2010-05-27T12:46:00.001-07:00