Lirtex - Technology on the Edge of Time

Microcontroller In Circuit Serial Programming (ICSP) with Microchip PIC and Atmel AVR

Lior Chen — Fri, 03 Feb 2012 21:48:17 +0000

In Circuit Serial Programming is a method of directly programming a Microchip PIC or Atmel AVR while in they are connected to a circuit, as opposed to programming the chip ahead, and only then soldering it to a circuit. There are many benefits to ICSP, but also some important design considerations which I will try to highlight.

In circuit programming has many advantages:

It shortens the development cycle – it is really annoying to take a chip out of the board each time it needs to be reprogrammed, and it’s even much harder with SMD.
Allows customer and in field firmware upgrades
Calibrate the system during manufacturing or in the field
Assign unique ID \ serial number to product

How to prepare your circuit to work with ICSP?

The programmer uses serial signaling scheme to program the chip in circuit. The signaling is carried through the programming clock (PGC or ICSPCLK) and the programming data (PGD or ICSPDAT) pins. In addition, the MCLR/VPP pin is used as either a high voltage programming signal or an attention indicator to the device.

Wherever application allows, use dedicated pins for ICSP. It will save you much trouble. Not sharing a pin both for ICSP and I/O for example, minimizes the preparation work which needs to be done to allow ICSP.

Often, and especially true with low pin devices, it is not possible to dedicate the 3 needed pins just for ICSP, and when want them to have dual functionality.

In this case:

1. Isolate Vpp from the circuit by using a Schotkey diode and an R/C. NOTE: in some devices, like the PIC12F629, this pin will be driven to about 13 volts by the programmer while programming the device. Make sure whatever is connected to the Vpp pin can sustain this voltage level, or isolate it with an appropriate resistor or a Schotkey diode.

2. Isolate ICSP_Clock and ICSP_Data from the rest of the circuit. The isolation method is application specific, which unfortunately means there is no ready recipe. Often, a resistive isolation works fine. Recommended resistor values are 1k to 10k.

3. Physically locate the ICSP header as close as possible to the programmed chip, to reduce attenuation.

Common Microchip PIC ICSP layouts

Additional reading and references

Fast Object Tracking – Robot Computer Vision

Lior Chen — Thu, 16 Sep 2010 01:17:05 +0000

I wanted my robot to be able to track object and follow them. The first thing I wanted to do is give the robot the ability to follow an object with its head camera. The head camera is mounted on a pan-tilt servo system, and hence is capable of moving left and right, up and down (as seen in the picture below).

My second object tracking goal was to make the robot chase after an object, much like a dog would chase a ball thrown by his owner. This kind of tracking is quite harder – it would use the head camera tracking from the previous step, and combine it with rest of the robot sensors to follow the object.

How?

To achieve that I’m going to use several basic image processing \ computer vision algorithms. I’m going to use the OpenCV library. OpenCV, as it’s name suggests, is an open-source computer-vision library originally

developed by Intel. It is cross-platform (I have used it both on a PC and on the ARM based Beagleboard). OpenCV is fairly easy to use if you have basic knowledge in image-processing.

The first object I wanted to track was a plain colored orange ball.

Color based tracking

Filter only the orange color from the image. To do that, I converted the image to the HSV color-space, and then used the cvInRange filter twice to filter the orange colors.

In the first picture below you can see the video steam converted to the HSV color space, and in the second picture you can see the result of the red color filtering (all colors except red were filtered out).

(python code)


#declare necessary objects
hsv_frame = cvCreateImage(size, IPL_DEPTH_8U, 3)

thresholded = cvCreateImage(size, IPL_DEPTH_8U, 1)

thresholded2 = cvCreateImage(size, IPL_DEPTH_8U, 1)

hsv_min = cvScalar(0, 50, 170, 0)

hsv_max = cvScalar(10, 180, 256, 0)

hsv_min2 = cvScalar(170, 50, 170, 0)

hsv_max2 = cvScalar(256, 180, 256, 0)
# convert to HSV for color matching

# as hue wraps around, we need to match it in 2 parts and OR together

cvCvtColor(frame, hsv_frame, CV_BGR2HSV)

cvInRangeS(hsv_frame, hsv_min, hsv_max, thresholded)

cvInRangeS(hsv_frame, hsv_min2, hsv_max2, thresholded2)

cvOr(thresholded, thresholded2, thresholded)

Shape based tracking

Then, I used Hough transform to detect the shape of a circle. Before applying the hough transform I smoothed the image because it seems to improve the results.

# pre-smoothing improves Hough detector
cvSmooth(thresholded, thresholded, CV_GAUSSIAN, 9, 9)
circles = cvHoughCircles(thresholded, storage, CV_HOUGH_GRADIENT, 2, thresholded.height/4, 100, 40, 20, 200)

The result

The result is pretty impressive. The code functions very well and detects the ball under most circumstances (i.e. the ball is far from the camera, close to the camera, slow movement, fast movement, etc).

You can see the result in this video:

http://www.youtube.com/watch?v=CigGvt3DXIw

Full python sources including servo movement



/*****************************************************************************************

*  Name    : Fast object tracking using the OpenCV library                               *

*  Author  : Lior Chen <chen.lior@gmail.com>                                             *

*  Notice  : Copyright (c) Jun 2010, Lior Chen, All Rights Reserved                      *

*          :                                                                             *

*  Site    : http://www.lirtex.com                                                       *

*  WebPage : http://www.lirtex.com/robotics/fast-object-tracking-robot-computer-vision   *

*          :                                                                             *

*  Version : 1.0                                                                         *

*  Notes   : By default this code will open the first connected camera.                  *

*          : In order to change to another camera, change                                *

*          : CvCapture* capture = cvCaptureFromCAM( 0 ); to 1,2,3, etc.                  *

*          : Also, the code is currently configured to tracking RED objects.             *

*          : This can be changed by changing the hsv_min and hsv_max vectors             *

*          :                                                                             *

*  License : This program is free software: you can redistribute it and/or modify        *

*          : it under the terms of the GNU General Public License as published by        *

*          : the Free Software Foundation, either version 3 of the License, or           *

*          : (at your option) any later version.                                         *

*          :                                                                             *

*          : This program is distributed in the hope that it will be useful,             *

*          : but WITHOUT ANY WARRANTY; without even the implied warranty of              *

*          : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               *

*          : GNU General Public License for more details.                                *

*          :                                                                             *

*          : You should have received a copy of the GNU General Public License           *

*          : along with this program.  If not, see <http://www.gnu.org/licenses/>        *

******************************************************************************************/

#!/usr/bin/python

# -*- coding: utf-8 -*-
from opencv.cv import *

from opencv.highgui import *

from threading import Thread

#import serial
class RobotVision:

	cvSize size

	cvImage hsv_frame, thresholded, thresholded2

	cvScalar hsv_min, hsv_max, hsv_min2, hsv_max2

	cvCapture capture;
	def InitBallTracking():

		globals size,  hsv_frame, thresholded, thresholded2, hsv_min, hsv_max, hsv_min2, hsv_max2, capture

		print "Initializing ball Tracking"

		size = cvSize(640, 480)

		hsv_frame = cvCreateImage(size, IPL_DEPTH_8U, 3)

		thresholded = cvCreateImage(size, IPL_DEPTH_8U, 1)

		thresholded2 = cvCreateImage(size, IPL_DEPTH_8U, 1)
		hsv_min = cvScalar(0, 50, 170, 0)

		hsv_max = cvScalar(10, 180, 256, 0)

		hsv_min2 = cvScalar(170, 50, 170, 0)

		hsv_max2 = cvScalar(256, 180, 256, 0)
		storage = cvCreateMemStorage(0)
		# start capturing form webcam

		capture = cvCreateCameraCapture(-1)
		if not capture:

			print "Could not open webcam"

			sys.exit(1)
		#CV windows

		cvNamedWindow( "Camera", CV_WINDOW_AUTOSIZE );
	def TrackBall(i):

		t = Thread(target=TrackBallThread, args=(i,))

		t.start()
	def TrackBallThread(num_of_balls):

		globals size,  hsv_frame, thresholded, thresholded2, hsv_min, hsv_max, hsv_min2, hsv_max2, capture

		while 1:

			# get a frame from the webcam

			frame = cvQueryFrame(capture)
			if frame is not None:
				# convert to HSV for color matching

				# as hue wraps around, we need to match it in 2 parts and OR together

				cvCvtColor(frame, hsv_frame, CV_BGR2HSV)

				cvInRangeS(hsv_frame, hsv_min, hsv_max, thresholded)

				cvInRangeS(hsv_frame, hsv_min2, hsv_max2, thresholded2)

				cvOr(thresholded, thresholded2, thresholded)
				# pre-smoothing improves Hough detector

				cvSmooth(thresholded, thresholded, CV_GAUSSIAN, 9, 9)

				circles = cvHoughCircles(thresholded, storage, CV_HOUGH_GRADIENT, 2, thresholded.height/4, 100, 40, 20, 200)
				# find largest circle

				maxRadius = 0

				x = 0

				y = 0

				found = False

				for i in range(circles.total):

					circle = circles[i]

					if circle[2] > maxRadius:

						found = True

						maxRadius = circle[2]

						x = circle[0]

						y = circle[1]
				cvShowImage( "Camera", frame );
				if found:

					print "ball detected at position:",x, ",", y, " with radius:", maxRadius
					if x > 420:

						# need to pan right

						servoPos += 5

						servoPos = min(140, servoPos)

						servo(2, servoPos)

					elif x < 220:

						servoPos -= 5

						servoPos = max(40, servoPos)

						servo(2, servoPos)

					print "servo position:", servoPos

				else:

					print "no ball"

Sample Sources

This c++ code takes a video stream from an attached video camera, looks for an orange ball inside the stream, and prints the coordinates of the ball.
Three “debug” windows are shown to clarify the process: 1) the video capture. 2) the stream after the conversion to HSV, 3) the stream after conversion to HSV, color-filtering, and Hough transform.



/*****************************************************************************************

*  Name    : Fast object tracking using the OpenCV library                               *

*  Author  : Lior Chen <chen.lior@gmail.com>                                             *

*  Notice  : Copyright (c) Jun 2010, Lior Chen, All Rights Reserved                      *

*          :                                                                             *

*  Site    : http://www.lirtex.com                                                       *

*  WebPage : http://www.lirtex.com/robotics/fast-object-tracking-robot-computer-vision   *

*          :                                                                             *

*  Version : 1.0                                                                         *

*  Notes   : By default this code will open the first connected camera.                  *

*          : In order to change to another camera, change                                *

*          : CvCapture* capture = cvCaptureFromCAM( 0 ); to 1,2,3, etc.                  *

*          : Also, the code is currently configured to tracking RED objects.             *

*          : This can be changed by changing the hsv_min and hsv_max vectors             *

*          :                                                                             *

*  License : This program is free software: you can redistribute it and/or modify        *

*          : it under the terms of the GNU General Public License as published by        *

*          : the Free Software Foundation, either version 3 of the License, or           *

*          : (at your option) any later version.                                         *

*          :                                                                             *

*          : This program is distributed in the hope that it will be useful,             *

*          : but WITHOUT ANY WARRANTY; without even the implied warranty of              *

*          : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               *

*          : GNU General Public License for more details.                                *

*          :                                                                             *

*          : You should have received a copy of the GNU General Public License           *

*          : along with this program.  If not, see <http://www.gnu.org/licenses/>        *

******************************************************************************************/
#include <opencv/cvaux.h>

#include <opencv/highgui.h>

#include <opencv/cxcore.h>

#include <stdio.h>
#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include <math.h>

#include <float.h>

#include <limits.h>

#include <time.h>

#include <ctype.h>
int main(int argc, char* argv[])

{
    // Default capture size - 640x480

    CvSize size = cvSize(640,480);
    // Open capture device. 0 is /dev/video0, 1 is /dev/video1, etc.

    CvCapture* capture = cvCaptureFromCAM( 0 );

    if( !capture )

    {

            fprintf( stderr, "ERROR: capture is NULL \n" );

            getchar();

            return -1;

    }
    // Create a window in which the captured images will be presented

    cvNamedWindow( "Camera", CV_WINDOW_AUTOSIZE );

    cvNamedWindow( "HSV", CV_WINDOW_AUTOSIZE );

    cvNamedWindow( "EdgeDetection", CV_WINDOW_AUTOSIZE );
    // Detect a red ball

    CvScalar hsv_min = cvScalar(150, 84, 130, 0);

    CvScalar hsv_max = cvScalar(358, 256, 255, 0);
    IplImage *  hsv_frame    = cvCreateImage(size, IPL_DEPTH_8U, 3);

    IplImage*  thresholded   = cvCreateImage(size, IPL_DEPTH_8U, 1);
    while( 1 )

    {

        // Get one frame

        IplImage* frame = cvQueryFrame( capture );

        if( !frame )

        {

                fprintf( stderr, "ERROR: frame is null...\n" );

                getchar();

                break;

        }
        // Covert color space to HSV as it is much easier to filter colors in the HSV color-space.

        cvCvtColor(frame, hsv_frame, CV_BGR2HSV);

        // Filter out colors which are out of range.

        cvInRangeS(hsv_frame, hsv_min, hsv_max, thresholded);
        // Memory for hough circles

        CvMemStorage* storage = cvCreateMemStorage(0);

        // hough detector works better with some smoothing of the image

        cvSmooth( thresholded, thresholded, CV_GAUSSIAN, 9, 9 );

        CvSeq* circles = cvHoughCircles(thresholded, storage, CV_HOUGH_GRADIENT, 2,

                                        thresholded->height/4, 100, 50, 10, 400);
        for (int i = 0; i < circles->total; i++)

        {

            float* p = (float*)cvGetSeqElem( circles, i );

            printf("Ball! x=%f y=%f r=%f\n\r",p[0],p[1],p[2] );

            cvCircle( frame, cvPoint(cvRound(p[0]),cvRound(p[1])),

                                    3, CV_RGB(0,255,0), -1, 8, 0 );

            cvCircle( frame, cvPoint(cvRound(p[0]),cvRound(p[1])),

                                    cvRound(p[2]), CV_RGB(255,0,0), 3, 8, 0 );

        }
        cvShowImage( "Camera", frame ); // Original stream with detected ball overlay

        cvShowImage( "HSV", hsv_frame); // Original stream in the HSV color space

        cvShowImage( "After Color Filtering", thresholded ); // The stream after color filtering
        cvReleaseMemStorage(&storage);
        // Do not release the frame!
        //If ESC key pressed, Key=0x10001B under OpenCV 0.9.7(linux version),

        //remove higher bits using AND operator

        if( (cvWaitKey(10) & 255) == 27 ) break;

    }
     // Release the capture device housekeeping

     cvReleaseCapture( &capture );

     cvDestroyWindow( "mywindow" );

     return 0;

   }

Linux Robotic Platform – an Intelligent Robot

Lior Chen — Mon, 05 Jul 2010 10:18:19 +0000

I have always wanted to experiment with robotics, and lately I’ve found the time to build an “intelligent”, open-source robotic platform.

The platform runs embedded debian linux, and includes the following main capabilities:

1. Computer Vision (imitation of the human vision. The robot sees and “understands” what it sees). For this I have extensively used the OpenCV project.

2. Speech Synthesis (imitation of human speech. The ability to speak). For this I have used Espeak.

3. Speech Recognition (the ability to understand vocal commands). For this I have used CMU Sphinx 4 (after modifying some of the files in the project)

Just a teaser, before I upload more videos:

http://www.youtube.com/watch?v=okt-2_VxGfc

List of Computer Vision capabilities:

1. Line Following

2. Object Tracking

3. Facial Recognition (uses face API from face.com)

List of Speech Synthesis Capabilities:

1. Speaking the current action (“Moving Forward” etc)

2. Saying “Hi ” when it recognizes a face

Current list of Speech Recognition Capabilities:

1. Full movement control (“Move Forward\Backward”, “Turn Left\Right”, “Stop”)

2. Initialization of algorithms: “Follow Line\RedBall”, “Find Face”

Robot Diagram

Automatic Caller Identifier for Maemo (Nokia Linux OS)

Lior Chen — Tue, 01 Jun 2010 20:43:43 +0000

Automatic Caller Identification uses several sites on the internet to find the identification of unknown incoming calls, and display it while receiving such calls.

The project is developed for Maemo, Nokia’s embedded Linux operating system.

For years I have waited for having my own phone that would run Linux. A phone I will be able to use just like any other system, stacked with a full programming tool-chain, ssh access, a decent packaging system, and my favorite set of application. Finally, that day has come. Nokia N900 is a fully based Linux based phone which runs Maemo – an SDK and a software platform which is based on my long loved Debian Linux distribution.

This post will describe the process of developing an Maemo application for the Nokia N900. I will use my Automatic Caller Identification program as an example.

Automatic Caller Identification?

Simply put, an automatic caller identification system is a system that can identify unknown numbers (i.e. phone numbers which are not currently stored in your phone book). Since the N900 has a built in internet connection (either Wifi or 3G), I wanted to create a program that once an unidentified call is received, will use several sites in the internet to identify the caller and display its details. Since I live in Israel I first experienced with Israeli numbers, but the code is modular enough to extend it to other countries \ internet databases as well. The database I used was http://441il.com/.

The development Process

Development Environment

Maemo SDK

Live example

http://www.youtube.com/watch?v=viuhEDIjAIA

Links and Source-code

https://garage.maemo.org/projects/caller-id/

Building a Custom Debian Kernel for the BeagleBoard

Lior Chen — Sun, 24 May 2009 11:49:26 +0000

While trying to get my WIFI dongle to work with the BeagleBoard, I noticed that the dongle’s module was not compiled into the kernel. So I had to build a new kernel from scratch. Since building a new kernel under the BeagleBoard will take a LOT of time, I decided to cross-compile a kernel for the ARM architecture under my AMD-64 arch PC.

The following steps describes building a custom Debian kernel for the BeagleBoard using cross-compiling:

Installing required dependencies

Install proper build environment:

apt-get install git-core kernel-package fakeroot build-essential \
curl libncurses-dev uboot-mkimage

Edit /etc/apt/sources.list and add the Embedded Debian Project sources:

#debian embedded
deb http://www.emdebian.org/debian/ unstable main

Now execute:

apt-get update
apt-get install cpp-4.3-arm-linux-gnu g++-4.3-arm-linux-gnu gcc-4.3-arm-linux-gnu

You now have a build environment capable of compiling a kernel for the ARM platform. Next step is to acquire and compile the kernel

Acquiring and Compiling the Kernel

Retrieve the GIT checkout:

git clone git://git2.kernel.org/pub/scm/linux/kernel/git/tmlind/linux-omap-2.6.git
cd linux-omap-2.6/
git checkout 58cf2f1 -b v2.6.29-58cf2f1
git archive --format=tar --prefix=v2.6.29-58cf2f1/ v2.6.29-58cf2f1 | gzip > ../v2.6.29-58cf2f1.tar.gz
git checkout master
git branch v2.6.29-58cf2f1 -D
cd ..

Download kernel diffs and kernel config:

wget http://rcn-ee.homeip.net:81/dl/omap/beagle/v2.6.29-58cf2f1-oer34/v2.6.29-58cf2f1-oer34.diff
wget http://rcn-ee.homeip.net:81/dl/omap/beagle/v2.6.29-58cf2f1-oer34/defconfig

Extract Kernel Source

tar -xf v2.6.29-58cf2f1.tar.gz
cd v2.6.29-58cf2f1/

Apply Patch

patch -p1 < ../v2.6.29-58cf2f1-oer34.diff

Copy Defconfig

cp ../defconfig .config

Configure the kernel (requires libncurses5-dev installed)

make menuconfig

Build, Cross-Compiling:

make CROSS_COMPILE=arm-linux-gnu- uImage

A few moments later, you can find your new kernel in the ‘arch/arm/boot/’ directory.

Make modules:

make CROSS_COMPILE=arm-linux-gnu- modules
make CROSS_COMPILE=arm-linux-gnu- modules_install
make CROSS_COMPILE=arm-linux-gnu- modules_install INSTALL_MOD_PATH=arch/arm/boot”

Congratulations, a new kernel is compiled! Now move uImage and the arch/arm/boot directory to the sdcard.

Next step is to boot and test my WIFI dongle again.

You can find some more information about building a Debian kernel here.