+ Antworten
Seite 1 von 2 1 2 LetzteLetzte
Ergebnis 1 bis 20 von 21

Thema: Byte hex80

  1. #1
    User Kilobyte Themenstarter

    Registriert seit
    23.02.2014
    Fachbeiträge
    149
    Genannt
    7 Post(s)
    Hallo

    Ein Messgerät sendet einen unsigned Byte mit dem Wert (hex80 =dec128 =bin1000 000)an meine App.

    Da wir aber Vorzeichen behaftete Bytes in Java haben ist die Wertgrenze ja bei uns -128 bis 127. Das Problem wollte ich mit einer einfachen Rechnung umgehen.

    mit einer signedByteToInteger Methode. In der Theorie funktioniert das auch einwandfrei.

    Das Mysteriöse Problem ist nur, das genau dann wenn, das Gerät hex 80 sendet, dann empfängt die Android App "hex EF", dec -17. Das sind dann die falschen Ausgangswert für die weitere Berechnung. Woran liegt das?
    Geändert von SlaterB (05.08.2016 um 13:09 Uhr) Grund: Titel

  2. #2
    Global Moderator Viertel Gigabyte Avatar von SlaterB
    Registriert seit
    06.08.2008
    Fachbeiträge
    2.716
    Genannt
    291 Post(s)
    trifft das hier zufällig zu?
    https://github.com/MacroYau/Blue2Serial/issues/9
    Once I send the bytes with value of 128 to 255 by Bluetooth to Android then I see different bytes. I receive -17, -65, -67 instead of 128 to 255. But, it works with 0 to 127.
    oder kannst du weitere Informationen liefern?
    sind noch mehr Bytes vorhanden?

    mit welcher nennbaren beteiligten Technik Daten gelesen/ gesendet?,
    hast du beliebige Kontrolle über den Sender oder eine Alternative, für Tests, woher weißt du was gesendet wird?
    funktionieren Werte > hex 80?
    Hansa wird Meister

  3. #3
    User Kilobyte Themenstarter

    Registriert seit
    23.02.2014
    Fachbeiträge
    149
    Genannt
    7 Post(s)
    Hi

    Es wird sonst nur Text gesendet, das Problem ist auch lange Zeit nicht aufgefallen. Weil es nur für eine spezifische Situation gilt.
    Also die Übermittlung funktioniert an allen anderen Stellen super, es sind einfach Log, Berichte die an die App gesendet werden. Bis auf diese eine Stelle, da sind es einfach nur eine Folge von Bytes mehr nicht.
    Den Sender haben wir selbst gebaut und programmiert, durch ein Monitoring tool, kann man genau beobachten was er sendet. Wenn der Empfänger ein in c++ geschriebenes Programm ist, dann funktioniert es dort auch super.

    Zum Link: Was für ein Zufall, es ist genau das Problem und wir nutzen auch genau diese Lib

    Ich lese mich da rein und meld mich wenn ich es lösen konnte

    *** Edit ***

    Alles klar es lag an der Lib. selbst, eine Änderung der Bibliothek hat das ganze behoben.

    Genauer gesagt in Klasse SPPService:

    Code:
      mHandler.obtainMessage(BluetoothSerial.MESSAGE_READ, bytes, -1, read.getBytes()).sendToTarget();
    Per default in read.getBytes() wird einfach der falsche Charset benutzt.
    Code:
                   mHandler.obtainMessage(BluetoothSerial.MESSAGE_READ, bytes, -1, read.getBytes(StandardCharsets.US_ASCII)).sendToTarget();
    Hat das Problem behoben.

  4. #4
    Global Moderator Viertel Gigabyte Avatar von SlaterB
    Registriert seit
    06.08.2008
    Fachbeiträge
    2.716
    Genannt
    291 Post(s)
    tja, da war es auf jeden Fall die richtige Entscheidung von dir,
    dich an meine fortschrittlichen Suchmaschinenfähigkeiten zu wenden

    'android byte 128 239' war die letztlich passende Suche,
    und dafür musste ich erst lange lernen dass weder Hex-EF noch -17 (auch in Anführungszeichen, nicht als Suchausschluss) viel hilft, sondern der Gegenwert 239..
    Geändert von SlaterB (05.08.2016 um 16:39 Uhr)
    Hansa wird Meister

  5. #5
    Unregistered
    Gast/Guest
    Hallo, das Problem ist in etwa mein aktuelles. Da es hier noch recht übersichtlich ist, mache ich mal kein neuen Thread auf.

    Mein Android empfängt Daten über Bluetooth (Messwerte, Rohformat), bei dem Versuch diese korrekt zu lesen/speichern drehe ich mich leider im Kreis.

    Code 1:

    Java Code:
    1. byte[] readBuf = (byte[]) msg.obj;
    2.  
    3.                            int[] ret = new int[readBuf.length];
    4.                             for (short i = 0; i < readBuf.length; i++)
    5.                         {
    6.                               ret[i] = (readBuf[i]&255);
    7.                            }
    8.  
    9.  
    10.                             String strIncom = new String(ret, 0, msg.arg1); // erstelle String aus Bytes Array
    11.                             sb.append(strIncom);                                                // String anhängen
    12.                             int endOfLineIndex;
    13.                        
    14.  
    15.                             while ((endOfLineIndex = sb.indexOf("|0|")) >= 0) {                  // wenn end-of-line,
    16.                                 String sbprint;                                                 // extrahiere String
    17.                                 sbprint = sb.substring(0, endOfLineIndex);
    18.                                 sb.delete(0, sb.length());                                      // und löschen
    19.  
    20.                                 try {
    21.                                     File myFile = new File(path);
    22.                                     myFile.createNewFile();
    23.                                     FileOutputStream fOut = new FileOutputStream(myFile, true);
    24.                                     OutputStreamWriter myOutWriter =
    25.                                             new OutputStreamWriter(fOut);
    26.                                     myOutWriter.append(sbprint);
    27.                                     myOutWriter.close();
    28.                                     fOut.close();

    Ich hab versucht jedes Element in meinem Input-stream mit 0&FF zu
    erweitern... die untere Hälfte des Wertebereichs ist alles richtig, aber
    statt einer 0x80 erhalte ich dann eine: c2 80,

    für 0x81 eine c2 81, für 0x82 c2 82, usw.... Durch meine String-konvertierung läuft was falsch. Diese dient mir als Index um den Buffer richtig auszulesen.



    Code 2:

    Java Code:
    1.       byte[] readBuf = (byte[]) msg.obj;
    2.  
    3.                                 try {
    4.                                     File myFile = new File(path);
    5.                                     myFile.createNewFile();
    6.                                     FileOutputStream fOut = new FileOutputStream(myFile, true);
    7.                                    
    8.                                     fOut.write(readBuf);
    9.                                     fOut.close();

    Speichert die Werte richtig, dh. ich bekomme 0xFF aber der Buffer wird willkürlich gelesen, da der Index fehlt.

    Es gelingt mir aber nicht diesen ohne Stringkovertierung richtig auszulesen...

    Mein Ansatz findet sich in Code 3:

    Java Code:
    1.  byte[] readBuf = (byte[]) msg.obj;
    2.  
    3.                             for (int i = 0; i < readBuf.length - 2; i++) {
    4.                                 if (readBuf[i] == '|' && readBuf[i+1] == '0' && readBuf[i+2] == '|') {
    5.                                     int endePos = i;
    6.                                     break;
    7.                                 }
    8.                             }
    9.  
    10.                                 try {
    11.                                     File myFile = new File(path);
    12.                                     myFile.createNewFile();
    13.                                     FileOutputStream fOut = new FileOutputStream(myFile, true);
    14.                              
    15.                                     fOut.write(readBuf, 0, readBuf.endePos); //ist nicht...
    16.                                     fOut.close();


    Weiß jemand wie das richtig geht? mir, als Java-Neuling,gehen die Ideen aus... Danke im Voraus.

    *** Edit ***

    Sorry im Code 1 muss es heißen:


    String strIncom = new String(ret, 0, msg.arg1); // erstelle String aus Bytes Array
    [edit SlaterB: editiert]

    Danke fürs Freischalten.
    Geändert von SlaterB (13.09.2016 um 00:28 Uhr) Grund: Java-Tags

  6. #6
    Global Moderator Viertel Gigabyte Avatar von SlaterB
    Registriert seit
    06.08.2008
    Fachbeiträge
    2.716
    Genannt
    291 Post(s)
    edit:
    erste Hälfte bis zu ############ für dich vielleicht nicht ganz nötig, editiere gleich noch was dazu, edit: zweite Hälfte nun auch da


    erste Hälfte:

    die API gibt es ja auf Github, auch als Quellcode,
    kannst du beurteilen etwa welche Version du verwendest? könntest du den Code modifizieren und dann verwenden?

    ----------

    neues Issue 10 dort:
    https://github.com/MacroYau/Blue2Serial/issues/10
    wohl von @ZickZack


    seit 2 Monaten, seit Issue 9, sehe ich dort eine Änderung in der betroffenen Klasse
    https://github.com/MacroYau/Blue2Ser...PPService.java

    statt zuvor die wirklich falsche String-Umwandlung steht dort neuerdings, also bereits seit 2 Monaten
    Java Code:
    1. length = mInputStream.read(data);
    2. byte[] read = new byte[length];
    3. System.arraycopy(data, 0, read, 0, length);
    4. mHandler.obtainMessage(BluetoothSerial.MESSAGE_READ, length, -1, read).sendToTarget();
    also gar keine interne Umwandlung mehr in String, sondern Weiterreichen als byte[]..
    @ZickZack
    kannst du dazu etwas sagen, wie passt das zu deinem
    Zitat Zitat von ZickZack Beitrag anzeigen
    Alles klar es lag an der Lib. selbst, eine Änderung der Bibliothek hat das ganze behoben.

    Genauer gesagt in Klasse SPPService:
    Code:
      mHandler.obtainMessage(BluetoothSerial.MESSAGE_READ, bytes, -1, read.getBytes()).sendToTarget();
    Per default in read.getBytes() wird einfach der falsche Charset benutzt.
    Code:
                   mHandler.obtainMessage(BluetoothSerial.MESSAGE_READ, bytes, -1, read.getBytes(StandardCharsets.US_ASCII)).sendToTarget();
    Hat das Problem behoben.
    wenn doch die API schon seit 2 Monate kein read.getBytes() mehr hat?

    ob das Weiterreichen als byte[] gut oder schlecht ist kann ich kaum beurteilen,
    Alternative wäre wohl der Code aus dem zweiten Posting im Issue 10-Link

    -------------------

    wenn neueste API-Version nicht reicht (evtl. von @ZickZack was fertiges zu bekommen?)
    und eigene Code-Eingriffe nicht möglich sind oder es nicht besser machen,
    dann noch zwei Punkte:

    einerseits Datensenden ändern/ vereinfachen, in
    https://github.com/MacroYau/Blue2Serial/issues/9
    wurde genannt, womöglich Strings zu senden,
    aber auf 'Daten über Bluetooth (Messwerte, Rohformat)' hast du vielleicht keinen Einfluss oder unpraktisch?

    als letztes bliebe noch manuelle intensive Interpretation der Daten:
    wenn 'statt einer 0x80 erhalte ich dann eine: c2 80' gilt, dann vielleicht nach c2 80 schauen unddies in 0x80 umwandeln usw.,
    kann leicht unmöglich sein, falls auch c2 80 einzeln valide Werte sind

    dann muss doch korrekte Übertragung her oder so einfache Daten übertragen werden dass die kaputte API ausreicht

    ##############

    zweite Hälfte:

    Zitat Zitat von Unregistered Beitrag anzeigen
    Durch meine String-konvertierung läuft was falsch.
    da die API seit 2 Monaten die bytes direkt durchschickt ist dazu vielleicht gar kein Problem vorhanden,
    du sagst ja auch selber dass du den Fehler bei dir siehst

    was ist bei String strIncom = new String(ret, 0, msg.arg1); das 'msg.arg1',
    Anzahl der zu lesenden bytes?
    weißt du um CharSets für Strings? teste doch mal das von Zickzack genannte
    new String(ret, 0, msg.arg1, StandardCharsets.US_ASCII)

    aber was lässt dich überhaupt vermuten, dass die Daten in String umzuwandeln sind? was stellen die Daten überhaupt dar?
    allgemein keine empfehlenswerte Option für beliebige Daten,
    was dann ja auch mehr oder weniger den Fehler in der API ausgelöst hat, um den es hier ursprünglich ging, der dich aber vielleicht gar nicht betrifft

    was für Daten bekommst du in welchem genauen Format, warum willst du sie in String umwandeln, was genau erwartest du dann, was ist der Fehler?
    'statt einer 0x80 erhalte ich dann eine: c2 80' ist etwas ungenau

    oder mal anders gefragt: wie genau ist der gesuchte 'Index' formatiert, gib konkrete Beispiele zu den empfangenen Bytes, was du zum Auslesen planst, was schief geht,

    zu deinem 'Code 3' hast du nichts negatives dazugeschrieben, funktioniert das schon? reicht das nicht?
    Geändert von SlaterB (13.09.2016 um 10:07 Uhr)
    Hansa wird Meister

  7. #7
    Unregistered
    Gast/Guest
    Hi slaterB,
    Vielen Dank fuer deine ausführliche Antwort!!
    Ich bin grad noch beschäftigt, werde mich aber nochmal melden. Wollte nur mal im Voraus danke sagen

  8. #8
    Unregistered
    Gast/Guest
    ok fangen wir an, zunächst nochmal vielen Dank!


    Bevor ich auf die Einzelheiten eingehe:

    Für (StandardCharsets.US_ASCII)

    erhalte ich: cannot resolve Symbol... was muss ich da importieren?

    Danke!

    *** Edit ***

    Zwecks Übersicht und für die Nachwelt mal meine MainActivity.

    mit 3 x /////////////////////////////////////////////////////////////// sind die betroffenen Stellen markiert.

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

  9. #9
    Global Moderator Viertel Gigabyte Avatar von SlaterB
    Registriert seit
    06.08.2008
    Fachbeiträge
    2.716
    Genannt
    291 Post(s)
    import java.nio.charset.StandardCharsets;
    ab Java 1.7?

    hast du eine IDE wie Eclipse mit automatisch organisierten Import?
    Grundlagen wären empfehlenswert
    Hansa wird Meister

  10. #10
    Unregistered
    Gast/Guest
    ich programmier mit Android Studio. Der weigert sich aber das zu importieren.

  11. #11
    Unregistered
    Gast/Guest
    Java hab ich installiert 1.8.0_77

  12. #12
    Global Moderator Viertel Gigabyte Avatar von SlaterB
    Registriert seit
    06.08.2008
    Fachbeiträge
    2.716
    Genannt
    291 Post(s)
    etwas verrücktes wie 'Android Studio' zu nehmen oder 'import android.app.Activity;', das kann für sich böse enden,
    vielleicht nur ein reduziertes Java für Smartphones in Verwendung, wo dann das nicht zur Verfügung steht,

    Alternative wäre, von normalen IDEs und unbelasteten Hello World-Programm Dinge die unklar sind anzugehen,
    StandardCharsets ist in der API
    https://docs.oracle.com/javase/7/doc...dCharsets.html
    wie 'java.nio.ByteBuffer' oder ArrayList oder sonst was einfaches,
    jede API-Klasse muss importierbar sein, sonst halt was auch immer für ein Problem vorliegend, alles löschen,
    neuer Computer, neu installieren..

    wie gesagt vielleicht auch gar kein Thema für dich, nicht in der zweiten Hälfte

    'weigert sich aber das zu importieren' ist auch keine besonders korrekte Fehlermeldung
    Hansa wird Meister

  13. #13
    Unregistered
    Gast/Guest
    Sorry dass ich mich so sporadisch melde, arbeite an mehren Baustellen gleichzeitig

    Das importieren hat geklappt, sdk Version wurde auf 19 aktualisiert.

    Behoben hat das mein Problem leider nicht.


    So was wird überhaupt aufgenommen und was hat es mit dem |0| auf sich.

    Gesendet werden an das Handy Sensor-Messwerte, zusätzlich zu Beginn die gewählten Einstellungen, in Form von: " Sie messen im 2G Bereich(String)". Das wird alles richtig gesendet und gespeichert.

    Danach geht los. |0| markiert das erste Paket, danach folgen ca. 30 Werte, dann |1| dann wieder 30 Werte usw... , alles richtig.

    sobald das Startpaket |7f| überschreitet, steht dann da wenn ich es mit >>ret<< mache: 2c 0x80, statt nur 0x80. Für 0x81 eine 2c 81...

    Das gleiche Verhalten zeigt sich in den Messwerten die überhalb des oberen halben Wertebereichs liegen.

    Wobei wenn ich statt mit >>ret<< direkt mit >>readBuf<< weiter arbeite (siehe 1.Code)

    sind alle Werte über 0x80 gleich undzwar: c3 bf. (Sie messen XY immer noch korrekt).

    Bei Code 2, habe ich die 0xff korrekt da, nur:

    Da liest und/oder speichert das Handy den Buffer willkürlich und so wie ich das verstanden habe muss man beim Auslesen einen Index, Längenintervall o.ä. angeben damit er die Daten richtig liest, dh. alles einmal, nichts doppelt und chronologisch richtig.

    Code 3 ist nichts vollständiges, da ich nicht weiter wusste wie die richtigen Daten(-abschnitte) extrahieren soll.


    Danke vielmals für deine bisherigen Informationen, das ist für mich ein wichtiger Anhaltspunkt

    Am besten wäre ein Source-Code für einen Bluetooth-Datenlogger wo ich mir was abschauen könnte.

  14. #14
    Global Moderator Viertel Gigabyte Avatar von SlaterB
    Registriert seit
    06.08.2008
    Fachbeiträge
    2.716
    Genannt
    291 Post(s)
    erste Hälfte wiederum evtl. uninteressanter als zweite:


    Leute die es kennen gibt es wohl weniger als Sand am Meer, etwa @ZickZack vielleicht, der sich aber im Moment nicht meldet,
    oder auch du selber, unregistriert, vielleicht zu allen anderen Zeiten nicht da um anderen zu helfen

    die die da sind, kennen nicht unbedingt die API genau

    --------

    wie bist du überhaupt zu diesem Tool gekommen, was würdest du machen wenn es das nicht gäbe?
    wo immer es herkommt, gab es da kein Beispiel usw. dazu?

    im GitHub ist ein Beispiel genannt
    https://github.com/MacroYau/Blue2Ser...lActivity.java
    aber da ist wenig zu sehen.., anscheinend getString() aus aus AppCompatActivity oder höher für Empfang genutzt?

    --------

    ob passend oder nicht, mit bestimmend für das Thema hier am Anfang und den beiden Issues in Github
    https://github.com/MacroYau/Blue2Serial/issues/9
    https://github.com/MacroYau/Blue2Serial/issues/10
    geht es um die Klasse SPPService in der API
    https://github.com/MacroYau/Blue2Ser...PPService.java

    mit ConnectedThread, Handler,
    Codezeile mHandler.obtainMessage(BluetoothSerial.MESSAGE_READ, length, -1, read).sendToTarget();

    da ist es für mich verwirrend, warum du anscheinend in deinem Code, in der MainActivity, auch ConnectedThread, Handler,
    und Codezeile h.obtainMessage(RECIEVE_MESSAGE, bytes, -1, buffer).sendToTarget(); // Sende zum Handler
    hast..

    fällt dir dazu etwas zu sagen ein?
    hast du den Code irgendwo kopiert, unter welchen Anleitungen? oder wie sonst kommst du auf die Idee, etwas wie sendToTarget() einzutippen,
    darauf kommt ja nicht von alleine, was ist der Grundplan, der ja irgendwie vorhanden sein muss?

    ##########

    zweite Hälfte:


    Zitat Zitat von Unregistered Beitrag anzeigen
    sobald das Startpaket |7f| überschreitet, steht dann da wenn ich es mit >>ret<< mache: 2c 0x80, statt nur 0x80. Für 0x81 eine 2c 81...
    eine solche Angabe ist ungünstig, weil nichts genaues verraten wird,
    ist '|7f|' bzw. ein drüber also '|80|' eine Vermutung des Verhaltens des Senders oder kommt das auch schon im Programm an?
    meinst du damit eigentlich ein byte oder drei Bytes?

    'steht dann' kann ungenauer nicht sein, bist du mit der Endausgabe in der Fileoutputstream-Datei auf der Festplatte (oder wo auch immer) unzufrieden, was auch nur an verwendeten Datei-Leser liegen kann,
    oder stellst du das schon irgendwo im Programm fest?
    es gibt mehrere byte-Arrays im Programm, mehrere Positionen wo bytes Schritt um Schritt umgewandelt werden, da wäre Genauigkeit so wichtig..,
    welche konkreten Daten liegen je Position vor, werden in was umgewandelt, wo unzufrieden?

    wobei: hier ein Test der deinem Satz nahe kommt:
    Java Code:
    1. public class Test2 {
    2.     public static void main(String[] args)   {
    3.         byte[] readBuf = new byte[]          {-128};
    4.  
    5.         int[] ret = new int[readBuf.length];
    6.         for (short i = 0; i < readBuf.length; i++)    {
    7.             ret[i] = ((readBuf[i]) & 0xFF);
    8.         }
    9.         System.out.println("readBuf: " + Arrays.toString(readBuf));
    10.         System.out.println("ret    : " + Arrays.toString(ret));
    11.         String st = new String(ret, 0, ret.length);
    12.         System.out.println(st.length() + " - " + st);
    13.         System.out.println(Arrays.toString(st.getBytes()));
    14.     }
    15. }
    Ausgabe:
    Code:
    readBuf: [-128]
    ret    : [128]
    1 - €
    [-62, -128]
    aus einem byte -128 = 0x80 wird ein String mit den Bytes -62 = c1 + -128 = 0x80

    warum willst du die -128 überhaupt umwandeln, was genau erhoffst du dir im String auszulesen?
    ich vermute dass das hier nicht geht, ein Ansatz a la
    if (readBuf[i] == '|' && readBuf[i+1] == '0' && readBuf[i+2] == '|')
    klingt vielversprechender, je nachdem ob die '|' in einzelnen Bytes da sind, welche Bytes genau, das musst du alles feststellen

    wie hoch wird eigentlich gezählt wenn das mittlere Byte eine Nummerierung ist?
    du sagst |0| bis |0x80| geht, das ist ja schon die Hälfte der Zahlen, die in ein Byte passen, wie wird das 256. Paket angefangen, mit zwei Bytes für Zählung?
    kann ja dann irgendwann auch sein, dass das zweite Zähl-Byte just den Wert von '|' hat, auf sowas aufzupassen..

    das wird wohl kein anderer für dich (noch genauer als ich jetzt schon) machen, und ob du dafür der richtige bist?
    (ich bin in diesem Forum-Thema irgendwie recht frech, sorry falls störend)

    wichtig ist wahrscheinlich auch, die Nutzdaten dahinter dann direkt als bytes in eine Datei zu schreiben,
    Umwandlung in String und mit getBytes() die Bytes wieder raus ist immer als problematisch anzunehmen,
    es sieht ganz nach byte-Schnipseln aus, für mich

    ------

    das ursprüngliche Problem des Threads wiederum evtl. gar kein Thema bei dir,
    womöglich die API ja auch schon seit 2 Monaten korrekt, und dann verwendest du womöglich nicht einmal SPPService, weil selber ähnlichen Code..,
    lauter (Wo-)Möglichkeiten
    Geändert von SlaterB (16.09.2016 um 16:33 Uhr)
    Hansa wird Meister

  15. #15
    Unregistered
    Gast/Guest
    Hallo SlaterB,

    nochmal vielen, vielen Dank für deine Mühe. Irgendwie will bei mir die Zitier-funktion nicht, deshalb zitiere ich per "Hand".


    >>wie bist du überhaupt zu diesem Tool gekommen, was würdest du machen wenn es das nicht gäbe?


    Es gab eine "Vorarbeit" die jedoch sehr unstrukturiert ist. Ich arbeite mich ja auch noch ein Was mein Plan wäre ist wenn's nicht anders klappt, erst mal eine App zu proggen die nur Bluetoothdaten speichert, meine App macht noch einiges mehr. Ich denke ich werde es auch als Übung machen, wollte nur ein Projekt abschließen, und es hat eben nur dieses eine Detail gefehlt.

    >>wo immer es herkommt, gab es da kein Beispiel usw. dazu?

    Tutorials und AndroidStudio sind meine Quellen..


    >>ist '|7f|' bzw. ein drüber also '|80|' eine Vermutung des Verhaltens des Senders oder kommt das auch schon im Programm an?

    7f ist die höchste Zahl in hex-format die korrekt dargestellt wird auf der SD-Karte.
    Der Sender macht alles richtig, denn auf einem Terminal erscheint alles korrekt. Die Werte werden gesendet in Roh-Format(binär) wie Sie im Register ausgelesen werden.

    >>meinst du damit eigentlich ein byte oder drei Bytes?
    drei.


    >>'steht dann' kann ungenauer nicht sein,

    Sry, wenn die Datei auf der SD-Karte gelesen wird.
    Die Werte werden ja gespeichert. Deswegen konnte ich lange nicht ausschließen ob das Speichern oder das Lesen falsch war.


    >>es gibt mehrere byte-Arrays im Programm, mehrere Positionen wo bytes Schritt um Schritt umgewandelt werden, da wäre Genauigkeit so wichtig..,
    >>welche konkreten Daten liegen je Position vor, werden in was umgewandelt, wo unzufrieden?

    Eine Umwandlung brauche ich nicht. Es würde reichen wenn die Roh-Werte den Weg auf die SD-Karte finden. Wenn der Index zu ersetzen ist..
    Aber wenn etwas falsch gemacht wird, warum stimmt sonst alles?
    Und ausgerechnet ab 127 läuft es falsch. Muss dann wohl am unsigned liegen. Aber selbst wenn, wie kommt man dann auf eine C2 80, ein Minuszeichen ist doch anders kodiert?

    >>warum willst du die -128 überhaupt umwandeln, was genau erhoffst du dir im String auszulesen?

    sry, wenn ich mich nicht klar ausgedrückt hatte. Ich möchte sie nicht umwandeln. Mein Wertebereich geht von 0-255, also unsigned, so will ich es auch speichern

    Warum sie trotzdem gewandelt sind ist der Index.. den ich nicht-gewandelt im Code 3 hab versucht zu ersetzen. Ich bin ein Java-Neuling, denke immer an Pointer..^^

    Da ohne Wandlung die Werte korrekte sind aber auf der SD-Karte Ihre Reihenfolge nicht einhalten und sich manche mehrmals hintereinander vordrängeln.

    Bestimmt ist die Lösung eine einfache... Ich möchte einfach das Array/Byte-Steram wie es empfangen wird auf die SD-Karte legen. Mein Programm versteht aber nicht, dass sagen wir wenn das Array 10 Byte lang ist, diese gespeichert werden sollen, dann die nächsten 10 Byte, und nicht irgendwas und auch nicht dieselben 10 Byte nochmal. Darum der Index von |0| bis |0|, String extrahieren, Speichern Löschen, nächster String...

    Jetzt, beim ausformulieren meines Problems merke ich, dass es sicher nicht so schwer ist. Ich wusste nur nicht welchen Weg ich gehen sollte.

    >>wie hoch wird eigentlich gezählt wenn das mittlere Byte eine Nummerierung ist?

    255, also bis zum Überlauf und dann wieder von vorne

    >>du sagst |0| bis |0x80| geht, das ist ja schon die Hälfte der Zahlen, die in ein Byte passen

    genau und die andere Hälfte soll auch noch stimmen.

    An der Position wo ich nur ein Byte stehen haben müsste, habe ich auf der SD-Karte für 0x80 zwei Bytes: 0xc2 0x80, das C2-Byte soll verschwinden. Die gehören irgendwie zusammen. Wenn man um 1 immer erhöht folgt: C2 81... bis C2 bf und dann passiert: C3 80; C3 81...

    >>kann ja dann irgendwann auch sein, dass das zweite Zähl-Byte just den Wert von '|' hat, auf sowas aufzupassen..

    Das macht nichts. Der Index setzt sich aus 3 bytes zusammen. Der Start vom Paket ist eben mit diesen 3 Bytes gekennzeichnet: |Paketzahl|. Dadurch kann geprüft werden, ob alle Pakete richtig ankommen und selbst wenn Werte dem Zeichen "|" entsprechen, kennt man ja zusätzlich die Anzahl der Werte pro Paket und kann diese dann einem Messwert zuordnen. Natürlich funktioniert das nicht mehr so einfach, wenn sich plötzlich zwei Bytes einschleusen C2 80.

    Und sollten wirklich 3 Bytes zufällig den Messwerten |0| entsprechen, wird halt einmal ein kürzerer String extrahiert. Aber ich werde es dann mit Arrays probieren ohne Index.

    >>das wird wohl kein anderer für dich (noch genauer als ich jetzt schon) machen

    Das erwarte ich doch gar nicht Ich bin dir aber dankbar.


    Zu allen deinen Vorschlägen (auch in deinen vorherigen Posts) melde ich mich, wenn ich es mal verinnerlicht habe. Es hat mir schon sehr geholfen.

    Vielen Dank.

  16. #16
    Global Moderator Viertel Gigabyte Avatar von SlaterB
    Registriert seit
    06.08.2008
    Fachbeiträge
    2.716
    Genannt
    291 Post(s)
    Zitat Zitat von Unregistered Beitrag anzeigen
    An der Position wo ich nur ein Byte stehen haben müsste, habe ich auf der SD-Karte für 0x80 zwei Bytes: 0xc2 0x80, das C2-Byte soll verschwinden.
    das dürfte ziemlich sicher von der Umwandlung in String kommen, die aktuelle zumindest,

    ob es eine korrekte sinnvolle Umwandlung in einer Zeile gibt, mag ich mal nicht völlig ausschließen,
    weil ich die Daten immer noch nicht ganz verstehe, aber bezweifle es

    also die bytes direkt als bytes schreiben, bleibt nur die Frage nach dem Index

    Zitat Zitat von Unregistered Beitrag anzeigen
    Mein Programm versteht aber nicht, dass sagen wir wenn das Array 10 Byte lang ist, diese gespeichert werden sollen, dann die nächsten 10 Byte, und nicht irgendwas und auch nicht dieselben 10 Byte nochmal. Darum der Index von |0| bis |0|, String extrahieren, Speichern Löschen, nächster String...
    vage vage,
    geht es darum, dass vorherigen Nachrichten nochmal gespeichert werden oder willst du aus einer aktuellen Nachricht nur Teile speichern?

    Code 3 von Anfang ist wohl der richtige Weg, wie schon mal genannt,
    jetzt sehe ich dort gerade ein paar einfache Fehler, die zumindest kann ich korrigieren:
    Java Code:
    1. byte[] readBuf = (byte[]) msg.obj;
    2. int endePos = 0; // Variable vor der Schleife deklarieren
    3. for (int i = 0; i < readBuf.length - 2; i++) {
    4.   if (readBuf[i] == '|' && readBuf[i+1] == '0' && readBuf[i+2] == '|') {
    5.   // findet ja nur |0|, besser nur nach den || suchen, egal was bei i+1 steht
    6.  
    7.                 endePos = i;
    8.                 break;
    9.   }
    10. }
    11.      
    12. try {
    13.    File myFile = new File(path);
    14.    myFile.createNewFile();
    15.    FileOutputStream fOut = new FileOutputStream(myFile, true);
    16.                                  
    17.     fOut.write(readBuf, 0, endePos); // nicht readBuf.endePos..
    Hansa wird Meister

  17. #17
    Unregistered
    Gast/Guest
    Sorry für das ganze Wirrwarr.

    Also der relevante Code auf den es sich nur bezieht ist folgender (while schleife weg; ohne Stringbuilder also auch ohne Index).

    ich versuch diesmal konkret zu sein.

    Java Code:
    1.  
    2. switch (msg.what) {
    3.                         case RECIEVE_MESSAGE:
    4.                             byte[] readBuf = (byte[]) msg.obj;
    5.  
    6.  
    7.  
    8. String path = "sdcard/" + dateipfad.getText().toString() + ".txt";
    9.  
    10.                             try {
    11.  
    12.  
    13.                                     File myFile = new File(path);
    14.                                     myFile.createNewFile();
    15.                                     FileOutputStream fOut = new FileOutputStream(myFile, true);
    16.                                    fOut.write(readBuf, 0,readBuf.length);
    17. );
    18.                                     fOut.close();
    19. }

    Ziel: Wenn er was empfängt, soll das was empfangen wird gespeichert (einmal) und nur dann.

    Bisher: Er speichert ca. 20 werte, dann kommen ca 100 Nuller, dann speicher er die gleichen 20 Werte nochmal, dann wieder 100 Nuller, dann speichert er die nächsten folgenden 20 Werte.

    Was tun? Buffer verkleinern, for schleife..?

    *** Edit ***

    Mist, tschuldigung da ist ein }, zuviel, ich sollte mich wohl mal anmelden, dann kann ich auch bearbeiten?

    *** Edit ***

    Auf jeden Fall kannst du mir jetzt folgen

    Warum /oder wird nicht der Empfangspuffer beim auslesen Automatisch gelöscht, wie zB ein Register am Mikrocontroller.

    Das Problem bei deinem Code ist, so wie ich das beurteilen kann, dass das for dazu führt dass der Index einmal erkannt wird.

    Folglich habe ich ein Paket auf dem Speicher. Nun muss das nächste Paket ab da wo der Index gesetzt wurde bis zum nächsten Index gelegt werden.

    ich habe jetzt mal da wir nicht da Strings suchen in HEX formatiert, den Index |0| =if (readBuf[i] == 0x7c && readBuf[i + 1] == 0x30 && readBuf[i + 2] == 0x7c)

    geändert.

    Die endePos ist bei mir POS1, nun soll er immer von der POS1 zu POS2 beschreiben. Diese müssen sich fortlaufend aktualisieren.

    Meine Idee wäre es jetzt POS1 um die Anzahl der Werte(momentan:100) die mir bekannt sich zu erweitern = POS2.

    im Nächsten Schritt müsste für POS2 wieder zu POS1 werden...

    Die Index-Aktualisierung sollte dennoch erfolgen, falls ein Wert wegen kurz auftretender Störung nicht empfangen wurde.

    Denke sowas in die Richtig ist der richtige Weg, bisher habe ich:

    Code:
     case RECIEVE_MESSAGE:
                                byte[] readBuf = (byte[]) msg.obj;
    
    
    
                                       int POS1=0;
    
                                for (int i = 0; i < readBuf.length - 2; i++) {
                                    if (readBuf[i] == 0x7c && readBuf[i + 1] == 0x30 && readBuf[i + 2] == 0x7c) {
    
    
                                        POS1 = i;
                                        break;
                                    }
                                }
                                String path = "sdcard/" + dateipfad.getText().toString() + ".txt";
    
                                try {
                                        int POS2 = POS1+100;
    
                                        File myFile = new File(path);
                                        myFile.createNewFile();
                                        FileOutputStream fOut = new FileOutputStream(myFile, true);
                                       fOut.write(readBuf, POS1, POS2);
                                        fOut.close();
    Danke, dass du mich nicht so schnell aufgibst
    Geändert von SlaterB (16.09.2016 um 20:02 Uhr) Grund: Java-Tags

  18. #18
    Global Moderator Viertel Gigabyte Avatar von SlaterB
    Registriert seit
    06.08.2008
    Fachbeiträge
    2.716
    Genannt
    291 Post(s)
    RECIEVE ist falsch benannt,

    was die Lage ist ist weiterhin unklar, immer wieder dasselbe: du musst sagen welche Daten kommen,
    was genau alles passiert

    zunächst:
    löscht jemand die Datei vor dem Anfang des Programms bzw. ist das wichtig?
    FileOutputStream fOut = new FileOutputStream(myFile, true);
    schreibt ans Ende der vorhandenen Dabei,
    innerhalb des Programms sicher richtig, damit vorheriges nicht gelöscht wird,

    wenn immer wieder mit den gleichen Daten Programm neu begonnen, dann würde sich freilich gleiches sammeln

    --------

    danach:
    wieviele Nachrichten gibt es?,
    aus was genau besteht Nachricht 1, wieviele bytes, wieviele Werte, wieviele 'Nuller', was immer das bedeuten soll,
    wie sieht die Datei (bzw. der neu gespeicherte Anteil) aus nachdem Nachricht 1 gespeichert wurde?
    etwa dahinter Programmabbruch bewirken und anschauen,

    wurde genau der Inhalt von Nachricht 1 korrekt gespeichert?

    danach Nachricht 2, wieder genau zu sagen aus was sie besteht,
    und was genau ist danach der Inhalt der Datei, nicht genau Nachricht 1 und dahinter Nachricht 2?
    sondern was genau ist falsch, ist Nachricht 1 genau doppelt abgelegt oder was sonst das Problem?

    'irgendwo irgendwelche Nuller', das ist keine Aussage..

    edit:
    0 in Datei kann leicht davon kommen, dass der unbelegte Rest eines byte-Arrays mitgespeichert wird,
    bei fOut.write(readBuf, 0,readBuf.length); ja auch keine Kunst, nun fehlt der End-Index,
    das wusstest du ja schon selber, keine echte Frage,

    msg.arg1 wie in String strIncom = new String(ret, 0, msg.arg1);
    hilft vielleicht zu erkennen, wieviel vom Array belegt ist
    fOut.write(readBuf, 0,msg.arg1);
    schon die Lösung aller Probleme?..


    Zitat Zitat von Unregistered Beitrag anzeigen
    ich sollte mich wohl mal anmelden, dann kann ich auch bearbeiten?
    ich will mal auch Geheimnisse belassen, machen ja alles interessanter
    aber gut raten ist erlaubt
    Geändert von SlaterB (16.09.2016 um 20:15 Uhr)
    Hansa wird Meister

  19. #19
    Unregistered
    Gast/Guest
    Also die Lösung wäre doch wenn der endePos sich ständig aktualisiert und

    speichern wäre:

    fOut.write(readBuf,endePos , endePos+100);// oder würde er die Daten dann überschreiben?

  20. #20
    Global Moderator Viertel Gigabyte Avatar von SlaterB
    Registriert seit
    06.08.2008
    Fachbeiträge
    2.716
    Genannt
    291 Post(s)
    hast du fOut.write(readBuf, 0,msg.arg1); schon getestet, ohne weiteres besprechen zu müssen?

    zu
    Zitat Zitat von Unregistered Beitrag anzeigen
    fOut.write(readBuf,endePos , endePos+100);// oder würde er die Daten dann überschreiben?
    gäbe es sonst nur wieder viele neue Fragen,
    was sollte überschrieben werden und wieso diese Vermutung?
    was ist endePos, was steht davor in readBuf, wieso nicht zu speichern, wieso nur genau bis +100 dahinter speichern,

    außerdem wieder komplette Beispiel-Daten mit Länge, mit endePos und mit Ergebnis in Datei wünschenswert
    Hansa wird Meister

+ Antworten Thema als "gelöst" markieren
Seite 1 von 2 1 2 LetzteLetzte

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. Zertifikate für byte-welt.de und byte-welt.net abgelaufen
    Von Sen-Mithrarin im Forum Kritiken & Anregungen
    Antworten: 3
    Letzter Beitrag: 07.04.2016, 19:44
  2. Cast 0-255 int to byte
    Von tkausl im Forum Java-Grundlagen
    Antworten: 4
    Letzter Beitrag: 17.04.2014, 10:20
  3. Umrechnung von Bit, Byte und co.
    Von razer47 im Forum Theoretisches
    Antworten: 6
    Letzter Beitrag: 21.01.2014, 18:37
  4. Byte-Bit Erklärungsproblem
    Von FreundInNot im Forum Theoretisches
    Antworten: 9
    Letzter Beitrag: 24.10.2013, 09:24
  5. byte-welt
    Von The_S im Forum Spielwiese
    Antworten: 4
    Letzter Beitrag: 28.12.2007, 20:12

Berechtigungen

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