Welcome to the internet home of Andrew Wilkie

Blog

Data Visualiser

Data Visualiser

Along side the main project software, we developed a visualizer that would allow us to view the numerical data in a visual sense.

Project Update

Project Update

The clock is counting down and here is what we have completed and we still need to do before we can launch this balloon.

Simulator

Simulator

For our IT project, we created a simulation of the descent of the G(A)SP payload. It models the conditions that the real weather balloon will be subject to, such as different speeds and directions of wind, as it steers as close as it can to the desired location. It was written in Python and uses PyGame, however also uses self-constructed physics, GUI and simulation files. This ensures accuracy in our program, for example in that the descent changes according to not only the weight and surface area of the object, but also to the air density at different altitudes.

screenshot

It is a model of a feedback system in the physical world, as the real thing will take input from sensors, receive it through serial and send into the user interface, to then calculate the output and send it back to actuators (the servo that controls the rudder) altering the next input. The calculation we used to find the output, is called PID – Proportional-Integral-Derivative control. This algorithm tells us a sensible rate at which to alter the rudder, so that we don’t overshoot where we want to go and have a stable, controlled landing.

pid

This project gave us the opportunity to write the code for our real project before we’d even started making the hardware. It gave us an idea of the data and how we would use it to best steer the rudder effectively. We also now have an indicator of the limitations and effectiveness of our steering, such as what levels of wind it will be impossible to steer to certain locations in. For instance, it would be almost impossible to steer in a hurricane. As we were able to speed up the simulation, it gave us an idea of how long the descent will take and where the balloon would travel.
All of this knowledge is useful in the optimisation for the real launch, helping us to decide when it would be best to release the parachute so that we know it will have enough time to steer to a preferable landing location, giving us insight into the speed the payload will reach and how best to tune the PID algorithm.
If we had not tested our simulation before the real thing, errors that otherwise would have been overlooked may have resulted in a fail launch. That is why this simulation has been invaluable to our overall project.

giphy

Rocket Launch

Rocket Launch

In preparation for our final launch, we built a test rocket with prototypes on-board. This allowed us to test everything and find out what will work, what won’t, what should have worked and what we need to change and fix before the final deadline.

YICTE

YICTE

YICTE – Young ICT Explorers. YICTE is a competition run all around Australia getting students who love ICT and anything in general apply their knowledge and abilities to solve real world issues.

PCB Design

The PCB design is in its final stages and we are running through all of our design files with a fine tooth comb.

Our circuit board must have an Intel Edison connector, GPS, and a battery connector. Most of the other components on the board aren’t necessary but they would be great to have. These include such things as PWM output connectors, a USB connector, I²C, and a UART port. So in total our circuit board consists of a few connectors and port (Edison, USB, Battery in, PWM, I²C, UART, GPS and SD Card), 2 logic level shifters, a 9DOF (9 Degrees Of Freedom), and a Barometer.

 

Below is an image of what the file looks like from the PCB editor I am using. Everything in red is the top copper layer, everything in blue is the bottom layer of copper, and things in other colours (grey and black) represent the outlines of components, silk screen and the board dimensions. pcb

 

 

 

 

 

 

 

 

 

 

 

From this file I will export gerber files which contain all of the holes, silkscreen, solder-mask, pads, vias and everything else necessary fro the manufacturer to create the board.

The boards have altered slightly from what is shown here, but not too much. Our most recent files have been sent out to our manufacturer and we should receive them in a few weeks. The PCBs will look similar to the images below.

PCB Top side PCB Bottom side

 

Rudder Design

We wanted to make our balloon payload steerable. this was going to be achieved with a rudder, and here are some details on how we were going to achieve it.

Circuit Design

Circuit Design

Building a circuit take quite a bit of time and effort. A schematic has to be constructed – which is a diagram showing the links between all of the electronics. A prototype should be built and tested, the schematic refined and then finally the PCB […]

Setting Up the Code

Setting Up the Code

We’ve started working on the data logging side of the software, and a working prototype will be complete – of both software and hardware – in time for our YICTE competition entry.

We have decided on using C++ and Arduino as the programming languages for the software. This is because both Madeleine and I are familiar with Arduino and C++ and we know we can run this software type on our micro-controller – the Intel® Edison.

The first section of the code we have started to build is the “Setup” loop, as based off our state machine. This will contain all of the pre-flight checks and warn us if anything is disconnected or not working. Detecting these problems before the launch is vital and will allow us to know whether any hardware needs fixing right before the launch.

Within the loop, it initialises the serial ports and baud rate, creates the SD card data file and runs a sensor check. Below is a code snippet of what the setup loop will look like.

[code id=”code_id” language=”cpp”]
void setup() {

Serial.begin(9600);

while (!SD.begin(4)) { // check to see whether the SD card can be accessed
Serial.println("SD card inaccessable.");
delay(1000); //wait one second before trying again
}

for (int i =0; i++) {
//("gasp%d.csv", i)
if (!SD.exists(file)) { //check whether the new file already exists
break;
}
else {
Serial.print(file);
Serial.println(" already exists. Attempting File \"gasp%d.csv\". ", i+1);
}}

Serial.print("Creating ");
Serial.println(file);

// file = filename, f = actual file
File f = SD.open(file, FILE_WRITE);

if (f == NULL) {
Serial.println("File could not be accessed.");
while (true) {
delay(1000);
}
}
// load sensors
Serial.println("Loading Sensors…");

for (int i = 0; i < NUM_SENS; i++) {
Serial.print("Loading ");
Serial.print(i);
Serial.println("…");
Sensor* sensor = sensor[i]
}
}
[/code]

Once the setup loop is complete it will be time to work on the body of the data logging software – the part that actually logs the data. This code will be contained inside the main loop or “loop()” as Arduino defines it as.

After all of the main logging software has been completed we will undergo thorough testing to ensure that the addresses and connections of the hardware match the addresses used inside the software. Hopefully, this will prevent the software from failing unless under extreme external circumstances – like if the power is off (or someone’s bad soldering).

 

State Machine

A state machine – or Finite state machine (FSM) – is a way to model computations, which is commonly used in programming and logic circuits. In relation to programming, each state is a section of code or a function and each transition is a the method […]