Reading data can quickly become an issue. You could write your own little tool to read data off a certain port but there is a tool out there that make’s it much easier. Needing a tool that does exactly that for work, I spent a while on the internet looking for free (as in beer) software without any luck, so I moved to trial based commercial software and found one very good application.

It’s made by Eltima Software and is called Serial port monitor 4.0 (how original). The application let’s you do much more than what I needed but the features I used are:
Monitoring specific COM port and specifying it’s parameter (baud rate, databits, etc.)
Seeing the data results in a table format
Seeing the control data exchange

The tool performed very well in my environment and for the type of work I was doing. For my buying the software would not be an option since I only needed it for a few days but for it’s price, it might be a good buy if you need to do a lot of data monitoring.

Cross-compiling is compiling for a different architecture than the one you are currently working on. If it’s your first time doing that kind of work, it can rapidly become frustrating since there is no “silver bullet” method. In this post, I will try to explain a method that should work for most embedded device provided that the manufacturer has a toolchain readily available.

What you will need:

• A computer with a Linux distribution (I used Fedora 7 [it's old but it worked] )
• A compiler and the necessary libraries
• The toolchain for the processor
• Not necessary but will make you  life easier: a development environment (such as Eclipse)

Let’s take a look at the 4 items previously listed. First, the Linux distribution; it’s not 100% required but it will make your life a lot easier since most toolchains (patience, we’ll get to what it is soon) are compiled for Linux.

The compiler that is most often used is GCC, a great compiler, free (free as in speech and free as in beer) and readily available of all (or almost) Linux distributions. You can get the Tarballs off their website at http://gcc.gnu.org/ or just use the package manager in you environment. I would suggest installing the required libraries for the code you are compiling at this point if it’s not already done.

Toolchains, what are they? Toolchains are simply a set of compilers and libraries build to run on a certain architecture and compile for another. You will usually be able to get them from the manufacturer’s website or from the community. You will most likely find them packaged in Tarballs.

Finally, the development environment is useful because it let’s you consolidate and organize your code into neat folders and let’s you easily manage build options. With some addons, Eclipse will even let you sync a project directly from a SVN!

Architecture, what’s that?

Throughout this article, I will often refer to the ARM architecture and the x86 (also known as i386 or i486 or i686). The architecture simply refers to the CPU “design” and it’s a quick way of knowing what compiled code will work with which CPUs. The differences between each architecture and the reason for such differences is way beyond the scope of this article. Just keep in mind that when you select a compiler, an application or Linux distribution for you computer, you’ll probably be looking for the i386 (most Linux distributions will but different versions for i386 and i686, newer PCs run with i386) or the x86_64 (or x64) if you have a 64 bit processor. Note that i386 will work on 64 bit processor the the opposite is not true!

Let’s get started

First let’s assume that you have you environment set up, that you have some basic knowledge of Linux and that your code compiles on you current processor. Let’s also assume you’re not using some obscure libraries that you don’t have the source code for. Finally, I’ll assume that you have ROOT privileges on your system.

First step of the cross-compiling process is to locate the toolchain and download it to your home directory.

Next step is to extract it. If it’s a tarball, just execute the following command:

tar -xzf crosstool.tar

Once you have the content of the toolchain in a folder somewhere, we need to make it usable. This is where most people go their own ways. I found a very simple and effective way of using the toolchain and I’m sharing it because I think the other methods are more trouble than they are worth.

To get the toolchain working, let’s start by making a backup or our compilers. Execute the following commands in the console:

cp /usr/bin/gcc /usr/bin/gcc.bak

cp /usr/bin/g++ /usr/bin/g++.bak

Now that we have the backup done, we’ll remove the originals by running the following commands:

rm /usr/bin/gcc

rm /usr/bin/g++

And finally, we need a way of letting the OS think that we still have the compilers there, so we’ll add two symbolic links that will point to the toolchain’s compilers

ln -s /path/to/crosstool/bin/crosstool-name-gcc /usr/bin/gcc      
ex: ln -s /home/test/arm-none-linux-gnueabi/bin/arm-none-linux-gnueabi-gcc /usr/bin/gcc

ln -s /path/to/crosstool/bin/crosstool-name-gpp /usr/bin/gpp               
ex: ln -s /home/test/arm-none-linux-gnueabi/bin/arm-none-linux-gnueabi-gpp /usr/bin/gpp

Now that, we have some shinny new compilers, let’s test them with something simple. We’ll make a short “Hello World” program and compile it for your embedded device architecture. Type into a new file somewhere:

#include <stdio.h>

int main(void) {

       printf("Hello World!\n");

       return 0;

}

and save it as hello.c.

To compile, you can simply type the following command (assuming that you are executing that command from the same folder that contains the file):

gcc hello.c -o hello.arm

You should look for errors here, if it succeeds, you should not get anything back and you will be able to see the file in your current folder.

Finally, to confirm that you have a working environment, we will look at the file properties by executing the command:

file hello.arm

if the output specifies the embedded device’s processor, you should be fine. It should look like:

hello.arm: ELF 32-bit LSB executable, ARM, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.4.17, not stripped

In part two of this tutorial, we will look at getting the original compilers back in and some advanced method for larger application compiling. Even though I am not an expert on the subjet, feel free to post your issues and questions and I will do my best to find and provide answers!

Design

The design of this keyboard is unusual although it is very comfortable to work with. It features a small touchpad on the right side and touch sensitive volume control above it. It also has a brushed aluminum palm rest which keeps your hands somewhat cool even after a few hours of work. The keyboard is slim, measuring less than half an inch at the thickest point. Unfortunately, Logitech thought that having a glossy contour was a great idea but I can say that after just a few hours of work, it’s already full of finger marks, especially below the spacebar.

Keys

The keys on this keyboard make me think of those great IBM/Lenovo laptop keyboard. They are very sturdy and they feel well balanced. The only thing I can find to complain about is having the bottom row of keys rounded. This can get a bit annoying and takes a few days to get used to but won’t really affect your typing.

Features

Like I mentioned earlier, the keyboard feature a nice touchpad, in the form of a small disk, on the right side which is a great feature if you are going to use this keyboard for a home theatre system. On the other hand, having a touchpad means that you are losing the numpad For some, like myself, it’s not a big deal and we can live without it but if you are doing a lot of Excel and similar work, you may want to reconsider. The “touchdisk” has a scroll up/down and side scroll that work by moving your finger around the disk.

The keyboard also has quite a few multi-media keys. There’s the volume control above the touchpad which is touch sensitive and lights up when you slide your fingers over it to give you an idea of the current volume settings. Above it, you have a Media Center key that would be used to launch Media Center if you are on Windows Vista or Windows XP Media Center Edition; otherwise, it launches Windows Media Player, by default. Above the function keys, you have shortcut keys glowing when you hold the “Fn” key down. Most of these will use either your Windows settings or the software settings to start your email software, messaging, browser, etc. You will also find the “Play”, “Stop”, “Previous” and “Next” buttons. The last 5 “F” keys feature 5 programmable functions keys when you hold the “Fn” key.

Finally, on the right side, you will see the zoom-in/zoom-out, zoom reset and sleep button. These can come handy if you want to quickly zoom-in on a document while typing.

Software and connectivity

In my opinion, the software is great. It is very functional and you can easily find all the information and settings in a matter of seconds. The software gives you the opportunity to change a lot of setting including the behaviour of the “Fn” keys. In terms of connectivity, the device uses Bluetooth and comes bundled with an adapted in the event that you don’t have it already in your computer. The reception is great, you can be far enough and the computer still picks-up the signal very clearly.

Battery and other

The battery life for the keyboard is awesome. With only 90% of the battery, you will easily last a month if not two. In the rare events that you need to charge the keyboard, you simply drop it on the charging base for an hour or two and your back to 90%. Again, with the charging base, Logitech thought that it was a great idea to make everything glossy. This means that you will have a few finger marks on it too. To fight those marks, Logitech was nice enough to bundle a cleaning cloth that works well enough.

Conclusion

This keyboard is a joy to work with. It’s only disadvantages are that it does not have a numpad which for some can be very annoying. Another problem with the diNovo is the glossy casing which is a finger mark magnet. On the positive side, the keys are sturdy and the aluminum palm rest keeps your hands cool.

Pros

• Long battery life
• Sturdy and well balanced keys
• Brushed aluminum palm rest
• Feature packed keyboard and software
• Integrated touchpad

Cons

• Glossy finish
• Touchpad leaves no room for a numpad

Rating

8/10

It won’t be long until you see some content! Come back next week and I should have some stuff up for you to read!

You will probably also see some changes in the design and stuff but don’t be alarmed, everything should be stable by next saturday!