DAQopter from Digilent Design Contest

DAQopter” is a data acquisition and monitoring system for a wide range of signals using Digilent Wi-Fire and an Android device.

AdvancedFull instructions provided10 hours574

Things used in this project

Hardware components

Digilent Wi-FIRE: WiFi Enabled PIC32MZ Microcontroller Board

Story

The purpose of this project is to create an autonomous flying hexacopter that can be controlled with an Android device using a wireless connection and TCP sockets.

Tools Required

- 1 pcs Digilent Wi-FIRE: WiFi Enabled PIC32MZ Microcontroller Board

- 1 pcs chipKIT PGM Programmer/Debugger

- 1 pcs GWS Servo Kit

- 1 pcs Flame Wheel ARF KIT

- 1 pcs 3S LiPo Battery

- 6 pcs GP2Y0A02YK0F - Infrared Proximity Sensor Long Range

- 1 pcs TTL Serial JPEG Camera

- 6 pcs 5mm LED’s

Project Summary

The hexacopter receives a byte array from the Android device and decodes it as the values for the throttle, aileron, rudder, elevator commands need for the Naza M lite Flight controller. The controller operates the motor for the specific task needed. The Communication between the Wi-Fire and the Naza M is done using PWM servo signals.

The hexacopter has Infrared Proximity Sensors to avoid approaching objects in order to avoid a collision and damaging the device.

The object of this project is to make a device that can access places that people can’t and collect information about that place. This project can be transformed into a room scanning hexacopter that can detect persons in a fire with the front camera and avoid objects with the aid of the sensors. Could be used to scan tunnels or all sort of spaces or high altitude where a person could not go without risking their life.

Features and Specifications

A quadcopter, also called a quadrotor helicopter or quadrotor, is a multirotor helicopter that is lifted and propelled by four rotors. Quadcopters are classified as rotorcraft, as opposed to fixed-wing aircraft, because their lift is generated by a set of rotors (vertically oriented propellers).

Unlike most helicopters, quadcopters use two sets of identical fixed pitched propellers; two clockwise (CW) and two counter-clockwise (CCW). These use a variation of RPM to control lift and torque. Control of vehicle motion is achieved by altering the rotation rate of one or more rotor discs, thereby changing its torque load and thrust/lift characteristics.

Early in the history of flight, quadcopter (referred to as 'quadrotor') configurations were seen as possible solutions to some of the persistent problems in vertical flight; torque-induced control issues (as well as efficiency issues originating from the tail rotor, which generates no useful lift) can be eliminated by counter-rotation and the relatively short blades are much easier to construct. A number of manned designs appeared in the 1920s and 1930s. These vehicles were among the first successful heavier-than-air vertical take-off and landing (VTOL) vehicles. However, early prototypes suffered from poor performance, and latter prototypes required too much pilot workload, due to poor stability augmentation and limited control authority.

More recently quadcopter designs have become popular in unmanned aerial vehicle (UAV) research. These vehicles use an electronic control system and electronic sensors to stabilize the aircraft. With their small size and agile maneuverability, these quadcopters can be flown indoors as well as outdoors.

There are several advantages to quadcopters over comparably-scaled helicopters. First, quadcopters do not require mechanical linkages to vary the rotor blade pitch angle as they spin. This simplifies the design and maintenance of the vehicle. Second, the use of four rotors allows each individual rotor to have a smaller diameter than the equivalent helicopter rotor, allowing them to possess less kinetic energy during flight. This reduces the damage caused should the rotors hit anything. For small-scale UAVs, this makes the vehicles safer for close interaction. Some small-scale quadcopters have frames that enclose the rotors, permitting flights through more challenging environments, with a lower risk of damaging the vehicle or its surroundings.

Operation

The hexacopter has Infrared Proximity Sensors to avoid approaching objects in order to avoid a collision and damaging the device.

Code

/************************************************************************/
#include <MRF24G.h>                     // This is for the MRF24WGxx on a pmodWiFi or WiFiShield

/************************************************************************/
/*                    Required libraries, Do NOT comment out            */
/************************************************************************/
#include <DEIPcK.h>
#include <DEWFcK.h>

#include <Servo.h>
#include <SPI.h>

/************************************************************************/
/*                                                                      */
/*              SET THESE VALUES FOR YOUR NETWORK                       */
/*                                                                      */
/************************************************************************/

//IPv4 ipServer = {192,168,43,120};
IPv4 ipServer = {192,168,2,120};
unsigned short portServer = DEIPcK::iPersonalPorts44 + 300;     // port 44300

// Specify the SSID
//const char * szSsid = "AndroidAP";
//const char * szPassPhrase = "kjso0851";
const char * szSsid = "c17";
const char * szPassPhrase = "Politehnica";
#define WiFiConnectMacro() deIPcK.wfConnect(szSsid, szPassPhrase, &status)

Servo throttle;
Servo rudder;
Servo aileron;
Servo elevator;
Servo gear;

typedef enum
{
    NONE = 0,
    CONNECT,
    LISTEN,
    ISLISTENING,
    WAITISLISTENING,
    AVAILABLECLIENT,
    ACCEPTCLIENT,
    READ,
    WRITE,
    CLOSE,
    EXIT,
    DONE
} STATE;

STATE state = CONNECT;

unsigned tStart = 0;
unsigned tWait = 5000;
int flightControls[4];
String inString = "";
TCPServer tcpServer;
#define cTcpClients 2
TCPSocket rgTcpClient[cTcpClients];

TCPSocket * ptcpClient = NULL;

byte rgbRead[1024];
byte response[9] = {'m','u','l','t','z','a','m','\r','\n'};
int cbRead = 0;
int count = 0;

//int throttlePin = 9;
//int rudderPin = 10;
//int elePin = 6;
//int ailPin = 5;
//int gearPin = 11;

int throttlePin = 6;
int rudderPin = 9;
int elePin = 5;
int ailPin = 3;
int gearPin = 10;

int throttleSetting = 1220; //1220 us correspnds to 0% thrust on Naza. We want to always know what the throttle setting is for safety reasons.
int gearSetting = 1185;

IPSTATUS status;

void setup() {
    pinMode(28, OUTPUT);
    digitalWrite(28, LOW);    // set the LED off
    throttle.attach(throttlePin);
    rudder.attach(rudderPin);
    aileron.attach(ailPin);
    elevator.attach(elePin);
    gear.attach(gearPin);

    //Initial throttle controls: Zero thrust, all other controls neutral.
    //Imperfections in system necessitate using 1470 as opposed to 1500 in some cases
    flightControls[0] = 1220;
    flightControls[1] = 1470;
    flightControls[2] = 1500;
    flightControls[3] = 1470;
    throttleSetting = flightControls[0]; //Redundant, but done mostly for code clarity.
    throttle.writeMicroseconds(throttleSetting);
    aileron.writeMicroseconds(flightControls[1]);
    rudder.writeMicroseconds(flightControls[2]);
    elevator.writeMicroseconds(flightControls[3]);
    gear.writeMicroseconds(gearSetting); //1525 sets dji naza to "Attitude Hold" mode
                                  //1185 sets to "Manual" Mode
                                  //1855 sets to "GPS" mode




    Serial.begin(115200);
    Serial.println("DaqOpter");
    Serial.println("Copyright 2015");
    Serial.println("");
    Serial.println("throttle = " + (String) flightControls[0]);
    Serial.println("aileron  = " + (String) flightControls[1]);
    Serial.println("rudder   = " + (String) flightControls[2]);
    Serial.println("elevator = " + (String) flightControls[3]);
    Serial.println("");
    for (int i = 0; i < 50; i++)
    {
      throttle.writeMicroseconds(1220);
      aileron.writeMicroseconds(1850);
      rudder.writeMicroseconds(1220);
      elevator.writeMicroseconds(1220);
      delay(20);
    }


}

void loop() {

    switch(state)
    {

        case CONNECT:
//        	Serial.println("State = CONNECT");
            if(WiFiConnectMacro())
            {
                Serial.println("Connection Created");
                deIPcK.begin(ipServer);
                state = LISTEN;
            }
            else if(IsIPStatusAnError(status))
            {
                Serial.print("Unable to connection, status: ");
                Serial.println(status, DEC);
                state = CLOSE;
            }
                    throttle.writeMicroseconds(flightControls[0]);
        aileron.writeMicroseconds(flightControls[1]);
        rudder.writeMicroseconds(flightControls[2]);
        elevator.writeMicroseconds(flightControls[3]);
        throttleSetting = flightControls[0]; //We store the value of the throttle for safety during emergencyLanding()

            break;

    // say to listen on the port
    case LISTEN:
 //   	Serial.println("State = LISTEN");
        if(deIPcK.tcpStartListening(portServer, tcpServer))
        {
            for(int i = 0; i < cTcpClients; i++)
            {
                tcpServer.addSocket(rgTcpClient[i]);
            }
        }
        state = ISLISTENING;
                throttle.writeMicroseconds(flightControls[0]);
        aileron.writeMicroseconds(flightControls[1]);
        rudder.writeMicroseconds(flightControls[2]);
        elevator.writeMicroseconds(flightControls[3]);
        throttleSetting = flightControls[0]; //We store the value of the throttle for safety during emergencyLanding()

        break;

    case ISLISTENING:
 //   	Serial.println("State = ISLISTENING");
        count = tcpServer.isListening();
        Serial.print(count, DEC);
        Serial.print(" sockets listening on port: ");
        Serial.println(portServer, DEC);

        if(count > 0)
        {
            state = AVAILABLECLIENT;
        }
        else
        {
            state = WAITISLISTENING;
        }
                throttle.writeMicroseconds(flightControls[0]);
        aileron.writeMicroseconds(flightControls[1]);
        rudder.writeMicroseconds(flightControls[2]);
        elevator.writeMicroseconds(flightControls[3]);
        throttleSetting = flightControls[0]; //We store the value of the throttle for safety during emergencyLanding()

        break;

    case WAITISLISTENING:
 //   	Serial.println("State = WAITISLISTENING");
        if(tcpServer.isListening() > 0)
        {
            state = ISLISTENING;
        }
                throttle.writeMicroseconds(flightControls[0]);
        aileron.writeMicroseconds(flightControls[1]);
        rudder.writeMicroseconds(flightControls[2]);
        elevator.writeMicroseconds(flightControls[3]);
        throttleSetting = flightControls[0]; //We store the value of the throttle for safety during emergencyLanding()

        break;

    // wait for a connection
    case AVAILABLECLIENT:
//    	Serial.println("State = AVAILABLECLIENT");
        if((count = tcpServer.availableClients()) > 0)
        {
            Serial.print("Got ");
            Serial.print(count, DEC);
            Serial.println(" clients pending");
            state = ACCEPTCLIENT;
        }
                throttle.writeMicroseconds(flightControls[0]);
        aileron.writeMicroseconds(flightControls[1]);
        rudder.writeMicroseconds(flightControls[2]);
        elevator.writeMicroseconds(flightControls[3]);
        throttleSetting = flightControls[0]; //We store the value of the throttle for safety during emergencyLanding()

        break;

    // accept the connection
    case ACCEPTCLIENT:
//    	Serial.println("State = ACCEPTCLIENT");
        // accept the client
        if((ptcpClient = tcpServer.acceptClient()) != NULL && ptcpClient->isConnected())
        {
            Serial.println("Got a Connection");
            state = READ;
            tStart = (unsigned) millis();
        }

        // this probably won't happen unless the connection is dropped
        // if it is, just release our socket and go back to listening
        else
        {
            state = CLOSE;
        }
                throttle.writeMicroseconds(flightControls[0]);
        aileron.writeMicroseconds(flightControls[1]);
        rudder.writeMicroseconds(flightControls[2]);
        elevator.writeMicroseconds(flightControls[3]);
        throttleSetting = flightControls[0]; //We store the value of the throttle for safety during emergencyLanding()

        break;

    // wait fot the read, but if too much time elapses (5 seconds)
    // we will just close the tcpClient and go back to listening
    case READ:
 //   	Serial.println("State = READ");
        // see if we got anything to read
        if((cbRead = ptcpClient->available()) > 0)
        {
            cbRead = cbRead < sizeof(rgbRead) ? cbRead : sizeof(rgbRead);
            cbRead = ptcpClient->readStream(rgbRead, cbRead);
            if (cbRead >= 16)
            {
               Serial.print("Got ");
               Serial.print(cbRead, DEC);
               Serial.println(" bytes\n");
               for(int i=0; i < 4; i++)
               {
            	   inString = "";
            	   for(int j=i*4; j < i*4+4; j++)
            	   	   {
            		   	   inString += (char)rgbRead[j];
            	   	   }
            	   flightControls[i] = inString.toInt();
               }
               Serial.println("throttle = " + (String) flightControls[0]);
               Serial.println("aileron  = " + (String) flightControls[1]);
               Serial.println("rudder   = " + (String) flightControls[2]);
               Serial.println("elevator = " + (String) flightControls[3]);
               Serial.println("");
               throttleSetting = flightControls[0]; //We store the value of the throttle for safety during emergencyLanding()

            }
            digitalWrite(28, HIGH);   // set the LED on

            state = WRITE;
        }

        // If too much time elapsed between reads, close the connection
        else if( (((unsigned) millis()) - tStart) > tWait )
        {
           state = CLOSE;
        }
//        Serial.println("Armed. t =" + (String) throttleSetting + " a = " + (String) flightControls[1] + " r = " + (String) flightControls[2] + " e = " + (String) flightControls[3]);
        throttle.writeMicroseconds(flightControls[0]);
        aileron.writeMicroseconds(flightControls[1]);
        rudder.writeMicroseconds(flightControls[2]);
        elevator.writeMicroseconds(flightControls[3]);
        throttleSetting = flightControls[0]; //We store the value of the throttle for safety during emergencyLanding()

        break;

    // echo back the string
    case WRITE:
//    	Serial.println("State = WRITE");
        if(ptcpClient->isConnected())
        {
        	 if (cbRead > 2)
        	            {
            Serial.println("Writing: ");  

//            for(int i=0; i < cbRead; i++)
//            {
//                Serial.print(rgbRead[i], BYTE);
//            }
            for(int i=0; i < 9; i++)
            {
                Serial.print(response[i], BYTE);
            }
            Serial.println("");  

            //

            ptcpClient->writeStream(response, 9);
            }
            //else ptcpClient->writeStream(rgbRead, cbRead);
            state = READ;
            tStart = (unsigned) millis();
        }

        // the connection was closed on us, go back to listening
        else
        {
            Serial.println("Unable to write back.");  
            state = CLOSE;
        }
                throttle.writeMicroseconds(flightControls[0]);
        aileron.writeMicroseconds(flightControls[1]);
        rudder.writeMicroseconds(flightControls[2]);
        elevator.writeMicroseconds(flightControls[3]);
        throttleSetting = flightControls[0]; //We store the value of the throttle for safety during emergencyLanding()

        break;
        
    // close our tcpClient and go back to listening
    case CLOSE:
 //   	Serial.println("State = CLOSE");
//        ptcpClient->close();
//        tcpServer.addSocket(*ptcpClient);
//        Serial.println("");
//        state = ISLISTENING;
    	digitalWrite(28, LOW);    // set the LED off
    	state = READ;
            throttle.writeMicroseconds(flightControls[0]);
        aileron.writeMicroseconds(flightControls[1]);
        rudder.writeMicroseconds(flightControls[2]);
        elevator.writeMicroseconds(flightControls[3]);
        throttleSetting = flightControls[0]; //We store the value of the throttle for safety during emergencyLanding()

        break;

    // something bad happen, just exit out of the program
    case EXIT:
 //   	Serial.println("State = EXIT");
        tcpServer.close();
        Serial.println("Something went wrong, sketch is done.");  
        state = DONE;
        break;

    // do nothing in the loop
    case DONE:
    default:
        break;
    }

    // every pass through loop(), keep the stack alive
    DEIPcK::periodicTasks();
}

Credits

Angelo Pop & Blosenco Iuri

Posted by

Alex Wong

DAQopter from Digilent Design Contest