Design Manual (Cansat)

Can Satellite (CanSat)
Design Manual
University Space Engineering Consortium Japan (UNISEC)

November, 2011. Ver. 1.0.
Can Satellite (CanSat)

Copyright 2011 by University Space Engineering Consortium
All rights reserved. No part of this book may be reproduced or transmitted in any form or by any
means without permission of the author
Dedicated to
All the Japanese People
In a grateful appreciation
Acknowledgements
We wish to express our sincere appreciation to the following institutes and individuals
who have assisted me in the development of this text book: Professor Shinichi
NAKASUKA of the University of Tokyo, Ms. Rei Kawashima, first secretary general of
UNISEC Japan, all the staff members of Institute for Education on Space (IfES) at
Wakayama University and Ms. Emiko Ando, secretary of CLTP office, All participants of
first CanSat Leadership Training Program (CLTP1), Faculty of Engineering, Cairo
University. King Fahd University of Petroleum and Minerals (KFUPM).
Preface
The concept of Can-sat was proposed by professor Robert Twiggs of Stanford
University in 1999. Can-Sat is Soda can size satellite. Can-Sat is fundamental concept
in teaching space engineering to undergraduate students. The Can-Sat provides an
affordable way to acquire the students with the basic knowledge to many challenges in
building a satellite. In Can-Sat projects, students will be able to design, build and test a
small electronic payload that can fit inside a Soda can. The Can-Sat is launched and
ejected from a rocket or a balloon. By the use of a parachute, the Can-Sat slowly
descends back to earth performing its mission while transmitting telemetry. Post launch
and recovery data acquisition will allow the students to analyze the cause of success
and/or failure.
The present textbook is written especially to spread the knowledge of CanSatbased space education in a very systematic and interesting way. Up to our knowledge it
is the first textbook of its kind. The technical contains of the textbook were a collections
of lectures series given during the First CanSat Leader Training Program (CLTP1)
which help in Japan from February 14 to March 18, 2011 at Wakayama University. Also
from the experience gain from different participants attended this course. The book
covers most of the background required to design a baseline CanSat for data gathering
during its launching and descent and send it a ground station PC.
Table of Contents
Chapter 1: Introduction.................................................................................................................................................... 9
1.1 Motivation .................................................................................................................................................................... 9
1.2 Organization of the book ................................................................................................................................. 11
Chapter 2: Mission Profile and System Development ............................................................................... 13
2.1 Introduction .............................................................................................................................................................. 13
2.2 Mission Types........................................................................................................................................................... 13
2.3 Generalized hardware architecture for the CanSat ......................................................................... 14
Chapter 3: Introduction to mbed.............................................................................................................................. 15
3.1 Introduction .............................................................................................................................................................. 15
3.2 Create your first program ................................................................................................................................ 22
3.3 Playing with the built-in LEDs ...................................................................................................................... 23
3.4 Using a tact switch .............................................................................................................................................. 28
3.5 Communication with your PC ....................................................................................................................... 33
3.6 Analog input (connection with an accelerometer) .......................................................................... 37
3.7 Read the mbed API library .............................................................................................................................. 45
3.8 Writing a class library ........................................................................................................................................ 47
3.9 Using the mbed local file system ............................................................................................................... 61
3.10 Using the real-time clock .............................................................................................................................. 65
3.11 Writing a data recorder................................................................................................................................... 69
Chapter 4: Introduction to Global Positioning System (GPS)............................................................... 76
4.1 Introduction .............................................................................................................................................................. 76
4.2 GPS Standard data Format............................................................................................................................. 77
4.3 NMEA 0183 Format .............................................................................................................................................. 77
4.4 GPS Datum................................................................................................................................................................ 80
4.5 Geodetic Coordinate System ........................................................................................................................ 81
4.5.1 Conventional Terrestrial Reference System............................................................................... 82
4.5.2 The WGS 84 (World Geodetic System 1984) .............................................................................. 83
4.6 Converting from WGS84 to navigation coordinates (ENU) ....................................................... 83
4.7 Matlab Program Converting from WGS84 to navigation coordinates (ENU) .................. 85
Chapter 5: CanSat Hardware and Firmware Development ..................................................................... 89
6
5.1 Introduction .............................................................................................................................................................. 89

5.2 System Architecture ........................................................................................................................................... 89
5.3 GPS ................................................................................................................................................................................ 89
5.4 Accelerometer......................................................................................................................................................... 95
5.5 Gyroscope .............................................................................................................................................................. 100
5.6 Pressure and Temperature transducers ............................................................................................. 104
5.7 System integration............................................................................................................................................ 106
Chapter 6: Parachute Design .................................................................................................................................. 110
6.1 Introduction ........................................................................................................................................................... 110
6.2 Forces Acting on the Parachute .............................................................................................................. 110
6.3 Equilibrium of Forces in Steady Descent........................................................................................... 112
6.4 Parachute characteristics and performance .................................................................................... 113
6.5 Parachute simulation during descending .......................................................................................... 117
Chapter 7: CanSat Launchers ................................................................................................................................ 121
6.1 Introdcution ........................................................................................................................................................... 121
Chapter 8: Ground Station Development ........................................................................................................ 122
7. 1 Introduction.......................................................................................................................................................... 122
7.2 Ground Station System Architecture .................................................................................................... 122
7.3 Paring the RF-Communication Modules (XBEE-PRO) ............................................................... 123
7.3.1 Recommended Settings........................................................................................................................... 123
7.3.2 Installation ..................................................................................................................................................... 123
7.3.3 Setting up a serial connection ............................................................................................................. 123
7.3.4 COMM Settings ............................................................................................................................................. 123
7.3.5 Flashing the CanSAT module ............................................................................................................... 124
7.3.6 Flashing the Ground station PC module ........................................................................................ 125
7.3.7 Connecting the XBee module to your MAV................................................................................... 127
7.4 Interfacing mbed with XBEE-PRO........................................................................................................... 127
7.5 System Integration............................................................................................................................................ 128
7.6 Ground Station Software .............................................................................................................................. 131
Chapter 9: Mechanical Construction ................................................................................................................. 139
9.1 Introduction ........................................................................................................................................................... 139
9.2 Structural Design ............................................................................................................................................... 139
Chapter 10: Pre-Launching Testing .................................................................................................................... 144
7
9.1 Intrduction .............................................................................................................................................................. 144

Chapter 11: Data Analysis ........................................................................................................................................ 145
10.1 Introduction ........................................................................................................................................................ 145
References ........................................................................................................................................................................... 146
Appendix A mbed LPC LPC1768 Specification sheet .................................................................................... 147
Appendix B FREESCAL MMA7361LC Accelerometer Specification Sheets ....................................... 151
Appendix C Calibration technique for accelerometers............................................................................... 162
Appendix D SCP 1000 Absolute pressure sensor Specification Sheets .............................................. 167
Appendix E GPS GT-723F Specification Sheets ................................................................................................ 174
Appendix F Gyroscope Specification Sheet........................................................................................................ 185
Appendix G XBEE Specification Sheet ................................................................................................................... 197
Appendix H C/C++ basic data types, operators and control statements .......................................... 203
CHAPTER 1: INTRODUCTION
We will make the world that space activity is not something

special. If half of the countries on earth has ability to develop
satellite/spacecraft then it will be natural for human activity to go
out of gravity of the Earth
Rei Kawashima,
First Secretary General of
UNISEC
1.1 MOTIVATION
In November 1998 at the University Space Systems Symposium (USSS) held in Hawaii,
Prof. Bob Twiggs, Figure 1-1 (Stanford University Space Development Laboratory)
suggested the so-called "CanSat" concept, whereby the entire satellite would adopt the
size of a 350-ml can. This challenge launched the establishment of international
workshops and competitions. During the workshops and competitions throughout the
past decade, college students have designed and built CanSats; launched them by
rockets, balloons and/or model aircrafts; and collected data during the descent of the
CanSats by parachute, simulating the development of experiments in space. During
these hands-on activities, the students have been working on student-led satellite
development projects, realizing low-cost and short-term development programs [1].
Figure 1-1 Professor Bob Twiggs

CanSat is a small satellite analog, as shown in Figure 1-2. All of the components, such
as sensors, actuators, and GPS, are housed inside a 350-ml can. CanSat provides an
9
affordable opportunity for educators and students to acquire basic knowledge of space
engineering and to experience engineering challenges in building a satellite. The
student will be able to design and build a small electronic payload that can fit inside a
standard drink can (350 ml). The CanSats will be launched by a rocket or balloon and
released in the air. Using a parachute, the CanSat will slowly descend back to the
ground as it performs its designated mission (i.e., taking pictures and transmitting
telemetry). By analyzing the data recorded by the CanSat, participants will investigate
the reasons of its success and/or failure.
Figure 1-1 Rover-Type CanSat Developed by the CLTP

participants in 2011 at Wakayama University.
The CanSat-based space engineering education challenges innovative students to get
hands-on experience in a space related project during less than one year. As a space
engineering project students will get experience from conceptual design, through
integration and test, actual operation of the system. This will give the students
experience of taking part of one whole project cycle within one year or less. One of the
major advantages of the CanSat is the very low life cycle cost of the project. Thus,
universities could involve more students to space related projects. The CanSat is small,
non-orbiting and with limited complexity, but it is still like a "satellite" in terms of many of
the challenges real satellites faces.
Each year an annual CanSat competition is arranged in USA. This annual competition
allows teams from different universities and highschools to design and build a spacetype system, according to the specifications released by the competition organizing
committee, and then compete against each other at the end of two semesters to
determine the winners. More information about the annual CanSat competition can be
found in reference [1-2]. There are also several other CanSat competitions taking place
in America, Europe and Asia. In USA there is also another CanSat competition called
ARLISS, which has an international approach [1-3].
10
1.2 ORGANIZATION OF THE BOOK

The present textbook is written especially to spread the knowledge of CanSat-based
space education in a very systematic and interesting way. Up to our knowledge it is the
first textbook of its kind. The technical contains of the textbook were a collections of
lectures series given during the First CanSat Leader Training Program (CLTP1) which
help in Japan from February 14 to March 18, 2011 at Wakayama University. Also from
the experience gain from different participants attended this course. The book covers
most of the background required to design a baseline CanSat for data gathering during
its launching and descent and send it a ground station PC. The organization of the
textbook is as follow:
Chapter 1 serves as introduction to the subject with the motivation for space
engineering education.
Chapter 2: summaries the basic mission type for CanSat
Chapter 3 presents an introduction to the most important hardware components
of the CanSat which is the microcontroller. The material is dedicated to certain
type of microcontroller which is mbed NXP LPC1768 with its development online
environment. This environment makes it easy to use such microcontroller and
use other developers contributions from the mbed web site. Enormous example
and illustrations are given in chapter 3 to acquire the students the required skills
to write their own code.
Chapter 4 introduces the basic concepts and protocols of the GPS (Global
Positioning System). This sensor is quite new compared with the well know
accelerometers, gyroscope, pressure and temperature.
Chapter 5 deals with the interfaces of the mbed to different MEMS Transducers
(MicroElectroMechanical Sensors) like the accelerometer, gyroscope,
temperature, GPS, and pressure. Well test codes and developed class library for
each of commercial transducers are presented in this chapter. At the end of the
chapter, a program for system integration to read all the sensor and send then to
a serially connected PC is developed.
Chapter 6 introduces the basic concept of parachute analysis, simulation and
design and a nonlinear model to predict the motion of real parachute during
descending is developed and coded using MATLAB. Test example for a
descending parachute from given altitude is simulated and the results were
validated using lower order model.
Chapter 7 presents the concept for the telemetry between the CanSat and
Ground station PC. Commericall available RF comuunication modules were used.
11
Their interface with mbed and the needed firmware are developed. Ground
station PC software was developed using MATLAB.
Chapter 8 introduces the different technique and know-how for the mechanical
construction of CanSat.
Chapter 9 discusses some of the testing techniques for different MEMS sensors
used before launching to ensure the reliability of the developed CanSat.
Chapter 10 presents the technique to interpret and analyze the data acquired
during CanSat mission.
12
CHAPTER 2: MISSION PROFILE AND SYSTEM DEVELOPMENT

2.1 INTRODUCTION
CanSat mission should address the objectives of the mission. Then the design and
development should of the CanSat should produce CanSat that could achieve these
objectives with high reliability and robustness. Basic mission like remote sensing (or
imaging) or data acquisitions using different MEMS transducers usually performed for
educational purposes and the beginner to the CanSat based-space engineering
education.
More advanced mission like launching a CanSat from a specific point and performa a fly
back mission to return to another specific points usually done for advanced level training
or CanSat competition.
2.2 MISSION TYPES

The mission Type can basically divide into two categories:
1. Data acquisition Mission (include imaging, sensors data acquisition)
2. Come-back or Fly back mission
Figure 2-1 illustrates schematically the basic difference of between two missions
a) Data acquisition mission

b) Fly back or come-back mission
Figure 2-1 CanSat Mission types
Figure 2-2 shows three the different types of CanSat which was developed during the
CLTP1.
13
a) Data Acquisition CanSat
b) Fly-back CanSat
Figure 2-2 Photos show the different

types of CanSat.
c) Come-back CanSat
2.3 GENERALIZED HARDWARE ARCHITECTURE FOR THE CANSAT

Figure 2-3 shows the generalize hardware architecture for any type of CanSat.
The microcontroller is the heart of the CanSat and should interface with the transducers
and actuators as well as sending the data and receive commands from the ground
station PC. During the data acquisition mission CanSat only read data from sensors,
store and send it to the ground station PC. However, in come-back and fly-back mission
the data should be process on-board the CanSat and decision should taken to deploy
actuators for controls. The present textbook focuses on the basic type of CanSat which
is data acquisition CanSat.
14
CHAPTER 3: INTRODUCTION TO MBED

3.1 INTRODUCTION
Microcontroller called Mbed was chosen as the main on-board computer of the Can-Sat
which is known as an effective tool for rapid prototyping [3-1], shown in Figure 3-1.
Mbed has its developing environment online and no special software installation is
needed. There are numerous C++ libraries and classes available online for most of the
COTS MEMS components. Appendix H summaries the most important C/C++ basic data
types, operators and control statements
Figure 3-1 mbed Microcontroller

The package of the microcontroller shown in Figure 3-2 and contains an mbed
Microcontroller and USB lead. The following requirement is needed to start working with
the mbed.
A computer running Windows, MacOS X or GNU/Linux with

- a USB port,
- an Internet connection, and
- an active email address
A web browser - Internet Explorer, Firefox, Chrome or Safari
Figure 3-2 mbed package

15
Figure 3-3 shows the pin layout of mbed.
Figure 3-3 I/O pin layout and supported interfaces

The technical specifications of mbed NXP LPC1768 are
The mbed NXP LPC1768 is a 32-bit ARM Cortex-M3 Core running at 96MHz,
512KB FLASH, 64KB RAM with a comprehensive set of peripherals and a built-in
USB interface
Designed specifically to make ARM microcontrollers easily accessible for rapid
prototyping and experimentation
- 0.1" DIP pins so you can use it in breadboard, stripboard and through-hole
PCBs
- Powered via USB or an external power source
- Re-program it like a FLASH drive; it appears as a USB disk, and you just
drag on your .bin files
- Has on-board LEDs, and provides a serial port over the USB connection
to allow for printf-style debugging
- Lots of interfaces including Ethernet, USB Device and Host, CAN, SPI,
I2C and other I/O
More technical information about mbed NXP LPC1768 are presented in Appendix A.
Figures 3-4 and 3-5 show how you can sign up your account after plunging the mbed to
your PC.
16
Figure 3-4 Setting mbed

The setup instructions are as follows
Connect your mbed Microcontroller to a PC

Click the MBED.HTM link to get logged in
- Click MBED.HTM to open it in your web browser
- Choose "Signup", and create your mbed account - This will give you
access to the Website, Tools, Libraries and Documentation, as shown in
Figure 3-6.
Figure 3-5 Creating online mbed account
17
a) mbed web site
b) Handbook
c) Forum
d) cookbook
e)
Figure 3-6 features of mbed web site
To downloading a simple Hello World program from the www.mbed.org web site to the
mbed to the following:
Go to the web page

- http://mbed.org/handbook/Downloading-a-program
- Click HelloWorld_LPC1768.bin to download the program binary
- Save the binary to your mbed Microcontroller flash disk
Press the reset button, as shown in Figure 3-7.
- The newest program will be loaded and start running
18
Figure 3-7 mbed reset button and LEDs

To change the browser setting in IE8 to make the default download drive is med drive
using the regedit application in windows, steps illustrated in Figures 3-7 to 3-13 should
be done.
Figure 3-8 Accessing the Windows registry editor
19
Figure 3-9 Windows registry editor
Figure 3-10 Access Windows Internet Explorer node
20
Figure 3-11 Changing the download directory
21

3.2 CREATE YOUR FIRST PROGRAM
To create your first program to the following steps:
Open the mbed Compiler. Figure 3-14
Create a new program
- Right click "My Programs" to select "New Program..."
- Enter name of the program, then click "OK"
- New program will be created under "My Programs"
View the default source code, Shown in Figure 3-15.
Compile and download the program
- Click "Compile" button in the tool bar
- After a successful compilation, you will get a "Success" message
- If there were errors, they will show up in the "Compiler Output" window
Press the "reset" button
22
Figure 3-14 Creating your first program
Figure 3-15 write and compile your program
3.3 PLAYING WITH THE BUILT-IN LEDS

The Built-in LEDs are shown in Figure 3-16 which are:
LED1 to LED4
- can be turn on and off from a program
Status LED
- turns on when powered
- indicates the transmission status
23
Figure 3-16 Built-in LEDs

The mbed default program is as follows:
#include "mbed.h"
DigitalOut myled(LED1);
int main() {
while(1) {
myled = 1;
wait(0.2);
myled = 0;
wait(0.2);
}
}
After compiling, reseat button must be pressed to upload the program to the
microcontroller and the LED1 will blink. The following code is for blinking two LEDs
#include "mbed.h"
DigitalOut myled2(LED2);
int main() {
while(1) {
myled = 1;
myled2 = 1;
wait(0.2);
myled = 0;
myled2 = 0;
wait(0.2);
}
}
24
Using array can reduced the program length as in the following code
#include "mbed.h"
DigitalOut myleds[] = {LED1, LED2, LED3, LED4};
int main() {
while(1) {
myleds[0] = 1;
wait(0.2);
myleds[0] = 0;
wait(0.2);
}
}
The following code lights all LEDS
#include "mbed.h"
int main() {
while(1) {
myleds[0] =
myleds[1] =
myleds[2] =
myleds[3] =
wait(0.2);
myleds[0] =
myleds[1] =
myleds[2] =
myleds[3] =
wait(0.2);
}
}
1;
1;
1;
1;
0;
0;
0;
0;
Use a "for" loop

#include "mbed.h"
int main() {
while(1) {
for (int i = 0; i < 4; i++) {
myleds[i] = 1;
}
wait(0.2);
for (int i = 1; i < 4; i++) {
25
myleds[i] = 0;
}
wait(0.2);
}
}
Use a different "for" loop
#include "mbed.h"
int main() {
for (int i = 0;; i = (i + 1) % 4) {
myleds[i] = 1;
wait(0.2);
myleds[i] = 0;
wait(0.2);
}
}
To write a function, the following code give an example
#include "mbed.h"
void setMyLeds(bool arg) {
for (int i = 0; i < 4; i++) {
myleds[i] = arg;
}
}
int main() {
while(1) {
setMyLeds(1);
wait(0.2);
setMyLeds(0);
wait(0.2);
}
}
The function argument, body and data types is described in Figure 3-17.
26
function name
argument

type argument
name
void setM yLeds( bool
arg ) {
return type
for (int i = 0; i < 4; i + +) {

function body
myleds[i] = arg;
}
Figure 3-17 defining a function
To write another function is illustrated in the following code
#include "mbed.h"
void setMyLeds(bool arg0, bool arg1, bool arg2, bool arg3)
{
myleds[0] = arg0;
myleds[1] = arg1;
myleds[2] = arg2;
myleds[3] = arg3;
}
int main() {
while(1) {
setMyLeds(1, 1, 1, 1);
wait(0.2);
setMyLeds(0, 0, 0, 0);
wait(0.2);
}
}
Example 3-1: Count-down in binary
Write a program to count down from 15 to 0
- when the count reaches 0, flash all the LEDs, as shown in the following
Figure 3-18.
0 to 15 in binary
27
Figure 3-18 Example 3-1

Solution:
#include "mbed.h"
void setMyLeds(bool arg0, bool arg1, bool arg2, bool arg3) {
myleds[0] = arg0;
myleds[1] = arg1;
myleds[2] = arg2;
myleds[3] = arg3;
}
int main() {
for (int i = 15; i > 0; i--) {
setMyLeds(i & 8, i & 4, i & 2, i & 1);
wait(1.0);
}
for (bool on = false;; on = !on) {
setMyLeds(on, on, on, on);
wait(0.2);
}
}
3.4 USING A TACT SWITCH

A tact switch, shown in Figure 3-19, is type of switch that is only on when the button is
pressed. As soon as you release the button, the circuit is broken. It can also can be
described as a type of switch which is only on when the button is pressed
-
Legs 1 and 2 become connected when the button pressed

28
Legs 2 and 3 (1 and 4) are always connected
Figure 3-19 Tact or Tactile switch

Figure 3-20 illustrate how to connect the tact switch to mbed
Figure 3-20 Connecting the tact switch
Using the breadboard illustrated in Figure 3-21. Connection of both the tact switch and
mbed can be realized quickly, as shown in Figure 3-22. A breadboard (protoboard) is a
construction base for prototyping of electronics. The term is commonly used to refer to
solderless readboard (plugboard). Because the solderless breadboard does not require
soldering, it is reusable. This makes it easy to use for creating temporary prototypes
and experimenting with circuit design.
29
Figure 3-21 breadboard
Figure 3-22 mbed and tact switch connected using the breadboard
Reading a switch input
When the tact switch is pressed, the voltage of the p21 pin becomes the same
voltage as the vout pin; when released, the voltage goes down to the ground
level.
Write a program to turn on the LED1 while the tact switch is pressed, as shown in
Figure 3-23.
#include "mbed.h"
DigitalIn switchPressed(p21);
int main() {
while (true) {
myled = switchPressed;
}
}
A digital input, used for reading the state of a pin

30
DigitalIn(PinName) creates a DigitalIn object, connected to the specified pin

read() reads the input voltage, represented as 0 or 1 (int)
read() is overloaded to the operator int()
Figure 3-23 Digital input object

Pressing switch to reverse LED state is illustrated in the following code
#include "mbed.h"
DigitalIn switchPressed(p21);
int main() {
bool stateSW = false;
bool stateLED = false;
while (true) {
if (switchPressed != stateSW) {
stateSW = !stateSW;
if (stateSW) {
stateLED = !stateLED;
myled = stateLED;
}
}
}
}
A digital input, used to call a function on a raising or falling edge
InterruptIn(PinName) creates an InterruptIn, connected to the specified pin
rise(func) attaches a function to call when a rising edge occurs on the input
fall(func) attaches a function to call when a falling edge occurs on the input
Figure 3-24 Digital input signal

31
Reading a switch through interrupt is illustaed in the following code

#include "mbed.h"
InterruptIn switchEvent(p21);
void switchPressed() {
static bool stateLED;
stateLED = !stateLED;
myled = stateLED;
}
int main() {
switchEvent.rise(switchPressed);
while (true) {
wait(60);
}
}
Reading a switch through interrupt is illustrated in the following code
#include "mbed.h"
void switchReleased() {
static int n = 0;
myleds[(n + 3) % 4] = 0;
myleds[n % 4] = 1;
n++;
}
int main() {
switchEvent.fall(switchReleased);
while (true) {
wait(60);
}
}
Contact bounce (also called chatter) is a common problem with mechanical switches
and relays. Switch and relay contacts are usually made of springy metals that are forced
into contact by an actuator. When the contacts strike together, their momentum and
elasticity act together to cause bounce. The result is a rapidly pulsed electric current
instead of a clean transition from zero to full current. The effect is usually unimportant in
power circuits, but causes problems in some analogue and logic circuits that respond
fast enough to misinterpret the on-off pulses as a data stream. The effects of contact
bounce can be eliminated by modify the above code to be as follows
32
#include "mbed.h"
volatile bool interruptEnabled;
void switchReleased() {
static int n = 0;
if (interruptEnabled) {
myleds[(n + 3) % 4] = 0;
myleds[n % 4] = 1;
n++;
interruptEnabled = false;
}
}
int main() {
switchEvent.fall(switchReleased);
while (true) {
wait(0.1);
interruptEnabled = true;
}
}
3.5 COMMUNICATION WITH YOUR PC

To set a serial communication to the mbed and PC access mbed web site and
download the mbed windows serial port driver as illustrated in Figure 3-25.
Figure 3-25 Setting up the windows serial communication

NOTE: If the installer reports the message "mbedWinSerial_nnnnn.exe is not a valid
Win32 application". It is likely you are using Internet Explorer to download the installer
33
file, which sometimes seems to only download part of the installer application for an
unknown reason. To solve this, download the installer with a different browser (Firefox,
Chrome), and try again; this should solve the issue.
There is several applications for HyperTerminal. TeraTerm will be used in the following
sections as shown in Figure 3-26 and Figure 3-27.
Terminal applications for different OS
MacOS X
o CoolTerm (download and install required)
o screen command (available by default)
Windows
o CoolTerm (download and install required)
o TeraTerm (download and install required)
Linux
o screen command (available by default)
Figure 3-26 Setting up the Tera Term V1
34
Figure 3-27 Setting up the Tera Term V1

Serial communication with a PC:
The mbed Microcontroller can communicate with a host PC through a "USB

Virtual Serial Port" over the same USB cable that is used for programming
This enables you to:
- Print out messages to a host PC terminal
- Read input from the host PC keyboard
- Communicate with applications running on the host PC
To run a "Hello World" program do the following steps:
Create a HelloWorld program

Connect your mbed to the PC with USB cable
Compile and download it to your mbed
Open the terminal application, Figure 3-28.
Press the reset button
#include "mbed.h"
int main() {
printf("Hello World!\n");
}
35
Figure 3-28 Output of the Hello World code in the HyperTerminal

To send character data to mbed do the following steps:
Create an Echo program

Connect your mbed to the PC with USB cable
Compile and download it to your mbed
Open the terminal application
A message from the mbed appears
Type any characters from your PC, Figure 3-29.
#include "mbed.h"
int main() {
printf("Echoes back to the screen anything you type\n");
while (true) {
putchar(getchar());
}
}
36
Figure 3-29 Output of the Echoes back code
3.6 ANALOG INPUT (CONNECTION WITH AN ACCELEROMETER)

In this section connection with accelerometer will be described. Specifications of the
accelerometer employed here are presented in Table 3-1 and in Appendix B as well as
Figure 3-30 and Figure 3-31.
Table 3-1 Freescale: 3-Axis Low-g Accelerometer
3mm x 5mm x 1.0mm LGA-14 Package
Low current consumption: 400 A
Sleep mode: 3 A
Low voltage operation: 2.2 V 3.6 V
High sensitivity (800 mV/g @ 1.5g)
Selectable sensitivity (1.5g, 6g)
Fast turn-on time (0.5 ms Enable Response Time)
0g-detect for freefall protection
Robust design, high shocks survivability
Accelerometers are sensors and instruments for measuring, displaying and analysing
acceleration and vibration. They can be used on a stand-alone basis, or in conjunction
with a data acquisition system. Accelerometers are available in many forms. They can
be raw sensing elements, packaged transducers, or a sensor system or instrument,
incorporating features such as totalizing, local or remote display and data recording.
Accelerometers can have from one to three axes of measurement, the multiple axes
typically being orthogonal to each other. These devices work on many operating
principles. The most common types of accelerometers are piezoelectric, capacitance,
null-balance, strain gauge, resonance, piezoresistive and magnetic induction [3-2].
37
There are several physical processes that can be used to develop a sensor to measure
acceleration. In applications that involve flight, such as aircraft and satellites,
accelerometers are based on properties of rotating masses. In the industrial world,
however, the most common design is based on a combination of Newtons law of mass
acceleration and Hookes law of spring action.
Figure 3-30 I/O of the Freescale: 3-Axis Low-g Accelerometer
Figure 3-31 Pin description

Figure 3-32 and Figure 3-33 show the connection of the accelerometer with mbed.
38
Figure 3-32 Schematic connection of accelerometer to mbed
Figure 3-33 Connection of accelerometer to mbed on the breadboard

Write a program to read raw values
Set the accelerometer to 6g mode
Set the sleep mode OFF
Read the raw value (normalized to [0, 1]) of xout
Read the raw value (normalized to [0, 1]) of yout
Read the raw value (normalized to [0, 1]) of zout
Wait for 1 second
Repeat them forever!
The code can be written as follows:
39
#include "mbed.h"
AnalogIn x(p15);
AnalogIn y(p16);
AnalogIn z(p17);
DigitalIn zeroGDetect(p25);
DigitalOut gSelect(p26);
DigitalOut sleep(p24);
int main() {
gSelect = 1; // 6g mode
sleep = 1; // do not sleep
while (true) {
printf("x = %5.3f, y = %5.3f, z = %5.3f\n", x.read(),
y.read(), z.read());
wait(1.0);
}
}
AnalogIn can be described as follows:

Analog input, used for reading the voltage on a pin
AnalogIn(PinName) creates an AnalogIn, connected to the specified pin
read() reads the input voltage, represented a float in the range between 0.0 and
1.0
read() is overloaded to the operator float()
printf function formatting can be described as follows:
Writes a format string

printf(format, arg1, arg2, ...);
Arguments
o format : a template string that can contain embedded format tags, see
Table 3-2.
o arg1: the first variable substituted to the corresponding tag in the format
string
o arg2: the second variable substituted to the corresponding tag in the
format string
o arg1, arg2, ... are optional
40
Table 3-2 Printf embedded format tag examples
Compile, download and run it
Compile the program

If successfully compiled, it will automatically be downloaded to your mbed
Open your terminal application.
Press the reset button!
Figure 3-34 Accelerometer output to the HyperTerminal

The following program converts the readings to g values
#include "mbed.h"
AnalogIn x(p15);
AnalogIn y(p16);
AnalogIn z(p17);
41
float toG(float value) {

return ((value * 3.3) - 1.65) / 0.206;
}
int main() {
while (true) {
float accelX = toG(x.read());
float accelY = toG(y.read());
float accelZ = toG(z.read());
printf("x = %5.3f, y = %5.3f, z = %5.3f\n",
accelX, accelY, accelZ);
wait(1.0);
}
}
Defining a function
float
toG
( float
value
)
return type function name argument type argument name
Computing the tilt (inclination) as shown in Figure 3-35.
tilt angle = arcsin(aaxis / |a|)

- |a| = total acceleration
- aaxis = acceleration measured along the give axis
Figure 3-35 Compute the inclination using accelerometer reading

The code can be written as follows:
42
#include "mbed.h"
AnalogIn x(p15);
AnalogIn y(p16);
AnalogIn z(p17);
return ((value * 3.3) - 1.65) / 0.206;
}
int main() {
while (true) {
float accelX = toG(x.read());
float accelY = toG(y.read());
float accelZ = toG(z.read());
float accel = sqrt(accelX * accelX + accelY *
accelY + accelZ * accelZ);
float tiltX = asin(accelX/accel);
float tiltY = asin(accelY/accel);
float tiltZ = asin(accelZ/accel);
printf("accelX = %5.3f, accelY = %5.3f, accelZ
= %5.3f\n", accelX, accelY, accelZ);
printf("tiltX = %5.3f, tiltY = %5.3f, tiltZ
= %5.3f\n", tiltX, tiltY, tiltZ);
wait(1.0);
}
}
The commonly used mathematical function is listed in Table 3-3
Table 3-3 Commonly used mathematical functions are available
43
Zero G Detection
ZeroG pin becomes HIGH, when all 3 axes are at 0g
- Reading ZeroG pin is much faster than reading all 3 axes
- Can use an interrupt on a "Zero G event" occurrence
Enabling the application of free-fall protection
Reading 0G-Detect pin
#include "mbed.h"
DigitalOut leds[] = {LED1, LED2, LED3, LED4};
int main() {
while (true) {
if (zeroGDetect) { // zeroGDetect becomes 1 (true) if
0G is detected
for (int i = 0; i < 4; i++) {
leds[i] = 1;
}
}
wait(0.1);
}
}
Use an interrupt to detect 0G
#include "mbed.h"
InterruptIn zeroGEvent(p25);
void trigger() {
for (int i = 0; i < 4; i++) {
leds[i] = 1;
}
}
int main() {
44
zeroGEvent.rise(trigger);
while (true) {
wait(60);
}
}
Accelerometer calibration article is presented in Appendix C for further reading.
3.7 READ THE MBED API LIBRARY

An application programming interface (API) is a source code based specification
intended to be used as an interface by software components to communicate with each
other. An API may include specifications for routines, data structures, object classes,
and variables. This section describe how to access API libraries in the mbed.or web site
as shown in the Figures 3-36, 3-37, 3-38, and 3-39.
Figure 3-36 Accessing mbed API library
45
Figure 3-37 Accessing mbed API library
Figure 3-38 Accessing AnalogIn library
46
Figure 3-39 Accessing DigitalInOut library
3.8 WRITING A CLASS LIBRARY

This section illustrate how to creat API library for the accelerometer described in section
3.6.
Original code (accelerometer / tilt in 6g mode)
#include "mbed.h"
AnalogIn x(p15), y(p16), z(p17);
return ((value * 3.3) - 1.65) / 0.206;
}
int main() {
while (true) {
float accelX = toG(x);
float accelY = toG(y);
float accelZ = toG(z);
float accel = sqrt(accelX * accelX + accelY *
accelY + accelZ * accelZ);
float tiltX = asin(accelX/accel);
47
float tiltY = asin(accelY/accel);

float tiltZ = asin(accelZ/accel);
= %5.3f\n", accelX, accelY, accelZ);
printf("tiltX = %5.3f, tiltY = %5.3f, tiltZ
= %5.3f\n", tiltX, tiltY, tiltZ);
wait(0.2);
}
}
A class is an expanded concept of a data structure: instead of holding only data, it can
hold both data and functions.
An object is an instantiation of a class. In terms of variables, a class would be the type,
and an object would be the variable.
Classes are generally declared using the keyword class, with the following format:
class class_name {
access_specifier_1:
member1;
access_specifier_2:
member2;
...
} object_names;
Where class_name is a valid identifier for the class, object_names is an optional list of
names for objects of this class. The body of the declaration can contain members, that
can be either data or function declarations, and optionally access specifiers. a class can
include a special function called constructor, which is automatically called whenever a
new object of this class is created. This constructor function must have the same name
as the class, and cannot have any return type; not even void.
The accelerometer class name, constructors, and function can be listed as follows:
Name
- Accelerometer
Constructor
- Accelerometer(pins...)
Functions
- float getAccel() // get total acceleration
- float getAccelX(), getAccelY(), getAccelZ()
- float getTiltX(), getTiltY(), getTiltZ()
- void setScale(scale) // 1.5G or 6G mode
- void setSleep(bool) // set sensor to sleep mode
- bool detectedZeroG()
48
void setZeroGDetectListener(func) // call func at 0g
Rewrite using the accelerometer class

#include "mbed.h"
#include "Accelerometer.h"
Accelerometer accel(p15, p16, p17, p24, p25, p26); // x, y, z,
sleep, 0g, g-select
int main() {
accel.setScale(Accelerometer::SCALE_6G);
while (true) {
= %5.3f\n",
accel.getAccelX(), accel.getAccelY(),
accel.getAccelZ());
printf("tiltX = %5.3f, tiltY = %5.3f, tiltZ = %5.3f\n",
accel.getTiltX(), accel.getTiltY(), accel.getTiltZ());
wait(0.2);
}
}
Where Accelerometer.h can be written as:
#ifndef ACCELEROMETER_H
#define ACCELEROMETER_H
#include "mbed.h"
class Accelerometer {
public:
Accelerometer(PinName xoutPin, PinName youtPin,PinName
zoutPin,
PinName sleepPin, PinName zeroGDetectPin, PinName
gSelectPin);
enum Scale {SCALE_1_5G, SCALE_6G};
float getAccel();
float getAccelX();
float getAccelY();
float getAccelZ();
float getTiltX();
float getTiltY();
float getTiltZ();
void setScale(Scale scale);
void setSleep(bool on);
bool detectedZeroG();
void setZeroGDetectListener(void (*func)(void));
49
template<typename T> void setZeroGDetectListener(T* t, void

(T::*func)(void));
private:
AnalogIn xout, yout, zout;
DigitalIn zeroGDetect;
DigitalOut sleep;
DigitalOut gSelect;
InterruptIn zeroG;
float scale;
};
#endif
And Accelerometer.cpp can be written as:
Accelerometer::Accelerometer(PinName xoutPin, PinName
youtPin,PinName zoutPin,PinName sleepPin, PinName zeroGDetectPin,
PinName gSelectPin) :
xout(xoutPin), yout(youtPin), zout(zoutPin),
zeroGDetect(zeroGDetectPin),
sleep(sleepPin), gSelect(gSelectPin), zeroG(zeroGDetectPin)
{
sleep = 1; // normal mode
gSelect = 0; // 1.5G mode
scale = 0.8;
}
float Accelerometer::getAccel() {
float x = getAccelX();
float y = getAccelY();
float z = getAccelZ();
return sqrt(x * x + y * y + z * z);
}
float Accelerometer::getAccelX() {
return ((xout * 3.3) - 1.65) / scale;
}
float Accelerometer::getAccelY() {
return ((yout * 3.3) - 1.65) / scale;
}
float Accelerometer::getAccelZ() {
return ((zout * 3.3) - 1.65) / scale;
}
float Accelerometer::getTiltX() {
50
float a = sqrt(x * x + y * y + z * z);
return asin(x / a);
}
float Accelerometer::getTiltY()
float a = sqrt(x * x + y *
return asin(y / a);
}
float Accelerometer::getTiltZ()
float a = sqrt(x * x + y *
return asin(z / a);
}
y + z * z);
{
y + z * z);
void Accelerometer::setScale(Scale scale) {

switch (scale) {
case SCALE_1_5G:
this->scale = 0.8;
gSelect = 0;
break;
case SCALE_6G:
this->scale = 0.206;
gSelect = 1;
break;
}
}
void Accelerometer::setSleep(bool on) {
sleep = !on;
}
bool Accelerometer::detectedZeroG() {
return zeroGDetect;
}
void Accelerometer::setZeroGDetectListener(void (*func)(void)) {
zeroG.rise(func);
}
51
template<typename T> void

Accelerometer::setZeroGDetectListener(T* t, void
(T::*func)(void)) {
zeroG.rise(t, func);
}
The following figures will summarize the process of creating the API library
Figure 3-40 Open the complier window
52
Figure 3-41 Create new program
Figure 3-42 Enter the program name
Figure 3-43 Program folder is created
53
Figure 3-44 Create new file
Figure 3-45 Enter the file name accelerometer.h
54
Figure 3-46 Empty file will appear
Figure 3-47 Write down the Accelerometer.h
55
Figure 3-48 Create another new file
Figure 3-49 Enter the file name accelerometer.cpp
56
Figure 3-50 Write down the Accelerometer.cpp
Figure 3-51 Write the main function as written above
57
Figure 3-52 Compile the program
Figure 3-53 Successful compilation
58
Figure 3-54 Create a new libraray
Figure 3-55 Enter the library name as accelerometer
59
Figure 3-56 Drag the accelerometer.cpp to the library
Figure 3-57 Drag the accelerometer.h to the library
60
Figure 3-58 Library has been created
Figure 3-59 Publishing the library
3.9 USING THE MBED LOCAL FILE SYSTEM

A file system for accessing the local mbed USB disk drive allows programs to
read and write files on the same disk drive that is used to program the mbed
Microprocessor. Standard C file access functions are used to open, read and write. If
61
the microprocessor program makes an access to the local drive, it will be marked as
"removed" on the host computer. This means it is no longer accessible from the host
computer. The drive will only re-appear when the microcontroller program exits. Note
that if the program does not exit, you will need to hold down the reset button on the
mbed to be able to see the drive again.
The first example is to write "Hello World!" to a file is to write down a program to perform
the following function;
Create a local file system "local"
Create & open a new file "out.txt" on the file system, see Figure 3-60.
Write a message "Hello World!" to the file
Close the file
The resulting code will be as follows;
#include "mbed.h"
LocalFileSystem local("local");
int main() {
FILE *fp = fopen("/local/out.txt", "w");
fprintf(fp, "Hello World!\n");
fclose(fp);
}
To Run the program do the following steps:
Eject (or unmount) the mbed USB disk from your computer
o use "safely remove hardware" on Windows
o do NOT unplug the USB cable
The mbed USB disk will automatically be mounted, when the program finishes
Figure 3-60 OUT.TXT appears on your mbed

62
Standard C file access functions are

FILE - a file struct
fopen - creates/opens a file struct and returns its pointer, or returns 0 if it fails,
see Table 3-4
fgetc - reads a character from the file
fputc - writes a character to the file
fscanf - reads input from the file and scans according to the format
fprintf - writes a format string to the file
fclose - completes the file I/O operations and releases the file struct
Table 3-4 fopen access modes (text mode)
The following code shows how to read and write files

#include "mbed.h"
int main() {
FILE *fp = fopen("/local/out.txt", "r");
FILE *fp2 = fopen("/local/out2.txt", "w");
for (int c; (c = fgetc(fp)) != EOF; ) {
fputc(c, fp2);
}
fclose(fp);
fclose(fp2);
}
63
Figure 3-61 OUT2.TXT appears

To scan a data file, the following steps should be done
Use a text editor to create a file "number.txt" on your mbed USB disk; The first
line of the file should consist of your favorite number (positive integer)
Read the file and get the number x
Create a new file "sum.txt" and write a sentence (with appropriate substitutions to
x and xxx); The sum of all the integers from 1 to x is xxx.
The code will be as follow

#include "mbed.h"
int main() {
FILE *fp = fopen("/local/number.txt", "r");
FILE *fp2 = fopen("/local/sum.txt", "w");
int x;
fscanf(fp, "%d", &x);
long sum = 0;
for (int i = 1; i <= x; i++) {
sum += i;
}
fprintf(fp2, "The sum of all the integers from 1 to %d
is %d\n", x, sum);
fclose(fp);
fclose(fp2);
}
64
3.10 USING THE REAL-TIME CLOCK

The mbed Microcontroller device has a built-in real-time clock (RTC) to provide the time
to its applications. When powered, the time starts from 00:00:00 on Jan 1, 1970, which
requires an adjustment to report a correct time. If properly powered with a backup
battery, the RTC keeps running even when the mbed CPU itself is powered off.
To set the real time the time.h functions will be presented first. They are as follows;
time - gets current time; returns the current timestamp, the number of seconds
since January 1, 1970, 00:00:00 (the Epoch)
set_time - Initializes and sets the time of the mbed RTC (real-time clock) to the
time represented by the number of seconds from the
Epoch
localtime - converts a timestamp to a tm struct (time struct data)
strftime - converts a tm struct to a human-readable string
mktime - converts a tm struct to the corresponding timestamp
The following code setting the current time until December 1, 2011, time 00:00:00.
#include "mbed.h"
int main() {
time_t seconds;
char buf[32];
seconds = (((2011 - 1970) * 365 + (2011 - 1968) / 4)
+ 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 ) *
24 * 3600;
set_time(seconds);
seconds = time(NULL);
strftime(buf, sizeof(buf), "%x %X", localtime(&seconds));
printf("mbed rtc = %s (timestamp = %d)\n", buf, seconds);
}
The setting equation can be explained as follows
Days until the end of last years
(((2011 - 1970) * 365 + (2011 - 1968) / 4)

+ 31
+ 28
+ 31
+
30
+ 31
+ 31
+ 30
30 ) * 24 * 3600;
+
30
+
31
+
31
+
Days fro Janauray first until December 1, 2011,Time 00:00:00
The time format in the printf and strftime statements are defined in the following table.
65
Table 3-5 Time format specifiers
The following figures, Figure 3-62, shows the result on your terminal application
Figure 3-62 Time setting results in terminal application

The RTC keep running if connected to small 3V coin cell battery (e.g. CR1220). Use VB
and GND pins to connect the cell as shown in the following figure.
66
Figure 3-63 Backup Battery for RTC

To adjusting the RTC of your mbed use the next program to adjust the RTC and do the
following procedures
Open your terminal application with local echo mode on i.e. check the terminal
configuration setting to switch the echo mode to on status
Run the mbed program; It will ask you to type either t or T
o type t for displaying current RTC time (5 seconds)
o type T for adjusting the RTC: you are requested to enter the
Correct date and time in "yy/mm/dd hh:mm:ss" format
#include "mbed.h"
void printTime(int n) {
printf("\n");
time_t prev = time(NULL);
while (n > 0) {
time_t seconds = time(NULL);
if (prev != seconds) {
char buf[32];
strftime(buf, sizeof(buf), "%x %X",
localtime(&seconds));
printf("%s\n", buf);
prev = seconds;
n--;
}
}
}
void adjustTime() {
int n1, n2, n3, n4, n5, n6;
struct tm t;
printf("\nEnter current time (yy/mm/dd hh:mm:ss)\n");
scanf("%d/%d/%d %d:%d:%d", &n1, &n2, &n3, &n4, &n5, &n6);
67
t.tm_sec = n6;
t.tm_min = n5;
t.tm_hour = n4;
t.tm_mday = n3;
t.tm_mon = n2 - 1;
t.tm_year = n1 + 100;
set_time(mktime(&t));
}
int main() {
if (time(NULL) == (time_t) -1) {
set_time(0);
}
printf("Adjust RTC - Enter t or T\n");
while (true) {
switch (getchar()) {
case 'T':
adjustTime();
break;
case 't':
printTime(5);
break;
}
}
}
Figure 3-64 Adjusting the time
68
3.11 WRITING A DATA RECORDER

This section will describe how to write an acceleration data logger for the accelerometer
described above. First the following things should be done:
Choose 1.5G or 6G mode (or make it selectable)
Periodically (e.g. every 0.1 second), record the measurement and time to a local
file
Use a tact switch to start/stop recording
Use LEDs to show the status
The following hardware are required to perform this task:
an accelerometer (MMA7361L)
a tact switch
a breadboard and jump wires
a 9V battery (optional)
MMA7361L interface library
Figure 3-65 Logger output sample

Connection of the accelerometer is described in Figure 3-66 and Figure 3-67.
69
Figure 3-66 Schematic of wiring diagram
Figure 3-67 Circuiting on a breadboard

To import the accelerometer library follow the steps illustreated in the following figures
70
Figure 3-68 Import Library
Figure 3-69 Select mbed.org tab
71
Figure 3-70 Find the library and press "Import!"
Figure 3-71 Library has been imported
72
Figure 3-72 Documentation about the library
Figure 3-73 APIs of the library

The program for data logger can be written as follows:
#include "mbed.h"
73

DigitalIn swPressed(p21);
Accelerometer accel(p15, p16, p17, p24, p25, p26);
void logAccel(FILE *fp, Accelerometer& accel) {
char buf[32];
time_t seconds = time(NULL);
if (seconds == (time_t) -1) {
set_time(0);
seconds = 0;
}
float x = accel.getAccelX();
float y = accel.getAccelY();
float z = accel.getAccelZ();
float a = sqrt(x * x + y * y + z * z);
strftime(buf, sizeof(buf), "%X", localtime(&seconds));
fprintf(fp, "%s %5.3f %5.3f %5.3f %5.3f\n", buf, a, x, y,
z);
}
int main() {
FILE *fp = fopen("/local/accellog.txt", "a");
accel.setScale(Accelerometer::SCALE_6G);
for (bool on = true; !swPressed; on = !on) {
leds[0] = on;
wait(0.1);
}
for (int i = 0; i < 4; i++) {
leds[i] = true;
}
wait(1.0);
for (int i = 0; i < 4; i++) {
leds[i] = false;
}
while (!swPressed) {
leds[1] = true;
logAccel(fp, accel);
leds[1] = false;
wait(0.1);
74
}
fclose(fp);
}
75
CHAPTER 4: INTRODUCTION TO GLOBAL POSITIONING

SYSTEM (GPS)
4.1 INTRODUCTION
The Global Positioning System (GPS) is a satellite-based navigation system that was
developed by the U.S. Department of Defense (DoD) in the early 1970s as the next generation
replacement to the Transit system. Initially, GPS was developed as a military system to fulfill
U.S. military needs. However, it was later made available to civilians, and is now a dual-use system that can be accessed by both military and civilian users [4-1].
GPS provides continuous positioning and timing information anywhere in the world
under any weather conditions. Since GPS is a one-way-ranging (passive) system, it serves an
unlimited number of users. That is, users can only receive the satellite signals. GPS consists,
nominally, of a constellation of about 24 operational satellites [4-1].
GPS consists of three segments: space, control, and user, as shown in Figure 4-1. The
space segment consists of about 24 satellites constellation. The control segment of the GPS
system consists of a worldwide network of tracking stations. The user segment includes all
military and civilian users. With a GPS receiver connected to a GPS antenna, a user can
receive the GPS signals, which can be used to determine his or her position anywhere in the
world. GPS is currently available to all users worldwide at no direct charge [4-1].
Figure 4-1 GPS Segments
The idea behind GPS is rather simple. If the distances from a point on the Earth (a GPS
receiver) to three GPS satellites are known along with the satellite locations, then the location of
the point (or receiver) can be determined by simply applying the well-known concept of
76
resection [4-1]. That is all! But how can we get the distances to the satellites as well as the
satellite locations?.
Each GPS satellite continuously transmits a microwave radio signal composed of two
carriers, two codes (or more for modernized satellites), and a navigation message. When a
GPS receiver is switched on, it will pick up the GPS signal through the receiver antenna. Once
the receiver acquires the GPS signal, it will process it using its built-in processing software.
The partial outcome of the signal processing consists of the distances to the GPS satellites
through the digital codes (known as the pseudo ranges) and the satellite coordinates through
the navigation message. Theoretically, only three distances to three simultaneously tracked
satellites are needed. In this case, the receiver would be located at the intersection of three
spheres; each has a radius of one receiver-satellite distance and is centered on that particular
satellite as shown in Figure 4-2.
Figure 4-2 Basic idea of GPS positioning [4].
4.2 GPS STANDARD DATA FORMAT

Since individual GPS manufacturers have their own proprietary format for storing GPS
measurements, it can be difficult to combine data from different receivers. A similar problem is
encountered when interfacing various devices, including the GPS receiver. To overcome these
limitations, a number of research groups and agencies have developed standard formats for
various user needs. Brief description of one of these formats (NMEA 0183) will be presented in
the subsequent section which is the format of the GPS (GT-723F) employed in this textbook,
Specification sheet of the GPS receiver can be found in Appendix A.
4.3 NMEA 0183 FORMAT

NMEA was founded in 1957 by a group of electronics dealers to strengthen their
relationships with electronic manufacturers. The NMEA 0183 standards are data streams in the
ASCII format, transmitted at a rate of 4,800 bps, from a talker to a listener (one-way), where a
talker is a device that sends data to other devices (e.g., a GPS receiver) and a listener is a
device that receives data from another device (e.g., a laptop computer interfaced with the GPS
77
receiver). A high-speed version of NMEA 0183 is also available, which operates at a rate up to
38.4 K-baud.
The NMEA 0183 data streams may include information on position, datum, water depth,
and other variables. The data is sent in the form of sentences, each starting with a dollar sign
"$" and terminating with a carriage return-line feed "<CR><LF>"; the dollar sign "$" is followed
by a five-character address field, which identifies the talker (the first two characters) and the
format and data type (the last three characters). The data fields are separated by "," delimiter.
A null field (i.e., a field with zero length) is used when the value of the field is unavailable or
unreliable. The last field in any sentence follows a checksum delimiter character "*" and is a
checksum field. The maximum total number of characters in any sentence is 82 (i.e., a
maximum of 79 characters between the starting delimiter "$" and the terminating "<CR><LF>").
A number of these sentences are dedicated to GNSS (Global Navigation Satellite System),
including GPS and GLONASS (the Russian GPS counterpart) systems, while the remaining
sentences support other devices such echo sounders, gyroscopes, and others. Table 4-1
shows common GNSS-related NMEA sentences, which are defined in the current
version of NMEA 0183.
Our discussion will be restricted to one sentence only, which is commonly used
in practice-the GGA, or GPS fix data. This sentence represents the time, position, and
solution-related information. Figure 4-3 shows the general structure of the GGA
sentence, while Table 4-2 explains the terms of the sentence.
Table 4-1 Common GNSS-Related NEMA Sentences
NMEA Sentence
AlM
GBS
GGA
GMP
GNS
GRS
GSA
GST
GSV
Description
GPS almanac data
GNSS satellite fault detection
GPS fix data
GNSS map projection fix data
GNSS fix data
GNSS range residuals
GNSS DOP and active satellites
GNSS pseudorange error statistics
GNSS satellites in view
Figure 4-3 General Structure of a GGA sentence
78
Table 4-2 Explanation of GCA Sentence

Symbol
$
GP
GCA
,
hhmmss.ss
IIII.II
A
yyyyy.yy
a
x
xx
x.x
x.x
M
x.x
M
x.x
xxxx
*
hh
<CR><LF>
Explanation
Start of sentence delimiter
Talker identifier (GPS in this case)
Data identifier (GPS fix data in this case)
Data field delimiter
Time of position in UTC system
(hoursminutesseconds.decimall. Decimal
digits are variable.
Latitude (degreesminutes.decimall. Decimal digits are variable.
N/S (North or South)
Longitude (degreesminutes.decimal). Decimal digits are variable.
E/W (East or West)
GPS quality indicator (0 = Fix not available or invalid)
(1 = Point positioning with CIA-code)
(2 = DGPS with CIA-code)
(3 = Point Positioning with P-code)
(4 = RTK with ambiguity parameters fixed to integer values)
(5 = RTK with float ambiguity parameters)
(6 = Estimated [dead reckoning] mode)
(7 = Manula input model)
(8 = Simulator mode)
Number of satellites used in producing the solution
Horizontal Dilution of Precision (HOOP)
Altitude above geoid (Orthometric height)
Meters (units of Orthometric height)
Geoidal Height above the WGS84 ellipsoid (geoid-ellipsoid
separation) Meters (units of Geoidal Height)
Age of Differential GPS data in seconds (time since last RTCM
message type 1 or 9 was received; null filed when Differential GPS
mode is not used).
Differential reference station 10 (range 0000-1023)
Checksum delimiter character
Checksum field (last field in the sentence)
Sentence terminator
Most GPS receivers available on the market support the NMEA 0183 standards.
However, not all receivers with the NMEA 0183 port output all the GPS-specific
messages. In addition, some GPS receiver manufacturers may slightly change the
standard format. However, they typically provide software to interpret the data
sentence.
79
4.4 GPS DATUM

The fact that the topographic surface of the Earth is highly irregular makes it difficult for
geodetic calculations to be performed. To overcome this problem, geodesists adopted a
smooth mathematical surface, called the reference surface, to approximate the irregular
shape of the Earth (more precisely to approximate the global mean sea level, the geoid)
[4]. One such mathematical surface is the sphere, which has been widely used for lowaccuracy positioning. For high-accuracy positioning, such as GPS positioning, however,
the best mathematical surface to approximate the Earth and at the same time keep the
calculations as simple as possible was found to be the biaxial ellipsoid, as shown if
Figure 4-4. The biaxial reference ellipsoid, or simply the reference ellipsoid, is obtained
by rotating an ellipse around its minor axis, b. Similar to the ellipse, the biaxial reference
ellipsoid can be defined by the semiminor and semimajor axes (a, b) or the semi major
axis and the flattening (a, f), where f = 1-(b / a).
An appropriately positioned reference ellipsoid is known as the geodetic datum. In
other words, a geodetic datum is a mathematical surface, or a reference ellipsoid, with a
well-defined origin (center) and orientation. For example, a geocentric geodetic datum is
a geodetic datum with its origin coinciding with the center of the Earth. It is clear that
there is an infinite number of geocentric geodetic datums with different orientations.
Therefore, a geodetic datum is uniquely determined by specifying eight parameters: two
parameters to define the dimension of the reference ellipsoid, three parameters to
define the position of the origin, and three parameters to define the orientation of the
three axes with respect to the Earth [4-1]. Table 4-3 shows some examples of three
common reference systems and their associated ellipsoids.
Figure 4-4 (a) Relationship between the physical surface of

the Earth, the geoid, and the ellipsoid; (b) ellipsoidal
parameters.
Table 4-3 Example of Reference System and Associated Ellipsoid [4-1]

80
In addition to the geodetic datum, the so-called vertical datum is used in practice as a
reference surface to which the heights (elevations) of points are referred. Because the height of
a point directly located on the vertical datum is zero, such a vertical reference surface is
commonly known as the surface of zero height. The vertical datum is often selected to be the
surface that best approximates the mean sea level on a global basis (the geoid), as shown in
Figure 4-4.
4.5 GEODETIC COORDINATE SYSTEM

A coordinate system is defined as a set of rules for specifying the locations (also called
coordinates) of points [4-1]. This usually involves specifying an origin of the coordinates as well
as a set of reference lines (called axes) with known orientation. Figure 4-5 shows the case of a
three-dimensional coordinate system that uses three reference axes (x, y, and z) that intersect
at the origin (C) of the coordinate system. Coordinate systems may be classified as onedimensional, two dimensional, or three-dimensional coordinate systems, according to the
number of coordinates required to identify the location of a point. For example, a onedimensional coordinate system is needed to identify the height of a point above the sea surface.
Figure 4-5 Three-dimensional coordinate system

Coordinate systems may also be classified according to the reference surface, the
Orientation of the axes, and the origin. In the case of a three-dimensional geodetic (also known
as geographic) coordinate system, the reference surface is selected to be the ellipsoid. The
orientation of the axes and the origin are specified by two planes: the meridian plane through
the polar or z-axis (a meridian is a plane that passes through the north and south poles) and the
equatorial plane of the ellipsoid, as shown in Figure 4-5.
81
Of particular importance to GPS users is the three-dimensional geodetic coordinate system. In

this system, the coordinates of a point are identified by the geodetic latitude (), the geodetic
longitude (), and the height above the reference surface (h). Figure 4-6 shows these
parameters. Geodetic coordinates (, , and h) can be easily transformed to Cartesian
coordinates (x, y, and z) as shown in Figure 4-6 (b). To do this, the ellipsoidal parameters (a
and f) must be known. It is also possible to transform the geodetic coordinates ( and ) into a
rectangular grid coordinate (e.g., Northing and Easting) for mapping purposes. It is useful for
some applications to express the coordinates of a point in a system known as the East-NorthUp (ENU) system, which is related to the three-dimensional geodetic coordinate system
discussed earlier, as shown in Figure 4-7. The ENU has its origin at the user's (i.e., point's)
location; therefore, it is also known as the local-level system. The ENU system is a
right-handed. It is possible to transform the ENU coordinates into geodetic coordinates,
and vice versa.
Figure 4-6 (a) Concept of geodetic coordinate; (b) geodetic and Cartesian
coordinates.
4.5.1 CONVENTIONAL TERRESTRIAL REFERENCE SYSTEM
The Conventional Terrestrial Reference System (CTRS) is a three dimensional
geocentric coordinate system (i.e., its origin coincides with the center of the Earth; as
shown in Figure 4-5). The CTRS is rigidly tied to the Earth (i.e., it rotates with the Earth).
It is therefore also known as the Earth-centered, Earth-fixed (ECEF) coordinate system.
The orientation of the axes of the CTRS is defined as follows: The z-axis points toward
the conventional terrestrial pole, which is defined as the average location of the pole
during the period 1900-1905. The x-axis is defined by the intersection of the terrestrial
equatorial plane and the meridianal plane that contains the mean location of the
Greenwich observatory (known as the mean Greenwich meridian). It is clear from the
definition of the x- and z-axes that the xz-plane contains the mean Greenwich meridian.
The y-axis is selected to make the coordinate system right-handed (i.e., 90 degrees
east of the x-axis, measured in the equatorial plane). The three axes intersect at the
center of the Earth, as shown in Figure 4-5.
82
Figure 4-7 East-North-Up coordinate system

4.5.2 THE WGS 84 (WORLD GEODETIC SYSTEM 1984)
The WGS 84 is a three-dimensional, Earth-centered reference system developed
by the former U.S. Defense Mapping Agency now incorporated into a new agency, NGA.
WGS 84 is the official GPS reference system. In other words, a GPS user who employs
the broadcast ephemeris in the solution process will obtain his or her coordinates in the
WGS 84 system. The WGS 84 utilizes the CTRS combined with a reference ellipsoid
that is identical, up to a very slight difference in flattening, with the ellipsoid of the
Geodetic Reference System of 1980 (GRS 80); see Table 4-3. The latter was
recommended by the International Association of Geodesy for use in geodetic
applications.
4.6 CONVERTING FROM WGS84 TO NAVIGATION COORDINATES (ENU)

The transformation from ,h to ENU is a three stage process [4-2]:
1. Determine latitude, longitude and height of reference point, (;; h).
2. Express small changes in latitude, longitude and height in Earth Centered Earth Fixed
(ECEF) coordinates. GPS coordinates can be converted into ECEF coordinates using the
following formulae:
(4-1)
83
Where
a and e2 are the semi-major axis and the first numerical eccentricity of the Earth
respectively. To convert small changes in latitude, longitude and height into
ECEF coordinates we need to Taylor expand equation (4-1) about
d , d and h h dh .
(4-2)
3. By means of a rotation, displacements in ECEF coordinates are transformed to

ENU coordinates. The ECEF coordinates (dx; dy; dz) are orientated in such a
way that from the centre of the Earth the z points in the direction of true north, x
points in the direction of the prime meridian and the direction of y is 90o from the
prime meridian, see Figure 4-7. The orientation of ENU coordinates is
determined by rotating the ECEF Coordinates; firstly about the z axis by
degrees and then the new y axis by degrees.
(4-3)
Substituting equation (4-2) into equation (4-3), and ignoring terms of O(d3) and
O(dhd2) and higher, we get
84
(4-4)
Note: The coordinates (;;h) are ellipsoidal (WGS84), not spheroidal (geocentric). The
difference is most easily explained by Figure 4-8.
Figure 4-8 Ellipsoidal and spheroidal coordinates
4.7 MATLAB PROGRAM CONVERTING FROM WGS84 TO NAVIGATION

COORDINATES (ENU)
Armed with equation (4-4) we are now in a position to write a Matlab program.
The code for our program dllh2denu.m is given below. The routine dllh2denu is simple
to use, it requires two inputs; the first is a vector indicating the location of the reference
point in latitude, longitude in degrees and height in meters. The first input is a 1 x 3
vector of the form [4-2]:
llh0 = [; ; h] :
The second input is a n x 3 matrix indicating the location of the points of interest (e.g. the
location of the CanSat). The second input is of the form:
85
The resulting output is a n x 3 matrix with the first, second, and third columns,
representing the east, north and up displacement respectively in meters.
As an example suppose the location of the reference point is
and three points of interested are located at
To determine the location of these points in ENU coordinates we would run

dllh2denu in the following way:
86
m-file dllh2denu.m
function denu = dllh2denu(llh0,llh)
% CONSTANTS
%--------a = 6378137;
b = 6356752.3142;
e2 = 1 - (b/a)^2;
% Location of reference point in radians
%-------------------------------------phi = llh0(1)*pi/180;
lam = llh0(2)*pi/180;
h = llh0(3)
% Location of data points in radians
%---------------------------------dphi= llh(:,1)*pi/180 - phi;
dlam= llh(:,2)*pi/180 - lam;
dh = llh(:,3) - h;
87
% Some useful definitions

%-----------------------tmp1 = sqrt(1-e2*sin(phi)^2);
cl = cos(lam);
sl = sin(lam);
cp = cos(phi);
sp = sin(phi);
% Transformations
%---------------de = (a/tmp1+h)*cp*dlam - (a*(1-e2)/(tmp1^3)+h)*sp.*dphi.*dlam
+cp.*dlam.*dh;
dn = (a*(1-e2)/tmp1^3 + h)*dphi + 1.5*cp*sp*a*e2*dphi.^2 +
sp^2.*dh.*dphi + ...
0.5*sp*cp*(a/tmp1 +h)*dlam.^2;
du = dh - 0.5*(a-1.5*a*e2*cp^2+0.5*a*e2+h)*dphi.^2 - ...
0.5*cp^2*(a/tmp1 -h)*dlam.^2;
denu = [de, dn, du];
88
CHAPTER 5: CANSAT HARDWARE AND FIRMWARE

DEVELOPMENT
5.1 INTRODUCTION
The mission considered for the present CanSat under consideration is a data gathering
mission as presented in Chapter 2. This chapter will present the inference between
mbed and the different transducers connect to it. The MEMS transducer considered in
this mission is listed in Table 5-1. The appendices written in the last column of the table
it is for the full technical details of the corresponding transducer.
Table 5-1. Basic hardware for the Can-Sat Development
Component
Model
Note
2-Axis Gyro
LPR530AL
Appendix F
3 Axis
MMA7361LC
Appendix B
Accelerometer
Pressure Sensor
DSP 1000
Appendix D
GPS Module
GT-723F
Appendix E
5.2 SYSTEM ARCHITECTURE

Figure 5-1 shows the different interfaces between different hardware and the
microcontroller. In this chapter hardware implementation and firmware developments is
presented only for GPS, accelerometer, gyroscope, and pressure and temperature
sensor.
5.3 GPS
Chapter 4 provides a complete presentation to the GPS systems the GPS employed
here is GT-723F, shown in Figure 5-2. Only hardware implementation and firmware
class for the present GPS will be presented. Figure 5-3 shows the GPS-mbed circuit
diagram. The power source for GPS is taken from the mbed VU-5V output pin. General
purpose LI-PO 7.4V, 1300 mAh Li-Po Power pack is connected to the circuit with the
required regulator to provide 5 V and high current for servo and other on-board
electronics where the mbed output current is not enough. The jumper JP1 in the circuit
serve as hardware trigger for starting of the data gathering and storage from different
89
transducer. Software trigger can also be employed using accelerometer reading as the
value of acceleration goes to high during a rocket launch.
Figure 5-1 Hardware architecture of the CanSat
Figure 5-2 GPS GT-723F

The main program of mbed to interface with GPS is listed below along with the ccp and
h file needed to create the GPS class library as described in section 3.8 of chapter 3.
90
Figure 5-3 GPS circuit diagram

// Define the Libraries used in the program
#include "mbed.h"
#include "math.h"
#include "myGPS.h"
float temp;
// Define the Input and Output pins
// -------------------------------// Serial port for PC access
// ------------------------Serial pc(USBTX, USBRX);
//
// GPS pin assignment
// -----------------myGPS GPS(p13,p14);
int No_Sat;
float Direction_GPS;
float Speed_GPS;
float Latitude;
float Longitude;
float Altitude;
float T_Angle;
Ticker Send_data;
91
int main()
{
pc.baud(9600);
GPS.pc = &pc;
Send_data.attach(&Print_data,1);
while(1)
{
// endless loop for continuous reading of GPS data
}
}
void Print_data()
{
GPS.update();
No_Sat=GPS.Satnum;
Direction_GPS=GPS.Course;
Speed_GPS=GPS.Speed;
Latitude=GPS.Sec_Lat;
Longitude=GPS.Sec_Lon;
Altitude=GPS.Altitude;
T_Angle=GPS.Theta;
//RTC access
time_t seconds=time(NULL);
char buf[32];
//Print to PC
pc.printf("Time:, %s ,",buf);
pc.printf("GPS :, %2d, %.2f, %.2f, %.2f, %.2f, %.2f,
",No_Sat,GPS.Course, GPS.Speed , GPS.Sec_Lat, GPS.Sec_Lon,GPS.Altitude);
The CPP code

include "myGPS.h"
void myGPS::setTarget(float a,
{
T_Lat = a;
T_Lon = b;
}
void myGPS::update()
{
read_nmea();
chop_message(nmea1);
present_array();
float b)
92
chop_message(nmea2);
present_array();
}
myGPS::myGPS(PinName tx,PinName rx) :ser(tx,rx)
{
T_Lon = T_Lat= 0;
}
//--------------------read nmea from GPS unit-------------------void myGPS::read_nmea(void) {
//
//
char nmeabuff[100];
for(int i = 0; i< 5;i++)
do{
myGPS::ser.scanf("%s",nmea1);
}while(!((nmea1[2]=='P') and (nmea1[3]=='G') and (nmea1[4]=='G') and
(nmea1[5]=='A')));
// pc->printf("%s\r\n",nmea1);
do{
myGPS::ser.scanf("%s",nmea2);
}while(!((nmea2[2]=='P') and (nmea2[3]=='R') and (nmea2[4]=='M') and
(nmea2[5]=='C')));
// pc->printf("%s\r\n",nmea2);
}
//---------------- chop the nmea message separated by comma's----------int myGPS::chop_message(char nmea[]) {
for (int k=0; k<MAX_STR; k++) {
// just to make sure thet the
char array is set to 0x00
for (int l=0; l<STR_LEN; l++) {
gp[k][l]= 0x00;
};
}
int strcnt=0;
// string counter
int strpos=0;
// position inside the string
for (int k=0; k < MESS_LEN; k++) {
if (nmea[k] == '*') {
// detect end of message is
found
gp[strcnt][strpos]= 0x00;
// close the string with 0x00
return 0;
// the work is done, end of this
function
}
if (nmea[k] == 0x2c) {
// detect the comma
if (strpos == 0) {
gp[strcnt][0]= 'E';
// comma at position zero, string
must be empty
gp[strcnt][1]= 'm';
must be empty
gp[strcnt][2]= 'p';
must be empty
93
gp[strcnt][3]= 't';
gp[strcnt][4]= 'y';
must be empty
must be empty
gp[strcnt][5]= 0x00;
must be empty
} else {
gp[strcnt][strpos]= 0x00;
}
strcnt += 1;
strpos =0;
} else {
gp[strcnt][strpos]= nmea[k];
strpos += 1;
}
}
return 0;
}
// end the previous string

// increment to the next string
// start at position zero
// add char to string
// --------------- Dump only $GPGGA on the screen-----------------void myGPS::present_array() {

// --------------- Dump only $GPRMC on the screen-----------------if ((gp[0][2]=='P') and (gp[0][3]=='R') and (gp[0][4]=='M') and
(gp[0][5]=='C')) {
myGPS::Speed=(gp[7][0]-0x30)*100+(gp[7][1]-0x30)*10+(gp[7][2]0x30)+(gp[7][4]-0x30)/10.0; //10.0 giveg the floating point decimal
myGPS::Course=(gp[8][0]-0x30)*100+(gp[8][1]-0x30)*10+(gp[8][2]0x30)+(gp[8][4]-0x30)/10.0;
}
if ((gp[0][2]=='P') and (gp[0][3]=='G') and (gp[0][4]=='G') and
(gp[0][5]=='A')) {
int Lat_deg=(gp[2][0]-0x30)*10+(gp[2][1]-0x30);
int Lat_min=(gp[2][2]-0x30)*10+(gp[2][3]-0x30);
float Lat_sec=((((gp[2][5]-0x30)*1000+(gp[2][6]0x30)*100+(gp[2][7]-0x30)*10+(gp[2][8]-0x30)))/1000.000);
myGPS::Sec_Lat=Lat_deg*60*60+Lat_min*60+Lat_sec;
int Lon_deg=(gp[4][0]-0x30)*100+(gp[4][1]-0x30)*10+gp[4][2]0x30;
int Lon_min=(gp[4][3]-0x30)*10+(gp[4][4]-0x30);
float Lon_sec=((((gp[4][6]-0x30)*1000+(gp[4][7]0x30)*100+(gp[4][8]-0x30)*10+(gp[4][9]-0x30)))/1000.000);
myGPS::Sec_Lon=Lon_deg*60*60+Lon_min*60+Lon_sec;
#define PI 3.141592
myGPS::Theta=(PI-atan2((Sec_Lon-T_Lon),(Sec_Lat-T_Lat)))*180/PI;
myGPS::Satnum = (gp[7][0]-0x30)*10+(gp[7][1]-0x30);
myGPS:: Altitude = (gp[9][0]-0x30)*10000+(gp[9][1]0x30)*1000+(gp[9][2]-0x30)*100+(gp[9][3]-0x30)*10+(gp[9][4]-0x30)+(gp[9][6]0x30)*0.1;
}
}
94
The h code
include "mbed.h"
#define MESS_LEN
#define MAX_STR
#define STR_LEN
100
20
40
// maximum message length
class myGPS
{
public:
myGPS(PinName tx,PinName rx);
access this function;
//~myGPS();
// when you define the instance, you can

// when you deleted th
float Sec_Lon;
float Sec_Lat;
float Course;
float Speed;
float Theta;
int Satnum;
float Altitude;
Serial ser;
void setTarget(float, float);
void update();
Serial *pc;
private:
float T_Lon,T_Lat;
char nmea1[100];
char nmea2[100];
void read_nmea(void) ;
int chop_message(char []);
void present_array() ;
char gp[MAX_STR][STR_LEN];
};
5.4 ACCELEROMETER
Accelerometers, shown in Figure 5-4, are sensors and instruments for measuring,
displaying and analyzing acceleration and vibration. They can be used on a stand-alone
basis, or in conjunction with a data acquisition system. Accelerometers are available in
many forms. They can be raw sensing elements, packaged transducers, or a sensor
system or instrument, incorporating features such as totalizing, local or remote display
and data recording. Accelerometers can have from one to three axes of measurement,
the multiple axes typically being orthogonal to each other. These devices work on many
95
operating principles. The most common types of accelerometers are piezoelectric,

capacitance, null-balance, strain gauge, resonance, piezoresistive and magnetic
induction [3-2].
There are several physical processes that can be used to develop a sensor to measure
acceleration. In applications that involve flight, such as aircraft and satellites,
accelerometers are based on properties of rotating masses. In the industrial world,
however, the most common design is based on a combination of Newtons law of mass
acceleration and Hookes law of spring action.
The circuit diagram is shown in Figure 5-5 and the main, CPP and h codes are listed
below
Figure 5-4 Accelerometer MMA7361LC
Figure 5-5 Accelerometer and gyroscope circuit diagram
96

#include "mbed.h"
#include "math.h"
#include "myAccelero.h"
// Serial port for PC access
Serial pc(USBTX, USBRX);
float temp;
// Accelerometer pin assignment
AnalogIn x(p15);
AnalogIn y(p16);
AnalogIn z(p17);
DigitalIn Zero_g(p18);
//
myAccelero accel(p15,p16,p17); //x,y,z,0g
float X_g;
float Y_g;
float Z_g;
Ticker myticker;
Ticker Send_data;
void update()
{
X_g=accel.getAccelX();
Y_g=accel.getAccelY();
Z_g=accel.getAccelZ();
}
void Print_data()
{
//RTC access
char buf[32];
//Print to PC
pc.printf("Accel:, %.2f, %.2f, %.2f, ",X_g,Y_g,Z_g);
}
int main()
{
pc.baud(9600);
accel.setScale(myAccelero::SCALE_6G);
97
// Endless loop
while(1)
{
}
}
The cpp code

#include "mbed.h"
myAccelero::myAccelero(PinName xoutPin,PinName youtPin,PinName zoutPin):
xout(xoutPin),yout(youtPin),zout(zoutPin){/*,ZeroGDetect(ZeroGDetectPin),Zero
G(ZeroGDetectPin)*/
scale=0.8;
}
float myAccelero::getAccel(){
float x=getAccelX();
float y=getAccelY();
float z=getAccelZ();
return sqrt(x*x+y*y+z*z);
}
float myAccelero::getAccelX(){
return((xout*3.3)-1.65)/0.206;//-0.12;
}
float myAccelero::getAccelY(){
return((yout*3.3)-1.65)/0.206;//-0.11;
}
float myAccelero::getAccelZ(){
return((zout*3.3)-1.65)/0.206;//+0.04;
}
float myAccelero::getTiltX(){
float a=sqrt(x*x+y*y+z*z);
return asin(x/a)*180/ 3.141;
}
float myAccelero::getTiltY(){
return asin(y/a)*180/ 3.14;
}
float myAccelero::getTiltZ(){
98
return asin(z/a)*180/ 3.14;
}
void myAccelero::setScale(Scale scale){
switch (scale){
case SCALE_1_5G:
this->scale=0.8;
break;
case SCALE_6G:
this->scale=0.206;
break;
}
}
/*bool myAccelero::detectedZeroG(){
return zeroGDetect;
}
void myAccelero::setZeroGDetectListner(T* t, void(T::*func)(void)){
zeroG.rise(func);
}
template<typename T>void myAccelero::setzeroGDetectListner(T*
t,void(T::*func)(void)){
zeroG.rise(t,func);
}
*/
The h code
#ifndef myAccelero_H
#define myAccelero_H
#include "mbed.h"
class myAccelero{
public:
myAccelero(PinName xoutPin,PinName youtPin,PinName zoutPin);
enum Scale{SCALE_1_5G,SCALE_6G};
float getAccel();
float getAccelX();
float getAccelY();
float getAccelZ();
float getTiltX();
float getTiltY();
float getTiltZ();
//bool detectedZeroG();
//void setZeroGDetectListner(void(*func)(void));
//template<typename T>void setZeroGDetectListner(T* t,
void(T::*func)(void));
void setScale(Scale scale);
99
private:
AnalogIn xout,yout,zout;
//DigitalIn ZeroGdetect;
//InterruptIn zeroG;
float scale;
};
#endif
5.5 GYROSCOPE
Gyroscopes, shown in Figure 5-6, are used in various applications to sense either the
angle turned through by a vehicle or structure (displacement gyroscopes) or, more
commonly, its angular rate of turn about some defined axis (rate gyroscopes). The
sensors are used in a variety of roles such as:
Flight path stabilization

Autopilot feedback
Sensor or platform stabilization
Navigation.
Figure 5-6 Gyroscope LPR530AL

The circuit diagram is shown in Figure 5-5 and the main, CPP and h codes are listed
below
#include "mbed.h"
#include "math.h"
#include "myGyro.h"
float temp;
// Gyro sensor pin assignment
myGyro Gyro(p28,p27);
100
Ticker myticker;
Ticker Send_data;
void update()
{
Gyro.update();
}
void Print_data()
{
//RTC access
char buf[32];
//Print to PC
pc.printf("Gyro:, %.2f, %.2f, %.2f,%.2f, ",Gyro.x,Gyro.y,Gyro.z);
}
int main()
{
pc.baud(9600);
Gyro.pc = &pc;
Gyro.dt = 0.2;
Gyro.initialize();// Automatic initialization of gyro at the bigining,
Warning "Keep the gyro at rest at the beginning"
myticker.attach(&update,Gyro.dt);
// Endless loop
while(1)
{
}
}
The cpp code

#include "myGyro.h"
myGyro::myGyro(PinName a,PinName b) : gyro(a,
b),omega(0,0,0),Xaxi(1,0,0),Yaxi(0,1,0),Zaxi(0,0,1)
{
//omega(0,0,0),Xaxi(1,0,0),Yaxi(0,1,0),Zaxi(0,0,1)
}
myGyro::~myGyro()
{
;
}
void myGyro::initialize()
101
{
x0 = gyro.getGyroX();
y0 = gyro.getGyroY();
z0 = gyro.getGyroZ();
for(int i = 0 ; i < 99; i++)

{
x0 += gyro.getGyroX();
y0 += gyro.getGyroY();
z0 += gyro.getGyroZ();
}
x0/=100;
y0/=100;
z0/=100;
//pc->printf("avarage gyro values: %d %d %d\r\n",x0,y0,z0);
}
void myGyro::update()
{
int xn,yn,zn;
xn=gyro.getGyroX();
yn=gyro.getGyroY();
zn=gyro.getGyroZ();
x=(xn-x0)/14.375;
y=(yn-y0)/14.375;
z=(zn-z0)/14.375;
// pc->printf("gyro raw data : %d %d %d\r\n",xn,yn,zn);
myGyro::transform();
}
void myGyro::transform()
{
omega.set( x,y,z );
float o = sqrt(omega%omega);
omega = omega*(1./ (o==0?1:o));
o *= 2.;
// if o == 0 then 1 else o
Xaxi =(Xaxi-omega*(Xaxi%omega))*cos(toRad(o)*dt)
+(omega*Xaxi)*sin(toRad(o)*dt)
+omega*(omega%Xaxi);
Xaxi = Xaxi*(1./sqrt(Xaxi%Xaxi));
Yaxi =(Yaxi-omega*(Yaxi%omega))*cos(toRad(o)*dt)
+(omega*Yaxi)*sin(toRad(o)*dt)
+omega*(omega%Yaxi);
Yaxi = Yaxi*(1./sqrt(Yaxi%Yaxi));
Zaxi = Xaxi*Yaxi;
}
The h code
102
#include "mbed.h"
#include "math.h"
#define toRad(a) (a/180*3.1415)

#define toDeg(a) (a*180/3.1415)
class myGyro
{
public:
myGyro(PinName,PinName);
~myGyro();
void update();
void transform();
void initialize();
// constructor
// destructor
// update gyro data
class vector
{
public:
void set(float x,float y, float z)
{
vector::x=x;
vector::y=y;
vector::z=z;
}
vector(float x,float y, float z)
{
vector::x=x;
vector::y=y;
vector::z=z;
}
vector operator +(const vector& V)
{
return vector(x+V.x,y+V.y,z+V.z);
}
vector operator -(const vector& V)
{
return vector(x-V.x,y-V.y,z-V.z);
}
vector operator -()
{
return vector(-x,-y,-z);
}
vector operator *(const vector& V)
{
return vector(y*V.z-z*V.y,z*V.x-x*V.z,x*V.y-y*V.x);
}
vector operator *(const float& A)
{
return vector(x*A,y*A,z*A);
}
float operator %(const vector& V)
{
103
return x*V.x+y*V.y+z*V.z;
}
float x,y,z;
};
vector Xaxi;
vector Yaxi;
vector Zaxi;
float x,y,z;
float dt;
Serial *pc;
private:
int x0,y0,z0;
ITG3200 gyro;
vector omega;
};
5.6 PRESSURE AND TEMPERATURE TRANSDUCERS

Barometric pressure, shown in Figure 5-7, are invariably used for height measurement
in aircraft. As supplementary navigation aids, they are widely used for restricting the
growth of errors in the vertical channel of an inertial navigation system.
Figure 5-7 MEMS pressure sensor
104
The circuit diagram is shown in Figure 5-8 and the main is listed below. Online
SCP1000.lib class from mbed.org web site can be used for the present temperatue and
pressure transducer.
Figure 5-8 Pressure and Temperature circuit diagram

#include "mbed.h"
#include "math.h"
// Pressur sensor pin assignment
105
SCP1000 scp1000(p5,p6,p7,p8);
float temp;
int press;
Ticker myticker;
Ticker Send_data;
void update()
{
temp=scp1000.readTemperature();
press=scp1000.readPressure();
}
void Print_data()
{
//RTC access
char buf[32];
//Print to PC
pc.printf("Temp:, %.2f, Press:, %d\r\n",temp,press);
}
int main()
{
pc.baud(9600);
while(1)
{
}
}
5.7 SYSTEM INTEGRATION

Figure 5-9 present the circuits diagram for all the MEMS sensors described above. The main
program is listed below to print the reading through the PC serial port through the
HyperTerminal. The code will be extended to include sending the data to the ground station PC
in Chapter 7 section 7.5.
106
Figure 5-9 Complete circuit Diagram

#include "mbed.h"
#include "SCP1000.h"
#include "math.h"
#include "myGPS.h"
#include "myGyro.h"
SCP1000 scp1000(p5,p6,p7,p8);
float temp;
int press;
// Gyreo sensor pin assignment
//ITG3200 Gyro(p28,p27);
AnalogIn x(p15);
AnalogIn y(p16);
AnalogIn z(p17);
//GPS pin assignment
107
myGPS GPS(p13,p14);
//int i;
int No_Sat;
float Speed_GPS;
float Latitude;
float Longitude;
float Altitude;
float T_Angle;
// Motor variables
float propeller=0.0;
float rudder=0.5;
float elevator=0.5;
float para_sw=0.5;
//
float X_g;
float Y_g;
float Z_g;
Ticker myticker;
Ticker Send_data;
void update()
{
Gyro.update();
}
void Print_data()
{
GPS.update();
No_Sat=GPS.Satnum;
T_Angle=GPS.Theta;
//RTC access
char buf[32];
108
// wait(0.01);
//Print to PC
",No_Sat,GPS.Course, GPS.Speed , GPS.Sec_Lat, GPS.Sec_Lon,GPS.Altitude);
pc.printf("Gyro:, %.2f, %.2f, %.2f,%.2f, ",Gyro.x,Gyro.y,Gyro.z);
pc.printf("Motor:, %.2f,%.2f,%.2f,%.2f,
",propeller,rudder,elevator,para_sw);
}
109
CHAPTER 6: PARACHUTE DESIGN

6.1 INTRODUCTION
Parachute is a crucial element during the CanSat mission. Achieving both the desired
descent rate and stable decent are key parameters in parachute design, See Figure 6-1.
This chapter will introduce the basic theory and technique for designed a parachute for
a CanSat mission.
Figure 6-1 stable descending of parachute with CanSat

during the Japanese high school CanSat Championship
CanSat Koshien in 2011.
6.2 FORCES ACTING ON THE PARACHUTE

Forces and moments acting on a parachute canopy may be presented in several
ways. The two most frequently used methods, as shown in Figure 6-2, are with forces
oriented to the axis of flight and with forces oriented to the axis of the parachute canopy.
The tangential force, T: and the normal force, N, are calculated as follows
T = CT S q
(6-1)
N = CN S q
(6-2)
and
110
Where
CT = tangential force coefficient, dimensionless
CN = normal force coefficient, dimensionless
The resultant force, R, and the moment, M, are shown in the. The airflow fixed
system is preferred for aerodynamic performance calculations, and the parachute fixed
system for wing stress calculations. The aerodynamic coefficients CL> CD, CT, CN, and
CM can easily be determined in wind-tunnel measurements.
Figure 6-2 Forces Acting on a Parachute [6-1].

Wind-tunnel installations frequently measure normal and tangential force instead of
lift and drag. If , T, and N are known, the drag, D, can be calculated
D = T cos + N sin
(6-3)
For a parachute with an angle of attack, equal to zero, the drag force and the
tangential force are synonymous. Figure 6-3 shows the coefficients CT, CD, and CM
versus angle of attack for stable and unstable parachutes.
The coefficient presentation shows two interesting facts. The slope of the moment
coefficient curve, dCM/d for the unstable parachute is positive between -25 degrees
and +25 degrees; this is, by definition, destabilizing. This parachute will oscillate
approximately 25 degrees. The slope of the moment coefficient, dCM/d, for the stable
parachute is negative over the total angle of attack; this is, by definition, stabilizing. The
steeper the negative dCM/d slope, the greater is the stabilizing tendency of the
parachute, and the better is its damping capability against unstabilizing forces such as
sudden gusts of wind.
111
Figure 6-3 Coefficients CD, CT, and CM Versus Angle of Attack, , for Stable and
Unstable Parachute [6-1].
6.3 EQUILIBRIUM OF FORCES IN STEADY DESCENT

A stable parachute in unaccelerated descent has an equilibrium between the total
drag of the parachute and the load, DT, and the weight of the load and the parachute
assembly, W T (Figure 6-4). For steady descent
Figure 6-4 Forces Acting on a Parachute in

Steady Descent
DT
= WT or Dp + DL = Wp + WL
Where
DT = total drag, N
112
Dp = drag of parachute,N
DL = drag of load, N
WT= total weight, N
Wp= weight of parachute, N
WL= weight of load, N
In most cases, the drag of the load can be neglected in relation to the large drag of the
parachute. With drag, D = (CDS)P /2 v2 and DT = W T, and solving for v, the important
equation for rate of descent, ve, is obtained.
Ve
(6-4)
2W
SC D
Or in parachute terminology for rate of descent at sea level
Veo
2W
S o C Do o
(6-5)
And rate of descent at any altitude
Ve
2W
S o C Do o
(6-6)
/ o
Where o is the density at the sea level

In the above equation for the rate of descent, Ve
WT = weight of load and parachute assembly, N
So = canopy surface area, S2
CDO = parachute drag coefficient related to So
= air density at a specific altitude in kg/m3
During descent from altitude, the parachute system is constantly decelerated
because of the increasing air density. This can be ignored for slowly descending main
parachutes.
6.4 PARACHUTE CHARACTERISTICS AND PERFORMANCE

Parachute is a crucial element of any CanSat mission. Their performance
characteristics must be known and considered in calculating the descent rate. In the
early 19208, the circular, flat parachute manufactured from solid cloth was the primary
parachute used for the rescue of aviators, for sport jumping, and for airdrop of light
loads. In the 19305, the military began using parachutes for the airdrop of troops and
cargo and for the landing
113
deceleration of aircraft. Beginning in the 194Os, parachutes were used for recovery of
unmanned aircraft, missiles, ordnance devices, and, later, recovery of manned and
unmanned spacecraft.
Constructed Shape: The Plan and Profile columns define the constructed diameter
and the cross section of the parachute canopy.
Dc, the constructed diameter of the canopy, can be obtained from the drawing of the
specific parachute.
Nominal Diameter: Do, the nominal diameter of the parachute, can be calculated from
the total canopy surface area, So, including the area of the vent and all other openings:
Do 4S o / 1.1284 S o
(6-7)
Inflated Shape: Dp, the projected diameter of the inflated parachute canopy, is best
calculated from the projected or inflated canopy area, S p. as measured in wind-tunnel
tests. The projected diameter of a parachute varies with parachute type, canopy
porosity, suspension-line length, velocity, and canopy design. A large projected
diameter, Dp, will generally result in a large drag coefficient, CDo. The ratio of projected
diameter to nominal diameter, Dp/Do, is an indication of the drag effectiveness of the
parachute design; the larger the projected diameter in relation to the normal diameter,
the larger the drag coefficient.
Drag Coefficient: CDo is the drag coefficient related to the total canopy surface area, So,
The drag coefficient indicates how effectively a parachute canopy produces drag with a
minimum of cloth area, thereby minimizing weight and volume.
Opening-Force Coefficient. Cx, the opening-force coefficient, indicates the difference
between the instantaneous opening force and the steady drag force at constant speed.
This condition, called the infinite mass case, is obtained in wind-tunnel tests and in
parachute applications with high canopy loadings, W/(CdS)p. as exemplified by aircraft
deceleration parachutes and first-stage drogue chutes.
Average Angle of Oscillation. The angle of oscillation is measured in wind-tunnel tests
or during free-flight tests. Oscillation on most solid textile parachutes varies with size
and descent velocity. Large parachutes oscillate less than small parachutes. Unstable
parachutes tend to descend in an oscillating mode at rates of descent in excess of 7.62
m/s, glide at descent General Application. The general application column in Table 6-1
through 6-5 indicates the primary use of the particular parachute type. In descent rates
below 4.572 m/s, and mix glide and oscillation during medium rates of descent.
General Application. The general application column in Table 6-1 through 6-5
indicates the primary use of the particular parachute type.
Sw in Table 6-4 is the wetted upper canopy surface area on gliding parachutes.
Sw/So in Table 6-4 is the ratio of the upper surface area to total cloth area, including all
ribs and stabilizer panels.
114
Table 6-1 Solid Textile Parachute
115
Table 6-2 Slotted Parachute
Table 6-3 Rotating Parachute
116
Table 6-4 Maneuverable (Gliding) Parachute
Table 6-5 Balloon Type decelerator
6.5 PARACHUTE SIMULATION DURING DESCENDING

The partial differential equation which governs the parachute descending motion can be
written as:
117
C
dv
g D v
dt
m
dy
v
dt
(6-7)
Where
m = mass of parachutist
c = drag coefficient
g = gravitational acceleration
The results of the simulation are shown in Figure 6-5. The parachute is dropped from
500 meters altitude and has a mass of 1Kg and CD of 0.75 after opening. The chute
opens after 3 second in this simulation. The terminal (descent) velocity is 5.211 which in
an excellent agreement with the value computed using equation 6-4 which is 5.21176
m/sec. The total descending time for this CanSat is about 100 seconds.
Parachute Velocity & Position Vs Time (ODE23 solution)
velocity (m/sec)
15
10
10
20
30
40
50
60
70
80
90
100
110
10
20
30
40
50
60
time (sec)
70
80
90
100
110
distance (km)
1.5
0.5
Figure 6-5 Parachute velocity and position versus time;

parachute mass = 1kg, Cd after opening = 0.75; parachute
opening after 3 sec.
The MATLAB program and its associated function are listed below.
%
%
%
PCHUT.M
Simple Simulation of a Falling Parachutist
118
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
In this Matlab file a discontinuous change in the drag coefficient is used to

simulate the opening of the parachute at some user-defined time after the
initiation of free fall.
However, in this case, the numerical integration of the first order ODEs is
performed with a standard ODE solver built into Matlab - the ODE23 routine.
ODE23 uses a higher order approximation for the derivative terms and it uses
a technique referred to as "adaptive step control" to adjust the integration
interval during the calculation to guarantee that a desired error criterion is
satisfied. This makes life much easier, because now we do not have to
explicitly discretize the original ODEs and we do not have to worry about
picking a suitable integration step that gives good accuracy. Instead, we
simply give ODE23 information about the original ODEs, specify the desired
error limit and let it go from there.
In this case the defining eqns. are:
dv/dt = g - (0.5 Rho A Cd/m)v^2
and
where
m = mass of parachutist
Cd = drag coefficient
g = gravitational acceleration
Rho = air density
A
= reference area
dy/dt = v
Note that these can be written as

dz(1)/dt = z(2)
and
dz(2)/dt = g - (c/m)z(2)
where
z(1) = y
and
z(2) = v
This second form, which is referred to as standard state form, is the
one used by the ODE23 routine. These equations are included in the ODE
function file PCHUTA.M.
File prepared by J. R. White, UMass-Lowell (original Sept. 1997)
getting started
clear all,
close all,
nfig = 0;
set properties
global m g c1 c2 topen
m = 0.25;
% mass of parachutist (kg)
d = 1;
% parachute diameter (m)
A = 0.25*pi*d*d; % parachute reference area (m^2)
Rho = 1.225
% air density (kg/m^3)
Cd = 0.15
% Drag coefficient w/o chute
c1 = 0.5*Rho*Cd*A;
% nominal drag coefficient with no chute (kg/sec)
c2 = 5*c1;
% nominal drag coefficient with chute open (kg/sec)
g = 9.8;
% acceleration due to gravity (m/s^2)
pos = 0.5;
% initial height (km)
tol = 1.0e-3;
% max relative error allowed in solution
set time interval of interest, initial conditions, and time to open chute
to = 0;
tf = 600.0; % initial and final times (sec)
zo = [0 0]'; % initial position (m) and velocity (m/s) in vector form
disp(' Initially you are at a height of 500 m above ground.')
topen = input(' Input time for parachute to open (< 600 sec) : ');
call ODE23 to solve problem (original ODEs are in function file PCHUT3A.M)
options = odeset('RelTol',tol);
[t,z] = ode23('pchut4a',[to tf],zo,options);
plot velocity and position vs time
nfig = nfig+1;
figure(nfig)
subplot(2,1,1), plot(t,z(:,2),'b-'), grid, axis([to tf 0 10]);
119
title('CanSat Velocity & Position Vs Time (ODE23 solution)')

ylabel('velocity (m/sec)')
subplot(2,1,2), plot(t,pos-z(:,1)/1000,'r-'), grid
axis([to tf -pos/10 pos+1]);
ylabel('distance (km)'),xlabel('time (sec)')
%
%
%
end of simulation
The function PCHUTA.M is listed below

%
%
%
%
%
%
%
%
%
%
%
%
PCHUTA.M
Function for ODE to Evaluate Falling Parachutist Equations

(called from ODE23 in PCHUT.M )
The defining eqns are (in standard state form):

dz(1)/dt = z(2)
dz(2)/dt = g - (c/m)z(2)
where the value of c is time dependent (piecewise constant)
File prepared by J. R. White, UMass-Lowell (original Sept. 1997)
function zp = pchuta(t,z)
global m g c1 c2 topen
if t < topen
c = c1;
else
zp = zeros(length(z),1);
zp(1) = z(2);
zp(2) = g - (c/m)*z(2)*z(2);
%
%
%
c = c2;
end of function
120
end
CHAPTER 7: CANSAT LAUNCHERS

6.1 INTRODCUTION
Usually Can-Sat can be launched using one of the following methods:
1.
2.
3.
4.
Model rocket
RC model airplane
Balloon
High raise building
The advantages and disadvantage of each launching option will be disscusse and techniques to
design Water rocket laucher and ballon for launching will be given
. To be contined
121
CHAPTER 8: GROUND STATION DEVELOPMENT

7. 1 INTRODUCTION
This chapter describes how you can communicate the CanSat to a ground station and send
command to the CanSat as well as receive the collected data from it. MATLAB development
environment used to develop the ground station GUI software. A commercial ly available RF
communication module called XBEE-PRO having a range of 1500 meters (line of sight) is presented.
The configuration procedures to for the RF communication module are presented in a step by step
way.
7.2 GROUND STATION SYSTEM ARCHITECTURE

Figure 7-1 shows the basic elements to RF communication between the CanSat and
ground station PC. The communication cycle consists of:
1. CanSat with XBEE-PRO module connected with mbed as will be described later
(full hardware specification of XBEE-PRO is presented in Appendix G)
2. Computer
3. XBEE-Explorer unit
4. XBEE-PRO module connected to the computer through the XBEE-Explorer and
USB-Cable
Figure 7-1 Ground Station System Architecture

122
The two XBEE-PRO modules are similar and before connection to both the CanSat and
PC they must be paired first and this will be described the next section. Hardware and
firmware development for the XBEE-PRO with mbed will be presented. Finally the
software for the ground station PC using MATLAB PC will be presented.
7.3 PARING THE RF-COMMUNICATION MODULES (XBEE-PRO)

Radio module / radio modem is used to transmit the status/position of a CanSat to a ground
control station.
XBee-Pro modules from Digi International can be used in two modes: In one mode they
represent a mesh network. This is however not used by most users. In the mostly used
wireless serial link mode, they forward data on their serial interface via wireless to a
paired module.
This allows sending serial data wireless. Make sure to configure your mbed with the
same settings as your ground control station PC and the Xbee-Pro modules.
7.3.1 RECOMMENDED SETTINGS

For the 2.4 GHz v2.0/v2.5 modules:
Baud: 9600
Parity: N (none)
Data bits: 8
Stop bits: 1
Abbreviation for this mode: 57600 8N1
7.3.2 INSTALLATION
The simplest way to install the Xbee-Pro modules is to use X-CTU (XCTU) software [71]. This is a windows software from the manufacturer of the XBee-Pro modules and its
very simple to use. Then just connect theUSB XBee Explorer, described above, to your
windows computer. Now you can flash your XBee-Pro modules. If the program asks you
to reset the XBee-Pro, you have to connect the RST pin to the GND pin of the XBee
Explorer. You can make this with tweezers.
7.3.3 SETTING UP A SERIAL CONNECTION

For setting up a serial connection with the XBee-Pro you have to flash one module with
the coordinator AT firmware and the other with the router or end-device AT firmware.
7.3.4 COMM SETTINGS

123
1.
2.
3.
4.
Choose the first available USB serial port (e.g. COM15)

Leave all the default options, set the speed to 9600 baud
Click on Test/Query
You should get the modem firmware revision
7.3.5 FLASHING THE CANSAT MODULE

1. Put in the first module in the USB XBee Explorer. This will be the module for the
end device.
2. Start the X-CTU program and go to the modem configuration.
3. Select the function set ZNET 2.5 ROUTER/END DEVICE AT. The Mesh XBee
modules (XBP24-DM) have slightly differently named settings.
4. Set the pan id to 123 (or another number, must be the same as the pan id of the
coordinator). The PAN ID setting for XBP24-DM is named Modem VID.
5. Set the Node Identifier to CANSAT or another name.
6. Set the Baudrate you want to use. The ground station and the CANSAT module
should have the same Baudrate. Also you need to know what Baudrate the
current attached XBee-Pro has. 9600 is the maximum Baudrate setting for
bidirectional transfers to work correctly. At a higher Baudrate setting,
transmission can only be done in one direction.
7. Then write the firmware to the module
124
Figure 7-2 Flashing the CanSat Module
7.3.6 FLASHING THE GROUND STATION PC MODULE

1. Now put the groundstation module in the USB XBee Explorer.
2. Select the function set ZNET 2.5 COORDINATOR DEVICE AT. The Mesh XBeePro modules (XBP24-DM) have slightly differently named settings.
3. Set the pan id to 123 (or another number, must be the same as the pan id of the
end device). The PAN ID setting for XBP24-DM is named Modem VID.
4. Set the Destination Address Low (DL) to FFFF.
5. Set the Node Identifier to GROUNDSTATION or another name.
6. Set the Baudrate you want to use. The ground station and the MAV module
should have the same baudrate. Also you need to know what Baudrate the
current attached XBee-Pro has. 9600 is the maximum Baudrate setting for
125
bidirectional transfers to work correctly. At a higher Baudrate setting,

transmission can only be done in one direction.
7. Then write the firmware to the module.
Figure 7-3 Flashing Ground Station PC Module
126
7.3.7 CONNECTING THE XBEE MODULE TO YOUR MAV

Now you have to connect the CANSAT module to your board. You just need four wires.
One for ground, one for high level, one for RX and TX. Connect the DIN pin from the
XBee-Pro module to the TX pin of your board and connect the DOUT pin with the RX
pin.
7.4 INTERFACING MBED WITH XBEE-PRO

Figure 7.4 shows the wire connection of mbed to XBEE-PRO
Figure 7-4 Wire Connection between mbed and XBEE-PRO

The following is a simple mbed code to send the word Hello World to ground station
PC and the local PC connected to mbed, for development, upon pressing the reset
button of the mbed. HyperTerminal should be open on the ground station PC and the
port connected to the XBEE-Explore should be assigned, Figure 7.5 shows the output
upon pressing the reset button on the ground station PC.
#include "mbed.h"
127
// Xbee Tranceiver pin Assignment

Serial xbee(p9,p10);
DigitalOut rst1(p11); // Digital reset for the XBee, 200ns for
reset
int main()
{
pc.baud(9600);
xbee.baud(9600);
//Print to PC
pc.printf("Hello World\n");
//MatLab output
xbee.printf("Hello World");
Figure 7-5 HyperTerminal application shows a Hello World

written using another PC and send through the wireless module
XBEE-PRO.
7.5 SYSTEM INTEGRATION

In the section a revised version of the main code written in section 5.7 in chapter 5 to
include sending the data to the cround station PC through XBEE -PRO RF
communication module is presented. The revised code will be as follows:
#include "mbed.h"
#include "SCP1000.h"
#include "math.h"
#include "myGPS.h"
#include "myGyro.h"
128

SCP1000 scp1000(p5,p6,p7,p8);
float temp;
int press;
// Gyreo sensor pin assignment
//ITG3200 Gyro(p28,p27);
AnalogIn x(p15);
AnalogIn y(p16);
AnalogIn z(p17);
//GPS pin assignment
myGPS GPS(p13,p14);
//int i;
int No_Sat;
float Speed_GPS;
float Latitude;
float Longitude;
float Altitude;
float T_Angle;
// Xbee Tranceiver pin Assignment
Serial xbee(p9,p10);
DigitalOut rst1(p11); // Digital reset for the XBee, 200ns for
reset
//
float X_g;
float Y_g;
float Z_g;
Ticker myticker;
Ticker Send_data;
void update()
{
Gyro.update();
129
}
void Print_data()
{
GPS.update();
No_Sat=GPS.Satnum;
T_Angle=GPS.Theta;
//RTC access
char buf[32];
// wait(0.01);
//Print to PC
",No_Sat,GPS.Course, GPS.Speed , GPS.Sec_Lat,
GPS.Sec_Lon,GPS.Altitude);
pc.printf("Gyro:, %.2f, %.2f, %.2f,%.2f,
",Gyro.x,Gyro.y,Gyro.z);
//MatLab output
xbee.printf("%s, ",buf);
xbee.printf("%2d, %.2f, %.2f, %.2f, %.2f, %.2f, ",No_Sat,
Direction_GPS, Speed_GPS ,Latitude,Longitude,Altitude);
xbee.printf("%.2f, %.2f, %.2f, ",Gyro.x,Gyro.y,Gyro.z);
xbee.printf("%.2f, %.2f, %.2f, ",X_g,Y_g,Z_g);
xbee.printf("%.2f, %.2f\r\n",temp,press);
}
int main()
{
pc.baud(9600);
xbee.baud(9600);
GPS.pc = &pc;
Gyro.pc = &pc;
Gyro.dt = 0.2;
130
Gyro.initialize();// Automatic initialisation of gyro at the

bigining,Warning "Keep the gyro at rest at the begining"
accel.setScale(myAccelero::SCALE_6G);
// xBee Initialisation
rst1
=0; //Set reset pin to 1
wait(1); //Wait at least one millisecond
rst1
= 1; //Set reset pin to 1
wait(1); //Wait another millisecond
myticker.attach(&update,Gyro.dt);
while(1)
{
wait(0.1);
7.6 GROUND STATION SOFTWARE

Figure 7.6 shows an example of GUI software written using Matlab on the ground station PC.
The program receives all the data from CanSat and plots it on real-time as well as save it in a
log file. The program is written below.
131
Figure 7-6 Matlab Ground Station GUI Software

% ----------------------------------------------------------------------%
% Ground Station Monitoring M-File for CanSat Leadership Training Program
% By: Mohammed Khalil Ibrahim
% On: 4th March 2011
%
Wakayama University, Wakayama, Japan
% -----------------------------------------------------------------------%
%
% First Configure the COM port to receive data from the XBEE and collect
% data
% ---------------------------------------------------------------------%
clear all;
global DATA;
global XBEE;
fp1 = fopen('gs_plot.log', 'w');
Rearth = 6367*1000; % Earth radius in meter [m]
% Initializing;
% -----------time_old = 0;
% Accelerations
% ------------AX_old = 0;
AY_old = 0;
AZ_old = 0;
% Angular Velcoity
132
% ---------------WX_old = 0;
WY_old = 0;
WZ_old = 0;
% Pressure
% -------P_old = 100000;
% Temperature
% ----------T_old = 15;
% GPS data
% --------X_Target = 0;
Y_Target = 0;
Z_Target = 0;
LONG_TARGET = 10*pi/180;
LATI_TARGET = 10*pi/180;
% TARGET POSITION must be in rad.

% TARGET POSITION must be in rad.
X_old = 100;
Y_old = 100;
Z_old = 100;
% Controls
% -------RDRC_old =
ELVC_old =
PROP_old =
PARA_old =
0;
0;
0;
0;
clc;
fprintf('Communication with CanSat is ready... \n');
A=input('Hit any key to start to start. Press 0 then Enter key to
exit.\n','s');
if strcmp(A,'0')
break
end;
scrsz = get(0,'ScreenSize');
H = figure('Position',[50 50 scrsz(3)-100 scrsz(4)-150],'Name','Come-Back
CanSat Ground Station','NumberTitle','off');
while 1
XBEE = 0;
COMPORT = serial('COM10','BaudRate', 9600,'Parity', 'none','DataBits',8,
'StopBits',1);
COMPORT.Terminator = 'CR/LF';
COMPORT.BytesAvailableFcnMode = 'terminator';
COMPORT.BytesAvailableFcn = @Xbee;
COMPORT.timeout = 300;
fopen(COMPORT);
pause(0.6)
fprintf('Data from the main program = %s \n',DATA);
fclose(COMPORT);
133
delete(COMPORT);
LDATA= size(DATA);
VAR_START = findstr(DATA, ',');
NVAR = size(VAR_START);
NVAR(2)
% Assign the Varibale
% hh:mm:ss, GPS:,No. of Sat,Course,Speed, Latitude, Longitude,Altitude,
Gyro:,Wx,Wy,Wz, Accel:, Ax,Ay,Az, Motor:,RDR,ELV,PROP,PARA
if
NVAR(2) ==
TIME_STR =
NSAT_STR =
SPED_STR =
CORS_STR =
LATI_STR =
LONG_STR =
ALTI_STR =
WX_STR =
WY_STR =
WZ_STR =
AX_STR =
AY_STR =
AZ_STR =
RDRC_STR =
ELVC_STR =
PROP_STR =
PARA_STR =
T_STR
=
P_STR
=
18
DATA(1:VAR_START(1)-1);
DATA(VAR_START(1)+1:VAR_START(2)-1);
DATA(VAR_START(18)+1:LDATA(2));
LTIME = size(TIME_STR)
if LTIME(2) > 8
TIME_START = findstr(TIME_STR,':');
HOURS_STR
= TIME_STR(1:TIME_START(1)-1);
MINUTES_STR = TIME_STR(TIME_START(1)+1:TIME_START(2)-1);
SECONDS_STR = TIME_STR(TIME_START(2)+1:LTIME(2));
time_new =
str2num(SECONDS_STR) + 60 * str2num(MINUTES_STR) +
3600 * str2num(HOURS_STR); % Time in Seconds
if time_old == 0
time_old = time_new;
fprintf('NEW TIME CALCULATED 1\n');
continue;
end
end
fprintf('New point will be drawn\n');
time_new
time_old
%
% Write the raw data to a FILE here
% ---------------------------------
134
AX_new = str2num(AX_STR);
AY_new = str2num(AY_STR);
AZ_new = str2num(AZ_STR);
WX_new = str2num(WX_STR);
WY_new = str2num(WY_STR);
WZ_new = str2num(WZ_STR);
P_new
T_new
= str2num(P_STR);
= str2num(T_STR);
LATI = str2num(LATI_STR)*pi/(180*60*60);
LONG = str2num(LONG_STR)*pi/(180*60*60);
ALTI = str2num(ALTI_STR);
X_new
Y_new
Z_new
= Rearth*(LONG - LONG_TARGET);% CALCULATION IS NEEDED

= Rearth*(LATI - LATI_TARGET);% CALCULATION IS NEEDED
= str2num(ALTI_STR);% CALCULATION IS NEEDED
RDRC_new
ELVC_new
PROP_new
PARA_new
=
=
=
=
str2num(RDRC_STR);
str2num(ELVC_STR);
str2num(PROP_STR);
str2num(PARA_STR);
time_new
AX_new =
AY_new =
AZ_new =
= time_old;
AX_old;
AY_old;
AZ_old;
else
WX_new = WX_old;
WY_new = WY_old;
WZ_new = WZ_old;
P_new
T_new
= P_old;
= T_old;
X_new
Y_new
Z_new
= X_old;
= Y_old;
= Z_old;
RDRC_new
ELVC_new
PROP_new
PARA_new
=
=
=
=
RDRC_old;
ELVC_old;
PROP_old;
PARA_old;
end
%
% Decode the data from the stream of received from the COM Port
% ------------------------------------------------------------%
% Image
% ----subplot(4,4,16);
rgb = imread('Ground_Station.jpg');
135
image(rgb);
axis off
axis image
hold on;
% Remove axis ticks and numbers

% Set aspect ratio to obtain square pixels
%
% Plot the data
% ------------%
% Check that the time is 0
% GPS Data
% -------subplot(4,4,[3 4 7 8]);
plot3([X_old X_new], [Y_old Y_new], [Z_old Z_new],'r-');
GRID ON
title('Come-Back CanSat Trajectory');
hold on;
plot3(X_Target, Y_Target,
Z_Target,'ro','MarkerSize',20,'MarkerFaceColor','r');
hold on;
% X-Acceleration
% -------------subplot(4,4,1);
plot([time_old time_new], [AX_old AX_new],'b--');
title('X-Linear Acceleration');
hold on
% Y-Acceleration
% -------------subplot(4,4,2);
plot([time_old time_new], [AY_old AY_new],'b--');
title('Y-Linear Acceleration');
hold on
% Z-Acceleration
% -------------subplot(4,4,5);
plot([time_old time_new], [AZ_old AZ_new],'b--');
title('Z-Linear Acceleration');
hold on;
% Angular Acceleration in x-direction
% ----------------------------------subplot(4,4,6);
plot([time_old time_new], [WX_old WX_new],'g-');
title('X-Angular Acceleration');
hold on
% Angular Acceleration in y-direction
% ----------------------------------subplot(4,4,9);
plot([time_old time_new], [WY_old WY_new],'g-');
title('Y-Angular Acceleration');
hold on
136
% Angular Acceleration in z-direction

% ----------------------------------subplot(4,4,10);
plot([time_old time_new], [WZ_old WZ_new],'g-');
title('Z-Angular Acceleration');
hold on;
% Pressure
% -------subplot(4,4,11);
plot([time_old time_new], [P_old P_new],'c:');
title('Pressure in Pascal [N/{m^2}]');
hold on;
% Temperature
% ----------subplot(4,4,12);
plot([time_old time_new], [T_old T_new],'m-.');
title('Temperature in {C^o}');
hold on;
% Propeller Power
% --------------subplot(4,4,13);
plot([time_old time_new], [PROP_old PROP_new],'m-.');
title('Propeller Power');
hold on;
% Rudder Deflection
% ----------------subplot(4,4,14);
plot([time_old time_new], [RDRC_old RDRC_new],'m-.');
title('Rudder Deflection in deg.');
hold on;
% Elevator Deflection
% ----------------subplot(4,4,15);
plot([time_old time_new], [ELVC_old ELVC_new],'m-.');
title('Elevator Deflection in deg.');
hold on;
pause(0.2);
% mtit('ETAS Come-Back Ground Station PC',
'fontsize',18,'xoff',0,'yoff',.03,'color',[0.5 0 0]);
%
% UPDATE
% -----%
% Acceleration - Acceleromter
% --------------------------AX_old = AX_new;
137
AY_old = AY_new;
AZ_old = AZ_new ;
% Angular Velcoity; Gyro Data
% --------------------------WX_old = WX_new;
WY_old = WY_new;
WZ_old = WZ_new;
% Pressure
% -------P_old = P_new;
% Temperature
% ----------T_old = T_new;
% GPS data
% --------X_old = X_new;
Y_old = Y_new;
Z_old = Z_new;
% Time
% ---time_old = time_new;
RDRC_old
ELVC_old
PROP_old
PARA_old
%
%
%
=
=
=
=
RDRC_new;
ELVC_new;
PROP_new;
PARA_new;
SAVE THE DATA FILE

------------------
fprintf(fp1,'%f, %f , %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f\
n',time_new, X_new, Y_new, Z_new, AX_new, AY_new, AZ_new, WX_new, WY_new,
WZ_new, P_new, T_new, RDRC_new, ELVC_new, PROP_new, PARA_new );
%
% Close the serial port
%
end
fclose(fp1);
138
CHAPTER 9: MECHANICAL CONSTRUCTION

9.1 INTRODUCTION
The volume constraints for the any CanSat design are either 350 ml or 500 ml
can with maximum mass of about 1 Kg. A hard- foam was used to fill and support the
main PCB with microcontrollers and different MEMS sensors, batteries and Camera
inside Can. The RF-communication module and GPS was fixed outside the can and
guarded by soft foam. The final Can-Sat was tested several times with parachute had
high descent rate which resulted in a shock when touching the ground and it survived
the shock.
9.2 STRUCTURAL DESIGN

During mechanical construction of CanSat one must always take into
consideration the mass budget and the size of the CanSat. In most of the competitions
you need to launch your CanSat from 10-15 (?) cm diameter rockets. In addition to that
the mechanical structure of the CanSat must provide an adequate space to contain the
vulnerable electronic components. The design should protect it from shocks by
absorbing some of the energy that is generated during launch, release and parachute
deployment and landing.
The CanSat must have a mass of no more than 1000 g; considering its relatively
low weight and the small distance it will possibly fall, a wide range of material could be
considered as appropriate to fulfil the requirements, plastics and many different metals
would be suitable. 350 ml or 500 ml volume can may be used or you can manufacture
your own design cansat from different light-weight metal or composite materials such as
glass fabric, carbon composit or alumininum. Aluminium or aluminium alloys provide the
rigid structure desired while being light-weight, non-brittle commonly available and
cheap.
139
Figure 9-1 Cansat made of carbon composite

(Turkish Air Force Academy Team.
For a CanSat there is no need for thermal insulation if you are not going to send
the CanSat to an altitude of more than 1000 m. The temperature will not drop more than
6-7 degrees compare to ground temperature. For higher altitudes, such as she
temperature in the stratosphere (216 K) is significantly lower than the temperature on
ground. A CanSat that will be sent to such an altitude will be facing low temperature
condition which may threaten sensors to work properly. In order for this CanSat to be
successful, it must ensure that the electronic components (which are designed to
operate at around sea level temperatures) are not damaged and operate as long as
possible. This will be achieved by insulating the can to slow the temperature loss.
For the electronics, the PCB board should not be in direct contact with the outer
surface fo the CanSat. Applying soft materials, such as foam or some kind of insulating
material, on the edges of the frame holding the PCB boards, the shock will be more
dispersed. The space remaining will contain sensors and the batteries. The sensors will
need to be arranged so that they can still take data. The batteries can be firmly
connected to foam and supported by CanSat walls preventing from moving.
For the effective use of the instrumentation, they need to be positioned where
they can act correctly. This requires careful consideration of safety, operating
temperatures and other environmental factors.
The pressure sensor has a minimum operating temperature of aronud 233K .
This sensor requires access to the outside environment to take true readings of
atmospheric pressure. The temperature sensors will operate correctly until 233K, then
the readings are no longer reliable but the sensor will not be damaged. The radio
transmitter has a minimum operating temperature of 253 K. If the temperature inside
the probe is allowed to drop below ~253K the signal will be affected or interrupted. In
140
this case the thermal insulator will play a major role, delaying cooling as much as
possible.
After CanSat construction some simple temperature and shock resistance test
can be performed on it. The results of these tests can then be used to determine
whether the design was sufficient CanSat structure. CanSat also should be tested in
windy, stormy and icy conditions.
Figure 9-2 Wing Loading Test for a Fixed wing

CanSat
For different types of CanSats you need appropriate designs always taking into
account mass budget and size. Especially for come back competitons you may use
paragliding, rover back or fixed wing types of CanSat. Paragliding CanSat requires
direction and control mechanism. The direction in heavy weather may not support the
forces of the paraglide properly and the cansat may stall or drifted away. For a rower
back you should take into account the rower mechanism, obstacle avoidance system
and control in 2D condition. However, for a fixed wing CanSat you must control the
CanSat in 3D. Since you have limited space in the rocket your design must consider
wing folding, tail and if there exist engine propeller. The concept of the design must aim
to improve performance, weight, strenght and simplicity.
141
Figure 9-3. Rover back CanSat with paraglider

inside a rocket.
For a Mechanical design you should include drawings of the structure and
component layout and a list of materials and component selections. The mass budget
shall include allocation of masses to the various subsystems and/or components in a
tabular form.
Access to the electrical components is an important design consideration. During
the development and testing phase of the CanSat, the battery, circuit boards and the
transceiver will be removed and replaced several times. Easy access to these
components will save a significant amount of time over the entire development and
launch phase. In short, it is necessary to have a structure that is light, strong, versatile,
and easy to disassemble.
142
Figure 9-4. Assembly in the workshop
143
CHAPTER 10: PRE-LAUNCHING TESTING

9.1 INTRDUCTION
. To be continue
144
CHAPTER 11: DATA ANALYSIS

10.1 INTRODUCTION
To be continue
145
REFERENCES
1-1
www.cltp.info
1-2
http://www.cansatcompetition.com/
1-3
http://www.arliss.org
3-1
mbed programming workshop for cansat, senio networks, inc., 2011
3-2
Pedro Castillo, Rogelio Lozano and Alejandro E. Dzul, Modelling and Control
of Mini-Flying Machines, Springer-Verlag London Limited 2005
Ahmed El-Rabbany, Introduction to GPS, GNSS Technology and Applications
Series, second Edition, Artech House, 2006.
S. P. Drake, Converting GPS Coordinates (h) to Navigation Coordinates
(ENU), DSTO Electronics and Surveillance Research Laboratory, DSTO-TN0432, 2002.
T.W. Knacke, Parachute Recovery System, Design Manual, Parapublishing
1992.
http://www.digi.com
4-1
4-2
5-1
7-1
146
APPENDIX A MBED LPC LPC1768 SPECIFICATION SHEET
147
148
149
150
APPENDIX B FREESCAL MMA7361LC ACCELEROMETER

SPECIFICATION SHEETS
151
152
153
154
155
156
157
158
159
160
161
APPENDIX C CALIBRATION TECHNIQUE FOR ACCELEROMETERS
162
163
164
165
166
APPENDIX D SCP 1000 ABSOLUTE PRESSURE SENSOR

SPECIFICATION SHEETS
167
168
169
170
171
172
173
APPENDIX E GPS GT-723F SPECIFICATION SHEETS
174
175
176
177
178
179
180
181
182
183
184
APPENDIX F GYROSCOPE SPECIFICATION SHEET
185
186
187
188
189
190
191
192
193
194
195
196
APPENDIX G XBEE SPECIFICATION SHEET
197
198
199
200
201
202
APPENDIX H C/C++ BASIC DATA TYPES, OPERATORS AND

CONTROL STATEMENTS
Built-in data types
Character - represents an alphabet, number or symbol character

- char
Integer - represents an signed or unsigned integer
- signed char, short, int, long
- unsigned char, unsigned short, unsigned int, unsigned
long
Floating point number - in IEEE single or double precision format
- float
- double
Boolean - true or false
- bool
Arithmetic operations
Basic mathematical opeprators
- Addition (+)
- Subtraction (-)
- Multiplication (*)
- Division (/)
- Modulus (%)
Short-hand notation to perform a mathematical operation and an assignment at the
same time
+=, -=, *=, /=, %=
- Add 4 to a variable x and assign x to the result
x += 4;
Increment and decrement operators
Increment operator (++)

i++ is a short hand for i = i + 1 or i += 1
Decrement operator (--)
i-- is a short hand for i = i - 1 or i -= 1
Bitwise operators
Bitwise operators perform Boolean algebra on the corresponding bits in the

arguments to produce the result
Bitwise-and (&)
203
3 & 5 produces 1
2 & 4 produces 0
Bitwise-or (|)
3 | 5 produces 7
2 | 4 produces 6
Bitwise-xor (^)
3 ^ 5 produces 6
2 ^ 4 produces 6
Bitwise operators can be combined with = like &=, |= and ^=
Shift operators
Left shift operator(<<)produces the operand to the left of the operator shifted to
the left by the number of bits specified after the operator
1 << 1 produces 2
1 << 5 produces 32
7 << 3 produces 56
Right shift operator(>>)produces the operand to the left of the operator shifted to
the right by the number of bits specified after the operator
1 >> 1 produces 0
5 >> 1 produces 2
7 >> 2 produces 1
Relational operators
Relational operators establish a relationship between the values of the operands. They
produce a Boolean true if the relationship is true, and false if the relationship is false.
Less than (<)
Less than or equal to (<=)
Greater than (>)
Greater than or equal to (>=)
equivalent (==)
204
not equivalent (!=)
Logical operators
The binary logical operators produce a true or false based on the logical
relationship of its arguments
- Logical AND (&&)
- Logical OR (||)
The unary logical not operator will take a Boolean and produce its negation
- Logical NOT (!)
An expression is true if it has a non-zero value, and false if it has a value of

zero
If you print a bool, youll typically see a 1 for true and 0 for False Integer
and bool conversion
Integer and bool conversion
Integer to bool conversion

- Non zero integers are converted to true
- 0 is converted to false
bool to Integer conversion

- true is converted to 1
- false is conveted to 0
if-else, while, do-while statements

if (expression)
statement
if (expression)
statement
else
statement
while (expression)
statement
205
do
statement
while (expression);
Example:
if (n == -1)
printf("error\n");
if (n == 0)
n = 1;
else
n = n + 1;
while (n < 100)
n = n * n;
do
n = n * n;
while (n < 100);
for statement
for (initialization; conditional; step)
statement
for (int i = 0; i < 100; i++)
printf("square of %d = %d\n", i, i * i);
switch statement
switch (selector) {
case value1:
statement;
break;
case value2:
statement;
break;
...
default:
statement;
}
Example:
206
switch (response) {
case 'y':
printf("Yes\n");
break;
case 'n':
printf("No\n");
break;
case 'c':
printf("Cancel\n");
break;
default:
printf("Invalid\n");
}
207
CLTP Office
c/o University Space Engineering Consortium (UNISEC)
Central Yayoi 2Fl., 2-3-2 Yayoi, Bunkyo-ku, Tokyo, 113-0032, Japan
Tel :+81-3-5800-6645
Fax:+81-3-3868-2208
E-mail: [email protected]
www.cltp.info
ISBN-978-4-906837-00-7
C3053

Design Manual (Cansat)

Uploaded by

Copyright:

Available Formats

Design Manual (Cansat)

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Design Manual (Cansat)

Uploaded by

Copyright:

Available Formats

Can Satellite (CanSat)

University Space Engineering Consortium Japan (UNISEC)

Can Satellite (CanSat)

5.1 Introduction .............................................................................................................................................................. 89

9.1 Intrduction .............................................................................................................................................................. 144

We will make the world that space activity is not something

Figure 1-1 Professor Bob Twiggs

Figure 1-1 Rover-Type CanSat Developed by the CLTP

1.2 ORGANIZATION OF THE BOOK

CHAPTER 2: MISSION PROFILE AND SYSTEM DEVELOPMENT

2.2 MISSION TYPES

a) Data acquisition mission

a) Data Acquisition CanSat

Figure 2-2 Photos show the different

2.3 GENERALIZED HARDWARE ARCHITECTURE FOR THE CANSAT

CHAPTER 3: INTRODUCTION TO MBED

Figure 3-1 mbed Microcontroller

A computer running Windows, MacOS X or GNU/Linux with

Figure 3-2 mbed package

Figure 3-3 shows the pin layout of mbed.

Figure 3-3 I/O pin layout and supported interfaces

Figure 3-4 Setting mbed

Connect your mbed Microcontroller to a PC

Figure 3-5 Creating online mbed account

a) mbed web site

Figure 3-6 features of mbed web site

Go to the web page

Figure 3-7 mbed reset button and LEDs

Figure 3-8 Accessing the Windows registry editor

Figure 3-9 Windows registry editor

Figure 3-10 Access Windows Internet Explorer node

Figure 3-11 Changing the download directory

Figure 3-12 Changing the download directory

Figure 3-13 Changing the download directory

Figure 3-14 Creating your first program

Figure 3-15 write and compile your program

3.3 PLAYING WITH THE BUILT-IN LEDS

Figure 3-16 Built-in LEDs

Use a "for" loop

for (int i = 0; i < 4; i + +) {

Figure 3-18 Example 3-1

3.4 USING A TACT SWITCH

Legs 1 and 2 become connected when the button pressed

Legs 2 and 3 (1 and 4) are always connected

Figure 3-19 Tact or Tactile switch

Figure 3-20 Connecting the tact switch

Figure 3-21 breadboard

A digital input, used for reading the state of a pin

DigitalIn(PinName) creates a DigitalIn object, connected to the specified pin

Figure 3-23 Digital input object

Figure 3-24 Digital input signal

Reading a switch through interrupt is illustaed in the following code

3.5 COMMUNICATION WITH YOUR PC

Figure 3-25 Setting up the windows serial communication

Figure 3-26 Setting up the Tera Term V1

Figure 3-27 Setting up the Tera Term V1

The mbed Microcontroller can communicate with a host PC through a "USB

To run a "Hello World" program do the following steps:

Create a HelloWorld program

Figure 3-28 Output of the Hello World code in the HyperTerminal