Subversion Repositories FlightCtrl

Compare Revisions

Ignore whitespace Rev 1638 → Rev 1639

/trunk/_Settings.h
5,9 → 5,5
#define FAKTOR_P 1
#define FAKTOR_I 0.0001
 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Debug-Interface
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#define SIO_DEBUG 1 // Soll der Debugger aktiviert sein?
 
 
/trunk/analog.c
73,7 → 73,7
if(AdWertRoll < 1020) AnalogOffsetRoll--; else if(AdWertRoll > 1030) AnalogOffsetRoll++; else ready++;
if(AdWertGier < 1020) AnalogOffsetGier--; else if(AdWertGier > 1030) AnalogOffsetGier++; else ready++;
twi_state = 18;
i2c_start();
I2C_Start();
if(AnalogOffsetNick < 10) { GyroDefektN = 1; AnalogOffsetNick = 10;}; if(AnalogOffsetNick > 245) { GyroDefektN = 1; AnalogOffsetNick = 245;};
if(AnalogOffsetRoll < 10) { GyroDefektR = 1; AnalogOffsetRoll = 10;}; if(AnalogOffsetRoll > 245) { GyroDefektR = 1; AnalogOffsetRoll = 245;};
if(AnalogOffsetGier < 10) { GyroDefektG = 1; AnalogOffsetGier = 10;}; if(AnalogOffsetGier > 245) { GyroDefektG = 1; AnalogOffsetGier = 245;};
114,7 → 114,7
{
static unsigned char kanal=0,state = 0;
static signed int gier1, roll1, nick1, nick_filter, roll_filter;
static signed int accy, accx;
static signed int accy, accx,subcount = 0;
 
static long tmpLuftdruck = 0;
static char messanzahl_Druck = 0;
160,6 → 160,31
{
if(NeutralAccZ < 750)
{
subcount += 2;
if(modell_fliegt < 500) subcount += 100;
}
if(subcount > 1000) { NeutralAccZ++; subcount -= 1000;}
}
else if(AdWertAccHoch < -1)
{
if(NeutralAccZ > 550)
{
subcount -= 2;
if(modell_fliegt < 500) subcount -= 100;
if(subcount < -1000) { NeutralAccZ--; subcount += 1000;}
}
}
messanzahl_AccHoch = 1;
Aktuell_az = ADC;
Mess_Integral_Hoch += AdWertAccHoch; // Integrieren
Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen
 
/*
AdWertAccHoch = (signed int) ADC - NeutralAccZ;
if(AdWertAccHoch > 1)
{
if(NeutralAccZ < 750)
{
NeutralAccZ += 0.02;
if(modell_fliegt < 500) NeutralAccZ += 0.1;
}
176,6 → 201,7
Aktuell_az = ADC;
Mess_Integral_Hoch += AdWertAccHoch; // Integrieren
Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen
*/
kanal = AD_DRUCK;
break;
// "case 8:" fehlt hier absichtlich
/trunk/fc.c
65,7 → 65,7
int AdNeutralNick = 0,AdNeutralRoll = 0,AdNeutralGier = 0,StartNeutralRoll = 0,StartNeutralNick = 0;
int Mittelwert_AccNick, Mittelwert_AccRoll,Mittelwert_AccHoch, NeutralAccX=0, NeutralAccY=0;
int NaviAccNick, NaviAccRoll,NaviCntAcc = 0;
volatile float NeutralAccZ = 0;
int NeutralAccZ = 0;
unsigned char CosinusNickWinkel = 0, CosinusRollWinkel = 0;
long IntegralNick = 0,IntegralNick2 = 0;
long IntegralRoll = 0,IntegralRoll2 = 0;
172,6 → 172,46
return(motor);
}
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Debugwerte zuordnen
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void CopyDebugValues(void)
{
 
DebugOut.Analog[0] = IntegralNick / (EE_Parameter.GyroAccFaktor * 4);
DebugOut.Analog[1] = IntegralRoll / (EE_Parameter.GyroAccFaktor * 4);
DebugOut.Analog[2] = Mittelwert_AccNick / 4;
DebugOut.Analog[3] = Mittelwert_AccRoll / 4;
DebugOut.Analog[4] = MesswertGier;
DebugOut.Analog[5] = HoehenWert/5;
DebugOut.Analog[6] = AdWertAccHoch;// Aktuell_az;//(Mess_Integral_Hoch / 512);//Aktuell_az;
DebugOut.Analog[8] = KompassValue;
DebugOut.Analog[9] = UBat;
DebugOut.Analog[10] = SenderOkay;
DebugOut.Analog[11] = ErsatzKompass / GIER_GRAD_FAKTOR;
DebugOut.Analog[16] = NeutralAccZ;
DebugOut.Analog[18] = TransmitBlConfig;
//DebugOut.Analog[16] = Motor[0].Temperature;
//DebugOut.Analog[17] = FromNaviCtrl_Value.Distance;
// DebugOut.Analog[18] = VarioMeter;
// DebugOut.Analog[19] = WinkelOut.CalcState;
DebugOut.Analog[20] = ServoNickValue;
DebugOut.Analog[22] = Capacity.ActualCurrent;
DebugOut.Analog[23] = Capacity.UsedCapacity;
// DebugOut.Analog[22] = FromNaviCtrl_Value.GpsZ;
// DebugOut.Analog[24] = MesswertNick/2;
// DebugOut.Analog[25] = MesswertRoll/2;
// DebugOut.Analog[27] = (int)FromNaviCtrl_Value.Kalman_MaxDrift;
// DebugOut.Analog[28] = (int)FromNaviCtrl_Value.Kalman_MaxFusion;
// DebugOut.Analog[29] = (int)FromNaviCtrl_Value.Kalman_K;
//DebugOut.Analog[28] = I2CError;
DebugOut.Analog[29] = FromNaviCtrl_Value.SerialDataOkay;
DebugOut.Analog[30] = GPS_Nick;
DebugOut.Analog[31] = GPS_Roll;
}
 
 
 
void Piep(unsigned char Anzahl, unsigned int dauer)
{
if(MotorenEin) return; //auf keinen Fall im Flug!
233,8 → 273,10
 
ExpandBaro = 0;
 
TransmitBlConfig = 1;
motorread = 0;
 
CalibrierMittelwert();
 
Delay_ms_Mess(100);
 
CalibrierMittelwert();
265,8 → 307,8
NeutralAccZ = Aktuell_az;
 
// Save ACC neutral settings to eeprom
SetParamWord(PID_ACC_NICK, (uint16_t)NeutralAccY);
SetParamWord(PID_ACC_ROLL, (uint16_t)NeutralAccX);
SetParamWord(PID_ACC_NICK, (uint16_t)NeutralAccX);
SetParamWord(PID_ACC_ROLL, (uint16_t)NeutralAccY);
SetParamWord(PID_ACC_TOP, (uint16_t)NeutralAccZ);
}
else
519,7 → 561,7
//Start I2C Interrupt Mode
twi_state = 0;
motor = 0;
i2c_start();
I2C_Start();
}
 
 
1123,7 → 1165,6
ZaehlMessungen = 0;
} // ZaehlMessungen >= ABGLEICH_ANZAHL
 
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Gieren
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1193,46 → 1234,8
}
else KompassSignalSchlecht = 500; // so lange das Signal taub stellen --> ca. 1 sek
}
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Debugwerte zuordnen
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
if(!TimerWerteausgabe--)
{
TimerWerteausgabe = 24;
 
DebugOut.Analog[0] = IntegralNick / (EE_Parameter.GyroAccFaktor * 4);
DebugOut.Analog[1] = IntegralRoll / (EE_Parameter.GyroAccFaktor * 4);
DebugOut.Analog[2] = Mittelwert_AccNick / 4;
DebugOut.Analog[3] = Mittelwert_AccRoll / 4;
DebugOut.Analog[4] = MesswertGier;
DebugOut.Analog[5] = HoehenWert/5;
DebugOut.Analog[6] = Aktuell_az;//(Mess_Integral_Hoch / 512);//Aktuell_az;
DebugOut.Analog[8] = KompassValue;
DebugOut.Analog[9] = UBat;
DebugOut.Analog[10] = SenderOkay;
DebugOut.Analog[11] = ErsatzKompass / GIER_GRAD_FAKTOR;
//DebugOut.Analog[16] = Motor[0].Temperature;
//DebugOut.Analog[17] = FromNaviCtrl_Value.Distance;
// DebugOut.Analog[18] = VarioMeter;
// DebugOut.Analog[19] = WinkelOut.CalcState;
DebugOut.Analog[20] = ServoNickValue;
DebugOut.Analog[22] = Capacity.ActualCurrent;
DebugOut.Analog[23] = Capacity.UsedCapacity;
// DebugOut.Analog[22] = FromNaviCtrl_Value.GpsZ;
// DebugOut.Analog[24] = MesswertNick/2;
// DebugOut.Analog[25] = MesswertRoll/2;
// DebugOut.Analog[27] = (int)FromNaviCtrl_Value.Kalman_MaxDrift;
// DebugOut.Analog[28] = (int)FromNaviCtrl_Value.Kalman_MaxFusion;
// DebugOut.Analog[29] = (int)FromNaviCtrl_Value.Kalman_K;
//DebugOut.Analog[28] = I2CError;
DebugOut.Analog[29] = FromNaviCtrl_Value.SerialDataOkay;
DebugOut.Analog[30] = GPS_Nick;
DebugOut.Analog[31] = GPS_Roll;
}
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Drehgeschwindigkeit und -winkel zu einem Istwert zusammenfassen
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
if(TrichterFlug) { SummeRoll = 0; SummeNick = 0;};
1264,7 → 1267,6
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
if(UBat > BattLowVoltageWarning) GasMischanteil = ((unsigned int)GasMischanteil * BattLowVoltageWarning) / UBat; // Gas auf das aktuelle Spannungvieveau beziehen
GasMischanteil *= STICK_GAIN;
 
// if height control is activated
if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG) && !(Looping_Roll || Looping_Nick)) // Höhenregelung
{
/trunk/fc.h
55,18 → 55,19
extern int AdNeutralNick,AdNeutralRoll,AdNeutralGier, Mittelwert_AccNick, Mittelwert_AccRoll;
extern int NeutralAccX, NeutralAccY,Mittelwert_AccHoch;
extern unsigned char HoehenReglerAktiv;
extern volatile float NeutralAccZ;
extern int NeutralAccZ;
extern long Umschlag180Nick, Umschlag180Roll;
extern signed int ExternStickNick,ExternStickRoll,ExternStickGier;
extern unsigned char Parameter_UserParam1,Parameter_UserParam2,Parameter_UserParam3,Parameter_UserParam4,Parameter_UserParam5,Parameter_UserParam6,Parameter_UserParam7,Parameter_UserParam8;
extern int NaviAccNick,NaviAccRoll,NaviCntAcc;
extern unsigned int modell_fliegt;
void MotorRegler(void);
void SendMotorData(void);
extern void MotorRegler(void);
extern void SendMotorData(void);
//void CalibrierMittelwert(void);
//void Mittelwert(void);
void SetNeutral(unsigned char AccAdjustment);
void Piep(unsigned char Anzahl, unsigned int dauer);
extern void SetNeutral(unsigned char AccAdjustment);
extern void Piep(unsigned char Anzahl, unsigned int dauer);
extern void CopyDebugValues(void);
 
extern unsigned char h,m,s;
extern volatile unsigned char Timeout ;
80,7 → 81,6
extern unsigned char Parameter_Servo3,Parameter_Servo4,Parameter_Servo5;
extern char VarioCharacter;
 
 
extern unsigned char Parameter_Luftdruck_D;
extern unsigned char Parameter_MaxHoehe;
extern unsigned char Parameter_Hoehe_P;
/trunk/libfc1284.a
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/trunk/main.c
198,7 → 198,8
}
printf("\n\r===================================");
SendMotorData();
 
TransmitBlConfig = 1;
motorread = 0;
//if(EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG)
{
printf("\n\rCalibrating pressure sensor..");
246,19 → 247,20
while (1)
{
 
if(CheckDelay(timerPolling))
{
timerPolling = SetDelay(100);
LIBFC_Polling();
}
 
if(UpdateMotor && AdReady) // ReglerIntervall
{
UpdateMotor=0;
J4High;
if(WinkelOut.CalcState) CalMk3Mag();
else MotorRegler();
SendMotorData();
if(UpdateMotor) DebugOut.Analog[17]++;
J4Low;
ROT_OFF;
if(SenderOkay) SenderOkay--;
else
291,12 → 293,10
ROT_OFF;
if(!beeptime) FCFlags &= ~FCFLAG_I2CERR;
}
if(SIO_DEBUG && (!UpdateMotor || !MotorenEin))
{
if(!UpdateMotor)
{
DatenUebertragung();
BearbeiteRxDaten();
}
else BearbeiteRxDaten();
if(CheckDelay(timer))
{
static unsigned char second;
358,6 → 358,7
}
LED_Update();
Capacity_Update();
}
}
if(!SendSPI) { SPI_TransmitByte(); }
}
/trunk/rc.c
75,9 → 75,12
PPM_in[index] = tmp;
}
index++;
if(index == 5) J3High; else J3Low; // Servosignal an J3 anlegen
if(index == 6) J4High; else J4Low; // Servosignal an J4 anlegen
if(index == 7) J5High; else J5Low; // Servosignal an J5 anlegen
if(PlatinenVersion < 20)
{
if(index == 5) J3High; else J3Low; // Servosignal an J3 anlegen
if(index == 6) J4High; else J4Low; // Servosignal an J4 anlegen
if(index == 7) J5High; else J5Low; // Servosignal an J5 anlegen
}
}
}
}
145,9 → 148,12
ppm_in[index] = tmp;
}
else ROT_ON;
if(index == 5) J3High; else J3Low; // Servosignal an J3 anlegen
if(index == 6) J4High; else J4Low; // Servosignal an J4 anlegen
if(index == 7) J5High; else J5Low; // Servosignal an J5 anlegen
if(PlatinenVersion < 20)
{
if(index == 5) J3High; else J3Low; // Servosignal an J3 anlegen
if(index == 6) J4High; else J4Low; // Servosignal an J4 anlegen
if(index == 7) J5High; else J5Low; // Servosignal an J5 anlegen
}
}
if(index < 20) index++;
else
/trunk/twimaster.c
4,7 → 4,7
#include "main.h"
 
volatile unsigned char twi_state = 0;
unsigned char motor = 0;
unsigned char motor = 0,TransmitBlConfig = 0;
unsigned char motorread = 0,MissingMotor = 0;
 
MotorData_t Motor[MAX_MOTORS];
20,25 → 20,10
TWBR = ((SYSCLK/SCL_CLOCK)-16)/2;
}
 
//############################################################################
//Start I2C
void i2c_start(void)
//############################################################################
{
TWCR = (1<<TWSTA) | (1<<TWEN) | (1<<TWINT) | (1<<TWIE);
}
 
//############################################################################
void i2c_stop(void)
//############################################################################
{
TWCR = (1<<TWEN) | (1<<TWSTO) | (1<<TWINT);
}
 
void i2c_reset(void)
//############################################################################
{
i2c_stop();
I2C_Stop();
twi_state = 0;
motor = TWDR;
motor = 0;
49,10 → 34,10
TWSR = 0;
TWBR = 0;
i2c_init();
i2c_start();
I2C_Start();
i2c_write_byte(0);
}
 
/*
//############################################################################
void i2c_write_byte(char byte)
//############################################################################
61,10 → 46,9
TWDR = byte;
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);
}
*/
 
/****************************************/
/* Write to I2C */
/****************************************/
/*
void I2C_WriteByte(int8_t byte)
{
// move byte to send into TWI Data Register
74,24 → 58,8
// enable interrupt (TWIE = 1)
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);
}
*/
 
/****************************************/
/* Receive byte and send ACK */
/****************************************/
void I2C_ReceiveByte(void)
{
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE) | (1<<TWEA);
}
 
/****************************************/
/* I2C receive last byte and send no ACK*/
/****************************************/
void I2C_ReceiveLastByte(void)
{
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);
}
 
 
/*
//############################################################################
SIGNAL (TWI_vect)
122,10 → 90,10
if(!missing_motor) missing_motor = motor;
if((Motor[motor-1].State & MOTOR_STATE_ERROR_MASK) < MOTOR_STATE_ERROR_MASK) Motor[motor-1].State++; // increment error counter and handle overflow
}
i2c_stop();
I2C_Stop();
I2CTimeout = 10;
twi_state = 0;
i2c_start();
I2C_Start();
break;
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Reading Data
137,7 → 105,7
Motor[motorread].State &= ~MOTOR_STATE_PRESENT_MASK; // clear present bit
motorread++;
if(motorread >= MAX_MOTORS) motorread = 0;
i2c_stop();
I2C_Stop();
twi_state = 0;
}
else
157,7 → 125,7
Motor[motorread].MaxPWM = TWDR;
motorread++; // next motor
if(motorread >= MAX_MOTORS) motorread = 0;
i2c_stop();
I2C_Stop();
twi_state = 0;
break;
 
177,9 → 145,9
i2c_write_byte(0x80); // Value
break;
case 12:
i2c_stop();
I2C_Stop();
I2CTimeout = 10;
i2c_start();
I2C_Start();
break;
case 13:
i2c_write_byte(0x98); // Address of the DAC
194,9 → 162,9
i2c_write_byte(0x80); // Value
break;
case 17:
i2c_stop();
I2C_Stop();
I2CTimeout = 10;
i2c_start();
I2C_Start();
break;
case 18:
i2c_write_byte(0x98); // Address of the DAC
211,7 → 179,7
i2c_write_byte(0x80); // Value
break;
case 22:
i2c_stop();
I2C_Stop();
I2CTimeout = 10;
twi_state = 0;
break;
235,7 → 203,8
//############################################################################
{ // 2 3 4 5 6 7 8 9
unsigned char test[] = {0,0,'#',0x1F,255,30,100,64,0x00,7,8,9,10};
static unsigned char missing_motor,send = 0,crc = 0;
static unsigned char missing_motor,send = 0,crc = 0, read_temperature = 0;
 
switch(twi_state++)
{
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
254,7 → 223,8
break;
case 1:
i2c_write_byte(Motor[motor].SetPoint);
if(!(Motor[motor].Version & MOTOR_STATE_NEW_PROTOCOL_MASK)) twi_state++;
if(!(Motor[motor].Version & MOTOR_STATE_NEW_PROTOCOL_MASK)/* || !Motor[motor].SetPointLowerBits*/)
twi_state++;
break;
case 2:
if(!send++)
263,13 → 233,17
crc = 0xAA;
}
else
if(send == 9) i2c_write_byte(crc);
if(send == 9) i2c_write_byte(crc)
else
{
crc += test[send];
i2c_write_byte(test[send]);
}
if(!MotorenEin && motor == motorread && !PC_MotortestActive && (Motor[motorread].Version & MOTOR_STATE_NEW_PROTOCOL_MASK)) if(send <= 10) twi_state--;
if(TransmitBlConfig && !MotorenEin && motor == motorread && (Motor[motorread].Version & MOTOR_STATE_NEW_PROTOCOL_MASK))
{
if(send <= 10) twi_state--;
}
 
break;
case 3:
motor++;
278,10 → 252,10
if(!missing_motor) missing_motor = motor;
if((Motor[motor-1].State & MOTOR_STATE_ERROR_MASK) < MOTOR_STATE_ERROR_MASK) Motor[motor-1].State++; // increment error counter and handle overflow
}
i2c_stop();
I2C_Stop();
I2CTimeout = 10;
twi_state = 0;
i2c_start();
I2C_Start();
break;
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Reading Data
292,8 → 266,8
{
Motor[motorread].State &= ~MOTOR_STATE_PRESENT_MASK; // clear present bit
motorread++;
if(motorread >= MAX_MOTORS) motorread = 0;
i2c_stop();
if(motorread >= MAX_MOTORS) { TransmitBlConfig = 0; motorread = 0; }
I2C_Stop();
twi_state = 0;
}
else
313,17 → 287,16
Motor[motorread].MaxPWM = TWDR;
if(TWDR == 250)
{
//if(!Motor[motor].SetPoint)
Motor[motorread].Version |= MOTOR_STATE_NEW_PROTOCOL_MASK;
}
else if(TransmitBlConfig) Motor[motorread].Version = 0;
I2C_ReceiveLastByte(); //nack
break;
case 7: // read next
if(TWDR == 255) { if(!MotorenEin) Motor[motorread].Version = 0; DebugOut.Analog[24]++;}
Motor[motorread].Temperature = TWDR;
motorread++; // next motor
if(motorread >= MAX_MOTORS) { motorread = 0; }
i2c_stop();
if(motorread >= MAX_MOTORS) { TransmitBlConfig = 0; motorread = 0; }
I2C_Stop();
twi_state = 0;
break;
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
342,9 → 315,9
i2c_write_byte(0x80); // Value
break;
case 22:
i2c_stop();
I2C_Stop();
I2CTimeout = 10;
i2c_start();
I2C_Start();
break;
case 23:
i2c_write_byte(0x98); // Address of the DAC
359,9 → 332,9
i2c_write_byte(0x80); // Value
break;
case 27:
i2c_stop();
I2C_Stop();
I2CTimeout = 10;
i2c_start();
I2C_Start();
break;
case 28:
i2c_write_byte(0x98); // Address of the DAC
376,7 → 349,7
i2c_write_byte(0x80); // Value
break;
case 32:
i2c_stop();
I2C_Stop();
I2CTimeout = 10;
twi_state = 0;
break;
385,3 → 358,4
}
TWCR |= 0x80;
}
 
/trunk/twimaster.h
20,7 → 20,7
 
extern volatile unsigned char twi_state;
extern unsigned char motor,MissingMotor;
extern unsigned char motorread;
extern unsigned char motorread,TransmitBlConfig;
 
#define MAX_MOTORS 12
#define MOTOR_STATE_PRESENT_MASK 0x80
44,9 → 44,15
 
void i2c_reset(void);
extern void i2c_init (void); // I2C initialisieren
extern void i2c_start (void); // Start I2C
extern void i2c_stop (void); // Stop I2C
//extern void i2c_start (void); // Start I2C
//extern void i2c_stop (void); // Stop I2C
extern void i2c_write_byte (char byte); // 1 Byte schreiben
extern void i2c_reset(void);
 
#define I2C_Start() {TWCR = (1<<TWSTA) | (1<<TWEN) | (1<<TWINT) | (1<<TWIE);}
#define I2C_Stop() {TWCR = (1<<TWEN) | (1<<TWSTO) | (1<<TWINT);}
#define I2C_ReceiveByte() {TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE) | (1<<TWEA);}
#define I2C_ReceiveLastByte() {TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);}
#define i2c_write_byte(byte) {TWSR = 0x00; TWDR = byte; TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);}
 
#endif
/trunk/uart.c
584,7 → 584,7
}
if(((DebugDataIntervall>0 && CheckDelay(Debug_Timer)) || DebugDataAnforderung) && UebertragungAbgeschlossen)
{
//if(Poti3 > 64)
CopyDebugValues();
SendOutData('D', FC_ADDRESS, 1, (unsigned char *) &DebugOut,sizeof(DebugOut));
DebugDataAnforderung = 0;
if(DebugDataIntervall>0) Debug_Timer = SetDelay(DebugDataIntervall);