philip/MDH-UAV-Control-System
Archived
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Adde functionality

Browse Source 
Added fucntionality to make failseafes and bool toggles.
This commit is contained in:
Jonas Holmberg 2016-10-11 18:06:23 +02:00
parent a81bb6f808
commit 7deb9041a6
11 changed files with 681 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
UAV-ControlSystem/inc/config/eeprom.h
View File

@ -172,10 +172,18 @@ typedef enum {
EEPROM_PERIOD_ALTITUDE,
#endif
#if BEEPER
EEPROM_PERIOD_BEEPER
EEPROM_PERIOD_BEEPER,
#endif
/* Flags eeprom values */
EEPROM_FLAG_ARM,
EEPROM_FLAG_FLIGHTMODE_ACCELEROMETER,
EEPROM_FLAG_FLIGHTMODE_BAROMETER,
EEPROM_FLAG_FLIGHTMODE_COMPASS,
EEPROM_FLAG_FLIGHTMODE_GPS,
EEPROM_FLAG_FLIGHTMODE_1,
EEPROM_FLAG_FLIGHTMODE_2,
EEPROM_FLAG_FLIGHTMODE_3,
/* Counts the amount of system settings */
EEPROM_SYS_COUNT

170
UAV-ControlSystem/inc/drivers/failsafe_toggles.h Normal file
View File

@ -0,0 +1,170 @@
/*
* failsafe_toggles.h
*
* Created on: 10 okt. 2016
* Author: holmis
*/
#ifndef DRIVERS_FAILSAFE_TOGGLES_H_
#define DRIVERS_FAILSAFE_TOGGLES_H_
#include "stdint.h"
//Macro functions
#define getFlagMaskValue(x) (1 << x)
#define failSafe_vals_offset 0 //offset for the fail safe values in the bitfield
#define boolean_vals_offset 2 //offset for the booleans values in the bitfield
/*If a new value is added to the bitfield these IDs must be reviewed and checkd so that they still are correct*/
//failsafe values
#define systemFlags_Failsafe_rcChannelInRange_id 0 + failSafe_vals_offset
#define systemFlags_Failsafe_noRcReceived_id 1 + failSafe_vals_offset
//other flags
#define systemFlags_armed_id 0 + boolean_vals_offset
#define systemFlags_flightmode_acceleromter_id 1 + boolean_vals_offset
#define systemFlags_flightmode_barometer_id 2 + boolean_vals_offset
#define systemFlags_flightmode_compass_id 3 + boolean_vals_offset
#define systemFlags_flightmode_gps_id 4 + boolean_vals_offset
#define systemFlags_flightMode_1_id 5 + boolean_vals_offset
#define systemFlags_flightMode_2_id 6 + boolean_vals_offset
#define systemFlags_flightMode_3_id 7 + boolean_vals_offset
/*Mask values for each of the flag values*/
//failsafe values
#define systemFlags_Failsafe_rcChannelInRange_mask getFlagMaskValue(systemFlags_Failsafe_rcChannelInRange_id)
#define systemFlags_Failsafe_noRcReceived_mask getFlagMaskValue(systemFlags_Failsafe_noRcReceived_id)
//other flags
#define systemFlags_armed_mask getFlagMaskValue(systemFlags_armed_id)
#define systemFlags_flightmode_acceleromter_mask getFlagMaskValue(systemFlags_flightmode_acceleromter_id)
#define systemFlags_flightmode_barometer_mask getFlagMaskValue(systemFlags_flightmode_barometer_id)
#define systemFlags_flightmode_compass_mask getFlagMaskValue(systemFlags_flightmode_compass_id)
#define systemFlags_flightmode_gps_mask getFlagMaskValue(systemFlags_flightmode_gps_id)
#define systemFlags_flightMode_1_mask getFlagMaskValue(systemFlags_flightMode_1_id)
#define systemFlags_flightMode_2_mask getFlagMaskValue(systemFlags_flightMode_2_id)
#define systemFlags_flightMode_3_mask getFlagMaskValue(systemFlags_flightMode_3_id)
//typedef for the boolean value
typedef unsigned int booleanValue_t;
/* Struct containing all the failsafe on boolean values in the system */
typedef union bitSetRegion
{
struct
{
//fail-safe booleans
booleanValue_t rcChannelInRange : 1;
booleanValue_t noRcReceived : 1;
//Flag boleans that are not fail-safe
booleanValue_t armed : 1;
booleanValue_t acceleromter : 1;
booleanValue_t barometer : 1;
booleanValue_t compass : 1;
booleanValue_t gps : 1;
booleanValue_t flightMode_1 : 1;
booleanValue_t flightMode_2 : 1;
booleanValue_t flightMode_3 : 1;
}bitField;
uint64_t intRepresentation;
}boolFlags_t;
/* Stuct to define values that can be changed and manipulated by RC commands */
typedef struct
{
uint16_t minRange; //minimum range value in a RC channel (uint16 to save space, increase if higher ranges are needed)
uint16_t maxRange; //maximum range value in a RC channel (uint16 to save space, increase if higher ranges are needed)
uint8_t channelNumber; //The RC channel number for the value
uint8_t flagId; //ID for the flag to be changed in the system
}flags_Configuration_t;
typedef enum
{
FLAG_CONFIGURATION_ARM = 0,
FLAG_CONFIGURATION_FLIGHTMODE_ACCELEROMETER,
FLAG_CONFIGURATION_FLIGHTMODE_BAROMETER,
FLAG_CONFIGURATION_FLIGHTMODE_COMPASS,
FLAG_CONFIGURATION_FLIGHTMODE_GPS,
FLAG_CONFIGURATION_FLIGHTMODE_1,
FLAG_CONFIGURATION_FLIGHTMODE_2,
FLAG_CONFIGURATION_FLIGHTMODE_3,
//Counter
FLAG_CONFIGURATION_COUNT
}flags_configuration_IDs_t;
/* Stuct containing values for all the flags and failsafe booleans sin the system */
extern boolFlags_t systemFlags;
/* Array of flag configurations. These are values that can be set by RC. */
extern flags_Configuration_t flagConfigArr[FLAG_CONFIGURATION_COUNT];
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void initFlags();
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void flags_ProcessRcChannel(int rcChannel_ID, int value);
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void flags_Set_ID(int id);
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void flags_Clear_ID(int id);
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void flags_Toggle_ID(int id);
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
bool flags_IsSet_ID(int id);
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void flags_Set_MASK(int mask);
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void flags_Clear_MASK(int mask);
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void flags_Toggle_MASK(int mask);
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
bool flags_IsSet_MASK(int mask);
#endif /* DRIVERS_FAILSAFE_TOGGLES_H_ */

8
UAV-ControlSystem/inc/drivers/sbus.h
View File

@ -29,6 +29,7 @@
#define SBUS_MAX_CHANNEL 18 // Including two digital
#define STICK_CHANNEL_COUNT 4
#define AUX_CHANNEL_COUNT 4
#define MAX_AUX_CHANNEL_COUNT (SBUS_MAX_CHANNEL - STICK_CHANNEL_COUNT)
@ -128,4 +129,11 @@ bool sbus_frame_available();
***********************************************************************/
void sbus_read();
/***********************************************************************
* BRIEF: Give the value of a channel in "sbusChannelData" *
* INFORMATION: Given a channel id the value of that channel will be *
* returned. *
***********************************************************************/
int getChannelValue(sbusFrame_s frame, int id);
#endif /* DRIVERS_SBUS_H_ */

181
UAV-ControlSystem/src/config/cli.c
View File

@ -170,6 +170,39 @@ typedef enum
COMMAND_ID_PERIOD_BEEPER,
#endif
/* Commands for changing flag toggles from RC */
COMMAND_ID_FLAG_ARM_MINRANGE,
COMMAND_ID_FLAG_ARM_MAXRANGE,
COMMAND_ID_FLAG_ARM_CHANNEL,
COMMAND_ID_FLAG_FLIGHTMODE_ACCELEROMETER_MINRANGE,
COMMAND_ID_FLAG_FLIGHTMODE_ACCELEROMETER_MAXRANGE,
COMMAND_ID_FLAG_FLIGHTMODE_ACCELEROMETER_CHANNEL,
COMMAND_ID_FLAG_FLIGHTMODE_BAROMETER_MINRANGE,
COMMAND_ID_FLAG_FLIGHTMODE_BAROMETER_MAXRANGE,
COMMAND_ID_FLAG_FLIGHTMODE_BAROMETER_CHANNEL,
COMMAND_ID_FLAG_FLIGHTMODE_COMPASS_MINRANGE,
COMMAND_ID_FLAG_FLIGHTMODE_COMPASS_MAXRANGE,
COMMAND_ID_FLAG_FLIGHTMODE_COMPASS_CHANNEL,
COMMAND_ID_FLAG_FLIGHTMODE_GPS_MINRANGE,
COMMAND_ID_FLAG_FLIGHTMODE_GPS_MAXRANGE,
COMMAND_ID_FLAG_FLIGHTMODE_GPS_CHANNEL,
COMMAND_ID_FLAG_FLIGHTMODE_1_MINRANGE,
COMMAND_ID_FLAG_FLIGHTMODE_1_MAXRANGE,
COMMAND_ID_FLAG_FLIGHTMODE_1_CHANNEL,
COMMAND_ID_FLAG_FLIGHTMODE_2_MINRANGE,
COMMAND_ID_FLAG_FLIGHTMODE_2_MAXRANGE,
COMMAND_ID_FLAG_FLIGHTMODE_2_CHANNEL,
COMMAND_ID_FLAG_FLIGHTMODE_3_MINRANGE,
COMMAND_ID_FLAG_FLIGHTMODE_3_MAXRANGE,
COMMAND_ID_FLAG_FLIGHTMODE_3_CHANNEL,
COMMAND_ID_COUNT,
COMMAND_ID_NO_COMMAND
@ -283,6 +316,116 @@ const cliCommandConfig_t commandTable[COMMAND_ID_COUNT] = {
"task_period_beeper", COMMAND_ID_PERIOD_BEEPER, EEPROM_PERIOD_BEEPER, EEPROM_VALUE_TYPE_SYSTEM, 0, VAL_UINT_32, .valueRange = {0, 1000000000}
},
#endif
/* Commands for changing flag toggles from RC */
[COMMAND_ID_FLAG_ARM_MINRANGE] =
{
"flag_arm_minrange", COMMAND_ID_FLAG_ARM_MINRANGE, EEPROM_FLAG_ARM, EEPROM_VALUE_TYPE_SYSTEM, 0, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_ARM_MAXRANGE] =
{
"flag_arm_maxrange", COMMAND_ID_FLAG_ARM_MAXRANGE, EEPROM_FLAG_ARM, EEPROM_VALUE_TYPE_SYSTEM, 2, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_ARM_CHANNEL] =
{
"flag_arm_channel", COMMAND_ID_FLAG_ARM_CHANNEL, EEPROM_FLAG_ARM, EEPROM_VALUE_TYPE_SYSTEM, 4, VAL_UINT_8, .valueRange = {0, 18}
},
[COMMAND_ID_FLAG_FLIGHTMODE_ACCELEROMETER_MINRANGE] =
{
"flag_flightmode_accelerometer_minrange", COMMAND_ID_FLAG_FLIGHTMODE_ACCELEROMETER_MINRANGE, EEPROM_FLAG_FLIGHTMODE_ACCELEROMETER, EEPROM_VALUE_TYPE_SYSTEM, 0, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_FLIGHTMODE_ACCELEROMETER_MAXRANGE] =
{
"flag_flightmode_accelerometer_maxrange", COMMAND_ID_FLAG_FLIGHTMODE_ACCELEROMETER_MAXRANGE, EEPROM_FLAG_FLIGHTMODE_ACCELEROMETER, EEPROM_VALUE_TYPE_SYSTEM, 2, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_FLIGHTMODE_ACCELEROMETER_CHANNEL] =
{
"flag_flightmode_accelerometer_channel", COMMAND_ID_FLAG_FLIGHTMODE_ACCELEROMETER_CHANNEL, EEPROM_FLAG_FLIGHTMODE_ACCELEROMETER, EEPROM_VALUE_TYPE_SYSTEM, 4, VAL_UINT_8, .valueRange = {0, 18}
},
[COMMAND_ID_FLAG_FLIGHTMODE_BAROMETER_MINRANGE] =
{
"flag_flightmode_barometer_minrange", COMMAND_ID_FLAG_FLIGHTMODE_BAROMETER_MINRANGE, EEPROM_FLAG_FLIGHTMODE_BAROMETER, EEPROM_VALUE_TYPE_SYSTEM, 0, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_FLIGHTMODE_BAROMETER_MAXRANGE] =
{
"flag_flightmode_barometer_maxrange", COMMAND_ID_FLAG_FLIGHTMODE_BAROMETER_MAXRANGE, EEPROM_FLAG_FLIGHTMODE_BAROMETER, EEPROM_VALUE_TYPE_SYSTEM, 2, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_FLIGHTMODE_BAROMETER_CHANNEL] =
{
"flag_flightmode_barometer_channel", COMMAND_ID_FLAG_FLIGHTMODE_BAROMETER_CHANNEL, EEPROM_FLAG_FLIGHTMODE_BAROMETER, EEPROM_VALUE_TYPE_SYSTEM, 4, VAL_UINT_8, .valueRange = {0, 18}
},
[COMMAND_ID_FLAG_FLIGHTMODE_COMPASS_MINRANGE] =
{
"flag_flightmode_compass_minrange", COMMAND_ID_FLAG_FLIGHTMODE_COMPASS_MINRANGE, EEPROM_FLAG_FLIGHTMODE_COMPASS, EEPROM_VALUE_TYPE_SYSTEM, 0, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_FLIGHTMODE_COMPASS_MAXRANGE] =
{
"flag_flightmode_compass_maxrange", COMMAND_ID_FLAG_FLIGHTMODE_COMPASS_MAXRANGE, EEPROM_FLAG_FLIGHTMODE_COMPASS, EEPROM_VALUE_TYPE_SYSTEM, 2, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_FLIGHTMODE_COMPASS_CHANNEL] =
{
"flag_flightmode_compass_channel", COMMAND_ID_FLAG_FLIGHTMODE_COMPASS_CHANNEL, EEPROM_FLAG_FLIGHTMODE_COMPASS, EEPROM_VALUE_TYPE_SYSTEM, 4, VAL_UINT_8, .valueRange = {0, 18}
},
[COMMAND_ID_FLAG_FLIGHTMODE_GPS_MINRANGE] =
{
"flag_flightmode_gps_minrange", COMMAND_ID_FLAG_FLIGHTMODE_GPS_MINRANGE, EEPROM_FLAG_FLIGHTMODE_GPS, EEPROM_VALUE_TYPE_SYSTEM, 0, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_FLIGHTMODE_GPS_MAXRANGE] =
{
"flag_flightmode_gps_maxrange", COMMAND_ID_FLAG_FLIGHTMODE_GPS_MAXRANGE, EEPROM_FLAG_FLIGHTMODE_GPS, EEPROM_VALUE_TYPE_SYSTEM, 2, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_FLIGHTMODE_GPS_CHANNEL] =
{
"flag_flightmode_gps_channel", COMMAND_ID_FLAG_FLIGHTMODE_GPS_CHANNEL, EEPROM_FLAG_FLIGHTMODE_GPS, EEPROM_VALUE_TYPE_SYSTEM, 4, VAL_UINT_8, .valueRange = {0, 18}
},
[COMMAND_ID_FLAG_FLIGHTMODE_1_MINRANGE] =
{
"flag_flightmode_1_minrange", COMMAND_ID_FLAG_FLIGHTMODE_1_MINRANGE, EEPROM_FLAG_FLIGHTMODE_1, EEPROM_VALUE_TYPE_SYSTEM, 0, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_FLIGHTMODE_1_MAXRANGE] =
{
"flag_flightmode_1_maxrange", COMMAND_ID_FLAG_FLIGHTMODE_1_MAXRANGE, EEPROM_FLAG_FLIGHTMODE_1, EEPROM_VALUE_TYPE_SYSTEM, 2, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_FLIGHTMODE_1_CHANNEL] =
{
"flag_flightmode_1_channel", COMMAND_ID_FLAG_FLIGHTMODE_1_CHANNEL, EEPROM_FLAG_FLIGHTMODE_1, EEPROM_VALUE_TYPE_SYSTEM, 4, VAL_UINT_8, .valueRange = {0, 18}
},
[COMMAND_ID_FLAG_FLIGHTMODE_2_MINRANGE] =
{
"flag_flightmode_2_minrange", COMMAND_ID_FLAG_FLIGHTMODE_2_MINRANGE, EEPROM_FLAG_FLIGHTMODE_2, EEPROM_VALUE_TYPE_SYSTEM, 0, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_FLIGHTMODE_2_MAXRANGE] =
{
"flag_flightmode_2_maxrange", COMMAND_ID_FLAG_FLIGHTMODE_2_MAXRANGE, EEPROM_FLAG_FLIGHTMODE_2, EEPROM_VALUE_TYPE_SYSTEM, 2, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_FLIGHTMODE_2_CHANNEL] =
{
"flag_flightmode_2_channel", COMMAND_ID_FLAG_FLIGHTMODE_2_CHANNEL, EEPROM_FLAG_FLIGHTMODE_2, EEPROM_VALUE_TYPE_SYSTEM, 4, VAL_UINT_8, .valueRange = {0, 18}
},
[COMMAND_ID_FLAG_FLIGHTMODE_3_MINRANGE] =
{
"flag_flightmode_3_minrange", COMMAND_ID_FLAG_FLIGHTMODE_3_MINRANGE, EEPROM_FLAG_FLIGHTMODE_3, EEPROM_VALUE_TYPE_SYSTEM, 0, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_FLIGHTMODE_3_MAXRANGE] =
{
"flag_flightmode_3_maxrange", COMMAND_ID_FLAG_FLIGHTMODE_3_MAXRANGE, EEPROM_FLAG_FLIGHTMODE_3, EEPROM_VALUE_TYPE_SYSTEM, 2, VAL_UINT_16, .valueRange = {0, 2500}
},
[COMMAND_ID_FLAG_FLIGHTMODE_3_CHANNEL] =
{
"flag_flightmode_3_channel", COMMAND_ID_FLAG_FLIGHTMODE_3_CHANNEL, EEPROM_FLAG_FLIGHTMODE_3, EEPROM_VALUE_TYPE_SYSTEM, 4, VAL_UINT_8, .valueRange = {0, 18}
},
};
/***********************************************************************
@ -552,6 +695,37 @@ bool processCommand(uint8_t action, uint16_t id, uint64_t value)
return true;
}
void valuePointerToString(char * dst, uint16_t id, void * address)
{
switch(commandTable[id].valueType)
{
case VAL_UINT_8:
sprintf(dst,"%d", *((uint8_t *)address));
break;
case VAL_INT_8:
sprintf(dst,"%d", *((int8_t *)address));
break;
case VAL_UINT_16:
sprintf(dst,"%d", *((uint16_t *)address));
break;
case VAL_INT_16:
sprintf(dst,"%d", *((int16_t *)address));
break;
case VAL_UINT_32:
sprintf(dst,"%d", *((uint32_t *)address));
break;
case VAL_INT_32:
sprintf(dst,"%d", *((int32_t *)address));
break;
case VAL_UINT_64:
sprintf(dst,"%d", *((uint64_t *)address));
break;
case VAL_INT_64:
sprintf(dst,"%d", *((int64_t *)address));
break;
}
}
/***********************************************************************
* BRIEF: Will loop and read input from serial.
* INFORMATION: Will read input for the serial in a loop and will add
@ -747,16 +921,17 @@ void writeTaskInformation(uint16_t id)
{
//buffer
char buffer[maxStringSize_CLI];
char valBuffer[15];
//Get the correct pointer to the data
void * valuePointer = getDataAddresFromID(commandTable[id].valueId, commandTable[id].valueIdLoc);
//adjust to the correct addres with the offset
valuePointer += commandTable[id].addressValueOffset;
valuePointerToString(valBuffer, id, valuePointer);
//Formats the string so that it will be printed nicely
sprintf(buffer,"- %-35s Value: %-20d allowed range: %d - %d\n\r", commandTable[id].name, *((int *)valuePointer), (int)commandTable[id].valueRange.min, (int)commandTable[id].valueRange.max);
sprintf(buffer,"- %-40s Value: %-20s allowed range: %d - %d", commandTable[id].name, valBuffer, (int)commandTable[id].valueRange.min, (int)commandTable[id].valueRange.max);
TransmitBack(buffer);
TransmitBack("\n\r");
}
/***********************************************************************

44
UAV-ControlSystem/src/config/eeprom.c
View File

@ -21,6 +21,7 @@
#include "utilities.h"
#include "stm32f4xx_revo.h"
#include "Scheduler/scheduler.h"
#include "drivers/failsafe_toggles.h"
/* Reads the EEPROM version from EEPROM - Is compared to EEPROM_SYS_VERSION */
uint8_t stored_eeprom_identifier;
@ -93,6 +94,7 @@ EEPROM_DATA_t eeprom_sys_Arr[EEPROM_SYS_COUNT] = {
.dataPtr = &uart1_rx_inverter,
},
/* Task eeprom values */
[EEPROM_PERIOD_SYSTEM] =
{
.size = sizeof(SystemTasks[TASK_SYSTEM].desiredPeriod),
@ -184,7 +186,47 @@ EEPROM_DATA_t eeprom_sys_Arr[EEPROM_SYS_COUNT] = {
},
#endif
/* Flags eeprom values */
[EEPROM_FLAG_ARM] =
{
.size = sizeof(flags_Configuration_t),
.dataPtr = &(flagConfigArr[FLAG_CONFIGURATION_ARM]),
},
[EEPROM_FLAG_FLIGHTMODE_ACCELEROMETER] =
{
.size = sizeof(flags_Configuration_t),
.dataPtr = &(flagConfigArr[FLAG_CONFIGURATION_FLIGHTMODE_ACCELEROMETER]),
},
[EEPROM_FLAG_FLIGHTMODE_BAROMETER] =
{
.size = sizeof(flags_Configuration_t),
.dataPtr = &(flagConfigArr[FLAG_CONFIGURATION_FLIGHTMODE_BAROMETER]),
},
[EEPROM_FLAG_FLIGHTMODE_COMPASS] =
{
.size = sizeof(flags_Configuration_t),
.dataPtr = &(flagConfigArr[FLAG_CONFIGURATION_FLIGHTMODE_COMPASS]),
},
[EEPROM_FLAG_FLIGHTMODE_GPS] =
{
.size = sizeof(flags_Configuration_t),
.dataPtr = &(flagConfigArr[FLAG_CONFIGURATION_FLIGHTMODE_GPS]),
},
[EEPROM_FLAG_FLIGHTMODE_1] =
{
.size = sizeof(flags_Configuration_t),
.dataPtr = &(flagConfigArr[FLAG_CONFIGURATION_FLIGHTMODE_1]),
},
[EEPROM_FLAG_FLIGHTMODE_2] =
{
.size = sizeof(flags_Configuration_t),
.dataPtr = &(flagConfigArr[FLAG_CONFIGURATION_FLIGHTMODE_2]),
},
[EEPROM_FLAG_FLIGHTMODE_3] =
{
.size = sizeof(flags_Configuration_t),
.dataPtr = &(flagConfigArr[FLAG_CONFIGURATION_FLIGHTMODE_3]),
},

166
UAV-ControlSystem/src/drivers/failsafe_toggles.c Normal file
View File

@ -0,0 +1,166 @@
/*
* failsafe_toggles.c
*
* Created on: 10 okt. 2016
* Author: holmis
*/
#include "drivers/failsafe_toggles.h"
/* Stuct containing values for all the flags and failsafe booleans sin the system */
boolFlags_t systemFlags = {{0}};
/* Array of flag configurations. These are values that can be set by RC, should be read from eeprom. */
flags_Configuration_t flagConfigArr[FLAG_CONFIGURATION_COUNT] = {
[FLAG_CONFIGURATION_ARM] = {
.minRange = 1500,
.maxRange = 2000,
.channelNumber = 8,
.flagId = systemFlags_armed_id,
},
[FLAG_CONFIGURATION_FLIGHTMODE_ACCELEROMETER] = {
.minRange = 1600,
.maxRange = 2000,
.channelNumber = 5,
.flagId = systemFlags_flightmode_acceleromter_id,
},
[FLAG_CONFIGURATION_FLIGHTMODE_BAROMETER] = {
.minRange = 0,
.maxRange = 0,
.channelNumber = 0,
.flagId = systemFlags_flightmode_barometer_id,
},
[FLAG_CONFIGURATION_FLIGHTMODE_COMPASS] = {
.minRange = 0,
.maxRange = 0,
.channelNumber = 0,
.flagId = systemFlags_flightmode_compass_id,
},
[FLAG_CONFIGURATION_FLIGHTMODE_GPS] = {
.minRange = 0,
.maxRange = 0,
.channelNumber = 0,
.flagId = systemFlags_flightmode_gps_id,
},
[FLAG_CONFIGURATION_FLIGHTMODE_1] = {
.minRange = 0,
.maxRange = 0,
.channelNumber = 0,
.flagId = systemFlags_flightMode_1_id,
},
[FLAG_CONFIGURATION_FLIGHTMODE_2] = {
.minRange = 0,
.maxRange = 0,
.channelNumber = 0,
.flagId = systemFlags_flightMode_2_id,
},
[FLAG_CONFIGURATION_FLIGHTMODE_3] = {
.minRange = 0,
.maxRange = 0,
.channelNumber = 0,
.flagId = systemFlags_flightMode_3_id,
}
};
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void initFlags()
{
systemFlags.intRepresentation = 0;
}
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void flags_ProcessRcChannel(int rcChannel_ID, int value)
{
for (int i = 0; i < FLAG_CONFIGURATION_COUNT; i++)
{
if (flagConfigArr[i].channelNumber == rcChannel_ID)
{
if(value >= flagConfigArr[i].minRange && value <= flagConfigArr[i].maxRange)
{
flags_Set_ID(flagConfigArr[i].flagId);
}
else
{
flags_Clear_ID(flagConfigArr[i].flagId);
}
}
}
}
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void flags_Set_MASK(int mask)
{
systemFlags.intRepresentation |= mask;
}
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void flags_Clear_MASK(int mask)
{
systemFlags.intRepresentation &= ~(mask);
}
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void flags_Toggle_MASK(int mask)
{
systemFlags.intRepresentation ^= mask;
}
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
bool flags_IsSet_MASK(int mask)
{
return !( (systemFlags.intRepresentation ^ mask) & mask );
}
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void flags_Set_ID(int id)
{
flags_Set_MASK(getFlagMaskValue(id));
}
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void flags_Clear_ID(int id)
{
flags_Clear_MASK(getFlagMaskValue(id));
}
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
void flags_Toggle_ID(int id)
{
flags_Toggle_MASK(getFlagMaskValue(id));
}
/***********************************************************************
* BRIEF:
* INFORMATION:
***********************************************************************/
bool flags_IsSet_ID(int id)
{
return flags_IsSet_MASK(getFlagMaskValue(id));
}

71
UAV-ControlSystem/src/drivers/sbus.c
View File

@ -167,3 +167,74 @@ void sbus_read()
}
}
}
/***********************************************************************
* BRIEF: Give the value of a channel in "sbusChannelData" *
* INFORMATION: Given a channel id the value of that channel will be *
* returned. *
***********************************************************************/
int getChannelValue(sbusFrame_s frame, int id)
{
int toReturn = 0;
//find the correct channel from the provided value id
switch (id)
{
case 1:
toReturn = frame.chan1;
break;
case 2:
toReturn = frame.chan2;
break;
case 3:
toReturn = frame.chan3;
break;
case 4:
toReturn = frame.chan4;
break;
case 5:
toReturn = frame.chan5;
break;
case 6:
toReturn = frame.chan6;
break;
case 7:
toReturn = frame.chan7;
break;
case 8:
toReturn = frame.chan8;
break;
#if ((STICK_CHANNEL_COUNT + AUX_CHANNEL_COUNT) > 8)
case 9:
toReturn = frame.chan9;
break;
case 10:
toReturn = frame.chan10;
break;
case 11:
toReturn = frame.chan11;
break;
case 12:
toReturn = frame.chan12;
break;
case 13:
toReturn = frame.chan13;
break;
case 14:
toReturn = frame.chan14;
break;
case 15:
toReturn = frame.chan15;
break;
case 16:
toReturn = frame.chan16;
break;
case 17:
toReturn = frame.flag_DChannel_17;
break;
case 18:
toReturn = frame.flag_DChannel_18;
break;
#endif
}
return toReturn;
}

2
UAV-ControlSystem/src/drivers/system_clock.c
View File

@ -45,7 +45,7 @@ void system_clock_config(void)
RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;//RCC_HCLK_DIV4; //change to div4 if it broke. Changed to 2 to get usart3 to work.
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4);

1
UAV-ControlSystem/src/drivers/usart.c
View File

@ -383,7 +383,6 @@ uint32_t usart_poll(usart_profile *profile, // The USART profile to receive data
}
/***********************************************************************
* BRIEF: Get the DMA buffer that was most recently completed
* INFORMATION:

10
UAV-ControlSystem/src/main.c
View File

@ -23,6 +23,8 @@
#include "drivers/uart1_inverter.h"
#include "config/cli.h"
#include "config/eeprom.h"
#include "drivers/failsafe_toggles.h"
#include "drivers/sbus.h"
/**************************************************************************
* BRIEF: Should contain all the initializations of the system, needs to
@ -40,11 +42,15 @@ void init_system()
//Configure the clock
system_clock_config();
/* read saved variables from eeprom */
/* read saved variables from eeprom, in most cases eeprom should be read after a lot of the initializes */
readEEPROM();
//initialize the CLI
cliInit(USART1);
cliInit(USART6);
//init sbus
sbus_init();
#ifdef USE_LEDS
//Initialize the on board leds

29
UAV-ControlSystem/src/tasks_main.c
View File

@ -36,8 +36,9 @@
#include "config/eeprom.h"
#include "config/cli.h"
#include "drivers/sbus.h"
#include "drivers/failsafe_toggles.h"
#include "drivers/I2C.h"
#include "drivers/accel_gyro.h"
void systemTaskGyroPid(void)
{
@ -56,11 +57,22 @@ void systemTaskAttitude(void)
}
#define GET_CHANNEL_VALUE(id) { \
frame.chan##id \
}
void systemTaskRx(void)
{
//Interpret commands to the vehicle
sbus_read();
sbusFrame_s frame = sbusChannelData;
/* Process channel data for switches and toggles on the controller, starts after "stick" channels */
for (int i = STICK_CHANNEL_COUNT; i < STICK_CHANNEL_COUNT + AUX_CHANNEL_COUNT; i++) //ToDo: add define for the number of channels to process
{
flags_ProcessRcChannel(i+1, getChannelValue(frame, i+1));
}
}
bool systemTaskRxCheck(uint32_t currentDeltaTime)
@ -68,6 +80,8 @@ bool systemTaskRxCheck(uint32_t currentDeltaTime)
//This task is what is controlling the event activation of the systemTaskRx
//check if there is anything that has be received.
flags_Set_ID(systemFlags_Failsafe_noRcReceived_id);
//ToDo: add failsafe for no command revieved
return sbus_frame_available();
}
@ -91,8 +105,13 @@ bool systemTaskRxCliCheck(uint32_t currentDeltaTime)
void systemTaskSerial(void)
{
uint8_t c = 115;
uint8_t c = 118;
usart_transmit(&cliUsart, &c, 1, 1000000000);
if (flags_IsSet_ID(systemFlags_armed_id))
ledOnInverted(Led0_PIN, Led0_GPIO_PORT);
else
ledOffInverted(Led0_PIN, Led0_GPIO_PORT);
}
void systemTaskBattery(void)
@ -100,6 +119,10 @@ void systemTaskBattery(void)
//Keep track of the battery level of the system
uint8_t c = 98;
usart_transmit(&cliUsart, &c, 1, 1000000000);
if (flags_IsSet_MASK((systemFlags_flightmode_acceleromter_mask | systemFlags_armed_mask)))
ledOnInverted(Led1, Led1_GPIO_PORT);
else
ledOffInverted(Led1, Led1_GPIO_PORT);
}
void systemTaskBaro(void)