Subversion Repositories NaviCtrl

Compare Revisions

Ignore whitespace Rev 337 → Rev 338

/trunk/compass.c
75,6 → 75,7
s32 EarthMagneticField = 100;
s32 EarthMagneticFieldFiltered = 100;
s32 EarthMagneticInclination = 0;
s32 EarthMagneticInclinationTheoretic = 0;
u8 ErrorDisturbedEarthMagnetField = 0;
 
#define COMPASS_NONE 0
162,9 → 163,9
default:
break;
}
DebugOut.Analog[21] = MagVector.X;
DebugOut.Analog[22] = MagVector.Y;
DebugOut.Analog[23] = MagVector.Z;
DebugOut.Analog[24] = MagVector.X;
DebugOut.Analog[25] = MagVector.Y;
DebugOut.Analog[26] = MagVector.Z;
if(!((old.X == MagVector.X) || (old.Y == MagVector.Y) || (old.Z == MagVector.Z))) check_value_counter = 0; // Values are normally changing
 
if(check_value_counter > 5000)
/trunk/compass.h
13,6 → 13,7
extern volatile u8 Compass_CalState; // current calibration state
extern s32 EarthMagneticField;
extern s32 EarthMagneticInclination;
extern s32 EarthMagneticInclinationTheoretic;
extern s32 EarthMagneticFieldFiltered;
extern u8 ErrorDisturbedEarthMagnetField;
extern s16 Hx, Hy;
/trunk/gpx.c
63,6 → 63,10
#include "spi_slave.h"
#include "main.h"
#include "uart1.h"
#include "compass.h"
#include "analog.h"
#include "main.h"
#include "led.h"
 
//________________________________________________________________________________________________________________________________________
// Function: GPX_DocumentInit(GPX_Document_t *)
90,9 → 94,10
// Returnvalue: '1' if the gpx-file could be created.
//________________________________________________________________________________________________________________________________________
 
 
u8 GPX_DocumentOpen(s8 *name, GPX_Document_t *doc)
{
 
s8 string[60];
u8 retvalue = 0;
 
if(doc == NULL) return(0);
103,9 → 108,13
{
retvalue = 1; // the document could be created on the drive.
doc->state = GPX_DOC_OPENED; // change document state to opened. At next a placemark has to be opened.
fwrite_((void*)GPX_DOCUMENT_HEADER, sizeof(GPX_DOCUMENT_HEADER)-1,1,doc->file);// write the gpx-header to the document.
fwrite_((void*)GPX_DOCUMENT_HEADER1, sizeof(GPX_DOCUMENT_HEADER1)-1,1,doc->file);// write the gpx-header to the document.
sprintf(string, "<desc>FC HW:%d.%d SW:%d.%d%c & NC HW:%d.%d SW:%d.%d%c</desc>\r\n", FC_Version.Hardware/10,FC_Version.Hardware%10, FC_Version.Major, FC_Version.Minor, 'a'+FC_Version.Patch, Version_HW/10, Version_HW%10, VERSION_MAJOR, VERSION_MINOR, 'a'+ VERSION_PATCH);
fputs_(string, doc->file);
fwrite_((void*)GPX_DOCUMENT_HEADER2, sizeof(GPX_DOCUMENT_HEADER2)-1,1,doc->file);// write the gpx-header to the document.
}
 
Logging_FCStatusFlags1 = 0;
Logging_FCStatusFlags2 = 0;
return(retvalue);
}
 
155,6 → 164,8
return(retvalue);
}
 
 
 
//________________________________________________________________________________________________________________________________________
// Function: u8 GPX_TrackBegin(GPX_Document_t);
//
180,6 → 191,7
return(retvalue);
}
 
 
//________________________________________________________________________________________________________________________________________
// Function: u8 GPX_TrackEnd(KML_Document_t *doc)
//
271,7 → 283,7
{
 
u8 retvalue = 0;
s8 string[50];
s8 string[100];
 
if(doc == NULL) return(0);
 
314,7 → 326,7
sprintf(string, "<extensions>\r\n");
fputs_(string, doc->file);
// Altimeter according to air pressure
sprintf(string, "<Altimeter>%d</Altimeter>\r\n", NaviData.Altimeter);
sprintf(string, "<Altimeter>%d,'%c'</Altimeter>\r\n", NaviData.Altimeter,FromFC_VarioCharacter);
fputs_(string, doc->file);
// Variometer according to air pressure
sprintf(string, "<Variometer>%d</Variometer>\r\n", NaviData.Variometer);
353,7 → 365,7
fputs_(string, doc->file);
// Compassind deg
i16_1 = FromFlightCtrl.GyroHeading / 10;
sprintf(string, "<Compass>%03d</Compass>\r\n", i16_1);
sprintf(string, "<Compass>%03d,%03d</Compass>\r\n", i16_1,ToFlightCtrl.CompassHeading);
fputs_(string, doc->file);
// Nick Angle ind deg
sprintf(string, "<NickAngle>%03d</NickAngle>\r\n", NaviData.AngleNick);
361,9 → 373,32
// Roll Angle in deg
sprintf(string, "<RollAngle>%03d</RollAngle>\r\n", NaviData.AngleRoll);
fputs_(string, doc->file);
// magnetic field
sprintf(string, "<MagnetField>%03d</MagnetField>\r\n",(u16) (EarthMagneticField/5));
fputs_(string, doc->file);
// magnetic inclination & error
sprintf(string, "<MagnetInclination>%02d,%02d</MagnetInclination>\r\n",(s16)EarthMagneticInclination,(s16)(EarthMagneticInclination - EarthMagneticInclinationTheoretic));
fputs_(string, doc->file);
// BL Information
sprintf(string, "<MotorCurrent>%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d</MotorCurrent>\r\n",MotorCurrent[0],MotorCurrent[1],MotorCurrent[2],MotorCurrent[3],MotorCurrent[4],MotorCurrent[5],MotorCurrent[6],MotorCurrent[7],MotorCurrent[8],MotorCurrent[9],MotorCurrent[10],MotorCurrent[11]);
fputs_(string, doc->file);
sprintf(string, "<BL_Temperature>%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d</BL_Temperature>\r\n",MotorTemperature[0],MotorTemperature[1],MotorTemperature[2],MotorTemperature[3],MotorTemperature[4],MotorTemperature[5],MotorTemperature[6],MotorTemperature[7],MotorTemperature[8],MotorTemperature[9],MotorTemperature[10],MotorTemperature[11]);
fputs_(string, doc->file);
sprintf(string, "<AvaiableMotorPower>%03d</AvaiableMotorPower>\r\n",BL_MinOfMaxPWM);
fputs_(string, doc->file);
sprintf(string, "<FC_I2C_ErrorCounter>%03d</FC_I2C_ErrorCounter>\r\n",(s16)FC_I2C_ErrorConter);
fputs_(string, doc->file);
// Analog inputs of the NC
sprintf(string, "<AnalogInputs>%d,%d,%d,%d</AnalogInputs>\r\n",AnalogData.Ch4,AnalogData.Ch5,AnalogData.Ch6,AnalogData.Ch7);
fputs_(string, doc->file);
// NC Mode (contains the status)
sprintf(string, "<NCFlag>%02X</NCFlag>\r\n", NCFlags);
sprintf(string, "<NCFlag>0x%02X</NCFlag>\r\n", NCFlags);
fputs_(string, doc->file);
// Flags
sprintf(string, "<FCFlags2>0x%02x,0x%02x</FCFlags2>\r\n",Logging_FCStatusFlags1,Logging_FCStatusFlags2);
fputs_(string, doc->file);
Logging_FCStatusFlags1 = 0;
Logging_FCStatusFlags2 = 0;
// Status of the complete MikroKopter
sprintf(string, "<ErrorCode>%03d</ErrorCode>\r\n",ErrorCode);
fputs_(string, doc->file);
374,12 → 409,11
sprintf(string, "<TargetDistance>%d</TargetDistance>\r\n", NaviData.TargetPositionDeviation.Distance);
fputs_(string, doc->file);
// RC Sticks as Nick/Roll/Yaw
sprintf(string, "<RCSticks>%d, %d, %d</RCSticks>\r\n", FC.StickNick,FC.StickRoll, FC.StickYaw);
sprintf(string, "<RCSticks>%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d</RCSticks>\r\n", FC.StickNick,FC.StickRoll, FC.StickYaw, FC.StickGas,FC.Poti[0],FC.Poti[1],FC.Poti[2],FC.Poti[3],FC.Poti[4],FC.Poti[5],FC.Poti[6],FC.Poti[7]);
fputs_(string, doc->file);
// GPS Sticks as Nick/Roll/Yaw
sprintf(string, "<GPSSticks>%d, %d, %d</GPSSticks>\r\n", ToFlightCtrl.GPSStick.Nick, ToFlightCtrl.GPSStick.Roll, ToFlightCtrl.GPSStick.Yaw);
sprintf(string, "<GPSSticks>%d,%d,%d,'%c'</GPSSticks>\r\n", ToFlightCtrl.GPSStick.Nick, ToFlightCtrl.GPSStick.Roll, ToFlightCtrl.GPSStick.Yaw,NC_GPS_ModeCharacter);
fputs_(string, doc->file);
 
// eof extensions
sprintf(string, "</extensions>\r\n");
fputs_(string, doc->file);
/trunk/gpx_header.h
3,8 → 3,7
// Definition of gpx-header and footer elements for documents
//
//________________________________________________________________________________________________________________________________________
 
 
/*
const s8 GPX_DOCUMENT_HEADER[] =
{
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\r\n"
17,7 → 16,25
"</metadata>\r\n"
"\r\n"
};
*/
const s8 GPX_DOCUMENT_HEADER1[] =
{
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\r\n"
"<gpx creator=\"NC\" version=\"2.0\" >\r\n"
"\r\n"
"<metadata>\r\n"
"<link href=\"http://www.mikrokopter.de\">\r\n"
"<text>MikroKopter</text>\r\n"
"</link>\r\n"
};
 
const s8 GPX_DOCUMENT_HEADER2[] =
{
"</metadata>\r\n"
"\r\n"
};
 
 
//________________________________________________________________________________________________________________________________________
//
// footer of an gpx-file.
/trunk/main.c
138,12 → 138,15
s32 newErrorCode = 0;
UART_VersionInfo.HardwareError[0] = 0;
 
if(CheckDelay(I2C1_Timeout) || (Compass_Heading < 0)) DebugOut.Status[1] |= 0x08;
else DebugOut.Status[1] &= ~0x08; // MK3Mag green status
if(CheckDelay(I2C1_Timeout) || (Compass_Heading < 0)) DebugOut.StatusRed |= AMPEL_COMPASS;
else DebugOut.StatusRed &= ~AMPEL_COMPASS; // MK3Mag green status
 
if((FC.Error[1] & FC_ERROR1_I2C) || (FC.Error[1] & FC_ERROR1_BL_MISSING)) DebugOut.Status[1] |= 0x02;
else DebugOut.Status[1] &= ~0x02; // BL-Ctrl green status
if((FC.Error[1] & FC_ERROR1_I2C) || (FC.Error[1] & FC_ERROR1_BL_MISSING)) DebugOut.StatusRed |= AMPEL_BL;
else DebugOut.StatusRed &= ~AMPEL_BL; // BL-Ctrl green status
 
if(UART_VersionInfo.HardwareError[0] || UART_VersionInfo.HardwareError[1]) DebugOut.StatusRed |= AMPEL_NC;
else DebugOut.StatusRed &= ~AMPEL_NC;
 
if(CheckDelay(SPI0_Timeout))
{
LED_RED_ON;
150,8 → 153,8
sprintf(ErrorMSG,"no FC communication ");
newErrorCode = 3;
StopNavigation = 1;
DebugOut.Status[0] &= ~0x01; // status of FC Present
DebugOut.Status[0] &= ~0x02; // status of BL Present
DebugOut.StatusGreen &= ~AMPEL_FC; // status of FC Present
DebugOut.StatusGreen &= ~AMPEL_BL; // status of BL Present
UART_VersionInfo.HardwareError[0] |= NC_ERROR0_SPI_RX;
}
else if(CheckDelay(I2C1_Timeout))
164,7 → 167,7
newErrorCode = 4;
StopNavigation = 1;
UART_VersionInfo.HardwareError[0] |= NC_ERROR0_COMPASS_RX;
DebugOut.Status[1] |= 0x08;
DebugOut.StatusRed |= AMPEL_COMPASS;
}
else if(FC_Version.Compatible != FC_SPI_COMPATIBLE)
{
177,6 → 180,7
newErrorCode = 1;
StopNavigation = 1;
UART_VersionInfo.HardwareError[0] |= NC_ERROR0_FC_INCOMPATIBLE;
DebugOut.StatusRed |= AMPEL_NC;
}
 
else if(FC.Error[0] & FC_ERROR0_GYRO_NICK)
290,8 → 294,23
LED_RED_ON;
sprintf(ErrorMSG,"Magnet error ");
newErrorCode = 22;
DebugOut.Status[1] |= 0x08;
DebugOut.StatusRed |= AMPEL_COMPASS | AMPEL_NC;
UART_VersionInfo.HardwareError[0] |= NC_ERROR0_COMPASS_VALUE;
}
else if(BL_MinOfMaxPWM == 40 && (FC.StatusFlags & FC_STATUS_FLY) && !ErrorCode)
{
LED_RED_ON;
sprintf(ErrorMSG,"ERR:Motor restart ");
newErrorCode = 23;
DebugOut.StatusRed |= AMPEL_BL;
}
else if(BL_MinOfMaxPWM != 255 && (FC.StatusFlags & FC_STATUS_FLY) && !ErrorCode)
{
LED_RED_ON;
sprintf(ErrorMSG,"ERR:BL Limitation ");
newErrorCode = 24;
DebugOut.StatusRed |= AMPEL_BL;
}
else // no error occured
{
StopNavigation = 0;
303,8 → 322,6
ErrorCode = 0;
}
}
if(UART_VersionInfo.HardwareError[0] || UART_VersionInfo.HardwareError[1]) DebugOut.Status[1] |= 0x04;
else DebugOut.Status[1] &= ~0x04;
 
if(newErrorCode)
{
387,8 → 404,8
UART1_PutString("\n\r Version information:");
 
GetNaviCtrlVersion();
DebugOut.Status[0] = 0x04 | 0x08; // NC and MK3Mag
DebugOut.Status[1] = 0x00;
DebugOut.StatusGreen = AMPEL_NC | AMPEL_COMPASS; // NC and MK3Mag
DebugOut.StatusRed = 0x00;
 
Compass_Init();
 
/trunk/main.h
14,7 → 14,7
 
#define VERSION_MAJOR 0
#define VERSION_MINOR 25
#define VERSION_PATCH 12
#define VERSION_PATCH 16
// 0 = A
// 1 = B
// 2 = C
29,13 → 29,16
// 11 = L
// 12 = M
// 13 = N
// 14 = o
// 14 = O
// 15 = P
// 16 = Q
// 17 = R
 
#define VERSION_SERIAL_MAJOR 11
#define VERSION_SERIAL_MINOR 0
 
#ifndef FOLLOW_ME
#define FC_SPI_COMPATIBLE 25
#define FC_SPI_COMPATIBLE 26
#else
#define FC_SPI_COMPATIBLE 0xFF
#endif
/trunk/menu.c
72,10 → 72,8
 
 
u8 MenuItem = 0;
u8 MaxMenuItem = 16;
u8 MaxMenuItem = 17;
 
 
 
void Menu_Putchar(char c)
{
if(DispPtr < DISPLAYBUFFSIZE) DisplayBuff[DispPtr++] = c; ;
402,8 → 400,8
LCD_printfxy(0,2,"Y:%5i",MagVector.Y);
LCD_printfxy(0,3,"Z:%5i",MagVector.Z);
LCD_printfxy(8,1,"Field:%3i",EarthMagneticField/5);
LCD_printfxy(8,2,"Dec:%c%i.%1i", sign, abs(GeoMagDec)/10,abs(GeoMagDec)%10);
LCD_printfxy(8,3,"Inc:%2i", EarthMagneticInclination);
// LCD_printfxy(8,2,"Dec:%c%i.%1i", sign, abs(GeoMagDec)/10,abs(GeoMagDec)%10);
// LCD_printfxy(8,3,"Inc:%2i", EarthMagneticInclination);
LCD_printfxy(15,3,"(CAL)");
}
if(Keys & KEY4) // next step
413,6 → 411,12
}
if(Keys & KEY3)Compass_SetCalState(0); // cancel
break;
case 17:
LCD_printfxy(0,0,"Magnetic Field");
LCD_printfxy(0,1,"Field:%3i (Percent)",EarthMagneticField/5);
LCD_printfxy(0,2,"Declination:%c%i.%1i ", sign, abs(GeoMagDec)/10,abs(GeoMagDec)%10);
LCD_printfxy(0,3,"Inclination:%2i (%2i)", EarthMagneticInclination, EarthMagneticInclinationTheoretic);
break;
default:
//MaxMenuItem = MenuItem - 1;
MenuItem = 0;
/trunk/ncmag.c
75,8 → 75,9
#define MAG_TYPE_LSM303DLH 2
u8 NCMAG_MagType = MAG_TYPE_NONE;
 
#define CALIBRATION_VERSION 1
#define EEPROM_ADR_MAG_CALIBRATION 50
#define CALIBRATION_VERSION 1
#define EEPROM_ADR_MAG_CALIBRATION 50
#define MAG_CALIBRATION_COMPATIBEL 0xA1
 
#define NCMAG_MIN_RAWVALUE -2047
#define NCMAG_MAX_RAWVALUE 2047
177,6 → 178,7
#define LSM303DLH_CRA_RATE_15HZ 0x10 //default
#define LSM303DLH_CRA_RATE_30HZ 0x14
#define LSM303DLH_CRA_RATE_75HZ 0x18
 
// bit mask for gain
#define LSM303DLH_CRB_GAIN_XXGA 0x00
#define LSM303DLH_CRB_GAIN_13GA 0x20 //default
187,9 → 189,9
#define LSM303DLH_CRB_GAIN_56GA 0xC0
#define LSM303DLH_CRB_GAIN_81GA 0xE0
// self test value
#define LSM303DLH_TEST_XSCALE 655
#define LSM303DLH_TEST_YSCALE 655
#define LSM303DLH_TEST_ZSCALE 630
#define LSM303DLH_TEST_XSCALE 495
#define LSM303DLH_TEST_YSCALE 495
#define LSM303DLH_TEST_ZSCALE 470
 
// the i2c ACC interface
#define ACC_SLAVE_ADDRESS 0x30 // i2c slave for acc. sensor registers
251,7 → 253,7
 
u8 NCMag_CalibrationWrite(void)
{
u8 i, crc = 0xAA;
u8 i, crc = MAG_CALIBRATION_COMPATIBEL;
EEPROM_Result_t eres;
u8 *pBuff = (u8*)&Calibration;
 
269,7 → 271,7
 
u8 NCMag_CalibrationRead(void)
{
u8 i, crc = 0xAA;
u8 i, crc = MAG_CALIBRATION_COMPATIBEL;
u8 *pBuff = (u8*)&Calibration;
 
if(EEPROM_SUCCESS == EEPROM_ReadBlock(EEPROM_ADR_MAG_CALIBRATION, pBuff, sizeof(Calibration)))
333,7 → 335,8
// Save values
if(Compass_CalState != OldCalState) // avoid continously writing of eeprom!
{
#define MIN_CALIBRATION 256
// #define MIN_CALIBRATION 256
#define MIN_CALIBRATION 450
Calibration.MagX.Range = Xmax - Xmin;
Calibration.MagX.Offset = (Xmin + Xmax) / 2;
Calibration.MagY.Range = Ymax - Ymin;
622,7 → 625,7
{
s16 xscale, yscale, zscale;
u8 crb_gain, cra_rate;
u8 i = 0, retval = 1;
// u8 retval = 1;
 
switch(NCMAG_MagType)
{
635,7 → 638,7
break;
 
case MAG_TYPE_LSM303DLH:
crb_gain = LSM303DLH_CRB_GAIN_13GA;
crb_gain = LSM303DLH_CRB_GAIN_19GA;
cra_rate = LSM303DLH_CRA_RATE_75HZ;
xscale = LSM303DLH_TEST_XSCALE;
yscale = LSM303DLH_TEST_YSCALE;
643,7 → 646,7
break;
 
default:
return(0);
return;
}
 
MagConfig.cra = cra_rate|CRA_MODE_NORMAL;
713,7 → 716,7
break;
 
case MAG_TYPE_LSM303DLH:
crb_gain = LSM303DLH_CRB_GAIN_13GA;
crb_gain = LSM303DLH_CRB_GAIN_19GA;
cra_rate = LSM303DLH_CRA_RATE_75HZ;
xscale = LSM303DLH_TEST_XSCALE;
yscale = LSM303DLH_TEST_YSCALE;
/trunk/spi_slave.c
80,6 → 80,7
ToFlightCtrl_t ToFlightCtrl;
#define SPI0_TIMEOUT 500 // 500ms
volatile u32 SPI0_Timeout = 0;
u8 Logging_FCStatusFlags1 = 0,Logging_FCStatusFlags2 = 0;
 
// tx packet buffer
#define SPI_TXBUFFER_LEN (2 + sizeof(ToFlightCtrl)) // 2 bytes at start are for synchronization
112,7 → 113,10
u8 NC_GPS_ModeCharacter = ' ';
u8 FCCalibActive = 0;
u8 FC_is_Calibrated = 0;
 
u8 MotorCurrent[12];
u8 MotorTemperature[12];
u8 BL_MinOfMaxPWM; // indication if all BL-controllers run on full power
u32 FC_I2C_ErrorConter;
SPI_Version_t FC_Version;
 
//--------------------------------------------------------------
338,8 → 342,8
ToFlightCtrl.Param.Byte[2] = VERSION_PATCH;
ToFlightCtrl.Param.Byte[3] = FC_SPI_COMPATIBLE;
ToFlightCtrl.Param.Byte[4] = Version_HW;
ToFlightCtrl.Param.Byte[5] = DebugOut.Status[0];
ToFlightCtrl.Param.Byte[6] = DebugOut.Status[1];
ToFlightCtrl.Param.Byte[5] = DebugOut.StatusGreen;
ToFlightCtrl.Param.Byte[6] = DebugOut.StatusRed;
ToFlightCtrl.Param.Byte[7] = ErrorCode;
ToFlightCtrl.Param.Byte[8] = NC_GPS_ModeCharacter;
ToFlightCtrl.Param.Byte[9] = SerialLinkOkay;
528,6 → 532,7
HeadFreeStartAngle = Compass_Heading * 10;
Compass_Init();
FCCalibActive = 10;
FC_is_Calibrated = 0;
}
else
{
559,6 → 564,8
FC.StatusFlags2 = FromFlightCtrl.Param.Byte[11];
NaviData.FCStatusFlags = FC.StatusFlags;
NaviData.FCStatusFlags2 = FC.StatusFlags2;
Logging_FCStatusFlags1 |= FC.StatusFlags;
Logging_FCStatusFlags2 |= FC.StatusFlags2;
Parameter.ComingHomeAltitude = FromFlightCtrl.Param.Byte[10];
break;
 
570,6 → 577,8
FromFC_VarioCharacter = FromFlightCtrl.Param.Byte[6];
Parameter.GlobalConfig = FromFlightCtrl.Param.Byte[7];
Parameter.ExtraConfig = FromFlightCtrl.Param.Byte[8];
MotorTemperature[FromFlightCtrl.Param.Byte[9]] = FromFlightCtrl.Param.Byte[10];
MotorCurrent[FromFlightCtrl.Param.Byte[9]] = FromFlightCtrl.Param.Byte[11];
if(FromFC_VarioCharacter == '+' || FromFC_VarioCharacter == '-') // manual setpoint clears the NC-Parameter command
{
NCParams_ClearValue(NCPARAMS_ALTITUDE_RATE);
643,6 → 652,7
ServoParams.RollComp = FromFlightCtrl.Param.Byte[7];
ServoParams.RollMin = FromFlightCtrl.Param.Byte[8];
ServoParams.RollMax = FromFlightCtrl.Param.Byte[9];
BL_MinOfMaxPWM = FromFlightCtrl.Param.Byte[10];
break;
 
case SPI_FCCMD_VERSION:
657,10 → 667,10
FC.Error[3] |= FromFlightCtrl.Param.Byte[8];
FC.Error[4] |= FromFlightCtrl.Param.Byte[9];
Parameter.OrientationAngle = FromFlightCtrl.Param.Byte[10];
DebugOut.Status[0] |= 0x01; // status of FC Present
DebugOut.Status[0] |= 0x02; // status of BL Present
if(FC.Error[0] || FC.Error[1] || FC.Error[2] || FC.Error[3] || FC.Error[4]) DebugOut.Status[1] |= 0x01;
else DebugOut.Status[1] &= ~0x01;
DebugOut.StatusGreen |= AMPEL_FC; // status of FC Present
DebugOut.StatusGreen |= AMPEL_BL; // status of BL Present
if(FC.Error[0] || FC.Error[1] || FC.Error[2] || FC.Error[3] || FC.Error[4]) DebugOut.StatusRed |= AMPEL_FC;
else DebugOut.StatusRed &= ~AMPEL_FC;
break;
default:
break;
/trunk/spi_slave.h
28,6 → 28,12
extern u8 NC_GPS_ModeCharacter;
extern u8 FC_is_Calibrated;
extern u8 FCCalibActive;
extern u8 MotorCurrent[12];
extern u8 MotorTemperature[12];
extern u8 BL_MinOfMaxPWM; // indication if all BL-controllers run on full power
extern u32 FC_I2C_ErrorConter;
extern u8 FromFC_VarioCharacter;
extern u8 Logging_FCStatusFlags1,Logging_FCStatusFlags2;
 
typedef struct
{
/trunk/uart1.c
148,16 → 148,16
"I2C Error ",
"I2C Okay ", //15
"16 KompassKalm ",// "Kalman_K ",
"17 ",
"17 Inclination ",
"18 Horizontal ",
"19 Normal ",
"EarthMagnet [%] ", //20
"Z_Speed ",
"N_Speed ",
"E_Speed ",
"Magnet X ",
"Magnet Y ",
"Magnet Y ", //25
"Magnet Z ",
"Z_Speed ",
"N_Speed ",//25
"E_Speed ",
"Distance N ",
"Distance E ",
"GPS_Nick ",
/trunk/uart1.h
39,9 → 39,15
 
extern const u8 ANALOG_LABEL[32][16];
 
#define AMPEL_FC 0x01
#define AMPEL_BL 0x02
#define AMPEL_NC 0x04
#define AMPEL_COMPASS 0x08
 
typedef struct
{
u8 Status[2];
u8 StatusGreen;
u8 StatusRed;
u16 Analog[32]; // Debugwerte
} __attribute__((packed)) DebugOut_t;