Eric Zielinski

Dr. Bi

CMPS 358

16, February 2014

Assignment 1

The Gyro Sensor is a part usable with the LEGO Mindstorm Real Time System that enables it to

detect both the position of the system (relative to its starting position) and the rate at which its direction

is changing (in degrees-per-second). These readings are accurate to within three degrees. Knowing

this rate of change, referred to as “angular velocity,” and the current orientation of the system are of

incredible use in constructing a moving robot. The uses of these features are extremely important in

many areas, such as trying to keep a system moving in a straight line at a steady pace, having it turn in

a way that will keep it from crashing, or following a specified path properly.

The physical Sensor is relatively easy to find and connect to the rest of the system. It is a

sensor, and thus must be connected to the 1/2/3/4 ports (rather than the a/b/c/d ports used for motors

and other actuators) via the standard wires used for all attachments to the brick. Below is a picture of

the Gyro Sensor for your convenience: The Gyro Sensor. Note the distinct pattern on the Dark Gray bit. The pattern varies between models, but generally has the same basic shape.

Mounting the gyroscope on the robot so that the arrow pattern is parallel to the ground will result in left/right angle readings.

In order to measure up/down angles (if one wanted to measure the steepness of an incline, for example), the gyro sensor must be turned on its side, but not in a way that results in the arrow pattern being perpendicular to the ground, or the readings will be inaccurate.

On the software end of things, using the Gyro Sensor is relatively straightforward. Only two

packages need to be imported: the ports that the brick is connected to and the Gyro Sensor itself. The

import statements to import these are

import lejos.hardware.port.Port;

and

import lejos.hardware.sensor.EV3GyroSensor;

To construct the Gyro Sensor, you simply have to declare an instance of it as you would any object in

Java: EV3GyroSensor *nameOfInstanceVariable* = new

EV3GyroSensor(*portThatPhysicalGyroSensorIsConnectedTo*);

It should be noted that the description of the port that is entered as the parameter for the constructor can

be either a standard port or a “UART port.” UART stands for “Universal Asynchronous

Receiver/Transmitter, and UART ports are used when translating data between parallel form (in which

many bits of data are communicated between two processes at the same time) and serial form (in which

data is communicated one bit at a time).

The process of initializing and declaring the Gyro Sensor is roughly the same as it is for any

other sensor. You follow the syntax EV3GyroSensor *name* = new EV3GyroSensor(*port you’re

using*). An example is shown below,

EV3GyroSensor Gyro = new EV3GyroSensor(SensorPort.S1);

The Gyro Sensor as it appears in EV3 has 3 modes. “Gyro.getAngleMode()” returns the

orientation of the sensor in whole degrees. Counter-intuitively, Clockwise rotations will return

negative degrees, while counterclockwise rotations will return positive degrees. This measurement is

taken with respect to its start orientation. “Gyro.getRateMode()” returns the current angular velocity of

the system in degrees-per-second. Once again, a clockwise motion will result in a negative angular

velocity, while a counterclockwise motion will result in a positive angular velocity. Finally,

”Gyro.getAngleAndRateMode()” is a method that combines both the angle mode and the rate mode.

The first two modes may seem redundant, but testing shows that it operates at almost the exact same

speed as either of the individual measurements. In extremely time-sensitive situations it will likely

prove extremely beneficial to have a means of avoiding any unwanted operations.

Each of these three methods sets the sensor to the appropriate mode. To actually obtain a

reading, you must declare an array of long numbers and pass it as a parameter to the "fetch sample"

method of the sample provider the methods create. For example:

float[] AngleSamples = new float[2];

. . .

Gyro.getAngleMode().fetchSample(AngleSamples, 0);

The fetch sample method returns its readings based on exactly one reading in the case of the Gyro

Sensor. This is dangerous, given that any given reading can potentially be three degrees off. However,

the relatively high sample rate (rate at which the sensor can take readings) of 1 KHz suggests that

readings can be gathered quickly, so it may be wise to have the scanner take multiple readings and

simply pass the average of them to other functions in the program. The sample code I’ve designed to

go along with this guide demonstrates this, as it is able to accumulate 1000 readings, far more than you

would need to ensure accuracy, in roughly 5 seconds.

Calibrating the Gyro Sensor is incredibly simple. There is a void method called “Gyro.reset()”

which, as the name implies, resets the position and angular velocity of the sensor to zero. This method

should probably be used at the beginning of any operation involving the Gyro Sensor, to absolutely

ensure that no faulty readings will be lingering in the Sensor before readings begin. It should be noted

that the Gyro Sensor must remain completely motionless while the recalibration is taking place.

A Sample Programpackage Gyro_Tester;import lejos.hardware.sensor.EV3GyroSensor;import lejos.hardware.port.SensorPort;import lejos.hardware.lcd.*;import lejos.utility.Delay;

public class Gyro_Tester {

public static void main(String[] args) throws InterruptedException { EV3GyroSensor Gyro = new EV3GyroSensor(SensorPort.S1); Gyro.reset(); LCD.drawString("Sample size = "+Gyro.sampleSize(), 0, 2); Delay.msDelay(2000); LCD.clear(); long startTime; long result = 0; float[] AngleSamples = new float[2]; float[] RateSamples = new float[2]; float[] AngleRateSamples = new float[2]; Delay.msDelay(2000); //Get the Angle. for(int i = 0; i < 1000; i = i + 1){ startTime = System.currentTimeMillis(); Gyro.getAngleMode().fetchSample(AngleSamples, 0); LCD.drawString("Angle = ", 0, 2); LCD.drawString("= " + AngleSamples[0], 0, 3); Delay.msDelay(10); result = result + System.currentTimeMillis() - startTime - 10; } LCD.drawString("Average run time", 0, 5); LCD.drawString("= "+(result / 1000), 0, 6); Delay.msDelay(2000); LCD.clear(); Delay.msDelay(2000); //During the wait, begin manually changing the position of the //Gyro Sensor.

//Get the Angular Velocity. result = 0; for(int i = 0; i < 1000; i = i + 1){ startTime = System.currentTimeMillis(); Gyro.getRateMode().fetchSample(RateSamples, 0); LCD.drawString("Anglular Velocity", 0, 2); LCD.drawString("= " + RateSamples[0], 0, 3); Delay.msDelay(10); result = result + System.currentTimeMillis() - startTime - 10; } LCD.drawString("Average run time", 0, 5); LCD.drawString("= " + (result / 1000), 0, 6); Delay.msDelay(2000); LCD.clear(); Delay.msDelay(2000); //Get both. result = 0; for(int i = 0; i < 1000; i = i + 1){ startTime = System.currentTimeMillis(); Gyro.getAngleAndRateMode().fetchSample(AngleRateSamples, 0); LCD.drawString("Both", 0, 2); LCD.drawString("= " + AngleRateSamples[0]+ ", "+ AngleRateSamples[1], 0, 3);

Delay.msDelay(10); result = result + System.currentTimeMillis() - startTime - 10; } LCD.drawString("Average run time", 0, 5); LCD.drawString("= " + (result / 1000), 0, 6); Delay.msDelay(2000); //Let the last message display before ending the program. }

}

Sources:

Lejos EV3 API: http://www.lejos.org/ev3/docs/lejos/hardware/sensor/EV3GyroSensor.html

Explanation of a Gyro Sensor: http://www5.epsondevice.com/en/sensing_device/gyroportal/about.html

Explanation of a Gyroscope in general: http://en.wikipedia.org/wiki/Gyroscope

Blog Post focusing on The Gyro Sensor in EV3: https://lejosnews.wordpress.com/2014/06/05/getting-

heading-from-a-gyro/

Information on UART ports:

http://en.wikipedia.org/wiki/Universal_asynchronous_receiver/transmitter

Hardware specifications on the GyroSensor: http://education.lego.com/en-us/lego-education-product-

database/mindstorms-ev3/45505-gyro-sensor/