xiaoma de blog

Tricks

admin — Sat, 18 Dec 2010 10:02:58 +0000

[Ubuntu]

ISSUE: Nvidia display driver problem on a two graphics card PC.

[EE] No devices detected. No screen found.

SOLUTION:

lspci -v

Get PCI bus number for graphics cards, 1:0:0 and 6:0:0 for instance.

sudo vi /etc/X11/xorg.conf

Under section “Device”, add

BusID “PCI:1:0:0″

Restart X and everything works like a charm.

http://wiki.linuxquestions.org/wiki/Using_multiple_monitors

[CUDA]

ISSUE: “error while loading shared libraries: libcudart.so.3: cannot open shared object file: No such file or directory”

SOLUTION:

sudo vim /etc/ld.so.conf

Add “/usr/local/cuda/lib”

Save and quit.

ld config -v | grep cuda

山寨的联通3G网卡，无型号，隆信通，在Ubuntu 11.10下使用：

lsusb信息如下：

Bus 003 Device 003: ID 05c6:6000 Qualcomm, Inc. Mass Storage Device.

使用如下命令切换到modem模式：

usb_modeswitch -v 05c6 -p 1000 -M 5553424312345678000000000000061b000000020000000000000000000000 -R 1
切换成功后可ls /dev/tty*看到ttyUSBx的设备。

打开网络配置用户名和密码都为any，pin码为1234，网络为3gnet，其余默认。

iPad RC Toy Tank

admin — Sun, 21 Nov 2010 07:50:39 +0000

The drawing explains pretty much everything.

Compile PTAM&PTAMM on Snow Leopard

admin — Thu, 23 Sep 2010 14:15:49 +0000

1. Compile PTAM

1). Install TooN lib.

Download Toon.

-> cvs -z3 -d:pserver:anoncvs@cvs.savannah.nongnu.org:/cvsroot/toon co TooN

Make and install.

-> ./configure

-> make

-> make install

2). Install libcvd(32bit).

a) Download libcvd.

-> cvs -z3 -d:pserver:anoncvs@cvs.savannah.nongnu.org:/cvsroot/libcvd co libcvd

b) Edit cvd/gl_helpers.h. Use OpenGL/gl.h and OpenGL/glu.h.

c) Edit progs/calibrate.cxx. Replace GL_TEXTURE_RECTANGLE_NV with GL_TEXTURE_RECTANGLE_ARB.

d) Edit cvd_src/OSX/qtbuffer.cpp. Add #include

e) Create a new configure script configure_mac.sh:

#!/bin/bash

SDK="-isysroot /Developer/SDKs/MacOSX10.5.sdk"
SDKLIB="-Wl,-syslibroot,/Developer/SDKs/MacOSX10.5.sdk"
export MACOSX_DEPLOYMENT_TARGET="10.5"

ARCH="-arch i386"

export CFLAGS="$ARCH $SDK -mmacosx-version-min=10.5 -I /usr/local/include"
export CXXFLAGS="$ARCH $SDK -mmacosx-version-min=10.5 -I /usr/local/include"
export CPPFLAGS="$ARCH $SDK -mmacosx-version-min=10.5 -I /usr/local/include"
export LDFLAGS="$ARCH $SDKLIB -mmacosx-version-min=10.5 -I /usr/local/include"

CC="/usr/bin/gcc-4.2"
CXX="/usr/bin/g++-4.2"
OBJC="/usr/bin/gcc-4.2"

./configure $1 $2 $3 $4 $5 $6 $7 $8 $9

f) Configure.

-> ./configure_mac.sh --without-ffmpeg --x-libraries=/Developer/SDKs/MacOSX10.5.sdk/usr/X11/lib/ --x-includes=/Developer/SDKs/MacOSX10.5.sdk/usr/X11/include

g) Edit makefile.

Move all -L/opt/local/lib to the end of the argument list, giving priority to OSX10.5.sdk version of X11

h) Make and Install

-> make

-> install

3). Install gvars3

a) Download gvars3

-> cvs -z3 -d:pserver:anoncvs@cvs.savannah.nongnu.org:/cvsroot/libcvd co gvars3

b) Copy the previous configure_mac.sh.

-> sh configure_mac.sh --disable-widgets

-> make

-> make install

4). Compile PTAM

a) Copy /Build/OSX/Makefile and VideoSource_OSX.cc to source root directory.

b) Edit makefile. Compile 32bit.

-> CC = g++ -g -O3 -arch i386

-> make

-> make install

2. Compile PTAMM

a. Install lib3ds. Download the source. Copy configure_mac.sh. Do the same as above.

b. Copy PTAM/VideoSource_OSX.cc to PTAMM.

c. Copy PTAMM/Build/Linux/Makefile to PTAMM.

d. Edit VideoSource_OSX.cc. Add “namespace PTAMM{” after the includes and “}” at the end.

e. Edit makefile.

Change “LINKFLAGS = -L MY_CUSTOM_LINK_PATH -lGVars3 -lcvd $(3DSLIB)” => “LINKFLAGS = -framework OpenGL -framework VecLib -lGVars3 -lcvd $(3DSLIB)”.

Change “VIDEOSOURCE = VideoSource_Linux_DV.o” => “VIDEOSOURCE = VideoSource_OSX.o”

f. make and install.

Have fun:)

WPF path animation as opacity mask

admin — Thu, 03 Jun 2010 15:45:14 +0000

CODE

       xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation”
       xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”
       x:Name=”Window”
       Title=”Path Opacity Mask Animation Demo”
       Width=”640″ Height=”480″ xmlns:System=”clr-namespace:System;assembly=mscorlib”>

Heatsink Calculation

admin — Sun, 14 Mar 2010 11:15:38 +0000

When design power electronics, to prevent devices from overheating and damage, heatsinks are commonly used. How to calculate heatsinks is thus an issue.

The basic theory is a thermal equivalent of Ohm’s Law. For a power transistor:

T(j-a) = Pd x Rth(j-a)

T(j-a) (in degrees Celsius) is the temperature rise of the transistor above ‘ambient ’ temperature.

Pd (in watts)is the power disspipated.

Rth(j-a) (in degress Celsius per watt)is the total thermal resistance between the junction and the ambient.

A design example:

Unity3D with Windows 7 Multitouch

admin — Fri, 12 Feb 2010 07:08:41 +0000

[There is a video that cannot be displayed in this feed. Visit the blog entry to see the video.]

Here it goes. Build Unity 3D multitouch application on Windows 7 machines.

This video demonstrates an application built with Unity 3D with Windowns 7 multitouch input.

Thanks to Unity explosion framework Detonator. Nice work!

Unity 3D First Try

admin — Wed, 10 Feb 2010 02:51:38 +0000

Please view the full post to see the Unity content.

This is part of a tutorial in the book “Unity Game Development Essentials”

Use mouse and keyboard to control walk through.

Up/W: Forward

Down/S: Backward

Left/A: Left

Right/D: Right

Mouse: Look around and turn the player

Motor Control Tutorial(Part I)

admin — Sun, 31 Jan 2010 12:40:30 +0000

Motor Control Tutorial (Part I)

After working on several motor control projects, I decided to write this article about PID controller. This article will tell how to implement control loops (PID loops) in software. The hardware part will come soon.

PID Controller

A PID (proportional-integral-derivative) controller is a generic controller widely used in control systems. It calculates the difference value between a given set-point and measured value and attempts to minimize the difference.

The terminology “PID” tells that it includes three terms. Each term has a different effect on the controlled system. Figure 1 shows a block diagram of a basic PID controller.

Figure 1 Basic PID Controller

The standard mathematic form is

The three terms are

Implementation of a PID controller in a MCU chip requires a discrete form however.

Where

T is the sample period (sec).

Ti is the integral period (sec).

Td is the derivative period (sec).

Then the three terms finally become

Integrator Anti-windup

There are limitations in actuators. For a system that operates over a wide range of conditions, it may happen that the control variable reaches the actuator limits. When this happens, the feedback loop is broken. The integral term will build up since the error is nonzero. The controller output will become very large. When the control input changes, it may take a long time before the integrator and the controller output come back inside the saturation range. To avoid this situation, some anti-windup correction is need.

Below is one way to implement anti-windup in a conventional PID controller.

If the actuator is saturated, the error will decrease integrator and thus prevent windup.

C# Passing Parameters

admin — Sun, 31 Jan 2010 12:01:42 +0000

C# Passing Parameters

Passing Value-Type Parameters

A value-type variable contains its data directly as opposed to a reference-type variable, which contains a reference to its data. Therefore, passing a value-type variable to a method means passing a copy of the variable to the method. Any changes to the parameter that take place inside the method have no affect on the original data stored in the variable. If you want the called method to change the value of the parameter, you have to pass it by reference, using the ref or out keyword.

The following example demonstrates passing value-type parameters by value. The variable n is passed by value to the method SquareIt. Any changes that take place inside the method have no affect on the original value of the variable.


class PassingValByVal
{
    static void SquareIt(int x)
    // The parameter x is passed by value.
    // Changes to x will not affect the original value of x.
    {
        x *= x;
        System.Console.WriteLine("The value inside the method: {0}", x);
    }
    static void Main()
    {
        int n = 5;
        System.Console.WriteLine("The value before calling the method: {0}", n);

        SquareIt(n);  // Passing the variable by value.
        System.Console.WriteLine("The value after calling the method: {0}", n);

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }
}
/* Output:
    The value before calling the method: 5
    The value inside the method: 25
    The value after calling the method: 5
*/

The variable n, being a value type, contains its data, the value 5. When SquareIt is invoked, the contents of n are copied into the parameter x, which is squared inside the method. In Main, however, the value of n is the same, before and after calling the SquareIt method. In fact, the change that takes place inside the method only affects the local variable x.

The following example is the same as the previous example, except for passing the parameter using the ref keyword. The value of the parameter is changed after calling the method.


class PassingValByRef
{
    static void SquareIt(ref int x)
    // The parameter x is passed by reference.
    // Changes to x will affect the original value of x.
    {
        x *= x;
        System.Console.WriteLine("The value inside the method: {0}", x);
    }
    static void Main()
    {
        int n = 5;
        System.Console.WriteLine("The value before calling the method: {0}", n);

        SquareIt(ref n);  // Passing the variable by reference.
        System.Console.WriteLine("The value after calling the method: {0}", n);

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }
}
/* Output:
    The value before calling the method: 5
    The value inside the method: 25
    The value after calling the method: 25
*/

Passing Reference-Type Parameters

A variable of a reference type does not contain its data directly; it contains a reference to its data. When you pass a reference-type parameter by value, it is possible to change the data pointed to by the reference, such as the value of a class member. However, you cannot change the value of the reference itself; that is, you cannot use the same reference to allocate memory for a new class and have it persist outside the block. To do that, pass the parameter using the ref or out keyword.

The following example demonstrates passing a reference-type parameter, arr, by value, to a method, Change. Because the parameter is a reference to arr, it is possible to change the values of the array elements. However, the attempt to reassign the parameter to a different memory location only works inside the method and does not affect the original variable, arr.


class PassingRefByVal
{
    static void Change(int[] pArray)
    {
        pArray[0] = 888;  // This change affects the original element.
        pArray = new int[5] {-3, -1, -2, -3, -4};   // This change is local.
        System.Console.WriteLine("Inside the method, the first element is: {0}", pArray[0]);
    }

    static void Main()
    {
        int[] arr = {1, 4, 5};
        System.Console.WriteLine("Inside Main, before calling the method, the first element is: {0}", arr [0]);

        Change(arr);
        System.Console.WriteLine("Inside Main, after calling the method, the first element is: {0}", arr [0]);
    }
}
/* Output:
    Inside Main, before calling the method, the first element is: 1
    Inside the method, the first element is: -3
    Inside Main, after calling the method, the first element is: 888
*/

In the preceding example, the array, arr, which is a reference type, is passed to the method without the ref parameter. In such a case, a copy of the reference, which points to arr, is passed to the method. The output shows that it is possible for the method to change the contents of an array element, in this case from 1 to 888. However, allocating a new portion of memory by using the new operator inside the Change method makes the variable pArray reference a new array. Thus, any changes after that will not affect the original array, arr, which is created inside Main. In fact, two arrays are created in this example, one inside Main and one inside the Change method.

This example is the same as the previous example, except for using the ref keyword in the method header and call. Any changes that take place in the method will affect the original variables in the calling program.


class PassingRefByRef
{
    static void Change(ref int[] pArray)
    {
        // Both of the following changes will affect the original variables:
        pArray[0] = 888;
        pArray = new int[5] {-3, -1, -2, -3, -4};
        System.Console.WriteLine("Inside the method, the first element is: {0}", pArray[0]);
    }

    static void Main()
    {
        int[] arr = {1, 4, 5};
        System.Console.WriteLine("Inside Main, before calling the method, the first element is: {0}", arr[0]);

        Change(ref arr);
        System.Console.WriteLine("Inside Main, after calling the method, the first element is: {0}", arr[0]);
    }
}
/* Output:
    Inside Main, before calling the method, the first element is: 1
    Inside the method, the first element is: -3
    Inside Main, after calling the method, the first element is: -3
*/

All of the changes that take place inside the method affect the original array in Main. In fact, the original array is reallocated using the new operator. Thus, after calling the Change method, any reference to arr points to the five-element array, which is created in the Change method.

Swapping strings is a good example of passing reference-type parameters by reference. In the example, two strings, str1 and str2, are initialized in Main and passed to the SwapStrings method as parameters modified by the ref keyword. The two strings are swapped inside the method and inside Main as well.


class SwappingStrings
 {
     static void SwapStrings(ref string s1, ref string s2)
     // The string parameter is passed by reference.
     // Any changes on parameters will affect the original variables.
     {
         string temp = s1;
         s1 = s2;
         s2 = temp;
         System.Console.WriteLine("Inside the method: {0} {1}", s1, s2);
     }

     static void Main()
     {
         string str1 = "John";
         string str2 = "Smith";
         System.Console.WriteLine("Inside Main, before swapping: {0} {1}", str1, str2);

         SwapStrings(ref str1, ref str2);   // Passing strings by reference
         System.Console.WriteLine("Inside Main, after swapping: {0} {1}", str1, str2);
     }
 }
 /* Output:
     Inside Main, before swapping: John Smith
     Inside the method: Smith John
     Inside Main, after swapping: Smith John
*/

C# Boxing and Unboxing

admin — Sun, 31 Jan 2010 10:33:26 +0000

C# Boxing and Unboxing

Boxing is the process of converting a value type to the type object or to any interface type implemented by this value type. When the CLR boxes a value type, it wraps the value inside a System.Object and stores it on the managed heap. Unboxing extracts the value type from the object.

In relation to simple assignments, boxing and unboxing are computationally expensive processes. When a value type is boxed, a new object must be allocated and constructed. To a lesser degree, the cast required for unboxing is also expensive computationally.

Boxing

Boxing is used to store value types in the garbage-collected heap. Boxing is an implicit conversion of a value type to the type object or to any interface type implemented by this value type. Boxing a value type allocates an object instance on the heap and copies the value into the new object.

Consider the following declaration of a value-type variable:


int i=123;

The following statement implicitly applies the boxing operation on the variable i:


object o=i;      //Implicit boxing

The result of this statement is creating an object reference o, on the stack, that references a value of the type int, on the heap. This value is a copy of the value-type value assigned to the variable i. The difference between the two variables, i and o, is illustrated in the following figure.

Unboxing

Unboxing is an explicit conversion from the type object to a value type or from an interface type to a value type that implements the interface. An unboxing operation consists of:

Checking the object instance to make sure that it is a boxed value of the given value type.

Copying the value from the instance into the value-type variable.

The following statements demonstrate both boxing and unboxing operations:


int  i = 123;

object o = i;  //boxing

int j = (int) o;   //unboxing

The following figure demonstrates the result of the previous statements.