Lynxmotion Quadrino Nano - Raw Sensor Values

The Lynxmotion Quadrino Nano Flight Controller (with GPS) was originally designed as a flight controller for drones but, it also has awesome applications for robotic rovers too. Composed of an ATmega2560 (Arduino Mega Chipset), a collection of sensors, GPS and a host of I/O options it is an ideal "sensor ball" for navigation, positioning and more.

In this tutorial we'll be working with a small Arduino program that will give us data from:

• the MPU-9150 (gyroscope, accelerometer, magnetometer)
• the MS5611 (barometer)
• the Venus838FLP (GPS module)

based on the serial command we send to the Arduino. This will give us a starting point for understanding and utilizing the Quadrino Nano's sensors. In future tutorials we will reference this one as we put this unit to work!

Requirements

• Arduino IDE
• Lynxmotion Quadrino Nano Flight Controller (with GPS)
• The Quadrino-Nano-sensor files (github)

Helpful Experience

This tutorial is targeted at beginners, but some experience with the the Arduino IDE and C++ files (.cpp and .h) is helpful but, not required.

Download and open the files

First, download the files. Second, navigate to the Arduino IDE and go to "Sketch/Include Library/Add .ZIP Library and select ZIP file you just downloaded. (if you need any help with this step see https://www.arduino.cc/en/guide/libraries#toc4).

  Then navigate to your Arduino Examples folder. Towards the bottom of the list you will see an item called "QuadrinoNano_SensorDataLibrary", navigate there and click the "QuadrinoNano_SensorData" item.

Upload files to the Quadrino Nano

Next we're going to upload the files to the Quadrino Nano and work with the code before we dive into the specifics. First we need to plug the Quadrino Nano into our computer. Once we have the unit plugged into the computer we need to do two things before we can upload the code. First select the correct Arduino "Board" for the Quadrino Nano from the "Tools" menu. As we discussed above, the Quadrino Nano is an ATmega2560 at heart so we need to select either be the "Arduino/Genuino Mega or 26560" or the "Arduino Mega ADK" depending on your configuration (I had more success uploading with "Arduino Mega ADK"). Second select the appropriate port for your Arduino. If you're on Windows this may be "COM" followed by a number, on Mac it may be "tty" or something even wilder (like the picture shows below). Once we have the port and board selected we're ready to upload the sketch. To upload the sketch, you can press the arrow as shown in the image below or go to "Sketch/Upload" in the menu bar. After uploading you should see a message like the one below without any orange error messages. If you do have errors, there's a few things to check:

1. Make sure the Quadrino Nano is plugged in (this happens to me all the time)
2. Make sure the proper "Board" is selected from the tools menu
3. Make sure the proper "Port" is selected from the tools menu
4. Copy the error message and paste it in Google, often there will be a blog article or a Stack Overflow question about the issue
5. Check the official Arduino site especially the troubleshooting section

Run some commands

Now that we have everything uploaded, its time to run some commands. In order to do that we need to open the serial port by pressing the little magnifying glass icon as illustrated in the image below. Often when we open the Serial Monitor we just see garbage (as you can see in the image below), this usually means we need to set the baud rate to match our project. The baud rate needs to be set to "57600" and line endings should be set to "Both CL & NL". Use the diagram below to find and set these settings. Now that all our settings are correct you should see the printout like the image below (if you see some garbage at the very top of the Serial Monitor, don't worry, that happens when the serial port still has data in it that hasn't been cleared out). When you type in a number and press return, the Quadrino Nano starts reading that sensor and will keep reporting its value at a predefined interval until you press enter to stop reading from the sensors (barometer and temperature only read once and stop). After you've had a chance to experiment, we'll look into some of the details of how we get data from these different sensors.

Diving into the sensor commands

Probably the best way to get an understanding of how we read and interact with the Quadrino Nano's sensors is to take a look at the code itself. The function names are fairly self explanatory and the included notes by the original developers and myself attempt to make these files as readable as possible. That said, we will take a little time to look at the basics of each sensor below.

MPU-9150 commands and function files

The MPU-9150 is an Accelerometer, Gyroscope and Compass in a single chip. From the manufacturers (InvenSense) website:

The MPU-9150 is a System in Package (SiP) that combines two chips: the MPU-6050, which contains a 3-axis gyroscope, 3-axis accelerometer, and an onboard Digital Motion Processor™ (DMP™) capable of processing complex MotionFusion algorithms; and the AK8975, a 3-axis digital compass. The part's integrated 6-axis MotionFusion algorithms access all internal sensors to gather a full set of sensor data.

We communicate with it via I2C using the Arduino Wire Library. We read data from the accelerometer, gyroscope and compass in the same way by using a predefined function and predefined register addresses (often doing a two byte read, once for the low byte and again for the high byte). All of these register addresses are defined in "MPU9150.h" (included with the sketch). Below is a list of useful functions for reading the basics of the MPU-9150 when used in conjunction with "MPU9150.h".

// Clear the 'sleep' bit to start the sensor.
MPU9150_writeSensor(MPU9150_PWR_MGMT_1, 0);

// Start the compass
MPU9150_setupCompass();

// Read the Accelerometer
MPU9150_readSensor(MPU9150_ACCEL_XOUT_L,MPU9150_ACCEL_XOUT_H); // X-Axis
MPU9150_readSensor(MPU9150_ACCEL_YOUT_L,MPU9150_ACCEL_YOUT_H); // Y-Axis
MPU9150_readSensor(MPU9150_ACCEL_ZOUT_L,MPU9150_ACCEL_ZOUT_H); // Z-Axis

// Read the Gyroscope
MPU9150_readSensor(MPU9150_GYRO_XOUT_L,MPU9150_GYRO_XOUT_H); // X-Axis
MPU9150_readSensor(MPU9150_GYRO_YOUT_L,MPU9150_GYRO_YOUT_H); // Y-Axis
MPU9150_readSensor(MPU9150_GYRO_ZOUT_L,MPU9150_GYRO_ZOUT_H); // Z-Axis

// Read the Compass
MPU9150_readSensor(MPU9150_CMPS_XOUT_L,MPU9150_CMPS_XOUT_H); // X-Axis
MPU9150_readSensor(MPU9150_CMPS_YOUT_L,MPU9150_CMPS_YOUT_H); // Y-Axis
MPU9150_readSensor(MPU9150_CMPS_ZOUT_L,MPU9150_CMPS_ZOUT_H); // Z-Axis

uint32_t readRawTemperature(void);
uint32_t readRawPressure(void);
double readTemperature(bool compensation = false);
int32_t readPressure(bool compensation = false);
double getAltitude(double pressure, double seaLevelPressure = 101325);

void VenusDispatchMessage(int result){
 //f.GPS_FIX = venus_ctx.location.fixmode >=2;
 Serial.print("Latitude: ");
 Serial.print(float(venus_ctx.location.latitude/10000000.000000),6); // With 1.9 now we have real 10e7 precision
 Serial.print("\t Longitude: ");
 Serial.print(float(venus_ctx.location.longitude/10000000.000000),6);
 Serial.print("\t Altitude: ");
 Serial.print(float(venus_ctx.location.sealevel_alt /100));
 Serial.print("m \t Satelite Count: ");
 Serial.println(venus_ctx.location.sv_count);
 //GPS_coord[LON] = venus_ctx.location.longitude;
 //GPS_altitude = venus_ctx.location.sealevel_alt /100; // altitude in meter
 //GPS_numSat = venus_ctx.location.sv_count;

 // note: the following vars are currently not used in nav code -- avoid retrieving it to save time
 // also, Venus8 doesnt provide these in a way that we can easily calculate without taking cpu cycles
 //GPS_speed = venus_ctx.location.ground_speed; // in m/s * 100 == in cm/s
 //GPS_ground_course = venus_ctx.location.ground_course/100; //in degrees
}