Subversion Repositories NaviCtrl

/*#######################################################################################*/

// IMPORTANT NOTE:

// This is only a dummy implementation for errorfree compiling of the NaviCtrl sources.

// The GPS navigation routines are NOT included !

/*#######################################################################################*/

/*#######################################################################################*/

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include "91x_lib.h"

#include "uart1.h"

#include "GPS.h"

#include "timer.h"

#include "spi_slave.h"

#include "waypoints.h"

#include "i2c.h"

#define M_PI_180        (M_PI / 180.0f)

#define GPS_UPDATETIME_MS 200           // 200ms is 5 Hz

typedef enum

{

        GPS_FLIGHT_MODE_UNDEF,

        GPS_FLIGHT_MODE_FREE,

        GPS_FLIGHT_MODE_AID,

        GPS_FLIGHT_MODE_WAYPOINT

} GPS_FlightMode_t;

typedef struct

{

        float Gain;

        float P;

        float I;

        float D;

        float A;

        float ACC;

        u8 MinSat;

        s8 StickThreshold;

        float WindCorrection;

        s32 OperatingRadius;

        u32 NaviAngleLimitation;

        GPS_FlightMode_t  FlightMode;

} __attribute__((packed)) GPS_Parameter_t;

typedef struct

{

        Status_t Status; // invalid, newdata, processed

        s32 North;              // in cm

        s32 East;               // in cm

        s32 Bearing;    // in deg

        s32 Distance;   // in cm

} __attribute__((packed)) GPS_Deviation_t;

GPS_Deviation_t TargetDeviation;

GPS_Stick_t             GPS_Stick;

GPS_Parameter_t GPS_Parameter;

// the gps reference positions

GPS_Pos_t GPS_HoldPosition      = {0,0,0, INVALID};                     // the hold position

GPS_Pos_t GPS_HomePosition      = {0,0,0, INVALID};                     // the home position

GPS_Pos_t * GPS_pTargetPosition = NULL;                             // pointer to the actual target position

Waypoint_t* GPS_pWaypoint = NULL;                                               // pointer to the actual waypoint

//-------------------------------------------------------------

// Update GPSParamter

void GPS_UpdateParameter(void)

{

        static GPS_FlightMode_t FlightMode_Old = GPS_FLIGHT_MODE_UNDEF;

        // in case of bad receiving conditions

        if(FC.RC_Quality < 100)

        {       // set fixed parameter

                GPS_Parameter.FlightMode = GPS_FLIGHT_MODE_FREE;

                GPS_Parameter.Gain      = (float) 100;

                GPS_Parameter.P         = (float) 90;

                GPS_Parameter.I         = (float) 90;

                GPS_Parameter.D         = (float) 90;

                GPS_Parameter.A         = (float) 90;

                GPS_Parameter.ACC       = (float) 0;

                GPS_Parameter.MinSat = 6;

                GPS_Parameter.StickThreshold = 8;

                GPS_Parameter.WindCorrection = 0.0;

                GPS_Parameter.OperatingRadius = 0; // forces the aircraft to fly to home positon

                GPS_Parameter.NaviAngleLimitation = 125;

        }

        else

        {

                // update parameter from FC

                if(StopNavigation) GPS_Parameter.FlightMode = GPS_FLIGHT_MODE_FREE;

                else

                {

                        if     (Parameter.NaviGpsModeControl <  50) GPS_Parameter.FlightMode = GPS_FLIGHT_MODE_AID;

                        else if(Parameter.NaviGpsModeControl < 180) GPS_Parameter.FlightMode = GPS_FLIGHT_MODE_FREE;

                        else                                                    GPS_Parameter.FlightMode = GPS_FLIGHT_MODE_WAYPOINT;

                }

                GPS_Parameter.Gain      = (float)Parameter.NaviGpsGain;

                GPS_Parameter.P         = (float)Parameter.NaviGpsP;

                GPS_Parameter.I         = (float)Parameter.NaviGpsI;

                GPS_Parameter.D         = (float)Parameter.NaviGpsD;

                GPS_Parameter.A         = (float)Parameter.NaviGpsD;

                GPS_Parameter.ACC       = (float)Parameter.NaviGpsACC;

                GPS_Parameter.MinSat = (u8)Parameter.NaviGpsMinSat;

                GPS_Parameter.StickThreshold = (s8)Parameter.NaviStickThreshold;

                GPS_Parameter.WindCorrection = (float)Parameter.NaviWindCorrection;

                GPS_Parameter.OperatingRadius = (s32)Parameter.NaviOperatingRadius * 100; // conversion of m to cm

                GPS_Parameter.NaviAngleLimitation = (u32) Parameter.NaviAngleLimitation * 2;

        }

        // FlightMode changed?

        if(GPS_Parameter.FlightMode != FlightMode_Old) BeepTime = 100; // beep to indicate that mode has switched

        FlightMode_Old = GPS_Parameter.FlightMode;

}

//-------------------------------------------------------------

// This function defines a good GPS signal condition

u8 GPS_IsSignalOK(void)

{

        if( (GPSData.Status != INVALID) && (GPSData.SatFix == SATFIX_3D) &&  (GPSData.NumOfSats >= GPS_Parameter.MinSat)) return(1);

        else return(0);

}

//------------------------------------------------------------

// Checks for manual control action

u8 GPS_IsManuallyControlled(void)

{

        if( ( (abs(FC.StickNick) > GPS_Parameter.StickThreshold) || (abs(FC.StickRoll) > GPS_Parameter.StickThreshold)) && (GPS_Parameter.StickThreshold > 0)) return 1;

        else return 0;

}

//------------------------------------------------------------

// copy GPS position from source position to target position

u8 GPS_CopyPosition(GPS_Pos_t * pGPSPosSrc, GPS_Pos_t* pGPSPosTgt)

{

        u8 retval = 0;

        if((pGPSPosSrc == NULL) || (pGPSPosTgt == NULL)) return(retval);        // bad pointer

        // copy only valid positions

        if(pGPSPosSrc->Status != INVALID)

        {

                // if the source GPS position is not invalid

                pGPSPosTgt->Longitude   = pGPSPosSrc->Longitude;

                pGPSPosTgt->Latitude    = pGPSPosSrc->Latitude;

                pGPSPosTgt->Altitude    = pGPSPosSrc->Altitude;

                pGPSPosTgt->Status              = NEWDATA; // mark data in target position as new

                retval = 1;

        }

        return(retval);

}

//------------------------------------------------------------

u8 GPS_ClearPosition(GPS_Pos_t * pGPSPos)

{

        u8 retval = FALSE;

        if(pGPSPos == NULL) return(retval);     // bad pointer

        else

                pGPSPos->Longitude      = 0;

                pGPSPos->Latitude       = 0;

                pGPSPos->Altitude       = 0;

                retval = TRUE;

        return (retval);

        GPS_Stick.Nick  = 0;

//------------------------------------------------------------

{

        SerialPutString("\r\n GPS init...");

        GPS_ClearPosition(&GPS_HoldPosition);

        GPS_pTargetPosition = NULL;

        WPList_Init();

}

        s32 bearing;

        bearing = (s32)(atan2(northdev, eastdev) / M_PI_180);

        return(bearing);

}

//------------------------------------------------------------

// Rescale xy-vector length if length limit is violated

void GPS_LimitXY(s32 *x, s32 *y, s32 limit)

{

        s32 dist;

        dist = (s32)hypot(*x,*y);       // the length of the vector

        if ((dist != 0L) && (dist > limit))

        // if vector length is larger than the given limit

        {       // scale vector compontents so that the length is cut off to limit

                *x = (*x * limit) / dist;

//------------------------------------------------------------

// transform the integer deg into float radians

//------------------------------------------------------------

{

  return ((double)deg  * 1e-7f); // 1E-7 because deg is the value in ° * 1E7

}

//------------------------------------------------------------

// calculate the deviation from the current position to the target position

u8 GPS_CalculateDeviation(GPS_Pos_t * pCurrentPos, GPS_Pos_t * pTargetPos)

{

        if((pCurrentPos->Status == INVALID) || (pTargetPos->Status == INVALID)) goto baddata;

        // simple the lat/lon difference. To convert that angular deviation into an

        // arc length the spherical projection has to be considered.

        // The mean earth radius is 6371km. Therfore the arc length per latitude degree

        // is always 6371km * 2 * Pi / 360deg =  111.2 km/deg.

        // is 111.2km * cos(latitude).

        // calculate the shortest longitude deviation from target

        temp1 = DegFromGPS(pCurrentPos->Longitude) - DegFromGPS(pTargetPos->Longitude);

        // outside an angular difference of -180 deg ... +180 deg its shorter to go the other way around

        // In our application we wont fly more than 20.000 km but along the date line this is important.

        if(temp1 > 180.0f) temp1 -= 360.0f;

        // calculate latitude deviation from target

        // this is allways within -180 deg ... 180 deg

        temp2 = DegFromGPS(pCurrentPos->Latitude) - DegFromGPS(pTargetPos->Latitude);

        // deviation from target position in cm

        // i.e. the distance to walk from the target in northern and eastern direction to reach the current position

        TargetDeviation.Status = INVALID;

        TargetDeviation.North = (s32)(11119492.7f * temp2);

        // If the position deviation is small enough to neglect the earth curvature

        // (this is for our application always fulfilled) the distance to target

        // can be calculated by the pythagoras of north and east deviation.

        TargetDeviation.North           = 0L;

        TargetDeviation.East            = 0L;

        TargetDeviation.Distance        = 0L;

        TargetDeviation.Bearing         = 0L;

        TargetDeviation.Status = INVALID;

        return FALSE;

}

//------------------------------------------------------------

void GPS_Navigation(void)

{

        static u32 beep_rythm;

        static u32 GPSDataTimeout = 0;

        // pointer to current target position

        static GPS_Pos_t RangedTargetPosition = {0,0,0, INVALID};               // the limited target position, this is derived from the target position with repect to the operating radius

        static s32 OperatingRadiusOld = -1;

        static u8 WPArrived = FALSE;

        static u32 WPTime = 0;

        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        //+ Check for new data from GPS-receiver

        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        switch(GPSData.Status)

        {

                case INVALID: // no gps data available

                        // do nothing

                        break;

                case PROCESSED: // the current data have been allready processed

                        // if no new data are available within the timeout switch to invalid state.

                        if(CheckDelay(GPSDataTimeout)) GPSData.Status = INVALID;

                        // wait for new gps data

                        break;

                case NEWDATA: // handle new gps data

                // update GPS Parameter from FC-Data via SPI interface

                GPS_UpdateParameter();

                        // wait maximum of 3 times the normal data update time before data timemout

                        GPSDataTimeout = SetDelay(3 * GPS_UPDATETIME_MS);

                        beep_rythm++;

                        // debug

                        DebugOut.Analog[21] = (u16)GPSData.Speed_North;

                        DebugOut.Analog[22] = (u16)GPSData.Speed_East;

                        DebugOut.Analog[31] = (u16)GPSData.NumOfSats;

                        // If GPS signal condition is sufficient for a reliable position measurement

                        if(GPS_IsSignalOK())

                        {

                                // if the MK is starting or the home position is invalid then store the home position

                                if((FC.MKFlags & MKFLAG_START) || (GPS_HomePosition.Status == INVALID))

                                {       // try to update the home position from the current position

                                        if(GPS_CopyPosition(&(GPSData.Position), &GPS_HomePosition))

                                        {

                                                BeepTime = 700; // beep on success

                                        }

                                        GPS_pWaypoint = WPList_Begin(); // go to start of waypoint list, return NULL of the list is empty

                                }

                                /* The selected flight mode influences the target position pointer and therefore the behavior */

                                // check for current flight mode and set the target pointer GPS_pTargetPosition respectively

                                {

                                        // the GPS control is deactived

                                        case GPS_FLIGHT_MODE_FREE:

                                                NaviData.NCFlags &= ~(NC_FLAG_PH | NC_FLAG_CH);

                                                NaviData.NCFlags |= NC_FLAG_FREE;

                                                // update hold position

                                                GPS_CopyPosition(&(GPSData.Position), &GPS_HoldPosition);

                                                // no target position

                                                GPS_pTargetPosition = NULL;

                                                break;

                                        // the GPS supports the position hold, if the pilot takes no action

                                        case GPS_FLIGHT_MODE_AID:

                                                NaviData.NCFlags &= ~(NC_FLAG_FREE | NC_FLAG_CH);

                                                NaviData.NCFlags |= NC_FLAG_PH;

                                                {

                                                    GPS_CopyPosition(&(GPSData.Position), &GPS_HoldPosition);

                                                        GPS_pTargetPosition = NULL;

                                                }

                                                else

                                                {

                                                        GPS_pTargetPosition = &GPS_HoldPosition;

                                                }

                                                break;

                                        // the GPS control is directed to a target position

                                        // given by a waypoint or by the home position

                                        case GPS_FLIGHT_MODE_WAYPOINT:

                                                NaviData.NCFlags &= ~(NC_FLAG_FREE | NC_FLAG_PH);

                                                NaviData.NCFlags |= NC_FLAG_CH;

                                                        if(GPS_pWaypoint->Position.Status == INVALID) // should never happen

                                                        {

                                                                GPS_pWaypoint = WPList_Next(); // goto to next WP

                                                                WPArrived = FALSE;

                                                                BeepTime = 255;

                                                        }

                                                        else // waypoint position is valid

                                                        {

                                                                // check if the pointer to the waypoint has been changed or the data have been updated

                                                                if((GPS_pWaypoint != GPS_pWaypointOld) || (GPS_pWaypoint->Position.Status == NEWDATA))

                                                                {

                                                                        GPS_pWaypointOld = GPS_pWaypoint;

                                                                        // reset the arrived bit to break a pending HoldTime of the old WP

                                                                        WPArrived = FALSE;

                                                                }

                                                                if(TargetDeviation.Status != INVALID)

                                                                {       // if the waypoint was not catched and the target area has been reached

                                                                        if(!WPArrived && (TargetDeviation.Distance < (GPS_pWaypoint->ToleranceRadius * 100)))

                                                                        {

                                                                                WPArrived = TRUE;

                                                                                WPTime = SetDelay(GPS_pWaypoint->HoldTime * 1000); // set hold time stamp

                                                                        }

                                                                }

                                                                // if WP has been reached once, wait hold time before trigger to next one

                                                                if(WPArrived)

                                                                {

                                                                        /* ToDo: Adjust GPS_pWaypoint->Heading, GPS_pWaypoint->Event handling */

                                                                } // EOF if(WPArrived)

                                                        }

                                                } // EOF waypoint trigger logic

                                                if(GPS_pWaypoint != NULL) // Waypoint exist

                                                {

                                                        // update the hold position

                                                        GPS_CopyPosition(&(GPSData.Position), &GPS_HoldPosition);

                                                        GPS_pTargetPosition = &(GPS_pWaypoint->Position);

                                                }

                                                else // no waypoint info available, i.e. the WPList is empty or the end of the list has been reached

                                                {

                                                        // fly back to home postion

                                                        if(GPS_HomePosition.Status == INVALID)

                                                        {

                                                                GPS_pTargetPosition = &GPS_HoldPosition; // fall back to hold mode if home position is not available

                                                                BeepTime = 255; // beep to indicate missin home position

                                                        }

                                                        else // the home position is valid

                                                        {

                                                                // update the hold position

                                                                GPS_CopyPosition(&(GPSData.Position), &GPS_HoldPosition);

                                                                // set target to home position

                                                                GPS_pTargetPosition = &GPS_HomePosition;

                                                        }

                                                }

                                                break;

                                        case GPS_FLIGHT_MODE_UNDEF:

                                        default:

                                                // update hold position

                                                GPS_CopyPosition(&(GPSData.Position), &GPS_HoldPosition);

                                                // no target position

                                                break;

                                }// EOF GPS Mode Handling

                                /* Calculation of range target based on the real target */

                                // if no target position exist clear the ranged target position

                                if(GPS_pTargetPosition == NULL) GPS_ClearPosition(&RangedTargetPosition);

                                {       // if the target position has been changed or the value has been updated or the OperatingRadius has changed

                                        if((GPS_pTargetPosition != pTargetPositionOld)  || (GPS_pTargetPosition->Status == NEWDATA) || (GPS_Parameter.OperatingRadius != OperatingRadiusOld) )

                                        {

                                                // calculate deviation of new target position from home position

                                                if(GPS_CalculateDeviation(GPS_pTargetPosition, &GPS_HomePosition))

                                                {

                                                        // check distance from home position

                                                        if(TargetDeviation.Distance > GPS_Parameter.OperatingRadius)

                                                        {

                                                                //calculate ranged target position to be within the operation radius area

                                                                NaviData.NCFlags |= NC_FLAG_RANGE_LIMIT;

                                                            TargetDeviation.Distance = GPS_Parameter.OperatingRadius;

                                                                GPS_LimitXY(&(TargetDeviation.East), &(TargetDeviation.North), TargetDeviation.Distance);

                                                                RangedTargetPosition.Status = INVALID;

                                                                RangedTargetPosition.Latitude = GPS_HomePosition.Latitude;

                                                                RangedTargetPosition.Latitude += (s32)((float)TargetDeviation.North / 1.11194927f);

                                                                RangedTargetPosition.Longitude = GPS_HomePosition.Longitude;

                                                                RangedTargetPosition.Longitude += (s32)((float)TargetDeviation.East / (1.11194927f * cos(RadiansFromGPS(GPS_HomePosition.Latitude))) );

                                                                RangedTargetPosition.Status = NEWDATA;

                                                        }

                                                        else

                                                        {       // the target is located within the operation radius area

                                                                // simple copy the loaction to the ranged target position

                                                                GPS_CopyPosition(GPS_pTargetPosition, &RangedTargetPosition);

                                                                NaviData.NCFlags &= ~NC_FLAG_RANGE_LIMIT;

                                                        }

                                                }

                                                else

                                                {       // deviation could not be determined

                                                        GPS_ClearPosition(&RangedTargetPosition);

                                                GPS_pTargetPosition->Status = PROCESSED;        // mark current target as processed!

                                OperatingRadiusOld = GPS_Parameter.OperatingRadius;

                                // calculate deviation of current position to ranged target position in cm

                                if(GPS_CalculateDeviation(&(GPSData.Position), &RangedTargetPosition))

                                        // implement your control code here based

                                        // in the info available in the TargetDeviation, GPSData and FromFlightCtrl.GyroHeading

                                        GPS_Stick.Nick = 0;

                                        GPS_Stick.Roll = 0;

                                        GPS_Stick.Yaw  = 0;

                                }

                                else // deviation could not be calculated

                                {   // do nothing on gps sticks!

                                        GPS_Neutral();

                                }

                        }// eof if GPSSignal is OK

                        else // GPSSignal not OK

                        {

                                GPS_Neutral();

                                // beep if signal is not sufficient

                                if(GPS_Parameter.FlightMode != GPS_FLIGHT_MODE_FREE)

                                {

                                        if(!(GPSData.Flags & FLAG_GPSFIXOK) && !(beep_rythm % 5)) BeepTime = 100;

                                        else if (GPSData.NumOfSats < GPS_Parameter.MinSat && !(beep_rythm % 5)) BeepTime = 10;

                                }

                        }

                    GPSData.Status = PROCESSED; // mark as processed

                        break;

        }

        DebugOut.Analog[27] = (s16)TargetDeviation.North;

        DebugOut.Analog[28] = (s16)TargetDeviation.East;

        DebugOut.Analog[29] = GPS_Stick.Nick;

        DebugOut.Analog[30] = GPS_Stick.Roll;

        // update navi data, send back to ground station

        GPS_CopyPosition(&(GPSData.Position), &(NaviData.CurrentPosition));

        GPS_CopyPosition(&RangedTargetPosition, &(NaviData.TargetPosition));

        NaviData.SatsInUse = GPSData.NumOfSats;

        NaviData.TargetPositionDeviation.Distance = TargetDeviation.Distance;

        NaviData.TargetPositionDeviation.Bearing = TargetDeviation.Bearing;