Probleme mit Bluetoothübertragung

Hallo,ich habe Probleme mit der Bluetoothübertragung vom Arduino zum Android.
Wenn mir die Daten des ADXL345 angezeigt werden sollen,funktioniert das nicht immer.Die Daten werden aber auf dem Seriellen Monitor angezeigt.
Senden der Daten (Tasten e,f,g,h,i,j,x,usw.)vom Android zum Arduino klappt einwandfrei.
Komischer Weise funktioniert es wieder,wenn ich das Board mega2560 austausche.Danach funktioniert das andere aber auch wieder.
Oder ist es eventl. ein Master Slave Problem des HC05 Moduls?
An der Android App die ich über APP-Inventor geschrieben habe kann es eigentlich nicht liegen,da die immer gleich geblieben ist.Habe die aber auch mehrmals neu installiert.
Hoffe das mir jemand einen Tipp geben kann.DANKE

//--------------Drehmoment--------------------//
int SenVLH = A2;             //Drehmomenteingang
int SenVLR = A3;
int SenVRH = A4;
int SenVRR = A5;
int SenHLH = A6;
int SenHLR = A7;
int SenHRH = A8;
int SenHRR = A9;
int SenMLH = A10;
int SenMLR = A11;
int SenMRH = A12;
int SenMRR = A13;
int SenMOH = A14;
int SenMOR = A15;
int drho = 2000;           //Drehmomentbegrenzung Hoch  bei 800
int drru = 2000;          //Drehmomentbegrenzung Runter  bei 1000
long bsz = 10;            //Bechleunigungszeit
byte beschleunigungInterval = 5;      // HochdimmenZeit
byte beschleunigungVLH = 0;
byte beschleunigungVLR = 0;
byte beschleunigungVRH = 0;
byte beschleunigungVRR = 0;
byte beschleunigungHLH = 0;
byte beschleunigungHLR = 0;
byte beschleunigungHRH = 0;
byte beschleunigungHRR = 0;
byte beschleunigungMLH = 0;
byte beschleunigungMLR = 0;
byte beschleunigungMRH = 0;
byte beschleunigungMRR = 0;
byte beschleunigungMOH = 0;
byte beschleunigungMOR = 0;
unsigned long previousMillisVLH = 0;   // Hochdimmen
unsigned long previousMillisVLR = 0;
unsigned long previousMillisVRH = 0;
unsigned long previousMillisVRR = 0;
unsigned long previousMillisHLH = 0;
unsigned long previousMillisHLR = 0;
unsigned long previousMillisHRH = 0;
unsigned long previousMillisHRR = 0;
unsigned long previousMillisMLH = 0;
unsigned long previousMillisMLR = 0;
unsigned long previousMillisMRH = 0;
unsigned long previousMillisMRR = 0;
unsigned long previousMillisMOH = 0;
unsigned long previousMillisMOR = 0;

//---------------Motorsteuerung---------------//
int VorneLinksHoch = 2;   //Digital
int VorneLinksRunter = 3;
int VorneRechtsHoch = 4;
int VorneRechtsRunter = 5;
int HintenLinksHoch = 6;
int HintenLinksRunter = 7;
int HintenRechtsHoch = 8;
int HintenRechtsRunter = 9;
int MitteLinksHoch = 10;
int MitteLinksRunter = 11;
int MitteRechtsHoch = 12;
int MitteRechtsRunter = 13;
int MoverHoch = 14;
int MoverRunter = 15;
//--------Beschleunigungssensor ADXL345----------//
int in1 = 20;   // Beschleunigungssensor
int in2 = 21;   // Beschleunigungssensor
#include <Wire.h>  // Wire library Beschleunigungssensor
int ADXL345 = 0x53; // Beschleunigungssensor
static   int data  =  Serial ;  //benennen der gesendeten Daten
#include "HC05.h"
float X_out, Y_out;  // Outputs Beschleunigungssensor
unsigned long startzeitadxl345 = 0;   //Delay in millis
#define        laufzeitadxl345   334UL  //Delay in millis 234

void setup() {
  //--------Beschleunigungssensor ADXL345----------//
  Serial.begin(9600); // Initialisiere Serielle Kommunikation um die Ergebnisse auf den Seriellen Monitor zu zeigen
  pinMode(in1, INPUT); // Beschleunigungssensor
  pinMode(in2, INPUT);// Beschleunigungssensor
  Wire.begin();   // Beschleunigungssensor
  Wire.beginTransmission(ADXL345); // Beschleunigungssensor
  Wire.write(0x2D); // Beschleunigungssensor
  Wire.write(8); // Beschleunigungssensor
  Wire.endTransmission();// Beschleunigungssensor
  delay(10);// Beschleunigungssensor
  //--------------Drehmoment--------------------//
  pinMode(SenVLH, INPUT); //Pin:LS BTS7960B
  pinMode(SenVLR, INPUT); //Pin:RS BTS7960B
  pinMode(SenVRH, INPUT); //Pin:LS BTS7960B
  pinMode(SenVRR, INPUT); //Pin:RS BTS7960B
  pinMode(SenHLH, INPUT); //Pin:LS BTS7960B
  pinMode(SenHLR, INPUT); //Pin:RS BTS7960B
  pinMode(SenHRH, INPUT); //Pin:LS BTS7960B
  pinMode(SenHRR, INPUT); //Pin:RS BTS7960B
  pinMode(SenMLH, INPUT); //Pin:LS BTS7960B
  pinMode(SenMLR, INPUT); //Pin:RS BTS7960B
  pinMode(SenMRH, INPUT); //Pin:LS BTS7960B
  pinMode(SenMRR, INPUT); //Pin:RS BTS7960B
  pinMode(SenMOH, INPUT); //Pin:LS BTS7960B
  pinMode(SenMOR, INPUT); //Pin:RS BTS7960B


  //---------------Motorsteuerung---------------//
  pinMode (2, OUTPUT);    //Pin:RPWM BTS7960B VL
  pinMode (3, OUTPUT);    //Pin:LPWM BTS7960B VL
  pinMode (4, OUTPUT);    //Pin:RPWM BTS7960B VR
  pinMode (5, OUTPUT);    //Pin:LPWM BTS7960B VR
  pinMode (6, OUTPUT);    //Pin:RPWM BTS7960B HL
  pinMode (7, OUTPUT);    //Pin:LPWM BTS7960B HL
  pinMode (8, OUTPUT);    //Pin:RPWM BTS7960B HR
  pinMode (9, OUTPUT);    //Pin:LPWM BTS7960B HR
  pinMode (10, OUTPUT);   //Pin:RPWM BTS7960B ML
  pinMode (11, OUTPUT);   //Pin:LPWM BTS7960B ML
  pinMode (12, OUTPUT);   //Pin:RPWM BTS7960B MR
  pinMode (13, OUTPUT);   //Pin:LPWM BTS7960B MR
  pinMode (14, OUTPUT);   //Pin:RPWM BTS7960B MO
  pinMode (15, OUTPUT);   //Pin:LPWM BTS7960B MO


  analogWrite (2, 0);      //alle Ausgänge auf 0 setzen
  analogWrite (3, 0);      //alle Ausgänge auf 0 setzen
  analogWrite (4, 0);      //alle Ausgänge auf 0 setzen
  analogWrite (5, 0);      //alle Ausgänge auf 0 setzen
  analogWrite (6, 0);      //alle Ausgänge auf 0 setzen
  analogWrite (7, 0);      //alle Ausgänge auf 0 setzen
  analogWrite (8, 0);      //alle Ausgänge auf 0 setzen
  analogWrite (9, 0);      //alle Ausgänge auf 0 setzen
  analogWrite (10, 0);     //alle Ausgänge auf 0 setzen
  analogWrite (11, 0);     //alle Ausgänge auf 0 setzen
  analogWrite (12, 0);     //alle Ausgänge auf 0 setzen
  analogWrite (13, 0);     //alle Ausgänge auf 0 setzen
  analogWrite (14, 0);     //alle Ausgänge auf 0 setzen
  analogWrite (15, 0);     //alle Ausgänge auf 0 setzen
}

void loop() {
  // === Lese Daten Beschleunigungssensor === //
  Wire.beginTransmission(ADXL345);
  Wire.write(0x32);
  Wire.endTransmission(false);
  Wire.requestFrom(ADXL345, 6, true); // Read 6 registers total, each axis value is stored in 2 registers

  X_out = ( Wire.read() | Wire.read() << 8);
  X_out = X_out + 1000;
  Y_out = ( Wire.read() | Wire.read() << 8);
  Y_out = Y_out + 1000;

  if (millis() - startzeitadxl345 >= laufzeitadxl345) {
    startzeitadxl345 = millis();
    Serial.print("ADXL345");
    Serial.print("|");
    Serial.print(X_out, 0);
    Serial.print("|");
    Serial.print(Y_out, 0);
    Serial.print("|");
    Serial.print(SenMLH);
    Serial.print("|");
    Serial.print(SenMLR);
    Serial.println();
  }




  int SenVLH = analogRead(A2);
  int SenVLR = analogRead(A3);
  int SenVRH = analogRead(A4);
  int SenVRR = analogRead(A5);
  int SenHLH = analogRead(A6);
  int SenHLR = analogRead(A7);
  int SenHRH = analogRead(A8);
  int SenHRR = analogRead(A9);
  int SenMLH = analogRead(A10);
  int SenMLR = analogRead(A11);
  int SenMRH = analogRead(A12);
  int SenMRR = analogRead(A13);
  int SenMOH = analogRead(A14);
  int SenMOR = analogRead(A15);
  //----Beschleunigung ausserhalb des Void-----//
  if ((beschleunigungVLH >= 3) && (beschleunigungVLH < 250))
    voliho();
  if ((beschleunigungVLR >= 3) && (beschleunigungVLR < 250))
    voliru();
  if ((beschleunigungVRH >= 3) && (beschleunigungVRH < 250))
    voreho();
  if ((beschleunigungVRR >= 3) && (beschleunigungVRR < 250))
    voreru();
  if ((beschleunigungHLH >= 3) && (beschleunigungHLH < 250))
    hiliho();
  if ((beschleunigungHLR >= 3) && (beschleunigungHLR < 250))
    hiliru();
  if ((beschleunigungHRH >= 3) && (beschleunigungHRH < 250))
    hireho();
  if ((beschleunigungHRR >= 3) && (beschleunigungHRR < 250))
    hireru();
  if ((beschleunigungMLH >= 3) && (beschleunigungMLH < 250))
    miliho();
  if ((beschleunigungMLR >= 3) && (beschleunigungMLR < 250))
    miliru();
  if ((beschleunigungMRH >= 3) && (beschleunigungMRH < 250))
    mireho();
  if ((beschleunigungMRR >= 3) && (beschleunigungMRR < 250))
    mireru();
  if ((beschleunigungMOH >= 3) && (beschleunigungMOH < 250))
    moho();
  if ((beschleunigungMOR >= 3) && (beschleunigungMOR < 250))
    moru();

  //---------------Motorsteuerung---------------//
  if (Serial.available() > 0)
  { char data = Serial.read();
    {
      Serial.print(data); //Ankommende Daten vom Handy
    }

    if (data == 'e')  {                 //EmpfangBluetooth
      voliho();
      delay(2);
    }
    if (data == 'f')  {                 //EmpfangBluetooth
      voliru();
      delay(2);
    }
    if (data == 'g')  {                 //EmpfangBluetooth
      voreho();
      delay(2);
    }
    if (data == 'h')  {                 //EmpfangBluetooth
      voreru();
      delay(2);
    }
    if (data == 'i')  {                 //EmpfangBluetooth
      hiliho();
      delay(2);
    }
    if (data == 'j')  {                 //EmpfangBluetooth
      hiliru();
      delay(2);
    }
    if (data == 'k')  {                 //EmpfangBluetooth
      hireho();
      delay(2);
    }
    if (data == 'l')  {                 //EmpfangBluetooth
      hireru();
      delay(2);
    }
    if (data == 'a')  {                 //EmpfangBluetooth
      miliho();
      delay(2);
    }
    if (data == 'b')  {                 //EmpfangBluetooth
      miliru();
      delay(2);
    }
    if (data == 'c')  {                 //EmpfangBluetooth
      mireho();
      delay(2);
    }
    if (data == 'd')  {                 //EmpfangBluetooth
      mireru();
      delay(2);
    }
    if (data == 'm')  {                 //EmpfangBluetooth
      moho();
      delay(2);
    }
    if (data == 'n')  {                 //EmpfangBluetooth
      moru();
      delay(2);
    }
    if (data == 'z')  {                 //EmpfangBluetooth
      alho();
      delay(2);
    }
    if (data == 'y')  {                 //EmpfangBluetooth
      alru();
      delay(2);
    }
    if (data == 'x')  {                 //EmpfangBluetooth
      alstop();
      delay(2);
    }
    if (data == 'w')  {                 //EmpfangBluetooth
      rechtslinks();
      vornehinten();
      delay(2);
    }
  }
}

void voliho() {
  unsigned long currentMillisVLH = millis();
  Serial.print("VorneLinksHoch ");
  Serial.print("Drehmoment "); Serial.println(SenVLH);
  analogWrite(3, 0);
  if (currentMillisVLH - previousMillisVLH >= bsz && SenVLH <= drho)
  {
    previousMillisVLH = currentMillisVLH;
    if (beschleunigungVLH <= 254) beschleunigungVLH += beschleunigungInterval;
    if (beschleunigungVLH == 255) beschleunigungVLH = 255;
    analogWrite(VorneLinksHoch, beschleunigungVLH);
    Serial.print(beschleunigungVLH);
  }
}
void voliru() {
  unsigned long currentMillisVLR = millis();
  Serial.print("VorneLinksRunter ");
  Serial.print("Drehmoment "); Serial.println(SenVLR);
  analogWrite(2, 0);
  if (currentMillisVLR - previousMillisVLR >= bsz && SenVLR <= (drru))
  {
    previousMillisVLR = currentMillisVLR;
    if (beschleunigungVLR <= 254) beschleunigungVLR += beschleunigungInterval;
    if (beschleunigungVLR == 255) beschleunigungVLR = 255;
    analogWrite(VorneLinksRunter, beschleunigungVLR);
  }
}
void voreho() {
  unsigned long currentMillisVRH = millis();
  Serial.print("VorneRechtsHoch ");
  Serial.print("Drehmoment "); Serial.println(SenVRH);
  analogWrite(5, 0);
  if (currentMillisVRH - previousMillisVRH >= bsz && SenVRH <= (drho))
  {
    previousMillisVRH = currentMillisVRH;
    if (beschleunigungVRH <= 254) beschleunigungVRH += beschleunigungInterval;
    if (beschleunigungVRH == 255) beschleunigungVRH = 255;
    analogWrite(VorneRechtsHoch, beschleunigungVRH);
  }
}
void voreru() {
  unsigned long currentMillisVRR = millis();
  Serial.print("VorneRechtsRunter ");
  Serial.print("Drehmoment "); Serial.println(SenVRR);
  analogWrite(4, 0);
  if (currentMillisVRR - previousMillisVRR >= bsz && SenVRR <= (drru))
  {
    previousMillisVRR = currentMillisVRR;
    if (beschleunigungVRR <= 254) beschleunigungVRR += beschleunigungInterval;
    if (beschleunigungVRR == 255) beschleunigungVRR = 255;
    analogWrite(VorneRechtsRunter, beschleunigungVRR);
  }
}
void hiliho() {
  unsigned long currentMillisHLH = millis();
  Serial.print("HintenLinksHoch ");
  Serial.print("Drehmoment "); Serial.println(SenHLH);
  analogWrite(7, 0);
  if (currentMillisHLH - previousMillisHLH >= bsz && SenHLH <= (drho))
  {
    previousMillisHLH = currentMillisHLH;
    if (beschleunigungHLH <= 254) beschleunigungHLH += beschleunigungInterval;
    if (beschleunigungHLH == 255) beschleunigungHLH = 255;
    analogWrite(HintenLinksHoch, beschleunigungHLH);
  }
}
void hiliru() {
  unsigned long currentMillisHLR = millis();
  Serial.print("HintenLinksRunter ");
  Serial.print("Drehmoment "); Serial.println(SenHLR);
  analogWrite(6, 0);
  if (currentMillisHLR - previousMillisHLR >= bsz && SenHLR <= (drru))
  {
    previousMillisHLR = currentMillisHLR;
    if (beschleunigungHLR <= 254) beschleunigungHLR += beschleunigungInterval;
    if (beschleunigungHLR == 255) beschleunigungHLR = 255;
    analogWrite(HintenLinksRunter, beschleunigungHLR);
  }
}
void hireho() {
  unsigned long currentMillisHRH = millis();
  Serial.print("HintenRechtsHoch ");
  Serial.print("Drehmoment "); Serial.println(SenHRH);
  analogWrite(9, 0);
  if (currentMillisHRH - previousMillisHRH >= bsz && SenHRH <= (drho))
  {
    previousMillisHRH = currentMillisHRH;
    if (beschleunigungHRH <= 254) beschleunigungHRH += beschleunigungInterval;
    if (beschleunigungHRH == 255) beschleunigungHRH = 255;
    analogWrite(HintenRechtsHoch, beschleunigungHRH);
  }
}
void hireru() {
  unsigned long currentMillisHRR = millis();
  Serial.print("HinteRechtsRunter ");
  Serial.print("Drehmoment "); Serial.println(SenHRR);
  analogWrite(8, 0);
  if (currentMillisHRR - previousMillisHRR >= bsz && SenHRR <= (drru))
  {
    previousMillisHRR = currentMillisHRR;
    if (beschleunigungHRR <= 254) beschleunigungHRR += beschleunigungInterval;
    if (beschleunigungHRR == 255) beschleunigungHRR = 255;
    analogWrite(HintenRechtsRunter, beschleunigungHRR);
  }
}
void miliho() {
  unsigned long currentMillisMLH = millis();
  Serial.print("MitteLinksHoch ");
  Serial.print("Drehmoment "); Serial.println(SenMLH);
  analogWrite(11, 0);
  if (currentMillisMLH - previousMillisMLH >= bsz )//&& SenMLH <= (drho))
  {
    previousMillisMLH = currentMillisMLH;
    if (beschleunigungMLH <= 254) beschleunigungMLH += beschleunigungInterval;
    if (beschleunigungMLH == 255) beschleunigungMLH = 255;
    analogWrite(MitteLinksHoch, beschleunigungMLH);
  }
}
void miliru() {
  unsigned long currentMillisMLR = millis();
  Serial.print("MitteLinksRunter ");
  Serial.print("Drehmoment "); Serial.println(SenMLR);
  analogWrite(10, 0);
  if (currentMillisMLR - previousMillisMLR >= bsz )//&& SenMLR <= (drru))
  {
    previousMillisMLR = currentMillisMLR;
    if (beschleunigungMLR <= 254) beschleunigungMLR += beschleunigungInterval;
    if (beschleunigungMLR == 255) beschleunigungMLR = 255;
    analogWrite(MitteLinksRunter, beschleunigungMLR);
  }
}
void mireho() {
  unsigned long currentMillisMRH = millis();
  Serial.print("MitteRechtsHoch ");
  Serial.print("Drehmoment "); Serial.println(SenMRH);
  analogWrite(13, 0);
  if (currentMillisMRH - previousMillisMRH >= bsz && SenMRH <= (drho))
  {
    previousMillisMRH = currentMillisMRH;
    if (beschleunigungMRH <= 254) beschleunigungMRH += beschleunigungInterval;
    if (beschleunigungMRH == 255) beschleunigungMRH = 255;
    analogWrite(MitteRechtsHoch, beschleunigungMRH);
  }
}
void mireru() {
  unsigned long currentMillisMRR = millis();
  Serial.print("MitteRechtsRunter ");
  Serial.print("Drehmoment "); Serial.println(SenMRR);
  analogWrite(12, 0);
  if (currentMillisMRR - previousMillisMRR >= bsz && SenMRR <= (drru))
  {
    previousMillisMRR = currentMillisMRR;
    if (beschleunigungMRR <= 254) beschleunigungMRR += beschleunigungInterval;
    if (beschleunigungMRR == 255) beschleunigungMRR = 255;
    analogWrite(MitteRechtsRunter, beschleunigungMRR);
  }
}
void moho() {
  unsigned long currentMillisMOH = millis();
  Serial.print("MoverHoch ");
  Serial.print("Drehmoment "); Serial.println(SenMOH);
  analogWrite(15, 0);
  if (currentMillisMOH - previousMillisMOH >= bsz && SenMOH <= (drho))
  {
    previousMillisMOH = currentMillisMOH;
    if (beschleunigungMOH <= 254) beschleunigungMOH += beschleunigungInterval;
    if (beschleunigungMOH == 255) beschleunigungMOH = 255;
    analogWrite(MoverHoch, beschleunigungMOH);
  }
}
void moru() {
  unsigned long currentMillisMOR = millis();
  Serial.print("MoverRunter ");
  Serial.print("Drehmoment "); Serial.println(SenMOR);
  analogWrite(14, 0);
  if (currentMillisMOR - previousMillisMOR >= bsz && SenMOR <= (drru))
  {
    previousMillisMOR = currentMillisMOR;
    if (beschleunigungMOR <= 254) beschleunigungMOR += beschleunigungInterval;
    if (beschleunigungMOR == 255) beschleunigungMOR = 255;
    analogWrite(MoverRunter, beschleunigungMOR);
  }
}
void alho()
{ Serial.println("AllesHoch");
  voliho();
  voreho();
  hiliho();
  hireho();
  miliho();
  mireho();
}
void alru()
{ Serial.println("AllesRunter");
  voliru();
  voreru();
  hiliru();
  hireru();
  miliru();
  mireru();
}
void alstop()
{ Serial.println("AusdieMaus ");
  analogWrite(2, 0);
  analogWrite(3, 0);
  analogWrite(4, 0);
  analogWrite(5, 0);
  analogWrite(6, 0);
  analogWrite(7, 0);
  analogWrite(8, 0);
  analogWrite(9, 0);
  analogWrite(10, 0);
  analogWrite(11, 0);
  analogWrite(12, 0);
  analogWrite(13, 0);
  analogWrite(14, 0);
  analogWrite(15, 0);
  beschleunigungVLH = 0;
  beschleunigungVLR = 0;
  beschleunigungVRH = 0;
  beschleunigungVRR = 0;
  beschleunigungHLH = 0;
  beschleunigungHLR = 0;
  beschleunigungHRH = 0;
  beschleunigungHRR = 0;
  beschleunigungMLH = 0;
  beschleunigungMLR = 0;
  beschleunigungMRH = 0;
  beschleunigungMRR = 0;
  beschleunigungMOH = 0;
  beschleunigungMOR = 0;
}
void rechtslinks() {
  Serial.print("RichtenLinksRechts");

  if ( X_out >= 1003) {
    Serial.println(" Links ist Hoch   ");
    miliru();
    mireho();
  }
  else if (X_out <= 997)
  { Serial.println(" Rechts ist Hoch   ");
    miliho();
    mireru();
  }
  else ((X_out > 997) & (X_out < 1003));
  { Serial.println("---RichtenLinksRechts STOP--- ");
    analogWrite(10, 0);
    analogWrite(11, 0);
    analogWrite(12, 0);
    analogWrite(13, 0);
  }
}
void vornehinten() {
  Serial.print("RichtenVorneHinten ");

  if (Y_out >= 1003)
  { Serial.println(" Vorne ist Hoch   ");
    voliru();
    voreru();
    hiliho();
    hireho();
  }
  else if (Y_out <= 997)
  { Serial.println(" Hinten ist Hoch   ");
    voliho();
    voreho();
    hiliru();
    hireru();
  }
  else ((Y_out > 997) & (Y_out < 1003));
  { Serial.println("---RichtenVorneHinten STOP---");
    analogWrite(2, 0);
    analogWrite(3, 0);
    analogWrite(4, 0);
    analogWrite(5, 0);
    analogWrite(6, 0);
    analogWrite(7, 0);
    analogWrite(8, 0);
    analogWrite(9, 0);
  }

}
//---------------Motorsteuerung---------------//
int VorneLinksHoch = 2;   //Digital
int VorneLinksRunter = 3;
int VorneRechtsHoch = 4;
int VorneRechtsRunter = 5;
int HintenLinksHoch = 6;
int HintenLinksRunter = 7;
int HintenRechtsHoch = 8;
int HintenRechtsRunter = 9;
int MitteLinksHoch = 10;
int MitteLinksRunter = 11;
int MitteRechtsHoch = 12;
int MitteRechtsRunter = 13;
int MoverHoch = 14;
int MoverRunter = 15;

Aber:

  //---------------Motorsteuerung---------------//
  pinMode (2, OUTPUT);    //Pin:RPWM BTS7960B VL
  pinMode (3, OUTPUT);    //Pin:LPWM BTS7960B VL
  pinMode (4, OUTPUT);    //Pin:RPWM BTS7960B VR
  pinMode (5, OUTPUT);    //Pin:LPWM BTS7960B VR
  pinMode (6, OUTPUT);    //Pin:RPWM BTS7960B HL
  pinMode (7, OUTPUT);    //Pin:LPWM BTS7960B HL
  pinMode (8, OUTPUT);    //Pin:RPWM BTS7960B HR
  pinMode (9, OUTPUT);    //Pin:LPWM BTS7960B HR
  pinMode (10, OUTPUT);   //Pin:RPWM BTS7960B ML
  pinMode (11, OUTPUT);   //Pin:LPWM BTS7960B ML
  pinMode (12, OUTPUT);   //Pin:RPWM BTS7960B MR
  pinMode (13, OUTPUT);   //Pin:LPWM BTS7960B MR
  pinMode (14, OUTPUT);   //Pin:RPWM BTS7960B MO
  pinMode (15, OUTPUT);   //Pin:LPWM BTS7960B MO

bzw.

//--------------Drehmoment--------------------//
int SenVLH = A2;             //Drehmomenteingang
int SenVLR = A3;
int SenVRH = A4;
int SenVRR = A5;
int SenHLH = A6;
int SenHLR = A7;
int SenHRH = A8;
int SenHRR = A9;
int SenMLH = A10;
int SenMLR = A11;
int SenMRH = A12;
int SenMRR = A13;
int SenMOH = A14;
int SenMOR = A15;

aber:



  int SenVLH = analogRead(A2);
  int SenVLR = analogRead(A3);
  int SenVRH = analogRead(A4);
  int SenVRR = analogRead(A5);
  int SenHLH = analogRead(A6);
  int SenHLR = analogRead(A7);
  int SenHRH = analogRead(A8);
  int SenHRR = analogRead(A9);
  int SenMLH = analogRead(A10);
  int SenMLR = analogRead(A11);
  int SenMRH = analogRead(A12);
  int SenMRR = analogRead(A13);
  int SenMOH = analogRead(A14);
  int SenMOR = analogRead(A15);

Ich versteh auch nicht:

  analogWrite (2, 0);      //alle Ausgänge auf 0 setzen
// und so weiter....

Allein, wenn Du eine Handvoll Arrays benutzt, wirst Du vermutlich auf lesbaren Code kommen...

Edit:
Und es sei mir der Hinweis erlaubt, das der Code nicht einmal compiliert.

Hallo,Danke für deine Antwort.
Compilieren macht der Code,sonst könnte ich den ja nicht auf den Arduino spielen.

Für mich ist der Code so lesbar,und ich verstehe,was ich geschrieben habe.

Das hat aber wohl nichts,mit meinem Bluetooth Problem zu tun.

Ja, mein Fehler.

Ungeachtet dessen; der Code ist unendlich lang ohne Grund.

Dann muss ich Dir sagen, das es mir leid tut - ich bin nicht bereit das aufzulösen und rauszufinden was Du meinst und nicht schreibst.

wenn ich das recht sehe dann hast du das Bluetooth-modul an der seriellen Schnittstelle angeschlossen die auch die Verbindung zum PC darstellt.

Das ist keine gute Idee.
Das bluetooth-modul sollte auf einer eigenen Schnittstelle sein.
Und der Arduino Mega 2560 hat ja gleich drei davon.

Ansonsten ist das mit den hardcodierten Ausgängen eine potentielle Fehlerquelle.
Man sollte sich für alle Sachen die man an mehr als einer Stelle benutzt Konstanten definieren.
Mit Konstante ändert man an einer einzigen Stelle etwas und kann sich dann sicher sein, dass alle anderen Stellen mitgeändert wurden.
Hart codierte Zahlen ändern sich nicht mit.
Da wird aus den 30 Minuten Zeitersparnis für hardcodierte Zahlen oft 300 Minuten Fehlersuche
bis man dann endlich dahinter kommt.

Aber vielleicht macht ja stundenlange Fehlersuche für dich den besonderen Reiz des Programmierens aus. Dann ist das die richtige Methode.
vgs

Mein Problem ist nicht die Länge oder lesbarkeit des Codes,sondern,das das Signal des ADXL345 nicht immer auf das Handy übertragen wird,obwohl die Daten auf dem seriellen Monitor angezeigt werden,und Daten vom Handy zum Arduino ohne Probleme gesendet werden.

Ok.
Ich bin raus.
Du verstehst Deinen Code. Du weisst, was da passiert.
Ich nicht.

Wenn Du weisst, was da passiert, kannst Du das auch lösen.

Dann werde ich das mal machen.Danke

Jetzt funktioniert wieder alles.Sketch zum x. mal aufgespielt.
Eventl.muss ich die Verkabelung mal prüfen,da auf dem Android stand:Broken Pipe