I was looking for a way to make the adjustment for my power supply more precise and easier to dial let’s say to a voltage like 3.3 , but without a built-in fine tune potentiometer this was difficult so I found one of those foam rings that are always on top of a CD box, and it fit perfectly over the dial making it bigger and now easier to dial any voltage. This works based on the “gears” principle  – with the larger “gear” attached , finger has to travel a longer distance to make same change, thus easier to dial anything in between that was before harder.

Plain and simple, but just thought to share the non-warranty voiding trick – acceptable choice if you can’t really open up the power supply and add a new potentiometer in series with the main one.  I am also glad I finally found a use for those CD foam rings If you’re curious what power supply it is on the picture, it is a Tenma budget 10A linear power supply works well except the above mentioned lack of fine-tune dial.

I finally got a minute to play with the MSP430 LaunchPad Kit I received, well almost for free from TI and immediately got some feedback to share with the development and marketing team.

First overall I think Launchpad is a great product and I am looking forward to seeing it improve, secondly my understanding is that its targeted market is starting engineers , hobbyist and alike … and I am speaking from that perspective.

I know you might hate me for this and maybe this is a banned word in your company but you should really look at Arduino and try to understand why it became so popular, in a nutshell let me break it down:

- the secret is in details, you might have a better product at a better price but if you can’t present it correctly it will not catch up with developers
- simplicity , simplicity , simplicity, too much information is as bad as no information, getting started manual DOES NOT have to be 182 pages long, half of which are telling about the entire TI lineup and various clock setup , get straight to the point show us the fun part !
- people don’t want so many options, so you must make choices for them , for example – choose a fixed clock mode (crystal or internal clock) and make it standard, let advanced users hack it if necessary, this will also make Launchpad programs more portable if you choose and “official” operating clock speed.
- make a free compiler and IDE : it makes no sense to have a paid compiler and charge a developer “pennies” compared to what that developer can bring you in hardware sales if he uses your chips , instead of spending money on giveaways and free lunches at trade shows , etc, just give the developers a free unlimited IDE and compiler, best promotion you can make and best boost in hardware sales for the future ! It is no coincidence Arduino was based on AVR the only major MCU manufacture to have multi-platform free compilers and IDE (both Microchips and TI’s free editions are limited and crippled).
- give free and no “string attached” MCU samples as Microchip has, same reason as above , you can’t cook dinner with MCUs if someone is ordering them they are an engineer and they might make a product that will use millions of your chips in the future, if you don’t make samples easy and fast , he might choose Microchip because today he is a student and he is broke, call it fate or whatever – unfair but fair ..
- in coding hide all the ugly details like the clock setup , in worst case scenario make a “launchpad” header file to contain all the technical stuff, if you make the “blinking led” program a one or two line program than you know you’re on the right way !
- make changing pin direction (output / input) prettier and more straightforward and avoid the | (OR) bit assignments, in worst case you can use some macros (as I explain here http://www.starlino.com/port_macro.html) , this style of assignments is confusing for beginners

Well that’s it for now, i might add more ideas … so check back or contact me directly if you’d like more feedback.

Microchip started marketing an Arduino clone called chipKit. Is this a correct decision to clone an open source platform as opposed to Texas Instrument's decision to create it's own platform LaunchPad ?

By the way the TI's platform is really cheap, I would say cheaper than components and PCB + shipping. Obviously TI wants more people to use it, however what it is lacking is the relaxed open-source crowd around it.

Is Arduino really something to follow ? What do you think ?

This article is a continuation of my IMU Guide, covering additional orientation kinematics topics. I will go through some theory first and then I will present a practical example with code build around an Arduino and a 6DOF IMU sensor (acc_gyro_6dof). The scope of this experiment is to create an algorithm for fusing gyroscope and accelerometer data in order to create an estimation of the device orientation in space. Such an algorithm was already presented in part 3 of my “IMU Guide” and a practical Arduino experiment with code was presented in the “Using a 5DOF IMU” article and was nicknamed “Simplified Kalman Filter”, providing a simple alternative to the well known Kalman Filter algorithm. In this article we’ll use another approach utilizing the DCM (Direction Cosine Matrix). For the reader that is unfamiliar with MEMS sensors it is recommended to read Part 1 and 2 of the IMU Guide article. Also for following the experiments presented in this text it is recommended to acquire an Arduino board and an acc_gyro_6dof sensor.

Prerequisites

No really advanced math is necessary. Find a good book on matrix operations, that’s all you might need above school math course. If you would like to refresh your knowledge below are some quick articles:
Cartesian Coordinate System – http://en.wikipedia.org/wiki/Cartesian_coordinate_system
Rotation – http://en.wikipedia.org/wiki/Rotation_%28mathematics%29
Vector scalar product – http://en.wikipedia.org/wiki/Dot_product
Vector cross product – http://en.wikipedia.org/wiki/Cross_product
Matrix Multiplication – http://en.wikipedia.org/wiki/Matrix_multiplication
Block Matrix – http://en.wikipedia.org/wiki/Block_matrix
Transpose Matrix – http://en.wikipedia.org/wiki/Transpose
Triple Product – http://en.wikipedia.org/wiki/Triple_product

Notations

Vectors are marked in bold text - so for example “v” is a vector and “v” is a scalar (if you can’t distinguish the two there’s problem with the text formatting wherever you’re reading this).

Part 1. The DCM Matrix

Generally speaking orientation kinematics deals with calculating the relative orientation of a body relative to a global coordinate system. It is useful to attach a coordinate system to our body frame and call it Oxyz, and another one to our global frame and call it OXYZ. Both the global and the body frames have the same fixed origin O (see Fig. 1). Let’s also define i, j, k to be unity vectors co-directional with the body frame’s x, y, and z axes – in other words they are versors of Oxyz and let I, J, K be the versors of global frame OXYZ.

Figure 1

Thus, by definition, expressed in terms of global coordinates vectors I, J, K can be written as:

I^G = {1,0,0} ^T, J^G={0,1,0} ^T , K^G = {0,0,1} ^T

Note: we use {…} ^T notation to denote a column vector, in other words a column vector is a translated row vector. The orientation of vectors (row/column) will become relevant once we start multiplying them by a matrix later on in this text.

And similarly, in terms of body coordinates vectors i, j, k can be written as:

i^B = {1,0,0} ^T, j^B={0,1,0} ^T , k^B = {0,0,1} ^T

Now let’s see if we can write vectors i, j, k in terms of global coordinates. Let’s take vector i as an example and write its global coordinates:

i^G = {i_x^G , i_y^G , i_z^G} ^T

Again, by example let’s analyze the X coordinate i_x^G, it’s calculated as the length of projection of the i vector onto the global X axis.

i_x^G = |i| cos(X,i) = cos(I,i)

Where |i| is the norm (length) of the i unity vector and cos(I,i) is the cosine of the angle formed by the vectors I and i. Using the fact that |I| = 1 and |i| = 1 (they are unit vectors by definition). We can write:

i_x^G = cos(I,i) = |I||i| cos(I,i) = I.i

Where I.i. is the scalar (dot) product of vectors I and i. For the purpose of calculating scalar product I.i it doesn’t matter in which coordinate system these vectors are measured as long as they are both expressed in the same system, since a rotation does not modify the angle between vectors so: I.i = I^B.i^B = I^G.i^G = cos(I^B.i^B) = cos(I^G.i^G) , so for simplicity we’ll skip the superscript in scalar products I.i , J.j , K.k and in cosines cos(I,i), cos(J,j), cos(K,k).

Similarly we can show that:

i_y^G = J.i , i_z^G=K.i , so now we can write vector i in terms of global coordinate system as:

i^G= { I.i, J.i, K.i}^T

Furthermore, similarly it can be shown that j^G= { I.j, J.j, K.j} ^T , k^G= { I.k, J.k, K.k} ^T.

We now have a complete set of global coordinates for our body’s versors i, j, k and we can organize these values in a convenient matrix form:

(Eq. 1.1)

This matrix is called Direction Cosine Matrix for now obvious reasons – it consists of cosines of angles of all possible combinations of body and global versors.

The task of expressing the global frame versors I^G, J^G, K^G in body frame coordinates is symmetrical in nature and can be achieved by simply swapping the notations I, J, K with i, j, k, the results being:

I^B= { I.i, I.j, I.k}^T , J^B= { J.i, J.j, J.k}^T , K^B= { K.i, K.j, K.k}^T

and organized in a matrix form:

(Eq. 1.2)

It is now easy to notice that DCM^B = (DCM^G)^T or DCM^G = (DCM^B)^T , in other words the two matrices are translates of each other, we’ll use this important property later on.

Also notice that DCM^B. DCM^G = (DCM^G)^T .DCM^G = DCM^B. (DCM^B)^T = I₃ , where I₃ is the 3×3 identity matrix. In other words the DCM matrices are orthogonal.

This can be proven by simply expanding the matrix multiplication in block matrix form:

(Eq. 1.3)

To prove this we use such properties as for example: i^GT. i^G = | i^G|| i^G|cos(0) = 1 and i^GT. j^G = 0 because (i and j are orthogonal) and so forth.

The DCM matrix (also often called the rotation matrix) has a great importance in orientation kinematics since it defines the rotation of one frame relative to another. It can also be used to determine the global coordinates of an arbitrary vector if we know its coordinates in the body frame (and vice versa).

Let’s consider such a vector with body coordinates:

r^B= { r_x^B, r_y^B, r_z^B} ^T and let’s try to determine its coordinates in the global frame, by using a known rotation matrix DCM^G.

We start by doing following notation:

r^G = { r_x^G , r_y^G , r_z^G } ^T.

Now let’s tackle the first coordinate r_x^G:

r_x^G = | r^G| cos(I^G,r^G) , because r_x^G is the projection of r^G onto X axis that is co-directional with I^G.

Next let’s note that by definition a rotation is such a transformation that does not change the scale of a vector and does not change the angle between two vectors that are subject to the same rotation, so if we express some vectors in a different rotated coordinate system the norm and angle between vectors will not change:

| r^G| = | r^B| , | I^G| = | I^B| = 1 and cos(I^G,r^G) = cos(I^B,r^B), so we can use this property to write

r_x^G = | r^G| cos(I^G,r^G) = | I^B || r^B| cos(I^B,r^B) = I^B. r^B = I^B. { r_x^B, r_y^B, r_z^B} ^T , by using one the two definition of the scalar product.

Now recall that I^B= { I.i, I.j, I.k}^T and by using the other definition of scalar product:

r_x^G = I^B. r^B = { I.i, I.j, I.k}^T . { r_x^B, r_y^B, r_z^B} ^T = r_x^B I.i + r_y^B I.j + r_z^B I.k

In same fashion it can be shown that:

r_y^G = r_x^B J.i + r_y^B J.j + r_z^B J.k
r_z^G = r_x^B K.i + r_y^B K.j + r_z^B K.k

Finally let’s write this in a more compact matrix form:

(Eq. 1.4)

Thus the DCM matrix can be used to covert an arbitrary vector r^B expressed in one coordinate system B, to a rotated coordinate system G.

We can use similar logic to prove the reverse process:

(Eq. 1.5)

Or we can arrive at the same conclusion by multiplying both parts in (Eq. 1.4) by DCM^B which equals to DCM^GT, and using the property that DCM^GT.DCM^G = I₃ , see (Eq. 1.3):

DCM^B r^G = DCM^B DCM^G r^B = DCM^GT DCM^G r^B = I₃ r^B = r^B

Part 2. Angular Velocity

So far we have a way to characterize the orientation of one frame relative to another rotated frame, it is the DCM matrix and it allows us to easily convert the global and body coordinates back and forth using (Eq. 1.4) and (Eq. 1.5). In this section we’ll analyze the rotation as a function of time that will help us establish the rules of updating the DCM matrix based on a characteristic called angular velocity. Let’s consider an arbitrary rotating vector r and define it’s coordinates at time t to be r(t). Now let’s consider a small time interval dt and make the following notations: r = r (t) , r’= r (t+dt) and dr = r’ – r:

Figure 2

Let’s say that during a very small time interval dt → 0 the vector r has rotated about an axis co-directional with a unity vector u by an angle dθ and ended up in the position r’. Since u is our axis of rotation it is perpendicular to the plane in which the rotation took place (the plane formed by r and r’) so u is orthogonal to both r and r’. There are two unity vectors that are orthogonal to the plane formed by r and r’, they are shown on the picture as u and u’ since we’re still defining things we’ll choose the one that is co-directional with the cross product r x r’, following the rule of right-handed coordinate system. Thus because u is a unity vector |u| = 1 and is co-directional with r x r’ we can deduct it as follows:

u = (r x r’) / |r x r’| = (r x r’) / (|r|| r’|sin(dθ)) = (r x r’) / (|r|² sin(dθ)) (Eq. 2.1)

Since a rotation does not alter the length of a vector we used the property that| r’| = |r|.

The linear velocity of the vector r can be defined as the vector:

v = dr / dt = ( r’ – r) / dt (Eq. 2.2)

Please note that since our dt approaches 0 so does dθ → 0, hence the angle between vectors r and dr (let’s call it α) can be found from the isosceles triangle contoured by r , r’ and dr:

α = (π – dθ) / 2 and because dθ → 0 , then α → π/2

What this tells us is that r is perpendicular to dr when dt → 0 and hence r is perpendicular to v since v and dr are co-directional from (Eq. 2.2):

v ⊥ r (Eq. 2.21)

We are now ready to define the angular velocity vector. Ideally such a vector should define the rate of change of the angle θ and the axis of the rotation, so we define it as follows:

w = (dθ/dt ) u (Eq. 2.3)

Indeed the norm of the w is |w| = dθ/dt and the direction of w coincides with the axis of rotation u. Let’s expand (Eq. 2.3) and try to establish a relationship with the linear velocity v:

Using (Eq. 2.3) and (Eq. 2.1):

w = (dθ/dt ) u = (dθ/dt ) (r x r’) / (|r|² sin(dθ))

Now note that when dt → 0, so does dθ → 0 and hence for small dθ, sin(dθ) ≈ dθ , we end up with:

w = (r x r’) / (|r|² dt) (Eq. 2.4)

Now because r’ = r + dr , dr/dt = v , r x r = 0 and using the distributive property of cross product over addition:

w = (r x (r + dr)) / (|r|² dt) = (r x r + r x dr)) / (|r|² dt) = r x (dr/dt) / |r|²

And finally:

w = r x v / |r|²­ (Eq. 2.5)

This equation establishes a way to calculate angular velocity from a known linear velocity v.

We can easily prove the reverse equation that lets us deduct linear velocity from angular velocity:

v = w x r ­ (Eq. 2.6)

This can be proven simply by expanding w from (Eq. 2.5) and using vector triple product rule (a x b) x c = (a.c)b – (b.c)a. Also we’ll use the fact that v and r are perpendicular (Eq. 2.21) and thus v.r = 0

w x r = (r x v / |r|²­) x r = (r x v) x r / |r|²­ = ((r.r) v + (v.r)r) / |r|²­ = ( |r|²­ v + 0) |r|² = v

So we just proved that (Eq. 2.6) is true. Just to check (Eq. 2.6) intuitively – from Figure 2 indeed v has the direction of w x r using the right hand rule and indeed v ⊥ r and v ⊥ w because it is in the same plane with r and r’.

Part 3. Gyroscopes and angular velocity vector

A 3-axis MEMS gyroscope is a device that senses rotation about 3 axes attached to the device itself (body frame). If we adopt the device’s coordinate system (body’s frame), and analyze some vectors attached to the earth (global frame), for example vector K pointing to the zenith or vector I pointing North – then it would appear to an observer inside the device that these vector rotate about the device center. Let w_x , w_y , w_z be the outputs of a gyroscope expressed in rad/s – the measured rotation about axes x, y , z respectively. Converting from the raw output of the gyroscope to physical values is discussed for example here: http://www.starlino.com/imu_guide.html . If we query the gyroscope at regular, small time intervals dt, then what gyroscope output tells us is that during this time interval the earth rotated about gyroscope’s x axis by an angle of dθ_x = w_xdt, about y axis by an angle of dθ_y = w_ydt and about z axis by an angle of dθ_z = w_zdt. These rotations can be characterized by the angular velocity vectors: w_x = w_x i = {w_x , 0 , 0 }^T , w_y = w_y j = { 0 , w_y , 0 }^T , w_z = w_z k = { 0 , 0, w_z }^T , where i,j,k are versors of the local coordinate frame (they are co-directional with body’s axes x,y,z respectively). Each of these three rotations will cause a linear displacement which can be expressed by using (Eq. 2.6):

dr₁ = dt v₁ = dt (w_x x r) ; dr₂ = dt v₂ = dt (w_y x r) ; dr₃ = dt v₃ = dt (w_z x r) .

The combined effect of these three displacements will be:

dr = dr₁ + dr₂ + dr₃ = dt (w_x x r + w_y x r + w_z x r) = dt (w_x + w_y + w_z) x r (cross product is distributive over addition)

Thus the equivalent linear velocity resulting from these 3 transformations can be expressed as:

v = dr/dt = (w_x + w_y + w_z) x r = w x r , where we introduce w = w_x + w_y + w_z = {w_x , w_y , w_z }

Which looks exactly like (Eq. 2.6) and suggests that the combination of three small rotations about axes x,y,z characterized by angular rotation vectors w_x , w_y , w_z is equivalent to one small rotation characterized by angular rotation vector w = w_x + w_y + w_z = {w_x , w_y , w_z }. Please note that we’re stressing out that these are small rotations, since in general when you combine large rotations the order in which rotations are performed become important and you cannot simply sum them up. Our main assumption that let us go from a linear displacement to a rotation by using (Eq. 2.6) was that dt is really small, and thus the rotations dθ and linear displacement dr are small as well. In practice this means that the larger the dt interval between gyro queries the larger will be our accumulated error, we’ll deal with this error later on. Now, since w_x , w_y , w_z are the output of the gyroscope, then we arrive at the conclusion that in fact a 3 axis gyroscope measures the instantaneous angular velocity of the world rotating about the device’s center.

Part 4. DCM complimentary filter algorithm using 6DOF or 9DOF IMU sensors

In the context of this text a 6DOF device is an IMU device consisting of a 3 axis gyroscope and a 3 axis accelerometer. A 9DOF device is an IMU device of a 3 axis gyroscope, a 3 axis accelerometer and a 3 axis magnetometer. Let’s attach a global right-handed coordinate system to the Earth’s frame such that the I versor points North, K versor points to the Zenith and thus, with these two versors fixed, the J versor will be constrained to point West.

Figure 3

Also let’s consider the body coordinate system to be attached to our IMU device (acc_gyro used as an example),

Figure 4

We already established the fact that gyroscopes can measure the angular velocity vector. Let’s see how accelerometer and magnetometer measurements will fall into our model.

Accelerometers are devices that can sense gravitation. Gravitation vector is pointing towards the center of the earth and is opposite to the vector pointing to Zenith K^B. If the 3 axis accelerometer output is A = {A_x , Ay , A_z } and we assume that there are no external accelerations or we have corrected them then we can estimate that K^B = -A. (See this IMU Guide for more clarifications http://www.starlino.com/imu_guide.html).

Magnetometers are devices that are really similar to accelerometers, except that instead of gravitation they can sense the Earth’s magnetic North. Just like accelerometers they are not perfect and often need corrections and initial calibration. If the corrected 3-axis magnetometer output is M = {M_x , My , M_z }, then according to our model I^B is pointing North , thus I^B = M.

Knowing I^B and K^B allows us calculate J^B = K^B x I^B.

Thus an accelerometer and a magnetometer alone can give us the DCM matrix , expressed either as DCM^B or DCM^G

DCM^G = DCM^BT = [I^B, J^B, K^B]^T

The DCM matrix can be used to convert any vector from body’s(devices) coordinate system to the global coordinate system. Thus for example if we know that the nose of the plane has some fixed coordinates expressed in body’s coordinate system as r^B = {1,0,0}, the we can find where the device is heading in other words the coordinates of the nose in global coordinate systems using (Eq. 1.4):

r^G = DCM^G r^B

So far you’re asking yourself if an accelerometer and a magnetometer gives us the DCM matrix at any point in time, why do we need the gyroscope ? The gyroscope is actually a more precise device than the accelerometer and magnetomer are , it is used to “fine-tune” the DCM matrix returned by the accelerometer and magnetometer.

Gyroscopes have no sense of absolute orientation of the device , i.e. they don’t know where north is and where zenith is (things that we can find out using the accelerometer and magnetometer), instead if we know the orientation of the device at time t, expressed as a DCM matrix DCM(t) , we can find a more precise orientation DCM(t+dt) using the gyroscope , then the one estimated directly from the accelerometer and magnetometer direct readings which are subject to a lot of noise in form of external (non-gravitational) inertial forces (i.e. acceleration) or magnetically forces that are not caused by the earth’s magnetic field.

These facts call for an algorithm that would combine the readings from all three devices (accelerometer, magnetometer and gyroscope) in order to create our best guess or estimate regarding the device orientation in space (or space’s orientation in device’s coordinate systems), the two orientations are related since they are simply expressed using two DCM matrices that are transpose of one another (DCM^G = DCM^BT ).

We’ll now go ahead and introduce such an algorithm.

We’ll work with the DCM matrix that consists of the versors of the global (earth’s) coordinate system aligned on each row:

If we read the rows of DCM^G we get the vectors I^B, J^B, K^B. We’ll work mostly with vectors K^B (that can be directly estimated by accelerometer) and vector I^B (that can be directly estimated by the magnetometer). The vector J^B is simply calculated as J^B = K^B x I^B , since it’s orthogonal to the other two vectors (remember versors are unity vectors with same direction as coordinate axes).

Let’s say we know the zenith vector expressed in body frame coordinates at time t₀ and we note it as K^B_0. Also let’s say we measured our gyro output and we have determined that our angular velocity is w = {w_x , w_y , w_z }. Using our gyro we want to know the position of our zenith vector after a small period of time dt has passed we’ll note it as K^B_1G . And we find it using (Eq. 2.6):

K^B_1G ≈ K^B₀ + dt v = K^B₀ + dt (w_g x K^B₀) = K^B₀ + ( dθ_g x K^B₀)

Where we noted dθ_g = dt w_g. Because w_g is angular velocity as measured by the gyroscope. We’ll call dθ_g angular displacement. In other words it tells us by what small angle (given for all 3 axis in form of a vector) has the orientation of a vector K^B changed during this small period of time dt.

Obviously, another way to estimate K^B is by making another reading from accelerometer so we can get a reading that we note as K^B_1A .

In practice the values K^B_1G will be different from from K^B_1A. One was estimated using our gyroscope and the other was estimated using our accelerometer.

Now it turns out we can go the reverse way and estimate the angular velocity w_a or angular displacement dθ_{a ­}= dt w_a , from the new accelerometer reading K^B_1A­ , we’ll use (Eq. 2.5):

w­_a = K^B₀ x v_a / | K^B₀|²­

Now v_a = (K^B_1A­ - K^B₀) / dt , and is basically the linear velocity of the vector K^B₀. And | K^B₀|²­­ = 1 , since K^B₀ is a unity vector. So we can calculate:

dθ_{a ­}= dt w_a = K^B₀ x (K^B_1A­ - K^B₀)

The idea of calculating a new estimate K^B_{1 ­} that combines both K^B_1A and K^B_1G is to first estimate dθ as a weighted average of dθ_a and dθ_g :

dθ = (s_a dθ_a + s_g dθ_g) / (s_a + s_g­), we’ll discuss about the weights later on , but shortly they are determined and tuned experimentally in order to achieve a desired response rate and noise rejection.

And then K^B_{1 ­} is calculated similar to how we calculated K^B_1G:

K^B₁ ≈ K^B₀ + ( dθ x K^B₀)

Why we went all the way to calculate dθ and did not apply the weighted average formula directly to K^B_1A and K^B_1G ? Because dθ can be used to calculate the other elements of our DCM matrix in the same way:

I^B₁ ≈ I^B₀ + ( dθ x I^B₀)

J^B₁ ≈ J^B₀ + ( dθ x J^B₀)

The idea is that all three versors I^B, J^B, K^B are attached to each other and will follow the same angular displacement dθ during our small interval dt. So in a nutshell this is the algorithm that allows us to calculate the DCM₁ matrix at time t₁ from our previous estimated DCM₀ matrix at time t­­₀. It is applied recursively at regular small time intervals dt and gives us an updated DCM matrix at any point in time. The matrix will not drift too much because it is fixed to the absolute position dictated by the accelerometer and will not be too noisy from external accelerations because we also use the gyroscope data to update it.

So far we didn’t mention a word about our magnetometer. One reasons being that it is not available on all IMU units (6DOF) and we can go away without using it, but our resulting orientation will then have a drifting heading (i.e. it will not show if we’re heading north, south, west or east), or we can introduce a virtual magnetometer that is always pointing North, to introduce stability in our model. This situation is demonstrated in the accompanying source code that used a 6DOF IMU.

Now we’ll show how to integrate magnetometer readings into our algorithm. As it turns out it is really simple since magnetometer is really similar to accelerometer (they even use similar calibration algorithms), the only difference being that instead of estimating the Zenith vector K^B vector it estimates the vector pointing North I^B. Following the same logic as we did for our accelerometer we can determine the angular displacement according to the updated magnetometer reading as being:

dθ_{m ­}= dt w_m = I^B₀ x (I^B_1M­ - I^B₀)

Now let’s incorporate it into our weighted average:

dθ = (s_a dθ_a + s_g dθ_g + s_m dθ_m) / (s_a + s_g +_­ s_m)

From here we go the same path to calculate the updated DCM_1­

I^B₁ ≈ I^B₀ + ( dθ x I^B₀) , K^B₁ ≈ K^B₀ + ( dθ x K^B₀) and J^B₁ ≈ J^B₀ + ( dθ x J^B₀),

In practice we’ll calculate J^B₁ = K^B₁ x I^B_1, after correcting K^B₁ and I^B₁ to be perpendicular unity vectors again , note that all our logic is approximated and dependent on dt being small, the larger the dt the larger the error we’ll accumulate.

So if vectors I^B₀, J^B₀, K^B₀ form a valid DCM matrix , in other words they are orthogonal to each other and are unity vectors, then we can’t say the same about I^B₁, J^B₁, K^B₁ , the formulas used for calculating them does not guarantee the orthogonality or length of the vector to be preserved , however we will not get a big error if dt is small, all we need to do is to correct them after each iteration.

First let’s see how we can ensure that two vectors are orthogonal again. Let’s consider two unity vectors a and b that are “almost orthogonal” in other words the angle between these two vectors is close to 90°, but not exactly 90°. We’re looking to find a vector b’ that is orthogonal to a and that is in the same plane formed by the vectors a and b. Such a vector is easy to find as shown in Figure 5. First we find vector c = a x b that by the rules of cross product is orthogonal to both a and b and thus is perpendicular to the plane formed by a and b. Next the vector b’ = c x a is calculated as the cross product of c and a. From the definition of cross product b’ is orthogonal to a and because it is also orthogonal to c – it end up in the plane orthogonal to c , which is the plane formed by a and b. Thus b’ is the corrected vector we’re seeking that is orthogonal to a and belongs to the plane formed by a and b.

Figure 5

We can extend the equation using the triple product rule and the fact that a.a = |a| = 1:

b’ = c x a = (a x b) x a = -a (a.b) + b(a.a) = b – a (a.b) = b + d , where d = – a (a.b) (Scenario 1, a is fixed b is corrected)

You can reflect a little bit on the results … So we obtain corrected vector b’ from vector b by adding a “correction” vector d = – a (a.b). Notice that d is parallel to a. Its direction is dependent upon the angle between a and b, for example in Figure 5 a.b = cos (a,b) > 0 , because angle between a and b is less than 90°thus d has opposite direction from a and a magnitutde of cos(a,b) = sin(b,b’).

In the scenario above we considered that vector a is fixed and we found a corrected vector b’ that is orthogonal to a. We can consider the symmetric problem – we fix b and find the corrected vector a’:

a’ = a – b (b.a) = a – b (a.b) = a + e, where e = - b (a.b) (Scenario 2, b is fixed a is corrected)

Finally in the third scenario we want both vectors to move towards their corrected state, we consider them both “equally wrong”, so intuitively we apply half correction to both vectors from scenario 1 and 2:

a’ = a – b (a.b) / 2 (Scenario 3, both a and b are corrected)
b’ = b – a (a.b) / 2

Figure 6

This is an relatively easy formula to calculate on a microprocessor since we can pre-compute Err = (a.b)/2 and then use it to correct both vectors:

a’ = a – Err * b
b’ = b – Err * a

Please note that we’re not proving that a’ and b’ are orthogonal in Scenario 3, but we presented the intuitive reasoning why the angle between a’ and b’ will get closer to 90°if we apply the above corrective transformations.

Now going back to our updated DCM matrix that consists of three vectors I^B₁, J^B₁, we apply the following corrective actions before reintroducing the DCM matrix into the next loop:

Err = ( I^B₁ . J^B₁ ) / 2

I^B₁^’ = I^B₁ – Err * J^B₁
J^B₁^’ = J^B₁ – Err * I^B₁
I^B₁^’’ = Normalize[I^B₁^’]
J^B₁^’’ = Normalize[J^B₁^’]
K^B₁^’’ = I^B₁^’’ x J^B₁^’’

Where Normalize[a] = a / |a| , is the formula calculating the unit vector co-directional with a.

So finally our corrected DCM₁ matrix can be recomposed from vectors I^B₁^’’, J^B₁^’’, K^B₁^’’ that have been ortho-normalized (each vector constitutes a row of the updated and corrected DCM matrix).

We repeat the loop to find DCM_{2 ,} DCM_{3 ,} or in general DCM _n , at any time interval n.

References

1. Theory of Applied Robotics: Kinematics, Dynamics, and Control (Reza N. Jazar)

2. Linear Algebra and Its Applications (David C. Lay)

3. Fundamentals of Matrix Computations (David S. Watkins)

4. Direction Cosine Matrix IMU: Theory (W Premerlani)

Additional Notes

For the implementation of the algorithm for now see my quadcopter project in particular releases 6/7 have a nice Processing program for visual display of the DCM matrix and a model plane. The entire code is on SVN repository:

http://code.google.com/p/picquadcontroller/source/browse/?r=7#svn%2Ftrunk

The code is in imu.h file:

http://code.google.com/p/picquadcontroller/source/browse/trunk/imu.h?r=7

A PDF Version of this article is available here

DCM Tutorial – An Introduction to Orientation Kinematics by Starlino (PDF, Rev 0.1 Draft)

Please mention and link to the source when using information in this article:

http://www.starlino.com/dcm_tutorial.html

Starlino Electronics  // Spring , 2011

So I decided to build one for  the the acc_gyro boards. But how do you hold the board in place ? Using screws is secure but takes long time to put a board in and out. I needed a faster way to test a larger amount of boards.

Well after several experimentations with velcro tape, rubber bands , and even custom fitted clamps made out of polymorth , I arrived at this simple solution, just use some headers with extra long leads , the pictures tell it all:

The board is basically held by the plastic parts of 2 long headers. You simply spread them apart, insert the board and then , when they come back together they hold the board in place by the spring action of the pogo pins that pushes the board up.

To remove the board simply spread the headers again and the board pops up …

Hope the method could be useful to someone , so decided to share.

//starlino//

Well Radioshack first thank you for replying and not ignoring us altogether. But we would like to see more actions being done. As a reply I will leave you with a related comment from a 10th grade student:

Hello, my name is Nic. I'm in grade 10 and I have an interest in electronics. But I have a lot of restrictions. I live in Canada in a town where there is no electronics shop other than "The Source" (Radioshack was bought out by The Source) which sells overpriced components that aren't the greatest quality, I'm far away from A1 Electronics which is a brilliant store in missisauga. And There is no Electronics course in my high school.  …

[Source: http://www.instructables.com/id/New-Life-for-Old-Printed-Circuit-Boards/ ]

 

$26.95  STEVAL-MKI093V1 ( breakout for LYPR540AH  – 3 axis analog gyro )

http://www.mouser.com/ProductDetail/STMicroelectronics/STEVAL-MKI093V1/?qs=Mmr5WwCtLzNTGieQUi715w%3d%3d

Looks like , Mouser has all datasheet , pictures and descriptions wrong at the time of this post.

correct datasheet   http://www.st.com/stonline/products/literature/bd/17906/steval-mki093v1.pdf

$26.95 STEVAL-MKI064V1 (breakout for LSM303DLH  3-axis magnetometer + 3-axis accelerometer)

http://www.mouser.com/ProductDetail/STMicroelectronics/STEVAL-MKI064V1/?qs=Mmr5WwCtLzNMjRxMWs1ArA%3d%3d

correct datasheet http://www.st.com/stonline/products/literature/bd/17844/steval-mki064v1.pdf

Order while they are in stock :-)

Create a file called  arduino.reg with the following contents:

Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\.pde]
@="Arduino.Document"

[HKEY_CLASSES_ROOT\Arduino.Document\shell\open\command]
@="\"C:\\arduino\\arduino.exe\" \"%1\""

Please note this assumes your arduino installation was unzipped to C:\arduino\ . If different , update accordingly the reg file but make sure to use double quotes \\ for path delimiter as highlighted above.

Next simply double click on the arduino.reg file you have created and the keys will be imported to your registry. Now when you right click on the .pde file you should see arduino as one of the options (and you can make it default program to open pde files). 

For $99  MuSA  could be a nice hackable platform for all sorts of motion-enabled applications.  It has a  built-in accelerometer , LCD  and a simple casing. Here is the description from ST:

"The platform comes with the LIS331DLH preinstalled on the board, but can support any digitaloutput accelerometer from ST in 3×3 or 3×5 mm packages connected to the microcontroller through an SPI interface, as well as the LIS344ALH analog-output accelerometer.

The MuSA platform features four buttons for navigating the menus. A mini-USB connector is available to exchange data with a PC, depending on the specific application, and also recharges the internal Li-ion battery. The battery is capable of providing power for approximately 7 hours of operation."

For device demonstration see video here:

http://www.st.com/stonline/domains/support/edemoroom/index.htm?id=14

If you found yourself in this funny situation you're not alone, the truth is that at this time  there are no serious retail stores for the electronics hobbyist, however there's a booming market !  Due to the current economic environment I doubt that someone would venture to open a nation-wide retail chain like the one Radioshack has, this being the reason I decided to write an open letter to the company. You might not like the Radioshack company but the truth is that we need them and they need us !

I am NOT going to send them this letter, instead I will put it out in the wild-wild web  and let the natural selection do its work. If it makes (or when it makes)  to someone in the Radioshack management  – it means there are enough people who think like I think to make it happen.

That being said , here is the letter, if you'd like to join the petition, leave a comment, post it on your blog, do whatever you feel like, just keep it civilized please.

"Dear RADIOSHACK,

We the electronics hobbyists of America would like to inform you that we are back ! Our soldering irons got cold during the 90's and 2000's  which made you pull all that interesting stuff to the back shelves. But we are the new generation and we are here to continue what our fathers and mothers have started, we are here to invent , change modify and rebuild this country back to it's glory days. We need your help though, we want our voices to be heard, we feel like you're not in touch with reality, while you were sleeping companies like Adafruit, Sparkfun, Make Magazine and many many others , have created a huge online community of new engineers and inventors who are the only hope that this country will once again regain it's edge in the technological field !

You shouldn't be threatened by these online retailers, neither should they be threatened by you, you should instead try to work together with them. In fact as a start you should try to resell their kits, they don't mind anyone copying their work, in fact they publish the schematics, code and advices how to use their products. They are not threatened by anyone, because they will never run out of ideas, they will always be one step ahead, and as long as this happens in our country we all have to gain !

We admire that you started carrying  Parallax products, however we find it somehow funny that searching for "Arduino" on Radioshack site returns "The BASIC Stamp Kit" , why not just start carrying Arduino just like Jameco recently did ?

If you're concerned that you don't have the market yet to pull those products from back shelves and create a larger inventory, don't forget that a market is not only the market that you have, but the market that you're going to create. Next time a father or mother  enters your store to buy batteries she might see all those interesting electronics kits and decide that's a good thing for their children to do in order to keep them busy and away from trouble. Why not get more involved in the community and organize or sponsor some electronics clubs, because we know you were sleeping – they are called nowdays  "hackerspaces". But don't worry they have nothing to do with hackers and bad guys, in fact they are very friendly and open to anyone.

We understand that things might be tough in the financial chapter right now, it might seem strange but we want to give you our money , just give us the stuff we need!  We are here to help and give you feedback. Together  we can change many things for the better. Never underestimate the power that our online community has!

With love,

The Electronics Hobbyists of America

"

Once again, if you'd like to join the petition please leave a comment or publish it on your site, let's hope they will hear us :)

//starlino//  

September 16, 2010

Newark has just launched their new hobbyist / maker oriented web site www.element14.com as well as their own video blog  persona Ben Heck. When I first saw Ben I thought "I didn't know Conan O'Brian is into electronics. Wait that's not Conan !". Just like David L. Jones from EEVBlog , Ben likes to take things apart even before turning them on. I enjoyed very much his X-Box tear down and custom foot controlled XBox controller  and I am looking forward to seeing more videos like this.

Jameco has teamed up with Make Magazine 's   Collin Cunningham and forged a series of video tutorials aimed towards electronics beginners. And yes they finally carry Arduino in stock  !

In the same spirit , Texas Instruments launched few months ago a subsidized development platform MSP430 LaunchPad trying to win the hearts of all those Microchip PIC and Atmel AVR fanboys out there. But word along the benches is that it ain't gonna happen unless they make it Arduino shield pin compatible :).

Old news already – but ST tried a similar move with their STM8S-Discovery kit , not sure how many people they converted but it's interesting to see some competition going on for this hobbyist /  maker , no-longer-niche market.

Adafruit and Sparkfun  are two wonderful pioneer companies that showed to the world that   [title of this post]  = TRUE  ! They started  from zero and reached millions of dollars in sales in just few years. A good example that if you like what you're doing and you are passionate about it – you're going to go a long way.

Overall my feeling is that we are witnessing a new boom right now.  Robotics and Electronics is for 2010's what  Internet was for 2000's and personal computers for 1990's. For all those still in doubt , or who haven't  send their college applications yet – this is THE FIELD to work in the next decade ! A lot of wonderful things are just waiting to happen ! Stay tuned and enjoy the ride.

Here are close-ups of the before and after desoldering:

As you can see desoldering something is really easy, and you get a really-really clean result with this tool.

There are few things to take care of though:

- do not touch the PCB traces for more than one second, this tool is hot and if you heat up the pads for too long it will suck them up
- buy several tip sizes for different jobs ,  i got  1mm (comes in the kit) and additionally I got  1.8mm and 2.3mm tips
- clean your tool regularly. The most replaced items are the ceramic filters so stock up on those, when they harden from the flux it's time to replace them.

Source: Hakko 808 Manual  (Download PDF)

Hakko 808 Kit comes with a carry-on case and few spare parts. What is missing is a holder, that you can buy separately (Hakko 633), however the tool will lay on it's side on the table without touching the surface so that will suffice if you don't have a holder. Another feature that is missing is a  an on/off switch, unplugging this from power outlet is not convenient especially if you have to crawl under the table with a hot tool on the table :)

Overall Hakko 808 is great tool , worth every penny, and I would buy it again if it breaks, speaking of which it is nicely build and has spare parts available so self-repair is possible and even encouraged and explained in the manual.

//starlino//

Hakko A1229: Hakko Replacement Pre-Filters for 808-5, 10/pkg.

Demo

Testing one axis:

Schematic

How it Works

The RC transmitter uses a potentiometer for each axis, it acts as a voltage divider sending a voltage of 0..5V (the middle position corresponds to 2.5V) to the analog input that is converted into a pule of  1..2ms that is sent over RF.

This module converts (amplifies and shifts) the accelerometer analog output , usually  1.65 +/- 0.4V to the same range of the potentiometer and sends it to the transmitter instead.

An op-amp in an inverting amplifier configuration is used. Vref is set manually by tuning the output to be 2.5V (or the PWM pulse to be 1.5 ms). However it is possible to calculate the theoretical value as follows:

Note that according to the rules of  a feedback op-amp the voltage on it's inverting/non-inverting terminals tends to equalize so   V(+) = V(-) and in our case  = Vref.

Since no significant current enters the op-amp , the currents going through R1 and R2 are equal:

( V(-) – Vin ) / R1 = ( Vout – V(-) ) / R2  

(Vref – Vin) / R1 = (Vout – Vref) / R2

solving for Vout gives us

Vout = Vref -  R2/R1 (Vin – Vref)    =   Vref( 1 + R2/R1)  – R2/R1 * Vin

now let's do some notations

G = – R2/R1

Vout = Vref( 1 – G)  -  G * Vin

According to our schematic  G =  R2 / R1 =  – 5.12 , this will convert the accelerometer swing of 0.4 V to a swing of   0.4 V * 5.12  ~  2V .

We want  to make   Vin = 1.65  correspond to a  Vout = 2.5 so we  have the equation

2.5 =  Vref (1 + 5.12)  – 5.12 * 1.65

from here we find

Vref =  (2.5 + 5.12 * 1.65 ) /  (1 + 5.12) = 1.78888 V

Well, this is the theoretical value , in practice we adjust the trimmer R3 until the output is 2.5 while the accelerometer is in laying in horizontal position (has an output of 1.65V).

How to Build

To build use a small proto-board following schematic. Part numbers are mentioned on schematic. Hook-up with the transmitter is described in images below and on the schematic. For accelerometer use Acc_Gyro or similar module, or build your own accelerometer break-out board.

The module is mounted in a free space under antenna using double-sided foam tape – best way to mount an accelerometer to avoid vibration. Note that we get +5V power for the module from the potentiometer contacts. You can test  with a led that the power contacts can deliver at least 20mV, the module uses far less <5mA.

Here is a close-up of the module, as you can see I did  my own accelerometer break-out board, but you can buy a pre-assembled one , there are many choices. You will need an analog accelerometer for this project.

Enjoy your new RC Tilt Transmitter. For any comments/questions use the comment form below.

//starlino//

The source code will be Open-Source and will be hosted on Google Code, you can get code for quad copter here:

http://code.google.com/p/picquadcontroller/source/browse/#svn/trunk

As usual I like to start with a video demo, it's basically me controlling the tilt of the quad using a RC controller:

This is a PID feedback algorithm and a "Simplified Kalman Filter" as  described in my other articles.

First of all there's a a RCGroups thread where I first introduced the project

http://www.rcgroups.com/forums/showthread.php?t=1235360

You'll find some specs there and I will put some material here  as well.

Here is Revision 0.1 of schematic (what I started with):

PicQuadControllerRev01.pdf

The major parts list is as follows:

MCU:  DSPIC33FJ128MC802  (http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en532302)

Sensors: 5DOF Acc_Gyro ( http://gadgetgangster.com/213 )  + 1Dof Pololu LIST300AL-BREAKOUT (http://www.pololu.com/catalog/product/765).

Motor Drivers:  Power N-Channel Mosfets (Many choices -Low Rds(on) and rated for the current , I used  IRLR8743 ). Schottky diodes to protect against back-EMF ( I used SS2H10-E3/52T )

Frame , motors propellers: I picked a ready platform that was on sale Dragandfly IV Frame these are actually brushed motors same ones as used in Esky helicopters.

I did some tests on the lift force potential of this frame+motors+props, and was surprise to find out it performed better than some entry-level brushless motors. The lift force of this platform is up to 2.25 lbs.  The results of lift-force experiments are compiled in this spreadheet: MotorLiftPower.pdf.

How I measured the lift force ?  I didn't have any fancy equipment so I simply fixed the quad in a vise and weighted  it it at different throttle levels – the difference in weight gave me the lift power.

For testing just one motor, I used a string attached to the weight:

I built a test rig out of wood for testing the tilt balancing algorithm as you see in the video.

Here are some close-ups of the motor drivers. You'll  see the Mosfets and the Schottky diodes, also note the extra solder added to support the high currents that will flow through those traces ( up to 5A per motor !).

Finally here is a view on the top of the board ( notice the PIC , the switching regulator  ,  Acc_Gyro 5DOF IMU and single axes Gyro breakout , from top-left to bottom right).

This is it for now hope to bring you more interesting stuff on this and other projects if time allows  !

//starlino//

Demo:

About the project:

For the hardware I used the Acc_Gyro sensor and a thumb-size PIC platform UsbThumb built around the inexpensive PIC18F14K50 chip that provides all the necessary USB connectivity and ADC inputs.

This setup is actually hardware compatible with my original Motion Gamepad design so all the software utilities and firmware will work on the Acc_Gyro + UsbThumb combination that is available as a kit under the name of UsbThumbImu . The Acc_Gyro fits on top of UsbThumb and this is not a coincidence since UsbThumb was designed as microcontroller helper for the Acc_Gyro with the idea of being able to provide the USB/Serial/SPI/I2C interface, as well as making use of the built-in 10bit ADC module of the PIC18F14K50.

In the pictures above headers are used to connect the device, so the end result is a little taller  than you could get if you'd simply solder the two boards together. Both devices have been designed for people that would like to extend  or experiment with the existing solution so there is a second row of connectors on the UsbThumb that can be used to connect buttons or other devices to the project. 

All that's it for now – hope you liked the project. It was really easy to built having the two important components UsbThumb and Acc_Gyro. You'll find more info on individual components on my website as well as  on the GadgetGangster site with whom I partnered to provide kits for anyone interested. If you don't find the necessary information, or you have any any suggestions, ideas or questions – as always feel free to drop me a line with in the comment area below.

//starlino//

It is basically a customization of Mouse emulation demo that Microchip bundles with their USB Framework.

The code responsible for enabling/disabling mouse emulation is triggered by a timer interrupt like so:

        OpenTimer0( TIMER_INT_ON &
                 T0_16BIT              &
                 T0_SOURCE_INT         &
                T0_PS_1_256);

                     ………….

        //These are your actual interrupt handling routines.

        #pragma interrupt YourHighPriorityISRCode
        void YourHighPriorityISRCode()
        {
                //Check which interrupt flag caused the interrupt.
                //Service the interrupt
                //Clear the interrupt flag
                //Etc.
        #if defined(USB_INTERRUPT)
                USBDeviceTasks();
        #endif
       
                if(INTCONbits.TMR0IF){
                        counter_s++;
                        //to interrupt every 1s we need to count FOSC / 4/ 256  = 46875 ticks (0xB71B)
                        //to count these ticks till overflow we need to set TMR0 to  0xFFFF – 0xB71B = 0x48E4
                       
                        TMR0H = 0×48; //will write to TMR0H buffer
                        TMR0L = 0xE4; //will write actual TMR0L / TMR0H 

                        INTCONbits.TMR0IF = 0;
                }

        }       //This return will be a "retfie fast", since this is in a #pragma interrupt section

       ……………..

       INTCONbits.TMR0IE = 0;  //disable Timer0 interrupt
        if(emulate_mode && counter_s > 3){      // seconds on
                counter_s = 0;
                emulate_mode = 0;
        }else if (!emulate_mode && counter_s > 60){     //seconds off
                counter_s = 0;
                emulate_mode = 1;
        }
        INTCONbits.TMR0IE = 1;

For full source code see:

http://code.google.com/p/usbthumb/source/browse/#svn/trunk/UsbThumbMousePrank

UsbThumb is an open-hardware platform, anyone can build their own:

http://code.google.com/p/usbthumb/source/browse/#svn/trunk/Hardware

or pick up a prebuilt SMT version of UsbThumb here: http://www.gadgetgangster.com/303

In order to upload a new firmware to USBThumb you need to enter the bootloader mode. This is done by connecting the  VPP pin to ground during the time when device is plugged into the USB port.

This can achieved by placing a jumper wire or a 1K resistor (recommended) between GND and VPP pin.

GND pin is number 1, and VPP is number 5. Make sure you do not confuse VPP with the nearby VDD(pin number 4) or you will get a short !!! To be safe use a 1K or 10K resistor instead of the wire. Wire/resistor can be held by the spring action, it only needs to make contact during a split second while the device is plugged. If you plan on making frequent firmware updates , soldering a header is recommended.

Before plugging the device to USB port,  start the "USB HID Bootloader" application (it is installed as part of the Microchip USB Framework, look in C:\Microchip Solutions\USB Device – Bootloaders\HID – Bootloader), a copy is placed here for download:

HIDBootLoader.zip

Next insert the USBThumb into the USB port (with the VPP and GND pins connected) , you should see a "Device attached." message in the USB HID Bootloader window.

Next steps are simple:

1. Click on “Open Hex File” button and select the new firmware .HEX file you want to load
2. Click on “Program/Verify” and wait for the process to complete
3. Unplug the device from USB port. Remove the jumber wire/resistor between GND and VPP pin.
4. Plug the device back and verify the new firmware is working (it depends on firmware and what you expect it to do).

The pictures below illustrate the above steps:

A custom PIC firmware  comes preloaded on the
"USBThumb Propeller Programmer" available on GadgetGangster.com, it allows you to use USBThumb as a Propeller Programmer but also as USB to Serial converter.

USBThumb (loaded with USBThumbSerial firmware)  is detected on your computer as a standard  CDC Modem device and works on all modern operating systems (Windows, Mac os , Linux).

On Windows you might be asked for driver path once you attach the device, simply use the driver part of the Microchip's USB Framework (it can be found in C:\Microchip Solutions\USB Device – CDC – Serial Emulator\inf\win2k_winxp ) , and I am including a copy for direct download here:

microchip_cdc_win2k_winxp.zip

On Windows you can identify USBThumb's COM port number from Device Manager:

On Mac OS, once you attach the device  you will get a prompt "A new network interface has been detected". Look in the /dev folder. You should see it as "/dev/tty.usbmodem411" or similar.

PropellerTool can scan all available ports and find the one that has a propeller chip attached. So the above step might not be necessary, however if you already know the COM port of USBThumb you can specify it explicitly.

In the PropellerTool go to  Edit > Preferences>Operation and update the "Serial Port Search" to the port number of USBThumb (COM15 in my example). In the "Propeller Reset Signal" choose DTR.

Next attach the USBThumb to your Propeller development board, USBThumb's serial  4-pin connector is pin compatible with PropPlug. The pins are marked as follows RX,TX,RST,GND.

To test the communication with the propeller board press F7.

If you experience problems make sure the port is not open by any other software (like for example the propeller terminal software)

In some rare cases if you computer power supply is too noisy, to ensure greater stability you can place a 18pF filtering capacitor between pins 24 (RB5)  and 25 (RB6). See picture below:

You can solder the capacitor permanently between these pins, or if you're planning to use USBThumb for other projects and you have soldered sockets to the board simply insert the capacitor in the socket between pins 24 and 25. You only need to take this step if you have intermittent problems with PropellerTool not detecting the Propeller chip.

The setup of BusPirate was simple. Simply plug it to your USB port, install the FDTI driver (if necessary). After that it will appear as a virtual COM port on you computer. You then can use your terminal of choice to interact with it. Here is sample session in Termite (my choice of terminal software):

You will have to figure out which port your BusPirate is on. If you can't figure it out, unplug it , observe list of ports, then plug it back to see which new port appeared – that's the one. List of COM ports can be found in Device Manager on Windows or in Termite Settings menu. Other COM settings are as follows:

Using the probe cable accessory, I did all connections on a breadboard guided by the schematic from MMA7456L datasheet . You will need just 4 Bus Pirate probes connected to the accelerometer. Below I am showing which ones and where you should connect them:

On the breadboard this looks something like this (I also have the oscilloscope probes connected to CLK and MOSI):

First thing to note – I used some shrink-wrap to isolate the Bus Pirate, but you can also put it in a case.

Second thing to note is that my accelerometer was mounted on a breakout board I made myself, I have a detailed tutorial how you can do SMT mounting and etch your own boards in my article "DIY Surface Mount on a Budget – Complete Walkthrough from PCB etching to Reflow" , check it out

Third thing – don't forget the the pull-up resistors (10K) on each bus line. It is required to pull-up the SDA and SCL lines (see resistors R1 and R2 on schematic). You can also try the BP pullup feature instead of external resistors.  The BusPirate on-board 10K pull-up resistors can be connected to the bus pins, by connecting  Vpu pin to a volate pin (3.3V), and then entering the p command to turn the pull-up feature on.

Finally, I used just one decoupling capacitor 0.1uF (the schematic shows 4 caps), also I did not bother to connect the N/C pins to ground.

However for stability you should ground the IADDR0 pin (3), on schematic they show a switch that allows a position where you can change the default address of the device. We won't need the switch for this experiment.

I later discovered that while using the BusPirate internal pull-up feature (Vpu connected to 3.3V),  after I disconnect the oscilloscope probes the setup was no longer working!!! It must be the noise on the bus – I said to myself. Oscilloscope probes have 18-22pf capacitors that actually eliminate some noise. I encountered this phenomenon many times, so I knew what is going on. I simply added two 18pF capacitors between SDA/SCL pins and ground and I was back in business. The noise is coming most of all from my computer power supply , and while working at 100Khz it becomes an issue.

Ok, so once done with the hardware part, moving on to the BusPirate interface. First send a reset command and check your firmware/hardware version. A command is sent in bus pirate by typing the command # followed by Enter. Now take note of the version I am using , if you're reading this article in a year or two there might be other versions available, so if something doesn't make sense , it might be because your have a different version of BusPirate.

I2C>#
#
RESET

Bus Pirate v3
Firmware v4.1 Bootloader v4.1
DEVID:0×0447 REVID:0×3043 (B5)
http://dangerousprototypes.com
HiZ>

For a complete list of commands you can type ?, I won't cover all commands in this article I'll just explain the ones we use. By default BP is in HiZ mode. HiZ means "High Impedance". Z is a common symbol for impedance – simply a fancy way to say that all probes are disconnected. To enter I2C mode simply type m and choose the I2C option ( 4 – in my version of BP). You will be asked other details about I2C setup, I chose 100Khz speed. Once you enter a mode other than HiZ the green MODE led should turn on on your BusPirate.

HiZ>m
m
1. HiZ
2. 1-WIRE
3. UART
4. I2C
5. SPI
6. JTAG
7. RAW2WIRE
8. RAW3WIRE
9. PC KEYBOARD
10. LCD
(1) >4
4
Mode selected
Set speed:
1. ~50KHz
2. ~100KHz
3. ~400KHz
(1) >2
2
READY

Next step – you need to turn power supplies on – you do this by typing W (must be capital W !!! lower w turns them off). Once this is done, the VREG led will turn on, indicating you have power on your 3.3 and/or 5V pins. We'll just use the 3.3V pin to power our project and leave the 5V pin alone, however you could selectively turn the later off.

I2C>W
W
POWER SUPPLIES ON

Now it's time to interact with our accelerometer, BP has a set of macros for each mode that you can check with the (0) command, the (1) macro happens to be a macro that scans all I2C address on the bus and displays the ones present. Each I2C slave device will have a 7bit address ($1D for MMA7456L) that comes in two flavors read(R) and write (W). To obtain the 8bit read/write address you shift the 7bit address to the left (same as multiply by 2) and set the 0th bit to 0 for write, and to 1 for read.

I2C>(1)
(1)
Searching 7bit I2C address space.
Found devices at:
0x3A(0x1D W) 0x3B(0x1D R)

You can verify that 0x1D * 2 + 0 = 0x3A , 0x1D * 2 +1 = 0x3B.

Now it's time to read something from the device. The MMA7456L configuration is divided into 1 byte registers that are described in the datasheet, for testing purposes let's read the register $0D that should contain the device I2C address (0x1D):

Let's send the following command and look at the output:

I2C>{0x3A 0x0D {0x3B r}
{0x3A 0x0D {0x3B r}
I2C START BIT
WRITE: 0x3A ACK
WRITE: 0x0D ACK
I2C START BIT
WRITE: 0x3B ACK
READ: 0x1D NACK
I2C STOP BIT

Now let me explain the BusPirate commands:

{ – sends a I2C start condition (ST)

} – send a I2C stop condition (SP)

0x3A 0x0D 0x3B are simply hex numbers representing bytes sent over the bus

r – reads one byte

There's no need to send the NAK signal, BusPirate will do it for you and also it will detect and display any AK(ACK) signals received from the slave (the accelerometer).

If this looks like magic to you right now , the following diagram will clarify things, it shows how I used the datasheet in order to construct a BusPirate command that would read one register. The register I am reading is $0D , which happens to be the device address, it should return $1D which is the I2C address for MMA7456L.

Now let's talk about writing a byte on the I2C bus.

Before getting acceleration data , we need to put MMA7456L into measurement mode, we also need to specify the sensibility for which there are 3 options 2g/4g/8g. This configuration is done through the Mode Control Register $16 (get the details from MMA7456L datasheet , page 9). For our settings we need to send the binary value of : 0b00000101 which sets mode to "measurement", and g-select to 2g. Let's do it:

I2C>{0x3A 0×16 0b00000101}
{0x3A 0×16 0b00000101}
I2C START BIT
WRITE: 0x3A ACK
WRITE: 0×16 ACK
WRITE: 0×05 ACK
I2C STOP BIT

Writing a register is even simpler than reading and I will show you how the BusPirate write command relates to the diagram from the MMA7456L datasheet:

Now that we've mastered reading/writing to an I2C bus , we're ready to read acceleration data. We have the option of reading 8-bit signed values from registers $06,$07,$08. These registers have a 64count/g resolution in 2g mode, meaning that an acceleration of 1 g will be represented as 64 (0×40) and  -1g will be represented as -64 (0xBF). We can read 3 consecutive registers from one command line as follows:

I2C>{0x3A 0×06 {0x3B r:3}
{0x3A 0×06 {0x3B r:3}
I2C START BIT
WRITE: 0x3A ACK
WRITE: 0×06 ACK
I2C START BIT
WRITE: 0x3B ACK
READ 0×03 BYTES:
0xFF ACK 0xF8 ACK 0x4A NACK
I2C STOP BIT

So we got following accelerometer output values for X,Y,Z axes: 0xFF (-1) , 0xF8 (-8) , 0x4A (74) which divided by sensitivity of 64counts per g, give us the values in Gs ~ -0.015g , -0.125g , 1.16g . It is close to what is expected from the output when the device is in horizontal position. The Z output seems to be off. We'll double check this and deal with it later.

Let's tilt the device on the X axis and see if it makes any difference in output, I tilted it roughly 45 degrees so that X and Z axis modulus should be roughly close to 64/2 = 32 and Y should remain close to 0.

I2C>{0x3A 0×06 {0x3B r:3}
{0x3A 0×06 {0x3B r:3}
I2C START BIT
WRITE: 0x3A ACK
WRITE: 0×06 ACK
I2C START BIT
WRITE: 0x3B ACK
READ 0×03 BYTES:
0xD7 ACK 0xF8 ACK 0x3F NACK
I2C STOP BIT

The results we got this time are X = 0xD7 (-41), Y = 0xF8 (-8), Z = 0x3F(63 !!!), now we can see clear that Z axis reading is offset. Luckily MMA7456L offers a way to correct these values and we'll use it. From first experiment we can see it needs to be offset by 74 – 64 ~ 10 counts. We can correct the accelerometer drift (for each axis). For Z axis we'll be using 2 registers:

"Offset drift Z value (LSB)" – register $14
"Offset drift Z value (MSB)" – register $15.

But what values should we write ? Let's start with the fact that our drift is about 10 counts, but this is in 2g scale. Scale in which drift must be specified is apparently 4g , so we need to offset Z by 10*4g/2g = 20 counts (in 4g scale) . Also our correction must be in different direction so the value to write is -20. Expressed as a signed DWORD this is 0xFFEC.

We'll write 2 registeres at once LSB (least significant byte) first.

I2C>{0x3A 0×14 0xEC 0xFF}
{0x3A 0×14 0xEC 0xFF}
I2C START BIT
WRITE: 0x3A ACK
WRITE: 0×14 ACK
WRITE: 0xEC ACK
WRITE: 0xFF ACK
I2C STOP BIT

Now let's check the readings in horizontal position again.

I2C>{0x3A 0×06 {0x3B r:3}
{0x3A 0×06 {0x3B r:3}
I2C START BIT
WRITE: 0x3A ACK
WRITE: 0×06 ACK
I2C START BIT
WRITE: 0x3B ACK
READ 0×03 BYTES:
0xFB ACK 0xF6 ACK 0×41 NACK
I2C STOP BIT

And here you go – the value for Z axis has been corrected to 0×41 (65) , close to what's expected ( 64).

In Conclusion:

This real life example of exploring and troubleshooting a chip with I2C interface shows what a valuable tool Bus Pirate is. Rather than bore you with a lot of theory and specs I tried to walk you through an example scenario I encountered myself. I hope that I interested you enough in Bus Pirate , accelerometers and digital interfaces in general to do your own further research of this topic.

//starlino//

The Acc_Gyro is mounted on a regular proto-shield on top of an Arduino Duemilanove board.

Parts needed to complete the project:

- Arduino Duemilanove (or similar Arduino platform)
- Acc_Gyro 5DOF IMU board
- Protoshield (optional)
- Breadboard
- Hook-up wire 22AWG

The hook-up diagram is as follows:

Acc_Gyro <—>  Arduino
5V          <—>  5V 
GND      <—>  GND
AX       <—>  AN0
AY       <—>  AN1
AZ       <—>  AN2
GX4      <—>  AN3 
GY4      <—>  AN4  

Once you have completed the hardware part, load the following sketch to your Arduino.

imu_arduino.zip

Run the project and make sure you are receiving an output on your serial terminal (you can start the terminal from your Arduino IDE).

To analyze the data I have developed a small utility called SerialChart. It is open-source so feel free to customize it for your own needs.

Here is the output from SerialChart software:

The test was performed as follows:

- first I was tilting the board slowly (marked "smooth tilting" on the screenshot)

- next I continued tilting the board, but I also started applying some vibration – by tapping the board quickly with my finger (marked "Titlting with vibration noise")

As you can see from the chart the filtered  signal (red line)  is indeed more immune to noise than the accelerometer readings alone (blue line). The filtered signal was obtained by combining the Accelerometer and Gyroscope data. Gyroscope data is important, because if you would simply average the Accelerometer data you would get a delayed signal. Given the simplicity of the code and of the algorithm I am satisfied with the results. One feature that I would like to add is compensation for the drift effect that you might encounter with some gyroscopes. However the Acc_Gyro board proved to be very stable in this respect, since it has built-in high pass filters.

If you'd like to experiment on your own, I recommended first reproducing this testing setup ,  then shift slowly towards your application needs. For example you may take the C code and port it to PIC's C18/C30 or AVR-GCC (it shouldn't be too dificult).

Below are some useful resources and their descriptions.

SerialChart executables can be downloaded from here:

SerialChart_01.zip

Once you start SerialChart application you will need to load the imu_arduino.scc configuration file for this project(included in the imu_arduino.zip) archive.

In this configuration file make sure to update the 'port' settings to Arduino's COM port. On my computer Arduino was detected on COM3, on yours it might be different.

For more information on configuration file syntax see:

http://code.google.com/p/serialchart/wiki/ConfigurationFileSyntax

You can also download and compile SerialChart from Google Code:

http://code.google.com/p/serialchart/source/browse/#svn/trunk

You will need a SVN client to checkout the code (I use RapidSVN for Windows).

SerialChart was developed using  Qt SDK from Nokia: http://qt.nokia.com/downloads

UPDATE 2010-03-18

Many people ask me what about the other 2 axis, here is the code that outputs 3 axis, including the SerialChart configuration script.

Imu_Arduino_3axis_output_2010-03-18.zip

I also removed some overhead code that Alex pointed out in the comments, this reduced the interval between samples.

In the example below I rotate the board around the X axis(blue) which is parallel to the ground.I do it by hand so X is not exactly 0, but close. The axes that change are Y(red) and Z(green).  Please note the relationship X^2+Y^2+Z^2 = 1. The dashed  cyan, magenta and lime lines are unfiltered signals coming from accelerometer alone (RwAcc).

//starlino//