My book is coming!!!!

I am feeling so excited with my book.. it is being painful because I am working so hard during late nights and my weekends while we were developing the Intel Galileo Gen 2. I hope to provide a good information to the community with some cool projects…

It is about Intel Galileo and Intel Galileo Gen 2 ... cool thinks are coming like

  • emotion recognition with openCV
  • Images and video capture with V4L2
  • Communication with LTE modems
  • Video card out through mini PCIe
  • How to make DHT sensor work
  • Hacking Intel libraries and IDE…

This is the Intel Galileo Gen 2:

This Intel Galileo Gen 2 has a lot of hw issues resolved including design changes… finally we have a decent GPIO expander with decent PWM as well. The ports can reach until 2.39 Mhz if configured properly and the pins used shares the same cluster because the pins are connected directly to SoC instead to be commanded via I2C. The board is a little bit bigger because we are not using the internal regulators of SoC, so we could reduce around 8F degrees the temperature.

The audio and weird audio jack for serial communication is gonne!! not we have micro USB connectors, OTG USB connector, the Linux terminal might be opened using FTDI cable, and much more….

I hope you enjoy this book!!!

How to “hack” CY8C9540A using I2C to set different freqs and duty cycles on intel Galileo Board

This is a short and very simple post but I decided to write it because I am pretty sure will be useful for some developers

Intel Galileo board has a GPIO explander called CY8C9540A that operates in 5V and is responsible for the PWM.

If you see the Servo library API, the methods implemented are the same methods implemented for Atmel micro-controllers except the fact we have two methods added that allow us to decide if the Servo trains will be 48Hz or 188Hz.

How the Servo library does that ? The Servo communicated with the CY8C9540A using I2C. The I2C communication can be done using the Wire API. Continue reading

PWM with low frequency using Arduino – Is the simplicity the best model ?

If you have a simple project and you need to develop a prototype quickly, I really like the OPEN solution offered by Arduino. It is open source, open hardware, free compiler, the language is close to C (easy.. easy…), it is very affordable and we can count to thousands of different examples how to use arduino to communicate with sensors, control IO’s, displays, gsm modules, etc.

OK.. let’s talk about my problem…

I was wondering if it is possible to program the Arduino Uno R3 in order to use the Pulse With Modulation (PWM) functions like analogWrite() but for very low frequencies like 5 Hz.

Why 5 Hz ? Imagine you need to send an ASCII sequence of bit using a GPIO and the purpose of this sequence is to simulate a serial keyboard with debounce of 200ms. Inverting this debounce we have 5 Hz and arduino Uno operating on 16Mhz you will conclude the analogWrite() is not able to provide this frequency.

Then you make some research and you discover it is possible to change the timers registers(TCCRnA and TCCRnB) on atmega but the best case you can reach is close to 31 khz (timer2) and to make your life a little worst, you realize also changes these registers the delay() function is impacted and some correction factor must be considered. This link has a nice reference that explain this.

Continue reading

Installing OpenGrok and Tomcat 7 on Ubuntu 13.04 quickly

If you are a developer you need a good source code navigator. I have used cscope to navigate and edit code directly from my terminal dismissing any graphical user interface but some people like to use the sourcenav or net beans ecosystem. However both are graphically nice but are “heavy” apps and also, if you want to share a way with your co-workers how to browser your code you will need to install the apps in different desktops.

But what about to have a fast way to navigate in your code, have fast crossed references  and share your source code with your co-workers dismissing the installation of source navigators on different desktops using your web browser ?

If you need something like this or if you wants a fast and easy installation of a good source navigation, I recommend OpenGrok. To be honest, even if I do not need to share my code with anyone, I use in my machine only for my personal code browsing.

OpenGrok runs as a webapp that means you and your co-workers can use your favorite browser navigator. Chrome, Firefox, Internet Explorer, whatever! you only need your preferable one to enjoy the code.

Considering OpenGrok is web based you will need to install a web server to be used as servlet server. OpenGroks supports Tomcat or Glassfish.

I am personally using tomcat 7 in my ubuntu 13.04. Let’s see the 3 basic steps:

Continue reading

How to download quickly the kernel source code used on your Ubuntu

I am really sorry if this post is so shot and newbie but I will use these instructions on my next posts.

Try typing:

#> sudo -i

#> cd /usr/src

#> apt-get source linux-image-$(uname -r)

If fails complaining about dpkg-source, you need the debian package development tools.

Install it doing:

#> apt-get install dpkg-dev

and try to download the source again.

You can get using git. If you prefer this method check this page.

I am using root (sudo -i) on this example because next post I will compile some code that requires the right permission to run the example codes.

Debugging tombstones with ndk-stack and addr2line

I really like to work with several components in a system including linux kernel or keep my emotions on userspace.

If you work with android and your are a real engineer, it is very difficult to resist the native support using Android NDK. If your software requires performance using graphic API like in OpenGL or if you need to access some specific information provided by some native library, the NDK fits for you.

However, bugs in native side sometimes takes time and usually it is not an easy and fast task. If you have the device and an easy way to reproduce the issue, it is ok but suppose you need to collect logs from remote users and the scenario is very difficult to reproduce. Some cases the users even see the crash visually but the system contains the logs blocking the approval of your software that must be completed to some costumer.. at this point the program/project managers team are “talking” in your ears… “fix it!”.

Working with Android, every time a process that runs on native side crashes, we have some small pieces of your stack in files called tombstones.

The tombstones are located at /data/tombstones as isolated files (one files represents one crash) or you can see them in your logcat Take a look in the adb shell:

root@android:/ # find . |grep tombs

root@android:/ #

The tombstone inform you about:

  1. Build fingerprint
  2. Crashed process and PIDs
  3. Terminated signal and fault address
  4. CPU registers
  5. Call stack
  6. Stack content of each call

I will not post a full tombstone here. Check the /data on your device and you will observe the 7 sessions mentioned above . Let’s go straight to the point.. how to debug the stack in tombstones files!

Continue reading

Android Services: Recommendations when using AIDL for continuous service and low current drain impact

Last month a lot things happened.. I lost my dad, moved to another location .. thus, this blog was not the priority but was not forgotten.

This post is related to some issues I have observed in some Dalvik implementation and some recommendations is you want to create a service that must remains running all the time even after a device power on/off or reset.

Suppose you need to create a “light” service that must be:

1) starts when every time your devices boots.

2) contains very nice parcelable objects using aidl syntax sharing them thru IPC

3) is used to monitor something every X minutes but cannot impact the current drain.

4) the service must use the “uptime”, I mean, must reports “how long” is running

5) must be able to receive interruptions and reports them

A good application of this service could be an alarm central unit for your car. You could create this project using your old Android phone and transforming your old phone and hidden it in your car. You can also connect this old phone disassembling a 12V charging and connecting in some spot using the terminals of your battery.

So, let’s go to some mistakes.. see the list below:

Continue reading

POSIX Threads and Joins – Parallel Programming – PART 1

During a long time we were “blessed” with computers that had only single CPU. The single CPU usually had a mediocre single core and thread. All software developed on that time executed sequential processing.

However, multi-cores and multi-threads processors were introduced in the market but if you do not develop your software trying to explore the hardware advantages your software might have the same performance if running in a single cpu machine.

You need to think also if you software will run in a computer isolated or if your software will be able to run in multiple computers sharing a common network and organize different tasks to resolve a common problem.

Today, I will write this post for my own reference using the POSIX threads and how to have the best usage of joins and mutex implementation. I am running in a ubuntu 10.04 but if you are running Windows you can use these examples installing the POSIX win32 compatibility module or installing Cygwin to simulate a linux shell.

Code compilation

All codes on this post were compiled using gcc and invoking the POSIX libraries thru command like under ubuntu 10.04. For example you can use:

gcc -pthread <my source code.c>


The first code is related to a model where we do not share the same memory space and there is no policy regarding the thread priorities or resources access management (although the threads runs in the same process sharing the same memory space this first example to resource are conflicted).

It is a simple code that creates 3 threads, passes arguments to them using strings and integers and then they are terminated.

Take a look in the code below:

Continue reading