+ Antworten
Ergebnis 1 bis 19 von 19

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

  1. #1
    WerWeißWas
    Gast/Guest
    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:


    Code:
            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();

  2. #2
    Unregistered
    Gast/Guest
    Java Code:
    1.  
    2.                 public void handleMessage (android.os.Message msg){
    3.  
    4.                     switch (msg.what) {
    5.                         case RECIEVE_MESSAGE:
    6.  
    7.                                                       // wenn Daten empfangen werden
    8.                             byte[] readBuf = (byte[]) msg.obj;
    9.  
    10.  
    11.                             String strIncom = new String(readBuf, 0, msg.arg1);
    12.  
    13.                                          // erstelle String aus Bytes Array
    14.                             sb.append(strIncom);                                                // String anhängen
    15.                             int endOfLineIndex;
    16.                             String path = "/sdcard/" + dateipfad.getText().toString() + ".txt";  //Environment.getExternalStorageDirectory().getPath()
    17.  
    18.  
    19.                             StringBuilder sbi = new StringBuilder();
    20.                             for (byte b : readBuf) {
    21.                                 sbi.append(String.format("%02X ", b));
    22.                             }
    23.  
    24.  
    25.  
    26.  
    27.                             while ((endOfLineIndex = sb.indexOf("0")) >= 0) {                  // wenn end-of-line,
    28.                                 String sbprint;                                                 // extrahiere String
    29.                                 sbprint = sb.substring(0, endOfLineIndex);
    30.                                 sb.delete(0, sb.length());                                      // und löschen
    31.  
    32.  
    33.                                 ///////Messwertedatei beschreiben//////////
    34.                                 try {
    35.  
    36.  
    37.  
    38.                                     File myFile = new File(path);
    39.                                     myFile.createNewFile();
    40.                                     FileOutputStream fOut = new FileOutputStream(myFile, true);
    41.                                     OutputStreamWriter myOutWriter =
    42.                                             new OutputStreamWriter(fOut);
    43.                                     myOutWriter.write(sbi.toString());
    44.                                     myOutWriter.close();
    45.                                     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?
    Geändert von SlaterB (21.07.2016 um 09:29 Uhr) Grund: Java-Tags

  3. #3
    Frequent User Halbes Megabyte Avatar von mogel
    Registriert seit
    01.08.2013
    Ort
    Geheimversteck
    Fachbeiträge
    654
    Genannt
    93 Post(s)
    Zitat Zitat von WerWeißWas Beitrag anzeigen
    Handy soll diese Binär-Werte empfangen und auf SD-Karte speichern.Entweder, gleiches Format in Binär, Hex oder DEC.
    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

    Zitat Zitat von WerWeißWas Beitrag anzeigen
    Das Problem ist, dass beim Empfangen die Daten als STRING interpretiert werden und dadurch "UNSINN" auf der Karte hinterlegt wird.
    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.
    Internal Development and Investment Optimization Trainer
    Bluetooth + binär!=String + SD-Card

    TreeDo - die clevere ToDo-Liste - 2:0

  4. #4
    Unregistered
    Gast/Guest
    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.

  5. #5
    Unregistered
    Gast/Guest
    ich weiß nicht wo mein Kommentar hin ist, deswegen nochmal:

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

  6. #6
    Global Moderator Viertel Gigabyte
    Registriert seit
    05.08.2008
    Fachbeiträge
    4.905
    Genannt
    309 Post(s)
    Off topic:

    Zitat Zitat von Unregistered Beitrag anzeigen
    ich weiß nicht wo mein Kommentar hin ist
    Um Spam zu verhindern, müssen manche Beiträge (von Unregistrierten) erst freigeschaltet werden - was hiermit passiert ist )


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

    Java Code:
    1.  
    2. int x = 0xFF; // "Hex"
    3. 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?

  7. #7
    Unregistered
    Gast/Guest
    >>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...

  8. #8
    Frequent User Megabyte
    Registriert seit
    01.08.2013
    Fachbeiträge
    1.722
    Genannt
    111 Post(s)
    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.

  9. #9
    Unregistered
    Gast/Guest
    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.

  10. #10
    Global Moderator Viertel Gigabyte
    Registriert seit
    05.08.2008
    Fachbeiträge
    4.905
    Genannt
    309 Post(s)
    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
    Java Code:
    1.  
    2. byte[] readBuf = (byte[]) msg.obj;
    3.  
    4. String path = "/sdcard/" + dateipfad.getText().toString() + ".txt";  //Environment.getExternalStorageDirectory().getPath()
    5.  
    6. File myFile = new File(path);
    7. myFile.createNewFile();
    8. FileOutputStream fOut = new FileOutputStream(myFile, true);
    9.  
    10. 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....

  11. #11
    Unregistered
    Gast/Guest
    >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 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.

  12. #12
    Global Moderator Viertel Gigabyte
    Registriert seit
    05.08.2008
    Fachbeiträge
    4.905
    Genannt
    309 Post(s)
    Zitat Zitat von Unregistered Beitrag anzeigen
    war das erste was ich versucht hatte. Wenns kein String war "cannot resolve"
    Was heißt das? (Ggf. genaue Fehlermeldung posten!)

  13. #13
    Unregistered
    Gast/Guest
    Fehlermeldung meint es soll heißen:

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

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

  14. #14
    Global Moderator Viertel Gigabyte
    Registriert seit
    05.08.2008
    Fachbeiträge
    4.905
    Genannt
    309 Post(s)
    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
    Java Code:
    1.  
    2. byte[] readBuf = (byte[]) msg.obj;
    3.  
    4. 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...)

  15. #15
    Unregistered
    Gast/Guest
    ups ich hatte immer noch mywriter, statt fOut.

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

    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

    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.
    Geändert von SlaterB (22.07.2016 um 22:54 Uhr) Grund: weniger doppelte edits

  16. #16
    Global Moderator Viertel Gigabyte Avatar von SlaterB
    Registriert seit
    06.08.2008
    Fachbeiträge
    2.701
    Genannt
    277 Post(s)
    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

    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
    Hansa wird Meister

  17. #17
    Global Moderator Viertel Gigabyte
    Registriert seit
    05.08.2008
    Fachbeiträge
    4.905
    Genannt
    309 Post(s)
    Ä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.

  18. #18
    Frequent User Megabyte
    Registriert seit
    01.08.2013
    Fachbeiträge
    1.722
    Genannt
    111 Post(s)
    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.

  19. #19
    Unregistered
    Gast/Guest
    >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:
    Java Code:
    1.  
    2. package com.example.xxx;
    3.  
    4.  
    5.  
    6.  
    7.  
    8. import java.io.File;
    9.  
    10. import java.io.FileOutputStream;
    11. import java.io.IOException;
    12. import java.io.InputStream;
    13. import java.io.OutputStream;
    14. import java.io.OutputStreamWriter;
    15. import java.lang.reflect.Method;
    16. import java.util.ArrayList;
    17. import java.util.List;
    18. import java.util.UUID;
    19.  
    20. import android.app.Activity;
    21. import android.content.Context;
    22. import android.hardware.Camera;
    23. import android.media.MediaRecorder;
    24. import android.os.Bundle;
    25. import android.view.SurfaceHolder;
    26. import android.view.SurfaceView;
    27. import android.view.View;
    28.  
    29. import android.widget.AdapterView;
    30. import android.widget.ArrayAdapter;
    31. import android.widget.Button;
    32. import android.widget.FrameLayout;
    33. import android.widget.Spinner;
    34.  
    35.  
    36. import android.widget.Toast;
    37. import android.bluetooth.BluetoothAdapter;
    38. import android.bluetooth.BluetoothDevice;
    39. import android.bluetooth.BluetoothSocket;
    40. import android.os.Build;
    41. import android.os.Handler;
    42. import android.util.Log;
    43. import android.view.View.OnClickListener;
    44. import android.widget.EditText;
    45. import android.widget.TextView;
    46.  
    47. public class MainActivity extends Activity {
    48.     private static final String TAG = "Musiktherapie";
    49.  
    50.     //Variablen setzen
    51.     Button btnOn, btnOff;
    52.     TextView txtArduino;
    53.     Handler h;
    54.     EditText dateipfad;
    55.     boolean recording;
    56.     final int RECIEVE_MESSAGE = 1;        // Status  for Handler
    57.  
    58.     //Methoden setzen
    59.     private BluetoothAdapter btAdapter = null;
    60.     private BluetoothSocket btSocket = null;
    61.     private StringBuilder sb = new StringBuilder();
    62.     private ConnectedThread mConnectedThread;
    63.     private Camera myCamera;
    64.     private MyCameraSurfaceView myCameraSurfaceView;
    65.     private MediaRecorder mediaRecorder;
    66.  
    67.     // SPP UUID Service
    68.     private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
    69.  
    70.  
    71.     private static String address = "20:15:06:24:45:69";
    72.  
    73.     /**
    74.      * Wird einmal aufgerufen wenn Activity startet
    75.      */
    76.     @Override
    77.  
    78.     public void onCreate(Bundle savedInstanceState) {
    79.         super.onCreate(savedInstanceState);
    80.         recording = false;
    81.         setContentView(R.layout.activity_main);
    82.  
    83.  
    84.  
    85.  
    86.         //Spinner inizialisieren für die G-Settings
    87.  
    88.         //liste mit items
    89.         final List<String> list=new ArrayList<String>();
    90.         list.add("G_Range 2");
    91.         list.add("G_Range 4");
    92.         list.add("G_Range 8");
    93.  
    94.  
    95.  
    96.         //spinner erstellen
    97.         final Spinner G  =(Spinner) findViewById(R.id.spinner);
    98.  
    99.  
    100.             //liste als adapter
    101.             ArrayAdapter<String> adp = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, list);
    102.             adp.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
    103.             G.setAdapter(adp);
    104.  
    105.  
    106.         G.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
    107.             @Override
    108.             public void onItemSelected(AdapterView<?> parentView, View selectedItemView, int position, long id) {
    109.                 mConnectedThread.write(String.valueOf(2*(G.getSelectedItemPosition())));
    110.             }@Override
    111.              public void onNothingSelected(AdapterView<?> parentView) {
    112.                   //  do nothing
    113.             }
    114.  
    115.  
    116.  
    117.         });
    118.  
    119.  
    120.  
    121.  
    122.                 ///////////Kameravorschau/////////////
    123.                 myCamera = getCameraInstance();
    124.  
    125.             myCameraSurfaceView=new MyCameraSurfaceView(this,myCamera);
    126.  
    127.             FrameLayout myCameraPreview = (FrameLayout) findViewById(R.id.videoview);
    128.             myCameraPreview.addView(myCameraSurfaceView);
    129.  
    130.             btnOn=(Button) findViewById(R.id.btnOn);
    131.  
    132.             btnOff=(Button) findViewById(R.id.btnOff);
    133.  
    134.     dateipfad=(EditText)this.findViewById(R.id.dateipfad);
    135.  
    136.  
    137.     Button btnOff = (Button) findViewById(R.id.btnOff);
    138.     btnOff.setOnClickListener(new
    139.  
    140.     OnClickListener() {
    141.         public void onClick (View v){
    142.             mediaRecorder.stop();                              
    143.             mConnectedThread.write("3");                      
    144.                     recording = false;
    145.                     Toast.makeText(getBaseContext(),
    146.                             "Messwerte gespeichert!",
    147.                             Toast.LENGTH_SHORT).show();
    148.                 }
    149.             }
    150.  
    151.             );
    152.  
    153.  
    154.  
    155.  
    156.  
    157.  
    158.         h=new
    159.  
    160.             Handler() {
    161.                 public void handleMessage (android.os.Message msg){
    162.  
    163.  
    164.  
    165.                     switch (msg.what) {
    166.                         case RECIEVE_MESSAGE:
    167.  
    168.                             // wenn Daten empfangen werden
    169.                             byte[] readBuf = (byte[]) msg.obj;
    170.  
    171.  
    172.                             String path = "/sdcard/" + dateipfad.getText().toString() + ".txt";  //Environment.getExternalStorageDirectory().getPath()
    173.  
    174.  
    175.  
    176.  
    177.  
    178.  
    179.  
    180.  
    181.                                 ///////Messwertedatei beschreiben//////////
    182.                                 try {
    183.  
    184.  
    185.  
    186.                                     File myFile = new File(path);
    187.                                     myFile.createNewFile();
    188.                                     FileOutputStream fOut = new FileOutputStream(myFile,true);
    189.  
    190.                                     fOut.write(readBuf);
    191.                                     fOut.flush();
    192.                                     fOut.close();
    193.  
    194.  
    195.  
    196.  
    197.                                 } catch (Exception e) {
    198.                                     Toast.makeText(getBaseContext(), e.getMessage(),
    199.                                             Toast.LENGTH_SHORT).show();
    200.                                 }
    201.                            
    202.                             break;
    203.                     }
    204.                 }
    205.  
    206.             }
    207.  
    208.             ;
    209.  
    210.             btAdapter=BluetoothAdapter.getDefaultAdapter();        // get Bluetooth adapter vom Smartphone
    211.  
    212.             checkBTState();
    213.  
    214.             //////////////ON-Button/////////////////
    215.             btnOn.setOnClickListener(new
    216.  
    217.             OnClickListener() {
    218.                 public void onClick (View v){
    219.  
    220.  
    221.                     if (recording) {
    222.                         // Aufnahme stoppen und Kamera loslassen
    223.                         mediaRecorder.stop();                       // Aufnahme stoppen
    224.                         releaseMediaRecorder();                      // Mediarecorder Objekt loslassen
    225.  
    226.                     } else {
    227.  
    228.                         //Kamera loslassen bevor der MediaRecorder startet
    229.                         releaseCamera();
    230.                         if (!prepareMediaRecorder()) {
    231.                             Toast.makeText(MainActivity.this,
    232.                                     "Fail in prepareMediaRecorder()!\n - Ended -",
    233.                                     Toast.LENGTH_LONG).show();
    234.                         }
    235.                         /////////// Aufnahme starten///////////
    236.                         mediaRecorder.start();
    237.                         recording = true;
    238.                     }
    239.  
    240.                     mConnectedThread.write("1");    // Sende "1" über Bluetooth zum mikrocontroller
    241.                     Toast.makeText(getBaseContext(), "Starte Messung", Toast.LENGTH_SHORT).show();
    242.                 }
    243.             }
    244.  
    245.             );
    246.  
    247.         }
    248.  
    249.  
    250.  
    251.     private Camera getCameraInstance() {
    252. // TODO Auto-generated method stub
    253.         Camera c = null;
    254.         try {
    255.             c = Camera.open();                  // Kamera-Instanz öffnen
    256.             c.setDisplayOrientation(90);
    257.         } catch (Exception e) {
    258.                                                 // Kamera nicht verfügbar
    259.         }
    260.         return c;                               // gibt null aus wenn Kamera nicht verfügbar
    261.     }
    262.  
    263.  
    264.     private boolean prepareMediaRecorder() {
    265.         myCamera = getCameraInstance();
    266.         mediaRecorder = new MediaRecorder();
    267.  
    268.         myCamera.unlock();
    269.         mediaRecorder.setCamera(myCamera);
    270.         //////Eigenschaften Videoaufnahme//////////
    271.         mediaRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER);
    272.         mediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
    273.         mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
    274.         mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
    275.         mediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
    276.         mediaRecorder.setAudioEncodingBitRate(128000);
    277.         mediaRecorder.setAudioSamplingRate(48000);
    278.         mediaRecorder.setVideoSize(1280,720);
    279.         mediaRecorder.setVideoEncodingBitRate(12000000);
    280.         mediaRecorder.setVideoFrameRate(30);
    281.         mediaRecorder.setOutputFile("sdcard/Musiktherapie.mp4");  //Dateipfad
    282.  
    283.  
    284.  
    285.         mediaRecorder.setPreviewDisplay(myCameraSurfaceView.getHolder().getSurface());
    286.         try {
    287.             mediaRecorder.prepare();
    288.         } catch (IllegalStateException e) {
    289.             releaseMediaRecorder();
    290.             return false;
    291.         } catch (IOException e) {
    292.             releaseMediaRecorder();
    293.             return false;
    294.         }
    295.         return true;
    296.     }
    297.  
    298.     private void releaseMediaRecorder() {
    299.         if (mediaRecorder != null) {
    300.             mediaRecorder.reset();          // Lösche Recorder Konfiguration
    301.             mediaRecorder.release();        // Lasse Recorderobjekt los
    302.             mediaRecorder = null;
    303.             myCamera.lock();                // Kamera schließen für später
    304.         }
    305.     }
    306.  
    307.     private void releaseCamera() {
    308.         if (myCamera != null) {
    309.             myCamera.release();             // Kamera loslassen für evtl. andere Anwendungen
    310.             myCamera = null;
    311.         }
    312.     }
    313.  
    314.     public class MyCameraSurfaceView extends SurfaceView implements SurfaceHolder.Callback{
    315.  
    316.         private SurfaceHolder mHolder;
    317.         private Camera mCamera;
    318.  
    319.         public MyCameraSurfaceView(Context context, Camera camera) {
    320.             super(context);
    321.             mCamera = camera;
    322.             mHolder = getHolder();
    323.             mHolder.addCallback(this);
    324.             // deprecated setting, but required on Android versions prior to 3.0
    325.             //mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    326.         }
    327.  
    328.  
    329.         public void surfaceChanged(SurfaceHolder holder, int format, int weight,
    330.                                    int height) {
    331.             if (mHolder.getSurface() == null){
    332.  
    333.                 return;
    334.             }
    335.  
    336.  
    337.             try {
    338.                 mCamera.stopPreview();
    339.             } catch (Exception e){
    340.             }
    341.  
    342.  
    343.             try {
    344.                 mCamera.setPreviewDisplay(mHolder);
    345.                 mCamera.startPreview();
    346.             } catch (Exception e){
    347.             }
    348.         }
    349.  
    350.         public void surfaceCreated(SurfaceHolder holder) {
    351.  
    352.             try {
    353.                 mCamera.setPreviewDisplay(holder);
    354.                 mCamera.startPreview();
    355.             } catch (IOException e) {
    356.             }
    357.         }
    358.  
    359.  
    360.         public void surfaceDestroyed(SurfaceHolder holder) {
    361.             // TODO Auto-generated method stub
    362.         }
    363.     }
    364.  
    365.   private BluetoothSocket createBluetoothSocket(BluetoothDevice device) throws IOException {
    366.       if(Build.VERSION.SDK_INT >= 10){
    367.           try {
    368.               final Method  m = device.getClass().getMethod("createInsecureRfcommSocketToServiceRecord", new Class[] { UUID.class });
    369.               return (BluetoothSocket) m.invoke(device, MY_UUID);
    370.           } catch (Exception e) {
    371.               Log.e(TAG, "Could not create Insecure RFComm Connection",e);
    372.           }
    373.       }
    374.       return  device.createRfcommSocketToServiceRecord(MY_UUID);
    375.   }
    376.    
    377.   public void onResume() {
    378.     super.onResume();
    379.  
    380.     Log.d(TAG, "...onResume - try connect...");
    381.     BluetoothDevice device = btAdapter.getRemoteDevice(address);
    382.  
    383.     try {
    384.         btSocket = createBluetoothSocket(device);
    385.     } catch (IOException e) {
    386.         errorExit("Fatal Error", "In onResume() and socket create failed: " + e.getMessage() + ".");
    387.     }
    388.  
    389.     btAdapter.cancelDiscovery();
    390.    
    391.     /////////////Verbindung aufbauen//////////
    392.     Log.d(TAG, "...Connecting...");
    393.     try {
    394.       btSocket.connect();
    395.       Log.d(TAG, "....Connection ok...");
    396.     } catch (IOException e) {
    397.       try {
    398.         btSocket.close();
    399.       } catch (IOException e2) {
    400.         errorExit("Fatal Error", "In onResume()" + e2.getMessage() + ".");
    401.       }
    402.     }
    403.      
    404.     //////////////Datenstrom erstellen///////////////
    405.     Log.d(TAG, "...Create Socket...");
    406.     mConnectedThread = new ConnectedThread(btSocket);
    407.     mConnectedThread.start();
    408.   }
    409.  
    410.   public void onPause() {
    411.     super.onPause();
    412.       releaseMediaRecorder();          // in der Pause mediarecorder loslassen
    413.       releaseCamera();                 // und Kamera loslassen
    414.     Log.d(TAG, "...In onPause()...");
    415.  
    416.     try     {
    417.       btSocket.close();
    418.     } catch (IOException e2) {
    419.       errorExit("Fatal Error", "In onPause() and failed to close socket." + e2.getMessage() + ".");
    420.     }
    421.   }
    422.    
    423.   private void checkBTState() {
    424.     // Prüfe Bluetooth Unterstützung und prüfe ob eingeschalten
    425.     if(btAdapter==null) {
    426.       errorExit("Fatal Error", "Bluetooth not support");
    427.     } else {
    428.       if (btAdapter.isEnabled()) {
    429.         Log.d(TAG, "...Bluetooth ON...");
    430.       } else {
    431.         //////Bluetooth einschalten//////
    432.           BluetoothAdapter.getDefaultAdapter().enable();
    433.       }
    434.     }
    435.   }
    436.  
    437.   private void errorExit(String title, String message){
    438.     Toast.makeText(getBaseContext(), title + " - " + message, Toast.LENGTH_LONG).show();
    439.     finish();
    440.   }
    441.  
    442. //////Datenverbindung///////
    443.   private class ConnectedThread extends Thread {
    444.         private final InputStream mmInStream;
    445.         private final OutputStream mmOutStream;
    446.      
    447.         public ConnectedThread(BluetoothSocket socket) {
    448.             InputStream tmpIn = null;
    449.             OutputStream tmpOut = null;
    450.  
    451.             try {
    452.                 tmpIn = socket.getInputStream();
    453.                 tmpOut = socket.getOutputStream();
    454.             } catch (IOException e) { }
    455.      
    456.             mmInStream = tmpIn;
    457.             mmOutStream = tmpOut;
    458.         }
    459.  
    460.         public void run() {
    461.             byte[] buffer = new byte[255];  // Pufferspeicher für den Stream
    462.             int bytes; // ausgegebene Bytes von read()
    463.  
    464.  
    465.  
    466.             //  InputStream lesen bis Fehler auftreten
    467.             while (true) {
    468.                 try {
    469.                     // Lese InputStream
    470.                     bytes = mmInStream.read(buffer);        // Erhalte Anzahl der Bytes und der Daten in "buffer"
    471.                     h.obtainMessage(RECIEVE_MESSAGE, bytes, -1, buffer).sendToTarget();     // Sende zum Handler
    472.                 } catch (IOException e) {
    473.                     break;
    474.                 }
    475.             }
    476.         }
    477.      
    478.         /* aus der Main activity aufrufen für das Senden zum msp */
    479.         public void write(String message) {
    480.             //Log.d(TAG, "...Data to send: " + message + "...");
    481.             byte[] msgBuffer = message.getBytes();
    482.             try {
    483.                 mmOutStream.write(msgBuffer);
    484.             } catch (IOException e) {
    485.              //   Log.d(TAG, "...Error data send: " + e.getMessage() + "...");
    486.               }
    487.         }
    488.     }
    489.  
    490.  
    491.  
    492.  
    493. }
    Geändert von Marco13 (23.07.2016 um 16:51 Uhr)

+ Antworten Thema als "gelöst" markieren

Direkt antworten Direkt antworten

Nenne eine bekannte Programmiersprache!

Aktive Benutzer

Aktive Benutzer

Aktive Benutzer in diesem Thema: 1 (Registrierte Benutzer: 0, Gäste: 1)

Ähnliche Themen

  1. App Entwickler/in für Android und iOS mit Bluetooth, BLE und WLAN Anbindung
    Von campusjaeger im Forum Angebote von Agenturen
    Antworten: 0
    Letzter Beitrag: 20.07.2016, 13:54
  2. [JAXB] String Referenz in XML auf String in .properties Datei
    Von PositiveDown im Forum XML-Programmierung
    Antworten: 1
    Letzter Beitrag: 10.01.2016, 17:45
  3. Antworten: 0
    Letzter Beitrag: 20.09.2014, 09:22
  4. String[] einem Vector<String[]> hinzufügen - Logikfehler
    Von Jack159 im Forum Java-Grundlagen
    Antworten: 6
    Letzter Beitrag: 28.12.2013, 04:06
  5. card layout
    Von Unregistriert im Forum AWT, Swing, JavaFX & SWT
    Antworten: 2
    Letzter Beitrag: 31.05.2009, 16:14

Berechtigungen

  • Neue Themen erstellen: Ja
  • Themen beantworten: Ja
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •