Post on 14-Jul-2018
PROJECT N°46
1
The MiniSat
Catarina Nunes
European School Luxembourg I
23, Boulevard Konrad Adenauer, L-1115, Luxembourg
S6 PTA
Abstract
Key words: Arduino Uno, Raspberry Pi, Satellite
A satellite is a device designed to be launched into orbit around a celestial body. The first satellite to
have been launched was Sputnik in 1957, ever since then more than a thousand satellites have been
sent into Earth’s orbit. The thing is, all of these satellites cost an extreme amount of money, but what
if it was possible to make them cheaper and smaller?
The aim of this project is to develop a small and cheap observation satellite. In this case it will be
launched up into the troposphere and collect data regarding various factors such as temperature,
atmospheric pressure, humidity and light. The data will then be retrieved and analyzed using a
computer program.
As the data handling unit of my MiniSat I will be using either a microcontroller, such as the Arduino
Uno, or a microcomputer, such as the Raspberry Pi. These components will be in charge of getting data
from the sensors. The power unit will be a 9v battery. To receive the data from the satellite to my
computer I will either be using a 45Hz radio transmitter and receiver, a GSM module or simply store
the data in a micro SD card and retrieve it once the MiniSat has landed. The payload is composed of a
set of sensors. There are multiple sensors capable of getting the data I want so I will be using the
cheapest ones.
I will be making a series of test in order to
choose between all the options and the
final product will be the cheapest, smallest
and easiest to build satellite made from all
these components.
2
1. Introduction
A satellite is a device designed to be launched into orbit around a celestial body. The first satellite to
have ever been launched was Sputnik in 1957, ever since then more than a thousand have been sent
into Earth’s orbit. My project is about building a cheap and easy to use satellite, which is not bigger
than 0.5 cubic meters and heavier than 5 kilos, which can be used by both scientists in remote locations
in search of new physical data and hobbyists that simply want to acquire some raw data.
A normal satellite usually has two main modules: the bus or service module and the communications
module. Inside the bus module there are the following subsystems: structural subsystem, it’s the base
structure of the satellite; the telemetry subsystem (aka the data handling unit), it’s in charge of
monitoring the on-board operation and sending data back to Earth; power subsystem, an array of solar
panels which convert the sun’s light into energy for the satellite; thermal control, controls the
temperature so as to prevent any damages to the on-board equipment; and finally , the attitude and
orbit control, which controls the satellite’s orbit and attitude. The communication module is in charge
of receiving commands from Earth.
A satellite always has a mission when launching into orbit. It could be monitoring physical factor of the
Earth (temperature, humidity, cloud movement, etc.) or it could be something entirely different such
as providing cellphone service, or GPS coordinates. All of these satellites may vary in many different
ways, their weight and size, their orbit type, but one thing that they all have in common is that they
are very expensive. A typical weather satellites costs around $290 million plus the cost of maintaining
it and launching it, which my range from $10 million to $400 million.
Right now there are more than four thousand satellites orbiting the Earth, this includes those still
operating and those no longer operating.
2. Materials
To build a smaller and cheaper satellite, the MiniSat, I focused on cheaper and easy to use components,
so all of those that are listed bellow can be found on Amazon and can be put together without needing
any soldiering or complicated maneuvers.
-Computer
If you wish to make any technology related project you need a computer. In this case I needed
to program the micro controller or microcomputer that will serve as my satellite’s data handling unit.
(As long as you are able to program any computer will do).
3
-Arduino or Raspberry Pi
Every satellite needs a data handling unit, in normal cases it would be a complete computer.
In this case I am considering using a microcontroller (Arduino) or a microcomputer (Raspberry Pi). The
difference between these two is that while an Arduino is very easy to use (from my point of view) and
can only do one thing at a time a Raspberry Pi takes a fairly long time to learn how to program but can
do as much as a normal computer.
-Sensors:
Humidity and temperature: DHT11 or DHT22
There are two main easy to use and soldering free temperature and humidity sensors on the
market, theses are the DHT11 and DHT22. Both measure relative humidity by measuring the electric
resistance between two electrodes inside their cases. As humidity also depends on temperature theses
sensors have a built in thermistor for measuring temperature. Relative humidity is measured in
percentage and temperature in degrees Celsius.
DHT11: low cost (less than 5 euros), works with voltage between the range of 3 and 5 volts (meaning
it works both with the Arduino and the Raspberry Pi), has humidity readings between 20 and 80
percent (average values in Luxembourg range between 27 and 96 percent) with a 5 percent accuracy
range, has temperature readings between 0 and 50 degrees Celsius (average values in Luxembourg
range between -1 and 23 degrees Celsius) with a plus or minus 2 degrees accuracy, it takes data once
every second.
DHT22: low cost (less than 10 euros), works with voltage between the range of 3 and 5 volts (meaning
it works both with the Arduino and the Raspberry Pi), has humidity readings between 0 and 100
percent (average values in Luxembourg range between 27 and 96 percent) with a 2 percent accuracy
range, has temperature readings between -40 and 125 degrees Celsius (average values in Luxembourg
range between -1 and 23 degrees Celsius) with a plus or minus 0.5 degrees accuracy, it takes data once
every two seconds.
Light: phototransistor or photoresistor
These are two types of components which react to light. A photoresistor, as the name implies,
changes it’s resistance according to the amount of light it receives while the phototransistor varies the
amount of voltage which passes through it.
4
Air Pressure: MRX4115A
To measure air pressure I was only able to find one solderless sensor, the MRX4115A. It
measures air pressure in an analog value which can be converted into pascals using a formula found
on it’s data sheet: Vout = 1024*(0.009*P – 0.095), vout being the analog value and P pressure in
kilopascals.
-Wireless transmitter (Bluetooth, Wi-Fi or radio)
To actually send the data from the satellite to the computer to be analyzed I needed a wireless
transmitter. I had four option: Bluetooth, radio or Wi-Fi. Using a Bluetooth mate would enable me to
send data not only to my computer but also to my phone by using a Bluetooth terminal app, but the
range would be lower than 20 meters. Wi-Fi allows a higher range than Bluetooth but both the satellite
and the computer would need access to the internet. Radio also allows for a higher range than
Bluetooth, I would only need a radio transceiver and receiver both connected to two different data
handling units (one on the satellite and one on the ground to receive the data), depending on the
voltage used on the radio transmitter I am able to increase or decrease it’s range.
-9V battery and battery holder
To provide power to the MiniSat I have chosen a 9V battery, this because both Arduino and
Raspberry Pi (the data handling units I was considering using) both work with this amount of Volts.
Anything bellow 5V and above 12V would fry my circuit, so I opted for and intermediate value.
-Wires
You will need male to male jumper cables and male to female ones. These are for connecting
the sensors and all the other components to each other.
3. Methods
All the equipment that I have chosen are simple to use and easy to get, but to actually build my satellite
I needed not only to test every single component separately (to check if I can program them or simply
if they are actually working), but also to combine those that I found more suitable together into a single
5
circuit and program. Also, because I had more than two choices for much of my equipment and I only
wanted to use what was more useful for my project I did some tests and additional internet research
to determine which ones I should use and which ones I should discard.
Data handling unit: Arduino or Raspberry Pi
As I already knew how to program an Arduino and due to the fact that although it does only one thing
at a time it does it very quickly, I decided to work with the Arduino instead of the Raspberry Pi. There
are also various types of Arduinos. You have, for example the Arduino Uno, Arduino Yun or the Arduino
Micro. The Uno is the easiest to use and has neither Bluetooth nor Ethernet incorporated. The Yun has
both Ethernet and Wi-Fi, and the Micro has lower processing capabilities than the Uno, has neither
Ethernet nor Bluetooth unlike the Yun but is much smaller than both of the above. As the initial
prototype for my project I decided to use the Arduino Uno simply because it is the simplest Arduino to
use and has the biggest online support and libraries.
Wireless transmitter: Bluetooth, Wi-Fi or radio
Bluetooth communication requires a Bluetooth mate connected to the Arduino and, if receiving
through a phone, a Bluetooth terminal app found in any app store or, if receiving through a computer,
a special program. I already had a Bluetooth mate, but it has a range bellow 20 meters, as such, it
would not be appropriate to use on my project.
Wi-Fi communication requires a special Wi-Fi shield for Arduino or an Arduino with Wi-Fi access
integrated such as the Arduino Yun. Both these items would add extra costs to my project as it is more
expensive than Bluetooth and radio communication. Even though Wi-Fi has a higher range than both
Bluetooth and radio it is more expensive and requires access to internet in both Arduino and computer,
as such I decided that I would not use it on the MiniSat, for now.
My last option was radio. Radio requires a radio transmitter connected to the Arduino on board of the
satellite and a radio receiver connected to another Arduino which is in turn connected to the
computer. It has a lower range than Wi-Fi, but is much cheaper. It is also easier to use since I don’t
have to make a program in my computer to receive the data, I can just read it out of the serial monitor.
Radio has a higher range than Bluetooth and is also cheaper and easier to use than Wi-Fi, as such, I
decided to use radio on my project. The radio set I used was a transmitter and receiver with a radio
frequency of 433 hertz, because it had a public library on internet with all the functions I needed to
operate it.
6
To experiment with the radio I did a simple Hello World sketch both for the transmitter and receiver.
The transmitter and receiver are connected to two different Arduinos.
For the circuit first connect the 5V and Ground pins from the Arduinos to two different breadboards;
then connect the receiver and transmitter to their respective breadboard. For the receiver the first pin
(counting from the left) connects to 5V, the second to a digital pin of the Arduino (I chose pin12) and
the third to Ground. For the transmitter the first pin is connected to a digital pin of the Arduino (I chose
pin 12), the second is connected to 5V and the third to Ground.
(The whole program is in writing after the conclusion).
Sensors:
Humidity and temperature: DHT11 or DHT22
Test1- for getting the values of temperature and humidity from the DHT11
For the circuit, first connect the 5V and Ground pins from the Arduino to the breadboard; then
connect the DHT11 to any part of the breadboard; the first pin of the sensor (counting from the left
side) connects to any Digital pin of the Arduino, I chose pin 7; the second pin of the sensor connects to
the 5V and the third and last pin to Ground. Keep in mind that the order of the pins may differ from
different DHT11 sensors due to the different manufacturers.
7
The program consists of three major parts: declaring the library, the setup and the main loop.
The results are readings taken 1 second apart (due to the fact that the loop in the Arduino only
runs once every second) of both temperature and humidity.
Declaring the library:
#include <dht.h>
dht DHT;
#define DHT11_PIN 7
The first line is the actual declaration of the library (this is done every time you want to use any kind
of library not just this one. The second is the library’s object (you also use this for other libraries) and
the third line is to define which digital pin our sensor is connected to, in this case it is the seventh
digital pin.
The setup:
Serial.begin(9600);
This is for letting the Arduino communicate with the computer through a serial monitor.
The main loop:
DHT.read11(DHT11_PIN);
Serial.print("Temperature = ");
Serial.print(DHT.temperature);
8
Serial.println(" C");
Serial.print("Humidity = ");
Serial.print(DHT.humidity);
Serial.println(" %");
The first line is for getting the data from the sensor, the Arduino reads the sensor and gets the data.
Then we write in the serial monitor “Temperature” followed by it’s actual value, obtained with the
.temperature function of the DHT object. We do the same thing for the humidity readings and end the
loop. In this program there is no need for any delay since the Arduino like the DHT11 only runs the
program once every second, meaning that every time the program runs the sensor is able to take
readings.
(The whole program is in writing after the conclusion)
Test2- for comparing the two DHT sensors, DHT11 and DHT22
We use the circuit from test1 and add the DHT22 to the breadboard. The pins of my DHT22
are different from the ones of my DHT11, the first one (counting from left to right) is connected to
Ground, the second one to 5V and the third one to a digital pin, I used digital pin number 8. Keep again
in mind that the pin order depends on the sensor due to the different manufacturers.
The program is basically the same as in test1 but we define the DHT22 pin before the setup
and add the part for it’s readings in the main loop.
The readings we get appear on the serial monitor, 1 second apart due to the delay, allowing
us to compare the readings of the two sensors. The delay is used because of the fact that the DHT22
can only take readings every 2 seconds.
9
(The whole program is in writing after the conclusion)
Light: photoresistor or phototransistor
Test1- checking the amount of light with the photoresisitor
While the photoresistor does react according to the amount of light it receives it does nt tell us the
amount of light in accurate measurements in SI unities, such as lux or candela. Instead I will use to
compare the light on the ground (I am going to call it normal light) and the light during launch and
descent.
Building the circuit is fairly easy. You connect the ground a 5V from the arduino to the
breadboard (as with any other test); connect te photoresistor to any part of the breadbord; one end
of the reisitor is connected to the 5V and the other to Ground through a 10Kohm resistor and an analog
pin (I chose the A0) simultaneously.
The program, like any other arduino program, conists of three major parts: the part before the
setup (used to declare any global variabbles, libraries, etc.), the setup and the main loop. The main
loop is the real important part. Here I define the sensorValue as the reading from the resistor
andestablish the limits to my light levels: normal, weak, very weak, intense, and very intense. By
coparing the sensorValue to the initalValue I am able to compare the light at ground level, and during
ascent and descent.
(The whole program is in writing after the conclusion)
10
“Test2”- researching the phototransistor
At the beginning of my project I pondered on using a phototransistor to evaluate quantity of
light, turns out that it is not a possible option. The problem is that phototransistors are particularly
sensitive to infrared (IR) light, which the sun strongly emits, so if I ever were to use this type of
transistor to measure the quantity of light of the sun not only would I not get any readable data I would
also probably ruin the transistor. Taking this into consideration I decided not to use the phototransistor
in my project.
Air pressure: Adafruit BME280 or MRX4115A
Test1- measuring air pressure
To actually measure the air pressure I needed to convert the sensors readings, this is because
the sensor reads air pressure bur converts it into another number. To do this conversion I needed the
conversion formula which I found on the sensors data sheet:
Vout = 1024*(0.009*P – 0.095)
In this formula the P is pressure in kilopascals and the vout is the actual sensor’s reading. Through
some arithmetic rearranging the formula becomes:
P = ((Vout/1024)+0.095)/0.000009
This time P is in pascals. Since I also wanted to know if the sensor was actually working I converted the
pressure in pascals into atmospheres, so if the sensor said the air pressure equals approximately 1
atmosphere I know that my formulas are correct and the sensor is working.
The circuit is quite simple. We connect the sensor to any part of the breadboard. It’s first pin
(it is marked with a notch) connects to an analogue pin in the Arduino (I chose A0); the second pin to
Ground and the third one to 5V; the other pins are not used.
11
The program also only involves a few global variables, the initialization of the communication
with the serial monitor in the setup; and the formulas to convert pascals into atmospheres and
millibars in the main loop.
(The whole program is in writing after the conclusion)
Altitude: combination of all sensors and hypsometric formula
To measure altitude I found a formula on the internet called the hypsometric formula. This
formula relates altitude to air pressure, sea level air pressure and temperature. For sea level air
pressure I used the average value of 101325 pascals and temperature in degrees Celsius.
𝑎𝑙𝑡𝑖𝑡𝑢𝑑𝑒 =
((101325𝑝𝑟𝑒𝑠𝑠𝑢𝑟𝑒
)
15.257
− 1)×(𝑡𝑒𝑚𝑝𝑒𝑟𝑎𝑡𝑢𝑟𝑒 + 273.15)
0.0065
The circuit is a mix of the ones I used before. Connect the DHT22 and pressure sensor like in
the previous tests and that’s it.
The only thing new to the program is the altitude formula:
altitude = ((pow(101325/pressure, 1/5.257)-1)*(temperature + 273.15))/0.0065;
To write it I needed to use an already existing function called pow, which allows me to power a number
to another number.
(The whole program is in writing after the conclusion)
12
Final Product:
To build the final circuit and program I just needed to combine all the things from the previous
tests which made quite a simple task.
The circuit:
(The whole program is in writing after the conclusion)
4. Results
Humidity and temperature test results:
After building the circuit and uploading the program what the Arduino showed me in the serial monitor
was my living room’s ambient temperature and relative humidity. At first it showed me the
temperature as 21C and humidity 46%; after 1 minute the temperature stayed the same but humidity
dropped to 45%; after 5 more minutes both temperature and humidity stayed the same. Then I blew
on the sensor and the humidity readings increased to 82%, they only returned to 45% after 280
seconds.
Through the results that I obtained I can say that the DHT11 takes a couple of minutes to adjust it’s
humidity readings, but nevertheless seems like a reliable sensor.
With the results from both tests I can conclude that both sensors are equally easy to use (they only
require installing the library), but the DHT22 is better than the DHT11. This is because the DHT22 is
more accurate when it comes to temperature (as it shows us decimals) and therefore more accurate
for humidity, since humidity depends on temperature. The DHT22 main problem is the fact that it can
only receive data every 2 seconds but due to the delay (it is optional to use delay but by using it the
data becomes clearer) that issue goes unnoticed and therefore becomes irrelevant. Concluding, while
13
the DHT11 is more compact and cheaper it is also more inaccurate than the DHT22, so I have decided
to use the DHT22 for this project.
Light test results:
Through these two tests I have concluded that the only possible way to get any accurate values on the
quantity of light would be to use an entirely different sensor that would give readings in either lux or
candela. Since I do not have access to such sensors right now I have decided to continue using the
photoresistor, but if I do acquire a sensor more adequate to this task in the future I will use it.
Air pressure test results:
Through this test I can conclude that the sensor and formulas work and are sufficiently reliable,
therefore I will be using this sensor in my project. Of course that if I find a new and better sensor I will
use it.
Altitude test results:
After building the circuit and uploading the program the serial monitor showed me an altitude
of 347 meters. Kirchberg’s (the place where I performed the experiment) actual altitude is 327 meters,
the difference between my value and the real value is most likely due to the fact that I did my
experiment inside my living room, which substantially changed the value of the temperature readings
of the DHT22. Through this test I can conclude that the hypsometric formula is good for using as long
as I keep in mind that it may show me a different value than in reality due to other factors.
Final product results:
My final result was an expected one. The circuit and program worked wonderfully after getting
rid of the bugs, and the MiniSat provided me actual accurate data of the several physical factors that I
wanted to measure.
5. Discussion
The final product seems reliable and has completed it’s objective: it is small, light, cheap and easy to
use. The next step would be figuring out how to make it rise to the troposphere (either through a
rocket, helium balloon or plane) and how it will descend down to Earth again (through a parachute).
14
The circuit and program in itself have no problems, but the MiniSat requires a case to contain the
circuit. This case would be ideally made out of a light metal such as aluminum and would be made
tailored to fit the MiniSat.
6. Conclusion
The MiniSat is a successful first prototype, but to actually use it in the field I still need to make some
improvements.
Programs:
Radio:
Receiver:
#include <VirtualWire.h>
const int receiverPin = 12;
byte message[VW_MAX_MESSAGE_LEN];
byte messageLength = VW_MAX_MESSAGE_LEN;
const int ledPin = 13;
void setup() {
Serial.begin(9600);
pinMode(ledPin, OUTPUT);
vw_set_rx_pin(receiverPin);
vw_setup(2000);
vw_rx_start();
}
15
void loop() {
digitalWrite(ledPin, LOW);
if (vw_get_message(message, &messageLength)){
digitalWrite(ledPin, HIGH);
Serial.print("Message: ");
for (int i = 0; i < messageLength; i++){
Serial.write(message[i]);
}
Serial.println();
}
}
Transmitter:
#include <VirtualWire.h>
const int transmitPin = 12;
const int ledPin = 13;
char* message = "Hello World";
void setup() {
pinMode (ledPin,OUTPUT);
vw_set_tx_pin(transmitPin);
vw_setup(2000);
}
16
void loop() {
digitalWrite(ledPin, LOW);
vw_send((uint8_t *)message, strlen(message));
vw_wait_tx();
digitalWrite(ledPin, HIGH);
delay(1000);
}
Humidity and temperature:
Test1:
#include <dht.h> dht DHT; #define DHT11_PIN 7 void setup() { Serial.begin(9600); } void loop() { DHT.read11(DHT11_PIN); Serial.print("Temperature = "); Serial.print(DHT.temperature); Serial.println(" C"); Serial.print("Humidity = "); Serial.print(DHT.humidity); Serial.println(" %"); delay(1000); }
Test2:
#include <dht.h> dht DHT;
17
#define DHT11_PIN 7 #define DHT22_PIN 8 void setup() { Serial.begin(9600); } void loop() { DHT.read11(DHT11_PIN); Serial.println("DHT11"); Serial.print("Temperature = "); Serial.print(DHT.temperature); Serial.println(" C"); Serial.print("Humidity = "); Serial.print(DHT.humidity); Serial.println(" %"); Serial.println(""); delay(1000); DHT.read22(DHT22_PIN); Serial.println("DHT22"); Serial.print("Temperature = "); Serial.print(DHT.temperature); Serial.println(" C"); Serial.print("Humidity = "); Serial.print(DHT.humidity); Serial.println(" %"); Serial.println(""); delay(1000); }
Light:
Test1
int photoPin = A0; float sensorValue; float initialValue; void setup() { Serial.begin(9600); initialValue = analogRead(photoPin); }
18
void loop() { sensorValue = analogRead(photoPin); if (sensorValue < initialValue + 100 && sensorValue > initialValue - 100){ Serial.println("light: normal"); } if (sensorValue > initialValue + 200){ Serial.println("light: very intense"); } else if (sensorValue > initialValue + 100){ Serial.println("light: intense"); } if (sensorValue < initialValue - 200){ Serial.println("light: very weak"); } else if (sensorValue < initialValue - 100){ Serial.println("light: weak"); } Serial.println(initialValue); Serial.println(sensorValue); delay(2000); }
Pressure:
const int pressurePin = A0; float pressure; float millibars; float atmospheres; float vout; float vin; void setup() { Serial.begin(9600); } void loop(){ vout = analogRead(pressurePin); pressure = ((vout/1024)+0.095)/0.000009;
19
millibars = pressure*100; atmospheres = pressure / 101325; Serial.println(); Serial.print("Pressure = "); Serial.print(pressure); Serial.println(" pa"); Serial.print("Pressure = "); Serial.print(millibars); Serial.println(" mbar"); Serial.print("Pressure = "); Serial.print(atmospheres); Serial.println("atm"); delay(1000); }
Altitude:
#include <dht.h> dht DHT; int dht22Pin = 8; int pressurePin = A1; const int ledPin = 13; float altitude; float temperature; float pressure; float vout; void setup() { Serial.begin(9600); pinMode(ledPin, OUTPUT); } void loop() { vout = analogRead(pressurePin); DHT.read22(dht22Pin); temperature = DHT.temperature; altitude = ((pow(101325/pressure, 1/5.257)-1)*(temperature + 273.15))/0.0065; Serial.print("Altitude= "); Serial.println(altitude);
20
delay(1000); }
Final Program:
#include <dht.h> #include <VirtualWire.h> dht DHT; int dht22Pin = 8; int photoPin = A0; int pressurePin = A1; const int ledPin = 13; const int transmitPin = 12; float temperature; float humidity; float sensorValue; float initialValue; float pressure; float millibars; float atmospheres; float vout; float altitude; char temp[12]; char humi[12]; char* light; char pascal[12]; char millibar[12]; char atmosphere[12]; char meters[12]; char* labelTemp = "Temperature: "; char* labelHumi = "Humidity: "; char* labelLight = "Light: "; char* labelPressure = "Pressure: "; char* labelMillibars = "Millibars: "; char* labelAtmospheres = "Atmospheres: "; char* labelAltitude = "Altitude: "; char* space = " "; void setup() { Serial.begin(9600);
21
pinMode(ledPin, OUTPUT); initialValue = analogRead(photoPin); vw_set_tx_pin(transmitPin); vw_setup(2000); } void loop() { // put your main code here, to run repeatedly: sensorValue = analogRead(photoPin); vout = analogRead(pressurePin); DHT.read22(dht22Pin); digitalWrite(ledPin, LOW); temperature = DHT.temperature; humidity = DHT.humidity; sendTemp(); sendHumi(); sendLight(); sendAirPressure(); sendAltitude(); delay(1000); digitalWrite(ledPin, HIGH); } void sendTemp(){ dtostrf(temperature, 13, 2, temp); Serial.write(temp); Serial.println(); vw_send((uint8_t*)labelTemp, strlen(labelTemp)); vw_wait_tx(); vw_send((uint8_t*)temp, strlen(temp)); vw_wait_tx(); vw_send((uint8_t*)space, strlen(space)); vw_wait_tx(); } void sendHumi(){ dtostrf(humidity, 13, 2, humi); Serial.write(humi);
22
Serial.println(); vw_send((uint8_t*)labelHumi, strlen(labelHumi)); vw_wait_tx(); vw_send((uint8_t*)humi, strlen(humi)); vw_wait_tx(); vw_send((uint8_t*)space, strlen(space)); vw_wait_tx(); } void sendLight(){ if (sensorValue < initialValue + 100 && sensorValue > initialValue - 100){ Serial.println("light: normal"); digitalWrite(ledPin, HIGH); light = "normal "; vw_send((uint8_t*)labelLight, strlen(labelLight)); vw_wait_tx(); vw_send((uint8_t*)light, strlen(light)); vw_wait_tx(); vw_send((uint8_t*)space, strlen(space)); vw_wait_tx(); } if (sensorValue > initialValue + 200){ Serial.println("light: very intense"); digitalWrite(ledPin, HIGH); light = "very intense "; vw_send((uint8_t*)labelLight, strlen(labelLight)); vw_wait_tx(); vw_send((uint8_t*)light, strlen(light)); vw_wait_tx(); vw_send((uint8_t*)space, strlen(space)); vw_wait_tx(); } else if (sensorValue > initialValue + 100){ Serial.println("light: intense"); digitalWrite(ledPin, HIGH); light = "intense "; vw_send((uint8_t*)labelLight, strlen(labelLight)); vw_wait_tx();
23
vw_send((uint8_t*)light, strlen(light)); vw_wait_tx(); vw_send((uint8_t*)space, strlen(space)); vw_wait_tx(); } if (sensorValue < initialValue - 200){ Serial.println("light: very weak"); digitalWrite(ledPin, HIGH); light = "very weak "; vw_send((uint8_t*)labelLight, strlen(labelLight)); vw_wait_tx(); vw_send((uint8_t*)light, strlen(light)); vw_wait_tx(); vw_send((uint8_t*)space, strlen(space)); vw_wait_tx(); } else if (sensorValue < initialValue - 100){ Serial.println("light: weak"); digitalWrite(ledPin, HIGH); light = "weak "; vw_send((uint8_t*)labelLight, strlen(labelLight)); vw_wait_tx(); vw_send((uint8_t*)light, strlen(light)); vw_wait_tx(); vw_send((uint8_t*)space, strlen(space)); vw_wait_tx(); } } void sendAirPressure(){ pressure = ((vout/1024)+0.095)/0.000009; millibars = pressure*100; atmospheres = pressure / 101325; dtostrf(pressure, 13, 2, pascal); vw_send((uint8_t*)labelPressure, strlen(labelPressure)); vw_wait_tx(); vw_send((uint8_t*)pascal, strlen(pascal)); vw_wait_tx(); vw_send((uint8_t*)space, strlen(space));
24
vw_wait_tx(); dtostrf(millibars, 13, 2, millibar); vw_send((uint8_t*)labelMillibars, strlen(labelMillibars)); vw_wait_tx(); vw_send((uint8_t*)millibar, strlen(millibar)); vw_wait_tx(); vw_send((uint8_t*)space, strlen(space)); vw_wait_tx(); dtostrf(atmospheres, 13, 2, atmosphere); vw_send((uint8_t*)labelAtmospheres, strlen(labelAtmospheres)); vw_wait_tx(); vw_send((uint8_t*)atmosphere, strlen(atmosphere)); vw_wait_tx(); vw_send((uint8_t*)space, strlen(space)); vw_wait_tx(); } void sendAltitude(){ altitude = ((pow(101325/pressure, 1/5.257)-1)*(temperature + 273.15))/0.0065; dtostrf(altitude, 13, 2, meters); vw_send((uint8_t*)labelAltitude, strlen(labelAltitude)); vw_wait_tx(); vw_send((uint8_t*)meters, strlen(meters)); vw_wait_tx(); vw_send((uint8_t*)space, strlen(space)); vw_wait_tx(); }
25
7. Acknowledgements
I would like to thank my biology teacher Manuela Pereira for her support and guidance; I would also
like to thank my father for his advice.
8. References
http://keisan.casio.com/exec/system/1224585971
https://weatherspark.com/averages/28839/Luxembourg
https://ccollins.wordpress.com/2013/12/11/how-to-measure-air-pressure-with-arduino/
http://www.farnell.com/datasheets/8723.pdf
https://learn.adafruit.com/dht/using-a-dhtxx-sensor
http://www.circuitbasics.com/how-to-set-up-the-dht11-humidity-sensor-on-an-arduino/
http://playground.arduino.cc/Main/DHTLib
http://www.micro4you.com/files/sensor/DHT11.pdf
https://learn.adafruit.com/measuring-light-with-a-beaglebone-black/you-will-need?view=all
https://learn.adafruit.com/photocells/overview?view=all
https://en.wikipedia.org/wiki/Lux
https://en.wikipedia.org/wiki/Lumen_(unit)
http://learn.parallax.com/tutorials/robot/shield-bot/robotics-board-education-shield-
arduino/chapter-6-light-sensitive-15
https://en.wikipedia.org/wiki/Photoresistor
http://www.instructables.com/id/RF-315433-MHz-Transmitter-receiver-Module-and-
Ardu/?ALLSTEPS
http://www.buildcircuit.com/how-to-use-rf-module-with-arduino/
http://www.pjrc.com/teensy/td_libs_VirtualWire.html
http://www.airspayce.com/mikem/arduino/VirtualWire/
http://randomnerdtutorials.com/rf-433mhz-transmitter-receiver-module-with-arduino/
http://www.instructables.com/id/Arduino-weather-station-with-RF433-MHz-modules/?ALLSTEPS