Bluetooth + binär!=String + SD-Card

Hallo zusammen, vielleicht kann mir ja hier geholfen werden, ich hoffe es sehr.

Ich dachte es ist eigentlich keine schwierige Sache, aber ich dreh mich grad im Kreis.

µC via Bluetooth sendet ->>> BINÄR - Werte->>> an Handy.

Binär-Werte: 8 Bit. (1stop/1Startbit).

Handy soll diese Binär-Werte empfangen und auf SD-Karte speichern.

Entweder, gleiches Format in Binär, Hex oder DEC.

Funktioniert soweit, so gut.

Das Problem ist, dass beim Empfangen die Daten als STRING interpretiert werden und dadurch “UNSINN” auf der Karte hinterlegt wird.

Eine 0b11111111 (FF) führt dazu, dass Folgendes auf die SD-Karte hinterlegt wird: ef bf bd.

Strings werden korrekt gespeichert ( logisch, jedoch brauch ich die gar nicht).

Also Problem bekannt, Lösung wäre:

Die Werte ungestringt und im gleichen Format zu speichern, leider muss ich sagen, dass mir das als Java-Anfänger Probleme bereitet.

Meine Versuche diesen Code zu ändern führten entweder dazu, dass die App abstürzt, Error, gar nichts gespeichert wird, kein Ordner hinterlegt wird oder keine Änderung eintrifft…

wie geht das den richtig? Rohwerte speichern, muss man in String formatieren? Gar nicht formatieren? Bin in Dec, dann in String??

Eins vorab, auf der µC-Ebene können die Werte nicht in String gewandelt werden aus Timing-Gründen.

Die Werte sind korrekt und werden auch im Terminal richtig dargestellt, der ERROR beim Übertragen liegt bei 0%.

Es liegt also definitiv am Code und der Formatierung.

Vielen Dank im Voraus.

Der relevante Codeschnipsel:



        Handler() {
                public void handleMessage (android.os.Message msg){

                    switch (msg.what) {
                        case RECIEVE_MESSAGE:

                                                      // wenn Daten empfangen werden
                            byte[] readBuf = (byte[]) msg.obj;


                            String strIncom = new String(readBuf, 0, msg.arg1);

                                         // erstelle String aus Bytes Array
                            sb.append(strIncom);                                                // String anhängen
                            int endOfLineIndex;
                            String path = "/sdcard/" + dateipfad.getText().toString() + ".txt";  //Environment.getExternalStorageDirectory().getPath()






                            while ((endOfLineIndex = sb.indexOf("0")) >= 0) {                  // wenn end-of-line,
                                String sbprint;                                                 // extrahiere String
                                sbprint = sb.substring(0, endOfLineIndex);
                                sb.delete(0, sb.length());                                      // und löschen


                                ///////Messwertedatei beschreiben//////////
                                try {



                                    File myFile = new File(path);
                                    myFile.createNewFile();
                                    FileOutputStream fOut = new FileOutputStream(myFile, true);
                                    OutputStreamWriter myOutWriter =
                                            new OutputStreamWriter(fOut);
                                    myOutWriter.write(sbprint);
                                    myOutWriter.close();
                                    fOut.close();




Handler() {
                public void handleMessage (android.os.Message msg){

                    switch (msg.what) {
                        case RECIEVE_MESSAGE:

                                                      // wenn Daten empfangen werden
                            byte[] readBuf = (byte[]) msg.obj;


                            String strIncom = new String(readBuf, 0, msg.arg1);

                                         // erstelle String aus Bytes Array
                            sb.append(strIncom);                                                // String anhängen
                            int endOfLineIndex;
                            String path = "/sdcard/" + dateipfad.getText().toString() + ".txt";  //Environment.getExternalStorageDirectory().getPath()


                            StringBuilder sbi = new StringBuilder();
                            for (byte b : readBuf) {
                                sbi.append(String.format("%02X ", b));
                            }




                            while ((endOfLineIndex = sb.indexOf("0")) >= 0) {                  // wenn end-of-line,
                                String sbprint;                                                 // extrahiere String
                                sbprint = sb.substring(0, endOfLineIndex);
                                sb.delete(0, sb.length());                                      // und löschen


                                ///////Messwertedatei beschreiben//////////
                                try {



                                    File myFile = new File(path);
                                    myFile.createNewFile();
                                    FileOutputStream fOut = new FileOutputStream(myFile, true);
                                    OutputStreamWriter myOutWriter =
                                            new OutputStreamWriter(fOut);
                                    myOutWriter.write(sbi.toString());
                                    myOutWriter.close();
                                    fOut.close();

Ich hab das jetzt so gelöst, es passt halbwegs. In Hex konvertiert.

Das Problem jetzt, mir fehlen Haufen Werte. Schafft das Handy zu speichern bei einer Baudrate von 200k?

Es filmt nämlich noch nebenbei Video und Ton, dürfte aber kein Problem sein?

es gibt keine Binärwerte, keine HEX-Werte und keine DEC-Werte - es gibt nur Bits - und deren Interpretation

Funktioniert soweit, so gut.

glaube ich nicht

Beweisführung abgeschlossen…
wie schon geschrieben - es gibt keine Binärwerte, keine HEX-Werte und keine DEC-Werte - sondern nur eine Interpretation von Bits.

Beim Übertragen von Daten (undefinierte Sammlung von Bits) werden über Funk oder auf der Kupferleitung (LAN) nur Bits übertragen. Was Du auf der einen Seite rein schiebst und auf der anderen Seite raus ziehst, ist der Übertragung völlig egal. Was auch immer Du auf der einen Seite rein schiebst, das ist kein String. Es fehlt dazu der Code um dies genauer beurteilen zu können.

Hallo Mogel.

Es fehlt dazu der Code um dies genauer beurteilen zu können.

µC: versendet Werte vom Sensor. 0b11100011 d.h. reine Rohwerte, so wie sie aus dem Register ausgelesen werden.

Code von APP steht ja bereits oben. Mein einziger halber Erfolg war diese in HEX zu konvertieren.

ich weiß nicht wo mein Kommentar hin ist, deswegen nochmal:

Der µC sendet Rohwerte 0b1001001 von Sensoren raus. (Also Zahlen).

[ot]

Um Spam zu verhindern, müssen manche Beiträge (von Unregistrierten) erst freigeschaltet werden - was hiermit passiert ist :D)
[/ot]

Zu Android-spezifischem werde ich nicht viel sagen können, aber wie mogel schon schrieb: Bits sind nur bits. Wenn du sowas machst wie

int x = 0xFF; // "Hex"
System.out.println(x); // Gibt 255 aus - "Dezimal"

Normalerweise sind solche Umwandlungen ziemlich trivial, aber hier fehlt (mir) ein bißchen kontext. Du meintes, es wird
0b1001001
gesendet. Wo und wie siehst du das? In was für eine Variablen ist das gespeichert? Wie gibst du das aus?

Normalerweise sind solche Umwandlungen ziemlich trivial, aber hier fehlt (mir) ein bißchen kontext.

Das ist auch mein Problem. Einfach die Roh-Werte wie sie einströmen auf die SD.Card zu speichern will mir nicht gelingen.

0b1001001 war ein Beispiel. Es wird genauso gesendet unformatiert wie es im µC Register gelesen wird. Nackte Rohwerte eben.

Für mein Beispiel, habe ich die analogen Spannung auf VCC gelegt und erhalte damit ein u_int8t WERT = ob11111111.

UDRO = (Wert); // sende Wert

jetzt hätte ich gerne auf meiner SD_Card hierfür stehen:

255
oder 11111111
oer FF…

Hast du irgendeine Möglichkeit zu verifizieren, dass die Daten auch korrekt zum Bluetooth-Modul gelangen? Einen Logiksniffer oder ein Oszi?

*** Edit ***

Ich sehe gerade, dass du scheinbar einen AVR verwendest und mit dem Bluetooth-Modul via UART kommunizierst. Ist die Baudrate korrekt eingestellt? Der richtige Takt hinterlegt?
Es könnte sein, dass du eine zu niedrige Baudrate eingestellt hast, sodass aus einem Byte mehrere werden.

hi cmrudolph

Die Baud beträgt 230.4K

genutzt wird ein Baudratenquarz, der Übertragungsfehler sollte bei 0% liegen, was auch im Terminal richtig dargestellt wird.

Mit einem Logic Analyzer hab ich das zusätzlich geprüft.

Es liegt also definitiv an der Hany-Applikation.

Nochmal mit dem Disclaimer, dass ich von Android und den hier genannten Begleittechnologien keine Ahnung habe: Das klingt, als wäre diese ganze String-Sache überflüssig.

Also, warum werden die Daten nicht direkt geschrieben? GROB sowas wie

byte[] readBuf = (byte[]) msg.obj;

String path = "/sdcard/" + dateipfad.getText().toString() + ".txt";  //Environment.getExternalStorageDirectory().getPath()

File myFile = new File(path);
myFile.createNewFile();
FileOutputStream fOut = new FileOutputStream(myFile, true);

fOut.write(readBuf); // (While-Schleife drum! Nur zur Verdeutlichung)

Mir ist nicht klar, was durch diese String-Umwandlung da erreicht werden soll. Und binärdaten mit einem “…Writer” schreiben ist meistens falsch…

Nochmal mit dem Disclaimer, dass ich von Android und den hier genannten Begleittechnologien keine Ahnung habe: Das klingt, als wäre diese ganze String-Sache überflüssig.

Freut mich dann umso mehr, dass du versuchst zu helfen :slight_smile: Ich habe leider auch kaum Erfahrung

Also, warum werden die Daten nicht direkt geschrieben? GROB sowas wie

war das erste was ich versucht hatte. Wenns kein String war „cannot resolve“. Mit readBuf.intoString() genau gleicher Mist wie mit .getBytes().

Also es werden nur paar Zeilen was gespeichert. Aber nichts sinnvolles.

Was heißt das? (Ggf. genaue Fehlermeldung posten!)

Fehlermeldung meint es soll heißen:

myOutWriter.append(String.valueOf(readBuf));

gut, bin ich einverstanden. Resultat ist aber das gleiche, wie readBuf.toString().

Nochmal: Die Umwandlung in einen String ist vielleicht gar nicht nötig.
Und mit einem “…Writer” Binärdaten zu schreiben ist praktisch immer falsch.

Was spricht gegen

byte[] readBuf = (byte[]) msg.obj;
 
fileOutputStream.write(readBuf); // Direkt FileOutputStream verwenden, um die BINÄR-Daten zu schreiben!

?!

(Es ist immernoch viel geraten, aber vielleicht kann klarer werden, wo ich falsch geraten habe…)

ups ich hatte immer noch mywriter, statt fOut.

Ja das ich keine Umwandlung brauche, ist mir von Anfang an klar :slight_smile:

Also moment, mit fOut schaut es schon etwas vernüftiger aus, ich probiere mal rum und meld mich dann.

Vielen Dank!!

*** Edit ***

ich näher mich meinem Ziel :slight_smile:

Habe es jetzt so stehen:

                switch (msg.what) {
                    case RECIEVE_MESSAGE:
                        // wenn Daten empfangen werden
                        byte[] readBuf = (byte[]) msg.obj;
                        //String strIncom = new String(readBuf, 0, msg.arg1);
                        // erstelle String aus Bytes Array
                       // sb.append(strIncom);                                                // String anhängen
                       // int endOfLineIndex;
                        String path = "/sdcard/" + dateipfad.getText().toString() + ".txt";  //Environment.getExternalStorageDirectory().getPath()
                        //sb.append(strIncom);                                                // String anhängen
                        //while ((endOfLineIndex = sb.indexOf("0")) >= 0) {                  // wenn end-of-line,
                          //  String sbprint;                                                 // extrahiere String
                            //sbprint = sb.substring(0, endOfLineIndex);
                            //sb.delete(0, sb.length());                                      // und löschen

///////////////////////////// hier

                            ///////Messwertedatei beschreiben//////////
                            try {
                                File myFile = new File(path);
                                myFile.createNewFile();
                                FileOutputStream fOut = new FileOutputStream(myFile,true);
                                fOut.write(readBuf);
                                fOut.flush();
                                fOut.close();

So. Jetzt werden die Werte richtig dargestellt, nur die Anordnung ist falsch.

Wenn ich grad nichts sende → Wird die SD-Karte mit nuller gefüllt. Eigentlich hätte ich gerne, dass sie in diesem Falle gar nicht beschrieben wird.

Unnnnnd, ich hab mir mal angeschaut, wo es kritisch wird, d.h. die Anzahl der Werte pro Paket abweicht und mir ist aufgefallen das ein Abschnitt immer korrekt dargestellt wird.

So. Auf der µC-Ebene, habe ich einen timergesteuerten Interrupt.

Wird dieser aufgerufen, sende ich einen Wert.

Bei bestimmten Fällen, sende ich wenn dieser aufgerufen wird 2 Werte!

Immer an den Grenzübergängen, von 2-> auf 1 oder umgekehrt, verliert es an Struktur.

Kann es sein, dass sich der „STREAM“ sich auf die letzten Empfangene Anzahl von Werte pro Zeitintervall einstellt, und im diesem gleichermaßen die nächsten Werte erwartet?

Das würde auch die Nuller erklären?

*** Edit ***

Bilder-Upload - Kostenlos Fotos hochladen und ins Netz stellen

Ich habe jetzt zum testen:
uint8t Cnt;

UDRO = 0xFF
UDRO = Cnt;
cnt++;

Aber da wo 61 ist sollte 62 folgen, der springt aber auf 25.

heißt dass, das Handy kommt nicht hinterher? (Es wird noch parallel dazu Ton und Video gespeichert)

Jemand eine Idee?

*** Edit ***

Geändert von SlaterB (Heute um 18:36 Uhr) Grund: weniger doppelte edits

Ich danke dir Slater und bitte um Verzeihung.

Habe die Frequenz auf 1 KHz runter und lasse nur eine Variable inkrementieren und ausgeben:

immer noch gleich -.- was läuft den da falsch.

das kommt durch die Kombination von Hinzufügen und Freischalten aus dem Forum-System, kein Fehler von dir,
durch deinen neuen Beitrag wieder nötig gewesen, nun mal ein Posting von mir damit nicht noch mehr mit dem vorherigen zusammengefügt wird :wink:

benutze ruhig JAVA-Tags statt CODE-Tags, falls es keinen Button gibt auch manuell einzutippen

ansonsten ganz schönes Durcheinander, hoffe Marco13 schaut ausreichend rein :wink:

Ähm. Ich versuch’s. Ein bißchen. Wenn ich den Eindruck hätte, dass der Fragesteller einem das Verstehen der Fragen leicht machen will, würde ich’s mehr versuchen. räusper. Vielleicht morgen nochmal schauen, falls niemand anderes mehr hilfreiche Tipps hat.

Hast du den Code im µC selbst geschrieben? Mich wundert, dass du ständig UDRO statt UDR0 schreibst und die geposteten Codefragmente enthalten ungültige Typen (korrekt ist uint8_t, nicht u_int8t oder uint8t).
Wenn der Code Nullen schreibt, dann scheint der µC diese auch zu senden, oder die Bibliothek, die du im Handy einsetzt um die Nachrichten zu empfangen, löst zu viele RECEIVE_MESSAGE-Ereignisse aus.

Du kannst ja mal Fragmente aus der µC-Firmware (den Sendeanteil, nicht den Messanteil) und noch Informationen zur verwendeten Clientbibliothek auf dem Handy posten.

Hast du den Code im µC selbst geschrieben? Mich wundert, dass du ständig UDRO statt UDR0 schreibst und die geposteten Codefragmente enthalten ungültige Typen
(korrekt ist uint8_t, nicht u_int8t oder uint8t).

Sry, ich meinte UDR0 und u_int8t. Der Code stimmt. Im Terminal ist ja auch alles korrekt.

jetzt bin ich schon soweit, dass ich nur eine Variable inkrementieren lasse und dann sende im 1 KHz-Takt und es werden immer noch nicht alle Werte gespeichert.

Wenn der Code Nullen schreibt, dann scheint der µC diese auch zu senden,

ist ausgeschlossen.

package com.example.xxx; import java.io.File; import java.io.Fil - Pastebin.com die komplette MainActivity.java

EDIT (Marco13) : Hab’ sie mal hier eingefügt:

package com.example.xxx;





import java.io.File;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import android.app.Activity;
import android.content.Context;
import android.hardware.Camera;
import android.media.MediaRecorder;
import android.os.Bundle;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;

import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.FrameLayout;
import android.widget.Spinner;


import android.widget.Toast;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.os.Build;
import android.os.Handler;
import android.util.Log;
import android.view.View.OnClickListener;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends Activity {
    private static final String TAG = "Musiktherapie";

    //Variablen setzen
    Button btnOn, btnOff;
    TextView txtArduino;
    Handler h;
    EditText dateipfad;
    boolean recording;
    final int RECIEVE_MESSAGE = 1;        // Status  for Handler

    //Methoden setzen
    private BluetoothAdapter btAdapter = null;
    private BluetoothSocket btSocket = null;
    private StringBuilder sb = new StringBuilder();
    private ConnectedThread mConnectedThread;
    private Camera myCamera;
    private MyCameraSurfaceView myCameraSurfaceView;
    private MediaRecorder mediaRecorder;

    // SPP UUID Service
    private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");


    private static String address = "20:15:06:24:45:69";

    /**
     * Wird einmal aufgerufen wenn Activity startet
     */
    @Override

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        recording = false;
        setContentView(R.layout.activity_main);




        //Spinner inizialisieren für die G-Settings

        //liste mit items
        final List<String> list=new ArrayList<String>();
        list.add("G_Range 2");
        list.add("G_Range 4");
        list.add("G_Range 8");



        //spinner erstellen
        final Spinner G  =(Spinner) findViewById(R.id.spinner);


            //liste als adapter
            ArrayAdapter<String> adp = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, list);
            adp.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
            G.setAdapter(adp);


        G.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
            @Override
            public void onItemSelected(AdapterView<?> parentView, View selectedItemView, int position, long id) {
                mConnectedThread.write(String.valueOf(2*(G.getSelectedItemPosition())));
            }@Override
             public void onNothingSelected(AdapterView<?> parentView) {
                  //  do nothing
            }



        });




                ///////////Kameravorschau/////////////
                myCamera = getCameraInstance();

            myCameraSurfaceView=new MyCameraSurfaceView(this,myCamera);

            FrameLayout myCameraPreview = (FrameLayout) findViewById(R.id.videoview);
            myCameraPreview.addView(myCameraSurfaceView);

            btnOn=(Button) findViewById(R.id.btnOn);

            btnOff=(Button) findViewById(R.id.btnOff);

    dateipfad=(EditText)this.findViewById(R.id.dateipfad);


    Button btnOff = (Button) findViewById(R.id.btnOff);
    btnOff.setOnClickListener(new

    OnClickListener() {
        public void onClick (View v){
            mediaRecorder.stop();                               
            mConnectedThread.write("3");                       
                    recording = false;
                    Toast.makeText(getBaseContext(),
                            "Messwerte gespeichert!",
                            Toast.LENGTH_SHORT).show();
                }
            }

            );






        h=new

            Handler() {
                public void handleMessage (android.os.Message msg){



                    switch (msg.what) {
                        case RECIEVE_MESSAGE:

                            // wenn Daten empfangen werden
                            byte[] readBuf = (byte[]) msg.obj;


                            String path = "/sdcard/" + dateipfad.getText().toString() + ".txt";  //Environment.getExternalStorageDirectory().getPath()








                                ///////Messwertedatei beschreiben//////////
                                try {



                                    File myFile = new File(path);
                                    myFile.createNewFile();
                                    FileOutputStream fOut = new FileOutputStream(myFile,true);

                                    fOut.write(readBuf);
                                    fOut.flush();
                                    fOut.close();




                                } catch (Exception e) {
                                    Toast.makeText(getBaseContext(), e.getMessage(),
                                            Toast.LENGTH_SHORT).show();
                                }
                            
                            break;
                    }
                }

            }

            ;

            btAdapter=BluetoothAdapter.getDefaultAdapter();        // get Bluetooth adapter vom Smartphone

            checkBTState();

            //////////////ON-Button/////////////////
            btnOn.setOnClickListener(new

            OnClickListener() {
                public void onClick (View v){


                    if (recording) {
                        // Aufnahme stoppen und Kamera loslassen
                        mediaRecorder.stop();                       // Aufnahme stoppen
                        releaseMediaRecorder();                      // Mediarecorder Objekt loslassen

                    } else {

                        //Kamera loslassen bevor der MediaRecorder startet
                        releaseCamera();
                        if (!prepareMediaRecorder()) {
                            Toast.makeText(MainActivity.this,
                                    "Fail in prepareMediaRecorder()!
 - Ended -",
                                    Toast.LENGTH_LONG).show();
                        }
                        /////////// Aufnahme starten///////////
                        mediaRecorder.start();
                        recording = true;
                    }

                    mConnectedThread.write("1");    // Sende "1" über Bluetooth zum mikrocontroller
                    Toast.makeText(getBaseContext(), "Starte Messung", Toast.LENGTH_SHORT).show();
                }
            }

            );

        }



    private Camera getCameraInstance() {
// TODO Auto-generated method stub
        Camera c = null;
        try {
            c = Camera.open();                  // Kamera-Instanz öffnen
            c.setDisplayOrientation(90);
        } catch (Exception e) {
                                                // Kamera nicht verfügbar
        }
        return c;                               // gibt null aus wenn Kamera nicht verfügbar
    }


    private boolean prepareMediaRecorder() {
        myCamera = getCameraInstance();
        mediaRecorder = new MediaRecorder();

        myCamera.unlock();
        mediaRecorder.setCamera(myCamera);
        //////Eigenschaften Videoaufnahme//////////
        mediaRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER);
        mediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
        mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
        mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
        mediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
        mediaRecorder.setAudioEncodingBitRate(128000);
        mediaRecorder.setAudioSamplingRate(48000);
        mediaRecorder.setVideoSize(1280,720);
        mediaRecorder.setVideoEncodingBitRate(12000000);
        mediaRecorder.setVideoFrameRate(30);
        mediaRecorder.setOutputFile("sdcard/Musiktherapie.mp4");  //Dateipfad



        mediaRecorder.setPreviewDisplay(myCameraSurfaceView.getHolder().getSurface());
        try {
            mediaRecorder.prepare();
        } catch (IllegalStateException e) {
            releaseMediaRecorder();
            return false;
        } catch (IOException e) {
            releaseMediaRecorder();
            return false;
        }
        return true;
    }

    private void releaseMediaRecorder() {
        if (mediaRecorder != null) {
            mediaRecorder.reset();          // Lösche Recorder Konfiguration
            mediaRecorder.release();        // Lasse Recorderobjekt los
            mediaRecorder = null;
            myCamera.lock();                // Kamera schließen für später
        }
    }

    private void releaseCamera() {
        if (myCamera != null) {
            myCamera.release();             // Kamera loslassen für evtl. andere Anwendungen
            myCamera = null;
        }
    }

    public class MyCameraSurfaceView extends SurfaceView implements SurfaceHolder.Callback{

        private SurfaceHolder mHolder;
        private Camera mCamera;

        public MyCameraSurfaceView(Context context, Camera camera) {
            super(context);
            mCamera = camera;
            mHolder = getHolder();
            mHolder.addCallback(this);
            // deprecated setting, but required on Android versions prior to 3.0
            //mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
        }


        public void surfaceChanged(SurfaceHolder holder, int format, int weight,
                                   int height) {
            if (mHolder.getSurface() == null){

                return;
            }


            try {
                mCamera.stopPreview();
            } catch (Exception e){
            }


            try {
                mCamera.setPreviewDisplay(mHolder);
                mCamera.startPreview();
            } catch (Exception e){
            }
        }

        public void surfaceCreated(SurfaceHolder holder) {

            try {
                mCamera.setPreviewDisplay(holder);
                mCamera.startPreview();
            } catch (IOException e) {
            }
        }


        public void surfaceDestroyed(SurfaceHolder holder) {
            // TODO Auto-generated method stub
        }
    }

  private BluetoothSocket createBluetoothSocket(BluetoothDevice device) throws IOException {
      if(Build.VERSION.SDK_INT >= 10){
          try {
              final Method  m = device.getClass().getMethod("createInsecureRfcommSocketToServiceRecord", new Class[] { UUID.class });
              return (BluetoothSocket) m.invoke(device, MY_UUID);
          } catch (Exception e) {
              Log.e(TAG, "Could not create Insecure RFComm Connection",e);
          }
      }
      return  device.createRfcommSocketToServiceRecord(MY_UUID);
  }
   
  @Override
  public void onResume() {
    super.onResume();
 
    Log.d(TAG, "...onResume - try connect...");
    BluetoothDevice device = btAdapter.getRemoteDevice(address);

	try {
		btSocket = createBluetoothSocket(device);
	} catch (IOException e) {
		errorExit("Fatal Error", "In onResume() and socket create failed: " + e.getMessage() + ".");
	}

    btAdapter.cancelDiscovery();
   
    /////////////Verbindung aufbauen//////////
    Log.d(TAG, "...Connecting...");
    try {
      btSocket.connect();
      Log.d(TAG, "....Connection ok...");
    } catch (IOException e) {
      try {
        btSocket.close();
      } catch (IOException e2) {
        errorExit("Fatal Error", "In onResume()" + e2.getMessage() + ".");
      }
    }
     
    //////////////Datenstrom erstellen///////////////
    Log.d(TAG, "...Create Socket...");
    mConnectedThread = new ConnectedThread(btSocket);
    mConnectedThread.start();
  }
 
  @Override
  public void onPause() {
    super.onPause();
      releaseMediaRecorder();          // in der Pause mediarecorder loslassen
      releaseCamera();                 // und Kamera loslassen
    Log.d(TAG, "...In onPause()...");
  
    try     {
      btSocket.close();
    } catch (IOException e2) {
      errorExit("Fatal Error", "In onPause() and failed to close socket." + e2.getMessage() + ".");
    }
  }
   
  private void checkBTState() {
    // Prüfe Bluetooth Unterstützung und prüfe ob eingeschalten
    if(btAdapter==null) { 
      errorExit("Fatal Error", "Bluetooth not support");
    } else {
      if (btAdapter.isEnabled()) {
        Log.d(TAG, "...Bluetooth ON...");
      } else {
        //////Bluetooth einschalten//////
          BluetoothAdapter.getDefaultAdapter().enable();
      }
    }
  }
 
  private void errorExit(String title, String message){
    Toast.makeText(getBaseContext(), title + " - " + message, Toast.LENGTH_LONG).show();
    finish();
  }

//////Datenverbindung///////
  private class ConnectedThread extends Thread {
	    private final InputStream mmInStream;
	    private final OutputStream mmOutStream;
	 
	    public ConnectedThread(BluetoothSocket socket) {
	        InputStream tmpIn = null;
	        OutputStream tmpOut = null;

	        try {
	            tmpIn = socket.getInputStream();
	            tmpOut = socket.getOutputStream();
	        } catch (IOException e) { }
	 
	        mmInStream = tmpIn;
	        mmOutStream = tmpOut;
	    }

	    public void run() {
	        byte[] buffer = new byte[255];  // Pufferspeicher für den Stream
	        int bytes; // ausgegebene Bytes von read()



	        //  InputStream lesen bis Fehler auftreten
	        while (true) {
	        	try {
	                // Lese InputStream
	                bytes = mmInStream.read(buffer);		// Erhalte Anzahl der Bytes und der Daten in "buffer"
                    h.obtainMessage(RECIEVE_MESSAGE, bytes, -1, buffer).sendToTarget();		// Sende zum Handler
	            } catch (IOException e) {
	                break;
	            }
	        }
	    }
	 
	    /* aus der Main activity aufrufen für das Senden zum msp */
	    public void write(String message) {
	    	//Log.d(TAG, "...Data to send: " + message + "...");
	    	byte[] msgBuffer = message.getBytes();
	    	try {
	            mmOutStream.write(msgBuffer);
	        } catch (IOException e) {
	         //   Log.d(TAG, "...Error data send: " + e.getMessage() + "...");
	          }
	    }
	}




}