[SpotSDKdirectory]/doc/javadoc directory 2 and look at the demonstration applications in the [SpotSDKdirectory]/Demos/

Transcription

1 Lab session 2: Accessing the Sensor Board. We learn how to access some of the elements included in the sensor board of our Sun SPOTs. This allows us to begin programming easy Java applications collecting environmental sensored data. Other elements included in the sensor board of the Sun SPOTs are the 3D Accelerometer, the general-purpose I/O pins, and the high current output pins. For the goals of this course, the 3D Accelerometer is of more interest and thus, in this session we will concentrate on working with it. This documentation is based on the documentation of Sun for the accelerometer, to be found at [SpotSDKdirectory]/doc/AppNotes/AccelerometerAppNote.pdf. 1 For more information about the general-purpose I/O pins and the high current output pins, you are addressed to the Sun SPOT documentation on Sun's website. Basically, both type of pins can be programmed through the classes in the package com.sun.spot.sensorboard.edemoboard and the package com.sun.spot.sensorboard.io. Introduction The sensor board (also called EDemoBoard) includes a 3D accelerometer, a temperature sensor, a light sensor, eight LEDs, two switches, five general-purpose I/O pins and four high current output pins. In the following, we give a rapid introduction to using these components in a Sun SPOT Java program. For more details, look at the Javadoc pages in the [SpotSDKdirectory]/doc/javadoc directory 2 and look at the demonstration applications in the [SpotSDKdirectory]/Demos/ CodeSamples directory. These applications show the details of using one or two sensor board devices. To work with any of the elements in the sensor board, you need to import the package com.sun.spot.sensorboard.edemoboard, which provides the programmer with an object instance of the sensor board and thus also of any of the elements in it. You also need to import the package com.sun.spot.sensorboard.peripheral, which contains interfaces and concrete implementations of various peripherals that are either connected to or built into the daughter cards. The simplest interfaces to sensor board devices are also described in the sections below. All of the sensor board input devices also have listener classes associated with them. These listener classes are detailed in the javadoc. 1 Also available at 2 Also at

2 Temperature Sensor The temperature sensor is the simplest of the sensors. There are no raw readings and no parameters to set. However, it is, inevitably, close to some heat sources in the Sun SPOT. More accurate temperature readings could be obtained with an external temperature sensor tied to the I/O pins on the sensor board. 1. Instantiate the temperature sensor object Import com.sun.spot.sensorboard.edemoboard; Import com.sun.spot.sensorboard.peripheral.itemperatureinput; ITemperatureInput ourtempsensor = EdemoBoard.getInstance().getADCTemperature(); 2. Read the temperature // The temperature can be read in Celsius double celsiustemp = ourtempsensor.getcelsius(); // or in Fahrenheit double fahrenheittemp= ourtempsensor.getfahrenheit(); Light Sensor The light sensor returns an integer that ranges from 0 to 750. Zero represents complete darkness. Peak sensitivity of light sensor is at 600nm wavelength. To use the light sensor: 1. Instantiate a light sensor object Import com.sun.spot.sensorboard.edemoboard; Import com.sun.spot.sensorboard.peripheral.ilightsensor; ILightSensor ourlightsensor = EdemoBoard.getInstance().getLightSensor(); 2. Get the light sensor raw reading. int lightsensorreading = ourlightsensor.getvalue(); This is fine for a constant light source. However, some light sources, specifically fluorescent light bulbs, while seeming constant to the human eye, actually vary rapidly. For these sources, it is better to use the method getaveragevalue(int n). The method will return the average of n samples taken at 1 millisecond intervals. If n is not specified, 17 samples will be taken, spanning one sixtieth of a second, or the usual length of a power/light cycle. int lightsensorreading = ourlightsensor.getaveragevalue(34); LEDs There are eight three-color LEDs on the demo sensor board, in a row. Each LED has a red, a green, and a blue emitter as part of the LED. Each individual color can have an intensity from 0 to 255, with 0 being off and 255 being as bright as possible.

3 To use the LEDs: 1. Instantiate the LED object array. Import com.sun.spot.sensorboard.edemoboard; Import com.sun.spot.sensorboard.peripheral.itricolorled; ITriColorLED[] ourleds = EdemoBoard.getInstance().getLEDs(); 2. Set the LED color desired. Colors are specified with the setrgb(int R, int G, int B) method. // set the LED color desired // set the first two LEDs to bright red, the next two to bright green, // the next two to bright blue, and the last two to white. // First two = bright red ourleds[0].setrgb(255,0,0); ourleds[1].setrgb(255,0,0); // Next two = bright green ourleds[2].setrgb(0,255,0); ourleds[3].setrgb(0,255,0); // Next two = bright blue ourleds[4].setrbg(0,0,255); ourleds[5].setrgb(0,0,255); // Last two = white ourleds[6].setrgb(255,255,255); ourleds[7].setrgb(255,255,255); 3. Turn the LEDs on. //turn the LEDs on for (int i = 0; i < 8; i++) ourleds[i].seton(); 4. If desired, turn the LEDs off. // turn the LEDs off for (int i = 0; i < 8; i++) ourleds[i].setoff(); You can also query the state of the LEDs using the ison(), getred(), getgreen(), and getblue() methods. The package com.sun.spot.sensorboard.peripheral.ledcolor gives support to work with predefined colors. Switches The sensor board has two switches on it. These are represented in the EdemoBoard object as an array of type ISwitch. You may query the state of the switches using the isopen() and isclosed() methods. Ordinarily you will implement an event loop

4 which will check the switches used in your application on a periodic basis, or you will ask the Sun SPOT to stop and wait for the switch state to change. When you want the SPOT to wait for the state switch to change, you would use the waitforchange() method. 1. Instantiate the switch array. Import com.sun.spot.sensorboard.edemoboard; Import com.sun.spot.sensorboard.iswitch; ISwitch[] ourswitches = EdemoBoard.getInstance().getSwitches(); 2. Look for a switch press. If you wanted a switch press and were willing to wait for it: if(ourswitches[0].isopen()) { // if it is open, wait for it to close ourswitches[0].waitforchange(); // Whether it was closed before or just closed, wait for it to open ourswitches[0].waitforchange(); Accelerometer The LIS3L02AQ Accelerometer is a low-power, three-axis linear accelerometer that is mounted on the demo sensor board of the Sun SPOT. The accelerometer can be used to measure the motion of the SPOT. It can also measure the SPOT's orientation with respect to gravity. The Z-axis is perpendicular to the Sun SPOT boards. The X-axis is parallel to the row of LEDs on the sensor board. The Y-axis is parallel to the long edge of the sensor board. The figure shows the accelerometer X, Y and Z axes. The plus (+) on the end of an axis indicates that when the device's acceleration vector increases in that direction, the associated accelerometer readings will grow larger. If the SPOT is sitting flat on a table then the acceleration due to the Earth's gravity will be 1g along the positive Z-axis, and 0g along the X and Y axes. Note that while gravity is pointing down (along the negative Z-axis) this is equivalent to a uniform upwards acceleration of 1g according to the Einstein equivalence principle even though the SPOT is not moving. The LIS3L02AQ accelerometer consists of a Micro-Electro-Mechanical System (MEMS) sensor element that is displaced from its nominal position when a linear acceleration is applied, causing an electrical imbalance that is read via the demo sensor board's analog-to-digital converter. The raw voltage value is then converted to g-force units. The accelerometer can be set to measure accelerations over a scale of either ± 2g or ± 6g. For a full description of the technical specifications of the LIS3L02AQ accelerometer please refer to the STMicroelectronics documentation at The SPOT library includes both the IAccelerometer3D interface that defines the basic methods that any three-axis accelerometer should support, and the

5 LIS3L02AQAccelerometer class that implements that interface along with several other methods specific to the LIS3L02AQ. The Basic Iaccelerometer3D API The basic methods used to read the current acceleration along each axis are getaccelx(), getaccely() and getaccelz(). See an example on how to use them: //Create an accelerometer interface instance import com.sun.spot.sensorboard.edemoboard; import com.sun.spot.sensorboard.iaccelerometer3d; IAccelerometer3D acc = EdemoBoard.getInstance().getAccelerometer(); //Read from the accelerometer double x_accel = acc.getaccelx(); double y_accel = acc.getaccely(); double z_accel = acc.getaccelz(); The readings will be in g-force units. There is also a method getaccel() that returns the vector sum of the acceleration along all three individual axes (i.e., its vector sum, Here is a code fragment that will loop until the acceleration along the X-axis exceeds ¼ g: import com.sun.spot.sensorboard.edemoboard; import com.sun.spot.sensorboard.iaccelerometer3d; import com.sun.spot.util.utils; IAccelerometer3D acc = EdemoBoard.getInstance().getAccelerometer(); while (true) { double ax = acc.getaccelx(); if (ax >= 0.25) { System.out.println( X acceleration above threshold: + ax); break; Util.sleep(250); // check every 1/4 second Here's another fragment to detect when the SPOT is in motion by checking for the total acceleration to deviate from the 1g of gravity: public boolean ismoving() throws IOException { double mag = acc.getaccel(); return Math.abs(mag - 1.0) >= 0.1; The accelerometer interface also has methods for determining the acceleration relative to a previously set acceleration. This measures only the relative acceleration and allows you to remove the force of gravity from your measurements. // Zero out the current forces on the SPOT, usually gravity acc.setrestoffsets();

6 // see if we are accelerating up or down double z_relative_accel = acc.getrelativeaccelz(); The set of methods, getrelativeaccelx(), getrelativeaccely(), getrelativeaccelz() and getrelativeaccel(), return the current acceleration relative to a previously measured acceleration. The method, setrestoffsets(), computes the current acceleration along each axis and saves it, establishing a new zero reading to be used by the above methods. Here is the above code example for method ismoving() rewritten using the relative acceleration routines: public boolean ismoving() throws IOException { return acc.getrelativeaccel() >= 0.1; IAccelerometer3D also has methods that calculate the orientation of the SPOT to the acceleration of the SPOT. When the SPOT is at rest, this acceleration will be gravity and the tilt (i.e., the inclination) will be relative to gravity. The methods are gettiltx(), gettilty(), gettiltz() use the acceleration along an axis in order to compute the inclination, of that axis with respect to the total acceleration the SPOT is experiencing. The tilt is measured in radians. To transform it to degrees, you can use the Math.toDegrees method. FIGURE 2: Computing the tilt Here is a code example to measure the tilt of the SPOT and display the tilt in the LEDs like a bubble in a level. This example is installed with the Sun SPOT SDK and can be found in the directory Demos/CodeSamples/AccelerometerSampleCode. public void demobubblelevel() { for (int i = 0; i < 8; i++) { leds[i].setoff(); // turn off all LEDs leds[i].setcolor(ledcolor.blue); // LEDs will be blue when lit while (true) { try { int tiltx = (int)math.todegrees(acc.gettiltx()); // tiltx is a value in the interval [-90, +90] int offset = -tiltx / 15; // bubble goes to higher side [6,-6] if (offset < -3) offset = -3; // clip angle to range [3, -3] if (offset > 3) offset = 3; leds[3 + offset].seton(); // use 2 LEDs to display "bubble"" leds[4 + offset].seton(); Utils.sleep(50); // update 20 times per second

7 leds[3 + offset].setoff(); // clear display leds[4 + offset].setoff(); catch (IOException ex) { System.out.println("Error reading accelerometer: " + ex); More details about the IAccelerometer3D class are available in the javadoc documentation 3. The LIS3L02AQAccelerometer3D class For most SPOT programs, the functionalities defined by IAccelerometer3D will be all that is needed. However, when requiring more control over the accelerometer than is available through this interface, then the LIS3L02AQAccelerometer class should be consulted. The LIS3L02AQAccelerometer API allows, among many other things, to measure accelerations over a scale of either ± 2g or ± 6g, and to calibrate the accelerometer. Documentation of this API can be found at [SpotSDKdirectory]/doc/AppNotes/AccelerometerAppNote.pdf Also available at

8 Exercises For doing these exercises you can use the code samples to be found at [SpotSDKdirectory]/Demos/CodeSamples as starting point or template. Those examples also show you other slightly more advanced functionalities that we have omitted here. Do also take into account that all of the sensor board input devices also have listener classes associated with them. 1 Have a detailed look at the examples at [SpotSDKdirectory]/Demos/CodeSamples referring to the temperature, light, LEDs and switches. Observe that all the new classes defined in these examples extend the class MIDlet. NOTE: A MIDLet is a MID Profile application. The application must extend this class to allow the application management software to control the MIDlet and to be able to retrieve properties from the application descriptor and notify and request state changes. The methods of this class allow the application management software to create, start, pause, and destroy a MIDlet. A MIDlet is a set of classes designed to be run and controlled by the application management software via this interface. The states allow the application management software to manage the activities of multiple MIDlets within a runtime environment. It can select which MIDlets are active at a given time by starting and pausing them individually. The application management software maintains the state of the MIDlet and invokes methods on the MIDlet to change states. The MIDlet implements these methods to update its internal activities and resource usage as directed by the application management software. The MIDlet can initiate some state changes itself and notifies the application management software of those state changes by invoking the appropriate methods. 2 Program an application to be run on the spot which shows the binary representation of a number using the LEDs. 3 Using the procedure done in the first exercise, program an application on the spot to show the measured temperature. 4 Using the procedure done in the first exercise, program an application on the spot to show the measured light. 5 Using the procedures done in the previous exercises, program an application on the spot to show, alternatively, the temperature and the light measure. The spot should change from one measure to the other by pressing a switch. 6 Using the procedure done in the first exercise, program an application on the spot that counts in binary. The spot should start with no LED switched on (i.e., number zero). When pressing one switch, it should add one unit to the (binary) number showed on the LEDs. When pressing the other switch, it should subtract one. The following exercises work with the accelerometer and are slightly more complex than the previous ones. For doing them you can use the code sample to be found at [SpotSDKdirectory]/Demos/CodeSamples/AccelerometerSamplecode as starting point or template. For doing exercises 9, 10 and 11, you need to use a little bit of communication (from the spot to the basestation), an example of which you can see at the telemetry demo.

9 7 Program an application to be run on the spot which shows (in binary representation, using the LEDs) the measurement of the accelerometer on the X-axis. 8 Protect your sunspot appropriately. Try that it shows (in binary representation, using the LEDs) an inference of the distance traversed (or velocity at which it was thrown) when throwing it in front of you. 9 Make a desktop application to show the measurements of the accelerometer in each axis in a numerical form. 10 Make a desktop application that initially shows an empty window with ball in it (at any position). The ball can not move alone, but it is moved by the user according to the acceleration that he applies on the sunspot. For moving the ball, only the X-axis and the Y-axis are to be considered (the Z-axis is ignored). Acceleration on the X-axis: the ball moves left or right, depending on which direction the spot is moved Acceleration on the Y-axis: the ball moves up or down, depending on which direction the spot is moved 11 Enrich the program of the previous exercise by substituting the empty window by a random maze.