Sensorübetragung von Android auf Raspberry Pi

Sockets, TCP/IP, (XML-)RPC und ähnliche Themen gehören in dieses Forum
Antworten
Alex1820
User
Beiträge: 2
Registriert: Sonntag 7. September 2014, 18:33

Hallo Zusammen,

anbei präsentiere ich mein aktuelles Projekt und dessen Problematik. Gründe für die Problematiken werden wahrscheinlich sein, dass ich in diesen Gebieten ein blutiger Anfänger bin und hoffe mir daher etwas erfahrene Unterstützung. :?

Bei meinem Projekt handelt es sich um eine Steuerungsapp, welche den Neigungssensor meines Smartphone oder Tablets ausliest und diese Werte anschließend an ein Raspberry Pi sendet. Hierbei aggiert dieser als Hotspot und somit als Server, welche die Daten später auf einer Webseite darstellt.

Problematik:
Meine Probleme zur Zeit sind aber bei der Datenübertragung vorhanden. Ich habe eine App erstellt, welche erfolgreich die Sensordaten ausliest. Nun stehe ich vor dem Rätsel wie ich diese Daten am besten über eine Socketverbindung zum Raspberry sende. Ich habe schon viel Zeit aufgewendet im Internet nach Möglichkeiten zu suchen, die zu meinem Projekt passen könnten. Leider war ich noch nicht so erfolgreich, was sicherlich auch daran liegen kann, dass ich vor lauter Wald die Bäume nicht mehr sehe. :roll:
Was vielleicht noch zu erwähnen wäre, wobei ich nicht weiß ob es wichtig ist. die App wurde ursprünglich mit Processing erstellt und nach Android Studio importiert.

Hier könnt ihr mal meinen aktuellen Programmiercode sehen:

Code: Alles auswählen

package processing.test.sensorkipp_pde;

import ketai.sensors.KetaiSensor;
import processing.core.PApplet;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;

import java.net.InetAddress;
import java.net.Socket;

import java.lang.*;
import java.io.*;


public class Sensorkipp_pde extends PApplet {

    private static class Client {

        private Socket socket = null;
        private BufferedReader reader = null;
        private BufferedWriter writer = null;

        public Client(InetAddress address, int port) throws IOException {

            socket = new Socket(address, port);
            reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        }

        public void send(String msg) throws IOException
        {
            writer.write(msg, 0, msg.length());
            writer.flush();
        }

        public String recv() throws IOException {

            return reader.readLine();
        }

        public static void main(String[] args) {

            try {
                InetAddress host = InetAddress.getByName("192.168.42.1");
                Client client = new Client(host, 9000);

                client.send("Verbindung zum Server steht!!!!");
                String response = client.recv();
                System.out.println("Client received: " + response);
            }
            catch (IOException e) {
                System.out.println("Caught Exception: " + e.toString());
            }
        }
    }

KetaiSensor sensor;

//In folgenden Variablen werden die X-, Y- und Z-Beschleunigungswerte eingetragen
float beschleunigungX, beschleunigungY, beschleunigungZ;

public void setup()
{
 
  sensor=new KetaiSensor(this);
  sensor.start();
  orientation (LANDSCAPE);

  textAlign(CENTER, CENTER);
  textSize(36);
}

public void draw ()
{
    //Variablen für die X- und Y-Positionen des Kreises
  int x=0, y=0;
    //Variablen für Kippwinkel der X- oder Y-Achse
  int kippWinkelY=0, kippWinkelX=0;
  background (0, 255, 0);

    //Fadenkreuz in der Mitte des Anzeigegerätes
  strokeWeight(2);
  line(300, 20, 300, 530);
  line(20, 300, 570, 300);

  //Berechnung der trigometrischen Berechnung der Kippwinkel In Grad (Int)
  // Wandelt von float in Int
  //Nach Rechts kippen ergibt ein positiven Winkel
  kippWinkelX= (int) (atan (beschleunigungY/beschleunigungZ) *180/PI);
  //Zum Benutzer kippen ergibt ein positiven Winkel
  kippWinkelY= (int) (atan (beschleunigungX/beschleunigungZ) *180/PI);

  //Umrechnung der Kippwinkel in dsa xy-Koordinatenpositionen
  x=(int)map(kippWinkelX, -90, 90, 0, 600);
  y=(int)map(kippWinkelY, -90, 90, 0, 600);

  // Kreis wird an gewünschter Koordinatenposition gezeichnet
  fill (255, 255, 255);
  ellipse(x, y, 50, 50);
  fill (0, 0 , 0);

  //Gibt Kippwinkel als Text aus
  text("Kippwinkel (\u00b0) : \n" + //(3)
  "X-Achse: " + kippWinkelX + "\n" +
  "Y-Achse: " + kippWinkelY + "\n", width/2, height/2);
}

public void onAccelerometerEvent (float x, float y, float z)
{
  //Folgende Methoden werden automatisch aufgerufen bei Sensorwertänderung
  beschleunigungX=-x;
  beschleunigungY=-y;
  beschleunigungZ=-z;
}


  public int sketchWidth() { return 600; }
  public int sketchHeight() { return 600; }
}
Ich fände es natürlich super, wenn ein paar von euch euer Wissen mit mir teilen könnten. :)
Zuletzt geändert von Anonymous am Sonntag 7. September 2014, 19:06, insgesamt 2-mal geändert.
Grund: Code Tags von Python zu Java geändert.
Benutzeravatar
pillmuncher
User
Beiträge: 1484
Registriert: Samstag 21. März 2009, 22:59
Wohnort: Pfaffenwinkel

@Alex1820: Vermutlich ist die Frage besser in einem Java-Forum aufgehoben, als in einem Python-Forum.
In specifications, Murphy's Law supersedes Ohm's.
BlackJack

@Alex1820: Die Fragen die man auch hier stellen könnte, weil sie unabhängig von Java oder Python sind, betreffen die generelle Übertragung, also was und wie zwischen den beiden Seiten ausgetauscht wird.

Du musst Dir klar machen was für Daten übertragen werden sollen, und wie die dann beim Transport repräsentiert werden.

Bei TCP brauchst Du ein Protokoll was erlaubt die Nachrichten voneinander zu trennen, weil das ein Datenstrom ist und der Empfänger an irgendwas erkennen können muss wann eine Nachricht zuende ist und die nächste anfängt.

Nachrichten mit drei Gleitkommawerten kann man zum Beispiel als Datenpakete fester Länge verschicken in dem man die Werte zum Beispiel als IEEE 754 floating-point "single format" in 4 Bytes kodiert und so 12 Bytes pro Datenpaket hat. Auf Java-Seite kann man das mit einem `DataOutputStream` machen und auf Python-Seite mit Hilfe des `struct`-Moduls wieder auseinander nehmen.

Oder man schickt die Zahlen als Text durch jeweils ein Leerzeichen (oder Komma, oder …) getrennt und mit einem Zeilenendekennzeichen abgeschlossen als Kennzeichen für das Ende einer Nachricht.

Oder man schickt JSON, YAML, XML, oder irgendein anderes etabliertes Format.
Alex1820
User
Beiträge: 2
Registriert: Sonntag 7. September 2014, 18:33

Danke für die schnelle Antwort. Allerdings bin ich wie schon erwähnt ein blutiger Anfänger und kann mit der Information nur bedingt etwas anfangen. :? Hilfreich wäre jedoch wenn jemand ein Codebeispiel hätte, damit ich es davon ableiten kann. Sicherlich gibt es hier Leute die auch schon versucht haben eine Fernsteuerung für ein Roboter oder ähnliches von einem Handy über ein Raspberry Pi zu programmieren?
Antworten