ProjectProto

OpenCV ARM - Face Detect

2013-06-02T14:33:00.000+08:00

Here's another application that uses opencv libraries in the Debian disto. It performs face detection using Haar cascade.

The code below continuously captures frames with a USB web-camera. (In this demo, I displayed a sample picture on a separate laptop but this will also work for actual faces). Using the input frames and a loaded Haar classifier cascade, vector of rectangles containing the detected faces is returned to the user. A bounding box is drawn to each face to show successful detection.

face_detect.py

import cv2.cv as cv

HAAR_CASCADE = "/usr/local/share/OpenCV/haarcascades/haarcascade_frontalface_default.xml"

cv.NamedWindow( "mycamera" )
capture = cv.CreateCameraCapture(0)
storage = cv.CreateMemStorage()
cascade = cv.Load(HAAR_CASCADE)

while True:
    image = cv.QueryFrame(capture)
    faces = cv.HaarDetectObjects(image, cascade, storage, 1.1, 3, cv.CV_HAAR_DO_CANNY_PRUNING, (100,100))
    for((x,y,w,h),i) in faces:
        cv.Rectangle(image, (x,y), (x+w, y+h), (0,255,0), 3)
    cv.ShowImage( "mycamera", image )
    if cv.WaitKey(5) > 0:
        break

cv.DestroyWindow( "mycamera" )

Below is the C/C++ equivalent of the above python script. (The code appears lengthy due to the comments and cleanup routines.)

face_detect.cpp

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/objdetect/objdetect.hpp>
using namespace cv;

#define HAAR_CASCADE "/usr/local/share/OpenCV/haarcascades/haarcascade_frontalface_default.xml"

int main(int argc, const char ** argv)
{
    cvNamedWindow( "mycamera" /*, CV_WINDOW_AUTOSIZE*/); // create camera window, 1=CV_WINDOW_AUTOSIZE(default,the user cannot resize the window)
    CvCapture *capture = cvCreateCameraCapture(0); // start capturing frames from camera (i.e. /dev/video0 device)
    CvMemStorage *storage = cvCreateMemStorage(); // create new memory storage
    CvHaarClassifierCascade *cascade = (CvHaarClassifierCascade *)cvLoad(HAAR_CASCADE); // load frontal face detector

    while (1){
        IplImage *image = cvQueryFrame(capture); // grab and retrieve frame
        CvSeq *faces = cvHaarDetectObjects(image, cascade, storage, 1.1, 3, CV_HAAR_DO_CANNY_PRUNING, cvSize(100,100)); // find rectangular regions that contain faces
        for(int i=0; i < faces->total; i++){
            CvRect *r = (CvRect *)cvGetSeqElem(faces, i); // get bounding rectangle of the detected face
            cvRectangle(image, cvPoint(r->x, r->y), cvPoint(r->x + r->width, r->y + r->height), cvScalar(0,255,0), 3); // draw a green rectangle
        }
        cvShowImage( "mycamera", image ); // display image within window
        if (cvWaitKey(5) > 0) // press any key to exit
            break;
    }
    // cleanups
    cvReleaseHaarClassifierCascade( &cascade ); // release cascade
    cvReleaseMemStorage( &storage ); // release memory storage
    cvReleaseCapture( &capture ); // stop capturing/reading
    cvDestroyWindow( "mycamera" ); // end camera window
    return 0;
}

OpenCV ARM - Hello World

2013-06-01T13:48:00.000+08:00

Here is a sample application that utilizes OpenCV in my customized Debian disto. Sample codes are posted below. The demo simply displays images captured by the camera. This can be extended to utilize other opencv functions.

hello_camera.py

import cv2.cv as cv

cv.NamedWindow( "mycamera", 1 )
capture = cv.CreateCameraCapture( 0 )

while True:
    img = cv.QueryFrame( capture )
    cv.ShowImage( "mycamera", img )
    if cv.WaitKey(20) > 0:
        break

cv.DestroyWindow( "mycamera" )

Below is the C/C++ equivalent of the above Python script.

hello_camera.cpp

#include <opencv2/highgui/highgui.hpp>
using namespace cv;

int main( int argc, const char** argv )
{
    cvNamedWindow( "mycamera", 1 ); // create camera window
    CvCapture *capture = cvCreateCameraCapture( 0 ); // start capturing frames from camera (i.e. /dev/video0 device)

    while(1){
        IplImage* img = cvQueryFrame( capture ); // grab and retrieve frame
        cvShowImage( "mycamera", img ); // display image within window
        if( waitKey(20) > 0 ) // press any key to exit (interval=20ms)
            break;
    }
    // cleanups
    cvReleaseCapture( &capture ); // stop capturing/reading // not needed in python (?)
    cvDestroyWindow( "mycamera" ); // end camera window
    return 0;
}

---------------------------------------------------------------------------
- thanks to hilite.me for formating the codes. (best viewed with Firefox browser)
- webcam can also be tested with guvcview (Applications Menu->Multimedia->guvcview)

Debian Wheezy on SUN4I (Allwinner A10)

2013-06-01T13:02:00.001+08:00

I purchased a mini android tv box available at cd-rking. The item is actually a re-branded BC218 (similar specs to MK802+). This connects to a hdmi monitor, and with a mouse and keyboard this can function as a mini computer. After some testing, I decided to customize a Debian image dedicated for OpenCV development.

download: Debian Wheezy armhf image (~164MB)
- Debian Wheezy w/ XFCE4 desktop (debootstrap log )
- Kernel 3.4.43 (6416f0bf9e32d0950ba6f768ac20228ce8940a79) [Linaro 4.7]
- natively build MALI GPU drivers
- natively build OpenCV 2.4.5 libraries (C/C++ and Python2.7 support)
- with build-essential (e.g. compiler) and python packages

instructions:
- needs at least 2G microSD card
- extract *.img file using p7zip or 7zip,
then use dd (Linux) or win32diskimager (Windows) to burn the image
- resize partitions (optional )
- root password: toor

notes:
- tested only on BC218; so the u-boot, script, and kernel may need to be modified to work for other boards)
- this Debian is intended only for opencv development, NOT for everyday use. There are other linux distro's that are more functional than this.
- no CedarX (VPU) libraries
- to keep the image size small: (1)there's no media player and no web browser included (wifi still works though); (2)remove docs, some locales, and /var/cache/ files.
- some kernel drivers in the default "sun4i_defconfig" were disabled. While, UVC, usb2serial, etc drivers were enabled for interfacing development.

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

update 06/09/13
Debian Wheezy armhf image V2
* with LXDE desktop
* apply some tweaks (may cause instability in the system!!!)
    - increase dram clock to 432MHz
    - increase default min cpu freq to 204MHz, default max to 1104MHz
    - use tmpfs for "tmp" and "log" folders
* re-build opencv libraries

If interested only on uboot and kernel files, here's the archive.

You may also need to mod the device by adding heatsink.

'yus

Stellaris Launchpad and Nokia 6100 LCD

2013-04-10T23:12:00.000+08:00

... interfacing Nokia 6100 LCD shield to Stellaris Launchpad.
The LCD library used in this demo is included in the LM4F GCC-ARM IDE package.

LM4F-GCC-ARM-IDE

2013-04-10T15:41:00.000+08:00

...an alternative Integrated Development Environment for TI's Stellaris® LM4F120 LaunchPad (ARM Cortex-M4F @80MHz, 256kB FLASH + 32kB SRAM)

download: lm4f-gcc-arm-ide-win32.7z 17.7 MB only.

IDE features:

fast light-weight IDE (PyQt based)
using gcc-arm-embedded 4.7.3
auto-completion (NOT IntelliSense)
code-outline using CLang
lm4flash (flash loader from lm4tools)
serial monitor
supports C++ projects
stellarisware peripheral driver library
supports 8 hardware UARTs: Serial0 to Serial7 (Serial0 is the same as the debug "Serial". Serial6 pins are mux w/ USB pins)
advanced libraries( USB device, FreeRTOS kernel)
basic libraries (gpio's, delay's, buttons, RGB led, N6100 lcd)

forum discussion link

STM32-GCC-ARM-IDE

2013-04-10T15:29:00.000+08:00

a port of Philrobokit IDE to STM32F1 w/ GCC-ARM toolchain

currently, only works for E-Gizmo's STM32 MCU Board
(STM32F100C8 @24MHz, 64kB FLASH + 8kB SRAM)

download: stm32-gcc-arm-ide-win32.7z 38.7 MB
previous version: svn-r125
forum discussion link

Android-OpenCV Object-Tracking

2012-04-22T21:38:00.000+08:00

Tracking a ping-pong ball using Android-OpenCV Library

source code:

svn co http://yus-repo.googlecode.com/svn/trunk/Android/apps/objtrack

* needs Android-NDK to build.
modify objtrack.cpp to detect other objects/colors

pre-built installer: Object-Track.apk
* only for Android phones with ARMv7-capable CPU and Gingerbread OS.

references:
OpenCV for Android (see Tutorial 2 Advanced - 1. Add Native OpenCV)
Tracking colored objects in OpenCV
Android-OpenCV Google-Group

##############################################
edit 05-05-12
interfacing the app to philrobokit-Anito board (observe the LEDs+buzzer states with respect to the ball position).

* Data are being transmitted via the usb2serial adapter (built-in to the kit) using android-serialport-api.

Quadruped - part 2

2012-02-18T11:45:00.000+08:00

my second prototype of a four-legged robot...
It is the same assembly with the previous. But this time, it's now powered by LPCXpresso (LPC1114) running CoOS. It's also controllable by bluetooth joystick.

source code (with all the revisions):

svn co http://yus-repo.googlecode.com/svn/trunk/Bots/quad_lpc1114

* source code can be build using Sourcery CodeBench Lite for ARM-EABI
* I'm using lpc21isp to load the binaries for the lpc1114 using built-in serial bootloader.
* demo video is on my previous post.

Bluetooth Joystick

2012-02-15T10:58:00.006+08:00

Android Bluetooth Dual-Joystick Controller

Sends 5 bytes every 200ms (or every 3 sec if idle).
data format: [ STX : radiusL : angleL : radiusR : angleR ]
where: STX = 0x55
radius = {0..10}
angle = {0..35} (or actual/10)

sample:

will send [ 0x55 : 0x0A : 0x12 : 0x05 : 0x09 ]
(**left-joystick is pulled backward; right-joystick leaning to the left)

Source code:
svn co https://yus-repo.googlecode.com/svn/trunk/Android/apps/btjoystick

Installer: BTJoystick.apk .

Joystick widget from Mobile-Anarchy.

demo on my quadruped:

#---------------------------------
edit 10/15/12
version 2: BTJoystick.v2.apk 45.8 KB

modifications:
* preference menu (e.g. "Menu->Connect" & "Menu->Options" )
* add four customizable buttons (send either an ascii char or a string)
* immediately send joystick data when a joystick returns to center position
* selectable data format, intervals and timeout
* prevent accidental closing

crossBuild ARM target binaries on ARM host

2012-01-14T10:20:00.005+08:00

... building STM32F10x (ARM Cortex-M3) sources on WM8505 (ARM9) host.

The Debian installation on my WM8505-based tablet already includes "build-essential" package (gcc, binutils, make, etc.) but, unfortunately, no "multilib" package available yet for debian armel =( . So I have to built my own bare-metal toolchain using croostool-ng. Using this config file, I was able to built this toolchain arm-none-eabi-4.6-armv5.tar.gz (just extract this archive to install). It took almost 20 hrs to finish on WM8505 ( at 300MHz with 128MB RAM ).

For testing the toolchain, I have chosen this STM32F103RB FreeRTOS demo (4 tasks example) sources since it requires "newlib" functions to build completely.

# export CROSS_COMPILE=/path/to/arm-none-eabi/bin/arm-none-eabi-
# make -s clean all
# make program

Also, STM32Loader also works properly on my host machine since it already has python-serial installed. Using "/dev/ttyWMT0" serial port* to transfer the binary using STM32's uart bootloader:

* USB-to-Serial adapters (e.g. FT232 and PL2303 based) will also work.

For serial-port monitor, I'm using "minicom" already installed on my Debian. Below is the expected result of the STM32 FreeRTOS demo:

Debian Wheezy on WM8505

2012-01-13T11:05:00.008+08:00

Installing Debian-Wheezy on microSD card is just simply extracting the two gzip archives into two separate partitions (see below).

$ sudo tar xzpvf wm8505-debian-wheezy-lxde.tar.gz -C /media/extpart/ ; sync
$ sudo tar xzpvf wm8505-kernel-3.0-fatpart.tar.gz -C /media/fatpart/ ; sync

At least 1GB card is needed for the installation, 2GB recommended. The first partition should be a FAT32 (or FAT16) where the "script" folder, containing the "scriptcmd" and "uImage" (linux kernel image) files, is located.The second partition should be an ext2 (or ext4) partition where the root file system will be extracted. Visit these sites for more references: projectgus.com, devio.us , cheap-hack.com.

username: root
password: root

* initial installation using debootstrap
* with minimal LXDE, dillo, build-essential, python, minicom, etc.
* wi-fi / ethernet working ; touchscreen NOT working

######################################################

side note:

Recovering "wload" and "u-boot" without a flash programmer.
However, this procedure needs an already working SPI Flash chip.
( I got mine from another unit. )

I soldered them both in a piggy-back connection, except for their #CS pins (pin 1 = chip select). I also soldered a wire on the pin-1 pad on the board and covered it with a kapton tape as an insulation. The other end of the wire is initially connected to the #CS pin of the working chip. The working chip will be only needed for the first boot until we got to u-boot console prompt (needs serial/uart connector).

After getting to the console(i.e press Enter key on the serial console while booting), transfer the #CS wire to the chip that needs to be reprogrammed (use SPDT switch, if needed).

Then, execute these commands (assuming that "wload.bin" and "u-boot.bin" binaries are already saved in the FAT partition of the SD card)

mmcinit

fatload mmc 0 0 wload.bin
erase ffff0000 +10000
cp.b 0 ffff0000 10000

fatload mmc 0 0 u-boot.bin
erase fff80000 +50000
cp.b 0 fff80000 50000

... here's the serial log for this process.

Quadruped

2011-07-23T10:39:00.003+08:00

My first prototype of a four-legged robot.
12 servo motors controlled by STM32F103RB (MiniSTM32 board).

It was previously a "tripod" =) . But then, later, another leg was added (3 servos per leg) for easy balancing even without using IMU sensors.

* PhilRobotics @ MOA July 17, 2011 (pics by vic)

WM8505 LCD driver

2011-04-03T21:06:00.002+08:00

Another low-level hack on my Android Apad ( ~~clone/fake Apad?~~ ).

This time it's now with the 800x480 GLCD driver. It's working, but I'm not sure if the initialization is complete (i.e. the hardware is, most probably, already initialized by the bootloader). I've just modified the sources from Wondermedia (look at "\common\wmt_logo\" folder). LCD routines here are not using the graphics engine (GE) of WM8505.

download Eclipse project here: ARM9_WM8505_LCD.zip

Read my previous post on how to set-up the tool-chain and how to load the program on WM8505.

expected output:

forum link: Re: Let's learn ARM using cheap 7" tablets

Hello World, WM8505!

2011-03-29T23:07:00.007+08:00

My first step in learning the ARM9 platform.

VIA / WonderMedia's WM8505 (ARM926EJ-S):

UART0 Connection:

Serial console connection details: Project Gus

Required Tools: all are free =)

GNU Toolchain for ARM Processors

Sourcery G++ Lite Edition

Eclipse IDE for C/C++ Developers

Helios SR2

Eclipse CDT (C/C++ Development Tooling)

CDT 7 for Eclipse Helios

GNU ARM Eclipse Plug-in

Plug-in_Installation

The goal is to run this simple code: (main.c)

int main()
{
   uart_init();
   while(1)
   {
      uart_puts("hello world, WM8505/ARM926!\r\n");
   }
   return 0;
}

It should output these strings on UART_0 port, just like this:

After setting up the tools, here are the next steps:
-Create new project on Eclipse

-Select target processor (WM8505 is a ARM926EJ-S processor)

-Select binary format for the flash image:

-linker setting:

- after building the project, open the generated *.map file to verify the linker output

*I don't know, yet, what's with this 0x03F80000 address.

This is the load address used by Wondermedia version of U-BOOT

- Complete Eclipse project files:
download here: ARM9_WM8505_UART0.zip

* most of the hardware initializations (e.g. clock settings) are already done by the bootloader,
so we don't have to worry about them for now.

Next question is, "how to load and run the code?
I've tested two ways of how to transfer the generated image to the RAM:
First is through tftp transfer, second is SD card load during boot-up.
Both method uses the bootloader, which is already present in the board (in the SPI flash).
My board got v1.1.4 of U-BOOT.

1. TFTP transfer to RAM.
- get a copy of this freeTFTPD32 server application.
- using the LAN adapter, connect board to host PC Ethernet
enter u-boot console, and type these commands:

tftp {load address} {image file}
go {load address}

* RAM load address can use other than 0x0

2. SD card scriptcmd
-guide: How to edit "scriptcmd"
-during boot-up, the u-boot will read the "scriptcmd" script in the "script" folder of the SD card.

fatload mmc 0 {load address} {image file}
go {load address}

*these commands can also be typed in the uboot console. ("mmcinit" must be sent first)

references:
Wondermedia GPL sources
WM8505 datasheets
forum link:
Let's learn ARM using cheap 7" tablets

MARG sensors + Bluetooth

2011-02-03T10:52:00.002+08:00

MARG (Magnetic, Angular Rate, and Gravity) sensor array used for AHRS (Attitude and Heading Reference Systems).

Android OpenGL 3D display on Samsung Spica (i5700).

Sparkfun 9DOF sensor stick SEN-10389, later replaced by SEN-10321.

Using ATmega328P, operated at 3.3V supply and 8MHz crystal. At this speed, reading sensors' measurements and computing "AHRSupdate" take about 31ms to complete. Default compiler setting is used on WinAVR. With 25Hz sampling rate, this leaves mega328p extra 9ms to do other tasks. Bluetooth SPP (serial) communication is buffered and interrupt driven, so no processing time is wasted in reading and sending data to the android phone.

References:
(1) Sebastian Madgwick's Alternative AHRS (MARG) algorithm - Quaternion implementation of Mayhony's DCM filter incorporating magnetic distortion compensation.
(2) Fabio Varesano's FreeIMU. Also using Madgwick's implementation of the DCM filter on Arduino platform.
(3) Rotation convertions by Martin Baker. Very good discussion on quaternions and other 3D representation like Euler angles and transformation matrix.
(4) OpenGL Transformation Matrix by Song Ho Ahn
(5) Similar discusion on diydrones.com started by Harinath

Android project examples:
Android Bluetooth
Bluetooth Chat
Android OpenGL Projects
OpenGL ES tutorial
Android Bluetooth Oscilloscope

Special thanks to the generous guy who gave me these toys, Thank you very much!

Inertial Measurement Unit + Bluetooth

2011-01-19T21:36:00.002+08:00

Arduino plus Android

* pitch and roll only
* Arduino code by fabio (www.varesano.net)

IMU Digital 6-DOF (ITG3200/ADXL345)
Arduino FIO

N6610 LCD 3D Demo Part II

2010-12-14T22:54:00.002+08:00

Instead of drawing only the edges of a polyhedron, this time we draw the faces and 'fill' it with corresponding colors. This demo now uses a dsPIC (16-bit and 40MIPS core) for "faster" and "smoother" graphics in the N6610/N6100 LCD (w/ pcf8833 controller). See "lcd6610.h" for the used pinouts.

There are several ways of "hidden surface removal". The easiest way, and most appropriate for drawing convex polyhedron is the use of Backface culling. "Backface" will determine whether a surface (e.g. triangular face) is need to be drawn or not.
/-----------------------------------------------------------------------------------/
Draw3D routine:

/***** Draw 3D object with given vertices, triangular faces and angles of rotation******/
void draw_3D(Vertex * V, Triangle * T, nVertices, nTriangles, R)
{
    // sin and cos values
    sinX = sin_table( R.x ) / 255.0;
    sinY = sin_table( R.y ) / 255.0;
    sinZ = sin_table( R.z ) / 255.0;

    cosX = cos_table( R.x ) / 255.0;
    cosY = cos_table( R.y ) / 255.0;
    cosZ = cos_table( R.z ) / 255.0;

    // calculate the new coordinates of points
        for (i=0; i< nVertices; i++)
        {
            tempX = V[i].x;
            tempY = V[i].y;
            tempZ = V[i].z;

            // store previous coordinates
            old_points[i] = new_points[i];

            // rotation on X axis
            py = tempY * cosX - tempZ * sinX;
            pz = tempY * sinX + tempZ * cosX;
            tempY =py; tempZ = pz;

            // rotation on Z axis
            px = tempX * cosZ - tempY * sinZ;
            py = tempX * sinZ + tempY * cosZ;
            tempX = px; tempY = py;

            // rotation on Y axis
            px = tempX * cosY - tempZ * sinY;
            pz = tempX * sinY + tempZ * cosY;

            // save the screen coordinates
            new_points[i].x = px * SCALE_FACTOR + OFFSETX;
            new_points[i].y = py * SCALE_FACTOR + OFFSETY;
        }
        // erase previous triangles
        for (i=0; i< nTriangles; i++)
        {
            if( !Backface( old_points[T[i].A], old_points[T[i].B], old_points[T[i].C] ) )
                fill_triangle(old_points[T[i].A], old_points[T[i].B], old_points[T[i].C], BG_COLOR);
        }
        // lcd plot new triangles
        for (i=0; i< nTriangles; i++)
        {
            if( !Backface( new_points[T[i].A], new_points[T[i].B], new_points[T[i].C] ) )
                fill_triangle(new_points[T[i].A], new_points[T[i].B], new_points[T[i].C], T[i].color);
        }
}

triangle color-fill routine:

void fill_triangle(Point A, Point B, Point C, color)
{ 
    // bubble sort points
    if(B.y< A.y){ P=A; A=B; B=P; }
    if(C.y< B.y){ P=B; B=C; C=P; }
    if(C.y< A.y){ P=A; A=C; C=P; }
    if(B.y< A.y){ P=A; A=B; B=P; }

    // compute dx's
    dx1=0, dx2=0, dx3=0;
    if (B.y-A.y > 0) dx1 = (float)(B.x-A.x)/(B.y-A.y);
    if (C.y-B.y > 0) dx2 = (float)(C.x-B.x)/(C.y-B.y);
    if (C.y-A.y > 0) dx3 = (float)(C.x-A.x)/(C.y-A.y);

    for(h = (i16) A.y; h < B.y; h++) {
        sx = A.x + ((h - A.y) * dx3);
        ex = A.x + ((h - A.y) * dx1);
        draw_hline(sx,ex,h,color);
    }
    for(h = (i16) B.y; h < C.y; h++) {
        sx = A.x + ((h - A.y) * dx3);
        ex = B.x + ((h - B.y) * dx2);
        draw_hline(sx,ex,h,color);
    }
}

(*another version of using dsPIC hardware multiplier/divider is included in the download)

detect whether a triangle is facing backward.

/***** BACKFACE CULLING  ******/
BOOL Backface(Point A, Point B, Point C)
{
    Point L1, L2; // lines/edges

    L1.x = A.x - B.x;
    L1.y = A.y - B.y;
    L2.x = C.x - B.x;
    L2.y = C.y - B.y;

    if( ((L1.x * L2.y)  - (L1.y * L2.x)) < 0 )
        return TRUE;
    return FALSE;
}

Complete MPLAB+C30 project (dsPIC33FJ16GS504):
n6610lcd_3D_demo_part2.zip

N6610 LCD 3D Demo

2010-12-08T22:52:00.003+08:00

Nokia 6610/6100 LCD 3D projections demo using Microchip's PIC18F25J11. PIC18F25J11 is clocked at 12MHz external oscillator with 4xPLL enabled. It's operated at 3.3V supply, same with the LCD (and so, direct connections and higher spi clock rates are possible).

The demo is all about simple 3D projection - no rendering, no raycasting, etc., just the plotting of edges/lines. It displays common polyhedrons like tetrahedron, hexahedron(cube), octahedron, square pyramid, and triangular prism.

"3Ddemo.c"

/***** Draw 3D object with given vertices, edges and angles of rotation******/
void draw_3D(Vertex * V, Edge * E, nVertices, nEdges, xRot, yRot, zRot)
{
 u8 i;
 float tempX,tempY,tempZ;    // temporary coordinates
 float sinX,sinY,sinZ,cosX,cosY,cosZ; // precomputed sin and cos values
 float px,py,pz;       // projected

 // sin and cos values
 sinX = sin_table( xRot ) / 255.0;
 sinY = sin_table( yRot ) / 255.0;
 sinZ = sin_table( zRot ) / 255.0;

 cosX = cos_table( xRot ) / 255.0;
 cosY = cos_table( yRot ) / 255.0;
 cosZ = cos_table( zRot ) / 255.0;

 // calculate the new coordinates of points
    for (i=0; i< nVertices; i++)
 {
  tempX = V[i].x;
  tempY = V[i].y;
  tempZ = V[i].z;

  // store previous coordinates
  old_points[i] = new_points[i];

  // rotation on X axis
  py = tempY * cosX - tempZ * sinX;
  pz = tempY * sinX + tempZ * cosX;
  tempY =py; tempZ = pz;

  // rotation on Z axis
  px = tempX * cosZ - tempY * sinZ;
  py = tempX * sinZ + tempY * cosZ;
  tempX = px; tempY = py;

  // rotation on Y axis
  px = tempX * cosY - tempZ * sinY;
  pz = tempX * sinY + tempZ * cosY;

  // save the screen coordinates
  new_points[i].x = (u8)px * SCALE_FACTOR + OFFSETX;
  new_points[i].y = (u8)py * SCALE_FACTOR + OFFSETY;
 }

 // lcd plot
 for (i=0; i< nEdges; i++)
 {
  // erase old edges
  drawline(
   old_points[E[i].start].x, old_points[E[i].start].y,
   old_points[E[i].end].x, old_points[E[i].end].y,
   BG_COLOR);
  // draw new edges
  drawline(
   new_points[E[i].start].x, new_points[E[i].start].y,
   new_points[E[i].end].x, new_points[E[i].end].y,
   LINE_COLOR);

 }

*based on original sources:
Nokia 6100 LCD with CCS C
3D Vector objects in C using the PIC micro

Microchip C18 project: n6610lcd_3D_demo.zip

Nokia LCDs - Proteus VSM Models

2010-11-18T22:44:00.004+08:00

Proteus VSM models for some Nokia LCDs

LCD controllers used:
PCF8833 - Nokia 6100/6610/6610i
S1D15G14 - Nokia 3530/3510i/3595
PCF8814 - Nokia 1100

Download: Nokia LCDs - Proteus VSM Models.zip
(MODELS + LIBRARY + some demos)
* just copy the files to their corresponding folder

//------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------
UPDATES:
11-21-10
    - N6610LCD model (&symbol) was updated based on the datasheet of PCF8833 alone,
        but the result was different from expected. =(
        again, this model still have lots of problems!
    - found a bug on the N3530LCD model (PASET & CASET commands affected),
        corrected model will be uploaded soon.
    - I apologize for I cannot upload the source codes (msvc++ 2008) for these projects.
    ( Proteus ISIS itself is NOT free. VSM SDK, I assume, is also not open-source).
        ask for code snippets here: "Creating Proteus Models" ,instead.

PIC18F USB LC Meter

2010-10-14T21:34:00.005+08:00

Inductance and Capacitance Meter using Microchip's PIC18F2550 connected to USB using HID class (Plug-n-Play).

* f1, f2. and f3 are the frequencies defined by the equations stated on Digital LC Meter.

diagram using internal Analog Comparator and Timer Peripherals of PIC18:

schematic with actual values:

*simulation on Proteus 7 is NOT working (particularly the LC oscillator part and internal pull-up on RB0)

download link (HEX and PC app): PIC18F2550_USB-HID_LC-Meter.zip
elab.ph forum link: PIC18F2550 USB LC Meter

# edit (10-20-10)

added "Calibration option" ( same PIC18F firmware )

reference capacitance range is 1.0nF +/- 5%
Fosc (20MHz crystal with PLL) frequency range is 48MHz +/- 200ppm

# edit (08-14-11)
V1.2 -> updated host-side application,
-> should now work both on 32-bit OS and 64-bit OS hosts.

Android Bluetooth Oscilloscope

2010-09-23T21:17:00.008+08:00

*This application is tested only with Samsung Galaxy GT-i5700 Spica (rooted Android 2.1 OS, i570EXXJD1 Baseband version).
The transmitter circuit uses Microchip's dsPIC33FJ16GS504 for the analog-to-digital conversion of the input signals on two channels. The processed data on the dsPIC are then transmitted to the phone (for waveform display) via the LMX9838 bluetooth SPP module.

specs/ranges:

time per division: {5us, 10us, 20us, 50us, 100us, 200us, 500us, 1ms, 2ms, 5ms, 10ms, 20ms, 50ms }
volt per division: {10mV, 20mV, 50mV, 100mV, 200mV, 500mV, 1V, 2V, GND}
analog input (depends on external pre-amplifier configuration): {-8V to +8V }

The source codes for the bluetooth communication is based on Bluetooth Chat example from http://developer.android.com. That example contains three java source files. And, I've completely copied the "DeviceListActivity.java", which is used for searching remote bluetooth devices. Then I've modified the "BluetoothChatService.java" to use only the RFCOMM Client functions, and used the well-known UUID "00001101-0000-1000-8000-00805F9B34FB" for the Bluetooth RFCOMM/SPP.

For the plotting of waveforms, I'm using SurfaceView object to draw on its canvas. This tutorial found on www.helloandroid.com helps me a lot for this task: "How to use canvas in your android".

The rest of the job mainly involves porting of my previous Python S60 script to JAVA language. It was too painful on my side, because I had to convert a single script file to multiple java + xml source files! Nonetheless, it was a good experience for me on learning the Android SDK (JAVA programming).

Project source codes for Android and dsPIC (with APK and HEX) :
AndroidBluetoothOscilloscope.zip

Electronicslab.ph forum link : Android Bluetooth Oscilloscope

Here are some interesting projects that are also based on the Bluetooth Chat example:
Bluetooth Controlled Model Car
SPRIME

Special thanks to:
Samdroid Forum for the customized/rooted firmwares for our Spica.
Tipidcp Spica users for sharing their tips and experiences with this android phone.

----------------------------------------------------------------------
#edit (10-15-2010)
Here's now my circuit. Nothing special on it, all are based on existing circuits.

*The dsPIC I have used is most probably NOT the best choice for this project because of the many left unused peripherals (extra pins). But, this is the only part readily available in my bin and it has the fastest ADC (2 x 2MSps) among the chips I have.
*If you prefer to change the input range via the op-amp preamp, the computation is located on the "adc.xmcd" file.
*You can use other SPP bluetooth modules aside from LMX. (accdg to manufacturer, it's already obsolete)

----------------------------------------------------------------------
#edit (9-14-2011)

It's almost a year now, and yet some people are still interested in this project (considered to be obsolete). So I've decided to place the source repository also on Google Code site. You can either Browse or use git to have your own local copy:

git clone https://code.google.com/p/android-bluetooth-oscilloscope/

See also the Changes, if you want also to learn on how to modify the code. I've started the first 'commit' with a simple "hello world" from the SDK project template. And then changes were made until the desired final oscilloscope application is achieved.

ZiLOG Z8F64xx Timer Calculator

2010-07-07T20:07:00.010+08:00

Sample code generator for ZiLOG's Z8F64xx Z8 Encore family of 8-bit Flash MCU's. Tested only with ZDSII v4.11 (C compiler-v3.60) on Z8F6423 running at 20MHz crystal. It's expected to work also with other parts, like Z8F6421 of e-Gizmo's IRC Slimboard. It generates sample codes of "timer interrupt" and "pulse width modulation(pwm)" for TIMER0, TIMER1, TIMER2, and TIMER3 peripherals. Please refer to the datasheet("part selection guide" table) of this family to see what timer peripherals are available on a particular part.

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

note: I'm a newcomer to javascript. Please notify me of found "bugs" in these code makers.

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

Bluetooth Controlled Mobot

2010-06-27T10:19:00.000+08:00

Bluetooth Controlled Mobot using Z8F0823 and LMX9838.

It's supposed to be my entry for a friendly competitions of "sumobots". But, I wasn't able to make it "autonomous" on time for the event. It only have four sensors on each corner to detect "black" lines, but no sensor for detecting an opponent. And so that I can still test the hardware, I just made it manually controllable by using my phone's bluetooth. The bluetooth module is the same circuit I used in my BT minibot . I also used the same python S60 script for my N6120c (Symbian phone) controller.

forum link: Filipino Version of Robot Wars

Mini-STM32 WAVE Audio Player

2010-06-01T23:49:00.001+08:00

Mini-STM32 SD/MMC WAV (RIFF-WAVE-LPCM format) Audio Player with Spectrum Display

Simple SD Audio Player with an 8-pin IC by ChaN

DSP (FFT) libraries for Cortex M3 by Ivan Mellen

CooCox CoOS real-time multi-task OS

minimal hardware modification:

demo video:

Project files: Mini-STM32 WAVE Audio Player.rar

forum link: Mini-STM32 board

PIC18F SD WAV Audio Player

2010-05-22T08:52:00.008+08:00

As inspired by Simple SD Audio Player by ChaN, this project uses Microchip's PIC18F2550 to read RIFF WAVE files, and display some file information on the N6610 LCD; And then it will play the audio itself through PIC's PWM with a simple RC filter on the output pin. The hardware actually comes from my previous project, and I just attached a ready-made audio amp (w/ speaker) for the demo.
Schematic:
Due to PIC's peripheral limitations, I only set the PWM frequency to 187.5kHz and not the 250kHz carrier frequency originally used by ChaN, because it's the maximum PWM frequency than can still get an 8-bit resolution of the duty cycles (=48MHz/256). It is also possible to use R-2R ladder in stead of (low-pass) filtering the PWM output since there still enough unused digital output pins for this approach.
On the software part, I wasn't able to make a good data buffering as good as what ChaN did. It's noticeable with WAVE files with higher bit-rates (=SampleRate*NumChannels*BitsPerSample). Nevertheless, it can still support up to 48kHz sampling rate, but with only Mono channel and 8-bits/sample resolution.

demo video:

Source code(PICC-18) with and without LCD: PIC18 SD WAV Audio Player

My on-going project: currently porting the code to STM32F103RB for additional features.

Some useful software (shareware) tools:
TextAloud - Text to Speech software
Switch Sound File Converter-multi format audio file converters

System Clock Frequency:		Hz
Select Timer Peripheral:
Desired Interrupt Rate:		Hz

System Clock Frequency:		Hz
Select Timer Peripheral:
Desired PWM Frequency:		Hz
Initial PWM Duty Cycle:		%