Pink Geek

The method getTiltX () returns the inclination angle in radians (in a range of -pi / 2 to + pi / 2). If we see the triangle below, the hypotenuse of the angle is the module of total acceleration, and the sinus of the angle is the acceleration of axis X divided by the module of total acceleration.

The document of the accelerometer shows an example of a simple application that blinks the LEDs according to the position of the accelerometer.

A Simple Example Using the Accelerometer

Let's look at the code and test it. If you are in doubt of how to create your project or how to test it in the Sun SPOT emulator, see the first part of this tutorial.

Make sure you have these imports in StartApplication:

import com.sun.spot.sensorboard.*;
import com.sun.spot.sensorboard.peripheral.IAccelerometer3D;
import com.sun.spot.util.Utils;

And here's the startApp method:

//first, we retrieve LEDs and accelerometers instances for these devices so they can be accessed and manipulated.
private ITriColorLED [] leds = DemoBoard.getInstance().getLEDs();
IAccelerometer3D acc = EDemoBoard.getInstance().getAccelerometer();

protected void startApp() throws MIDletStateChangeException {         

for (int i = 0; i < 8; i++) {
        leds[i].setOff();                   // turns off all LEDs
        leds[i].setRGB(0,200,0);     // turns LEDs green when turned on.
}
while (true) {
        try {
            int tiltX = (int)Math.toDegrees(acc.getTiltX()); // returns the value, in degrees, of the inclination on the X axis.
            int offset = -tiltX / 15;      
            if (offset < -3) offset = -3;  
            if (offset > 3) offset = 3;
            leds[3 + offset].setOn();      
            leds[4 + offset].setOn();     
            Utils.sleep(50);               
            leds[3 + offset].setOff();    
            leds[4 + offset].setOff();
        } catch (IOException ex) {
            System.out.println("Error reading accelerometer: " + ex);
        }
    }
}

After building the project and deploying the jar created in the virtual Sun SPOT solarium, you can right-click on the Sun SPOT, select "show sensors values", and play around with the X axis on the accelerometer tab to see the program running, as below:

Moving the cursor on the direction of negative values in the X axis is equivalent to moving the real Sun SPOT to the right, as seen in the picture. You can move and see that the LEDs follow the movement.

These are the methods that you probably will use in your project, but they are not the only ones. The LIS3L02AQAccelerometer class implements some specific methods.

For example, you can define in which scale to work from-2g to +2 g, or-6 to +6 g. The default, as seen in the screenshot above is from -2 to +2.

To change the scale, you must use the method setScale (LIS3L02AQAccelerometer.SCALE_2G); where SCALE_2G is the constant for the range of 2G and SCALE_6G is the constant for a scale of 6G. To use this method, you must include the library com.sun.spot.sensorboard.LIS3L02AQAccelerometer in your class. And to see the scale being used at the moment, you have the method getCurrentScale ().

Also, if you want to develop any application that uses the accelerometer in a very different way, you probably will be interested in more obscure methods such as getRawX (), getRawY () and getRawZ (), which are methods that return the values of voltage in each axis. This voltage is used to calculate the acceleration in each axis, using the formula a = (Raw - zeroOffset) / gain, where zeroOffset is the tension at rest and has a nominal value of 465.5 and the gain has a nominal value of 186.2 on the scale of 2G and 62 on the 6G scale.

To obtain the values of offset and gain, you have the methods getZeroOffsets (), getGains () and getRestOffsets () (the latter used to calculate relative acceleration). These methods return, each, a matrix [2] [3], where the first is the scale and then the desired axis. For example, zeroOffsets [scale] [0] returns zeroOffset on the scale used in the axis X. These matrices can be determined by methods setZeroOffsets, setGains and setRestOffsets.

The last method to be mentioned in this part of the tutorial is reset () which returns the scale to the default values and ensures that the accelerometer is not in self-test mode.

Calibrating the accelerometer

As each accelerometer is different, it is necessary to calibrate the Sun Spot. This is done by moving the accelerometer up and down in different ways. An application to calibrate the Sun SPOT is in the Sun SPOT SDK, Demos folder / CalibrateAccelorometer.

Because I don't have a real Sun SPOT yet, I will look further into this later.

And here we finish the second part of the tutorial. As I am studying the Sun SPOT for a project, I will focus my studies on what I intend to use, but if you are interested in anything in particular, tell me and I will try to talk about it here, ok?

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

To proceed to the next part of the tutorial (Meet the Sun SPOTs, with photos and a video of the Sun SPOT that arrived here), click here.

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

It will check if you have NetBeans. If you don't, install it as suggested, and Apacje Ant. This helps a lot when developing, trust me.

Moreover, there aren't any secrets to install this - it will check the requirements of the system, suggest installing something that is required and you don't have ... if you read at least the minimum (you know, those messages that usually appear with an exclamation ), you should not encounter problems here. But if you find any, post it in the comments section and I will try to help, of course.

If you did everything right, double-click the shortcut that is on your desktop and it will open the Sun SPOT Manager. The part that interests us is the Solarium

It is here that we have access to the Sun SPOT Emulator - click the small button written "Solarium" in the lower right corner and it will open the emulator (and where you can see the actual Sun SPOTS that you have connected to your PC).

Go to the "emulator" menu and select the option "new virtual spot". You will see an image of a small Sun Spot on your screen:

Okay, this is the emulator. By right-clicking it you will see the "Deploy MIDlet bundle," which is where you will select the program you did to test on the sun SPOT ... which leads us, of course, to the next step: how to do a program for the Sun SPOT?

Developing for the Sun SPOT with NetBeans

If you installed NetBeans with the Sun SPOT Manager, you already have the necessary plugins. But this is not the case for many people, so let's see how to install the necessary plugins. First, you must download this plugin and install it.

To install this plugin, open NetBeans and go the "Tools" menu -> Plug-ins.

On the Tab "downloads", select "add plug-ins" and select the plugin you just downloaded. After you install it, go to the available plug-ins tab, and reload the catalog. Install the plugins in the Sunspot category that appear:

Then, create a new project in the Java category, of Sun Spot Application type:

You will see that it creates a default class, StartApplication.java, which has all the "imports" needed to boot your Spot  - in fact, this is a program that you can test on your emulator. It doesn't do much, though - it comes down to blinking a light until you press a button.

The code for this is in startApp ():

The first line uses a method to get an instance of Switch 1, the first light is placed in a slightly red color on the second line and then it starts a loop that runs while Switch 1 is "open" (a switch closes a circuit when it is pressed, so the term "open" means an open circuit, ie, a button not pressed): turns a led on, waits a quarter of a second, turns off the led, waits a second and restarts the process.

When the switch is pressed, the program leaves the loop and notifyDestroyed is called to end the program (which calls destroyApp, that does nothing but make sure that all LEDs are turned off in this case).

To build the program and test it, you should build it, right-clicking on the project and selecting "build". This will generate a jar in the "suite" of your project.

Now, let's go to the last step: test your "Hello, Sun Spot world." project.

Testing the Project on the Emulator

Remember what I said about how we would test the application in Solarium? Return to the Solarium, where you created the Virtual Spot, right-click on it in "Deploy MIDlet bundle" and then select the jar file that you created.

To test, right-click on the SPOT, "MIDlet Run" -> "StartApplication". Okay, now you have an amazing sun spot that... ... flashes a LED!!

If you click again with the right button and then "Display Sensor Output" -> Internal frame, you will also see the values of the sensors (you can also change them through this interface), as below:

And here we finish the first part of the tutorial. I hope that in the next part we learn things more interesting than flashing LEDs, right?