Hilfe bei Hochschulprojekt benötig, UDP-Verbindung zum öffnen/ schließen einer Heckklappe

Hallo,
dies ist meine erste "Post" hier, bitte vergebt mir falls ich an einer falschen Stelle "poste".

Ich möchte für ein Schulprojekt eine Heckklappe mit einem Android Tablet öffnen bzw. schließen. Für die Verbindung mit dem Steuergerät der Heckklappe steht ein CAN-Wlan Modul von Avi saro zur Verfügung.

Das Problem ist nur, ich kenne mich mit der Programmierung von Android überhaupt nicht aus. Ich bin kein IT Mensch.

Zum Glück steht mir von einem vorherigen Projekt der passende UDP-Thread (UDP_Verbindung_ja va, siehe unten) zur Verfügung.
Das Layout habe ich auch schon zusammengestellt, das was fehlt ist die Verbindung des Layout mit dem UDP-Thread.
Kann mir jemand dabei helfen?

Der CAN-Daten (insgesamt 28 byte) Output sollte dabei wie folgt aussehen:

button "Öffnen" (open), 13. byte: {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
d.h. bei Betätigung des button "Öffnen" sollte das 13. byte den Wert 1 annehmen)
button "Schließen"(close), 14.byte:{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
button "STOP", 15. byte:{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
seekbar ("Heckklappengeschwindigkeit"), 16. byte, value: 50...100
zum Vorgeben der Geschwindigkeit

Der unterste Text (Heckklappenöffnungswinkel)sollte das 17. byte der empfangenen Nachricht anzeigen

UDP_Verbindung_ja va

public class UDP_Verbindung implements Runnable{

    private static final String TAGUDP = "UDP";
    final int UDP_Target_Port = 12345;
    private Thread threadUDP = null;
    private boolean isrunning = false;
    private DatagramSocket udpSocket = null;
    byte[] buffin = new byte[28];
    byte[] buffout = {0, 0, 0, 0, 0, 0, 8, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    DatagramPacket in = new DatagramPacket(buffin,buffin.length);
    DatagramPacket out = new DatagramPacket(buffout,buffout.length);
    int CAN_ID;
    int CAN_Length;
    private int udpStatus = 0;
    private Handler uiHandler = null;
    private int sendFlag = 0;
    String ip = "168.192.0.74";
    InetAddress addr = intToInetAddress(ipStringToInt( "192.168.0.74"));
    public int receive = 1; 
    private Set<String> listenToIds;


    public UDP_Verbindung(Handler uiHandler) {
        this.uiHandler = uiHandler;
        listenToIds = Collections.<String>emptySet();
    }

    public void setMessages(Set<String> messages){
        listenToIds = messages;
        Log.d(TAGUDP, "New Message IDs to listen to: ");
        for(String strId: listenToIds) {
            Log.d(TAGUDP, strId);
        }
    }


    @Override
    public void run() {

         try
            {
             Log.d(TAGUDP,"Verbindungsaufbau");   
             udpSocket = new DatagramSocket(UDP_Target_Port);
             udpSocket.setSoTimeout( 3000 );           
            } catch (SocketException ex)
            {
                ex.printStackTrace();
                Log.d(TAGUDP,"Verbindungsaufbau fehlgeschlagen");
                this.stop_service();

            }

            udpStatus = 1;
            Message msg1 = new Message();
            Bundle b1 = new Bundle();
            msg1.what = 1;
            b1.putInt("udpStatus", udpStatus);
            msg1.setData(b1);
            uiHandler.sendMessage(msg1);

            while (isrunning)
            {

                try
                {
                udpSocket.receive(in);
                //Log.d(TAGUDP,"Data received:");

                } 

                catch (IOException ex)
                {

                        Log.d(TAGUDP,"hier??");
                }



                InetAddress senderIP = in.getAddress();
                int senderPort = in.getPort();
                //Log.d(TAGUDP, senderIP.toString() + ":" + Integer.toString(senderPort) );
                buffin = in.getData();//---------------------Einlesen des Inhalts einer CAN Nachricht
                /*Log.d(TAGUDP, "LOsgeths:");
                for (int o = 0; o < 28; o++){
                    Log.d(TAGUDP, buffin[o] + " ");
                }*/
                //Log.d(TAGUDP, senderIP.toString() + ":" + Integer.toString(senderPort) );
                CAN_ID = buffin[8] + buffin[9]*256;//----------Ermitteln der CAN ID einer CAN Nachricht
                String CAN_ID_hex = Integer.toHexString(CAN_ID);
                if(listenToIds.contains(CAN_ID_hex)){
                    Log.d(TAGUDP, "Neue CAN Nachricht mit der ID " + CAN_ID_hex);
                    CAN_Length = buffin[6] & 15;//---------------Ermitteln der Länge einer CAN Nachricht
                    //Log.d(TAGUDP,"ID: " + CAN_ID + "    ");
                    byte[] canData = new byte[CAN_Length];
                    for (int l = 0; l < CAN_Length; l++){
                        canData[l] = buffin[12+l];
                        //Log.d(TAGUDP, buffin[12+l] + " ");
                        //Log.d(TAGUDP, Integer.toString(byteToUnsignedInt(buffin[12+l])));
                    }
                    Message msg = new Message();
                    Bundle b = new Bundle();
                    msg.what = 2;
                    b.putString("CAN_ID", CAN_ID_hex);
                    b.putByteArray("CAN_DATA",  canData);
                    b.putInt("CAN_LENGTH", CAN_Length);
                    msg.setData(b);
                    uiHandler.sendMessage(msg);
                }
            }


        }  


public static int byteToUnsignedInt(byte b) {
        return (0x00 << 24 | b & 0xff);
      }

public void start_Service(){
        Log.d(TAGUDP, "Start Thread");  
        this.threadUDP = new Thread(this);
        isrunning = true;
        threadUDP.start();
    }

public void stop_service() {

        Log.d(TAGUDP, "Trenne Verbindung"); 
        Log.d(TAGUDP, "Warte bis Thread durchgelaufen");
        isrunning = false;
        while(true) {
            try {
                if (threadUDP != null) {
                    threadUDP.join(500);
                }
                } catch (InterruptedException e) {
                e.printStackTrace();
            }
            break;
        }
        Log.d(TAGUDP, "Thread durchgelaufen");
        if (udpSocket != null)
        {
            Log.d(TAGUDP, "Schließe Socket");
            udpSocket.close();
            Log.d(TAGUDP, "geschlossen");
        }
        threadUDP = null;
        Log.d(TAGUDP, "UDP Thread geschlossen");

        udpStatus = 0;
        Message msg = new Message();
        Bundle b = new Bundle();
        msg.what = 1;
        b.putInt("udpStatus", udpStatus);
        msg.setData(b);
        uiHandler.sendMessage(msg);

    }

    public void setsendFlagValue(int flag) {
        this.sendFlag = flag;
    }

    public int getsendFlagValue() {
        return this.sendFlag;
    }

    public static int ipStringToInt(String str) {
         int result = 0;
         String[] array = str.split("\\.");
         if (array.length != 4) return 0;
         try {
             result = Integer.parseInt(array[3]);
             result = (result << 8) + Integer.parseInt(array[2]);
             result = (result << 8) + Integer.parseInt(array[1]);
             result = (result << 8) + Integer.parseInt(array[0]);
         } catch (NumberFormatException e) {
             return 0;
         }
         return result;
     }

    public static InetAddress intToInetAddress(int hostAddress) {
        InetAddress inetAddress;
        byte[] addressBytes = { (byte)(0xff & hostAddress),
                                (byte)(0xff & (hostAddress >> 8)),
                                (byte)(0xff & (hostAddress >> 16)),
                                (byte)(0xff & (hostAddress >> 24)) };

        try {
           inetAddress = InetAddress.getByAddress(addressBytes);
        } catch(UnknownHostException e) {
           return null;
        }
        return inetAddress;
    }

}

mein layout

ich habe jetzt mal auf die schnelle etwas zusammengestellt. Mir ist bewusst, dass darin tausende Fehler vorhanden sind, ich bin halt ein absoluter Anfänger. Es wäre echt super wenn jemand mir sagen könnte wie ich es richtig machen.

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Collections;
import java.util.Set;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity {

    private Button openbutton,closebutton,stopbutton;
    Handler handler;
    Thread thread;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        /////////////////////Button Finder//////////////////////
        openbutton=(Button)findViewById(R.id.buttonopen);
        closebutton=(Button)findViewById(R.id.buttonclose);
        stopbutton=(Button)findViewById(R.id.buttonstop);

        /////////////////////Button Listener///////////////////////
        openbutton.setOnClickListener(openbuttonListener);
        closebutton.setOnClickListener(closebuttonListener);
        stopbutton.setOnClickListener(stopbuttonListener);


        thread= new Thread(new UDP_Verbindung(handler));
        thread.start();
    }
}

public Button.OnClickListener openbuttonListener= new Button.OnClickListener(){
    @Override
    public void onClick(View arg0) {

        buffout[12]=1;
        new sendThread().execute();
    }

};

public Button.OnClickListener closebuttonListener= new Button.OnClickListener(){
    @Override
    public void onClick(View arg0) {

        buffout[13]=1;
        new sendThread().execute();
    }

};

public Button.OnClickListener stopbuttonListener= new Button.OnClickListener(){
    @Override
    public void onClick(View arg0) {

        buffout[14]=1;
        new sendThread().execute();
    }

};

public class sendThread extends AsyncTask<String, Integer, Boolean>{

    @Override
    protected Boolean doInBackground(String... arg0) {

        try {
            inet_addr = addr;
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


        DatagramPacket out = new DatagramPacket(buffout, buffout.length, inet_addr, UDP_Target_Port);
        try {
            socket= new DatagramSocket();
            socket.send(out);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return null;
    }
}

class UDP_Verbindung implements Runnable{

    private static final String TAGUDP = "UDP";
    final int UDP_Target_Port = 12345;
    private Thread threadUDP = null;
    private boolean isrunning = false;
    private DatagramSocket udpSocket = null;
    byte[] buffin = new byte[28];
    byte[] buffout = {0, 0, 0, 0, 0, 0, 8, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    DatagramPacket in = new DatagramPacket(buffin,buffin.length);
    DatagramPacket out = new DatagramPacket(buffout,buffout.length);
    int CAN_ID;
    int CAN_Length;
    private int udpStatus = 0;
    private Handler uiHandler = null;
    private int sendFlag = 0;
    String ip = "168.192.0.74";
    InetAddress addr = intToInetAddress(ipStringToInt( "192.168.0.74"));
    public int receive = 1;
    private Set<String> listenToIds;


    public UDP_Verbindung(Handler uiHandler) {
        this.uiHandler = uiHandler;
        listenToIds = Collections.<String>emptySet();
    }

    public void setMessages(Set<String> messages){
        listenToIds = messages;
        Log.d(TAGUDP, "New Message IDs to listen to: ");
        for(String strId: listenToIds) {
            Log.d(TAGUDP, strId);
        }
    }


    @Override
    public void run() {

        try
        {
            Log.d(TAGUDP,"Verbindungsaufbau");
            udpSocket = new DatagramSocket(UDP_Target_Port);
            udpSocket.setSoTimeout( 3000 );
        } catch (SocketException ex)
        {
            ex.printStackTrace();
            Log.d(TAGUDP,"Verbindungsaufbau fehlgeschlagen");
            this.stop_service();

        }

        udpStatus = 1;
        Message msg1 = new Message();
        Bundle b1 = new Bundle();
        msg1.what = 1;
        b1.putInt("udpStatus", udpStatus);
        msg1.setData(b1);
        uiHandler.sendMessage(msg1);

        while (isrunning)
        {

            try
            {
                udpSocket.receive(in);
                //Log.d(TAGUDP,"Data received:");

            }

            catch (IOException ex)
            {

                Log.d(TAGUDP,"hier??");
            }



            InetAddress senderIP = in.getAddress();
            int senderPort = in.getPort();
            //Log.d(TAGUDP, senderIP.toString() + ":" + Integer.toString(senderPort) );
            buffin = in.getData();//---------------------Einlesen des Inhalts einer CAN Nachricht
                /*Log.d(TAGUDP, "LOsgeths:");
                for (int o = 0; o < 28; o++){
                    Log.d(TAGUDP, buffin[o] + " ");
                }*/
            //Log.d(TAGUDP, senderIP.toString() + ":" + Integer.toString(senderPort) );
            CAN_ID = buffin[8] + buffin[9]*256;//----------Ermitteln der CAN ID einer CAN Nachricht
            String CAN_ID_hex = Integer.toHexString(CAN_ID);
            if(listenToIds.contains(CAN_ID_hex)){
                Log.d(TAGUDP, "Neue CAN Nachricht mit der ID " + CAN_ID_hex);
                CAN_Length = buffin[6] & 15;//---------------Ermitteln der Länge einer CAN Nachricht
                //Log.d(TAGUDP,"ID: " + CAN_ID + "    ");
                byte[] canData = new byte[CAN_Length];
                for (int l = 0; l < CAN_Length; l++){
                    canData[l] = buffin[12+l];
                    //Log.d(TAGUDP, buffin[12+l] + " ");
                    //Log.d(TAGUDP, Integer.toString(byteToUnsignedInt(buffin[12+l])));
                }
                Message msg = new Message();
                Bundle b = new Bundle();
                msg.what = 2;
                b.putString("CAN_ID", CAN_ID_hex);
                b.putByteArray("CAN_DATA",  canData);
                b.putInt("CAN_LENGTH", CAN_Length);
                msg.setData(b);
                uiHandler.sendMessage(msg);
            }
        }


    }


    public static int byteToUnsignedInt(byte b) {
        return (0x00 << 24 | b & 0xff);
    }

    public void start_Service(){
        Log.d(TAGUDP, "Start Thread");
        this.threadUDP = new Thread(this);
        isrunning = true;
        threadUDP.start();
    }

    public void stop_service() {

        Log.d(TAGUDP, "Trenne Verbindung");
        Log.d(TAGUDP, "Warte bis Thread durchgelaufen");
        isrunning = false;
        while(true) {
            try {
                if (threadUDP != null) {
                    threadUDP.join(500);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            break;
        }
        Log.d(TAGUDP, "Thread durchgelaufen");
        if (udpSocket != null)
        {
            Log.d(TAGUDP, "Schließe Socket");
            udpSocket.close();
            Log.d(TAGUDP, "geschlossen");
        }
        threadUDP = null;
        Log.d(TAGUDP, "UDP Thread geschlossen");

        udpStatus = 0;
        Message msg = new Message();
        Bundle b = new Bundle();
        msg.what = 1;
        b.putInt("udpStatus", udpStatus);
        msg.setData(b);
        uiHandler.sendMessage(msg);

    }

    public void setsendFlagValue(int flag) {
        this.sendFlag = flag;
    }

    public int getsendFlagValue() {
        return this.sendFlag;
    }

    public static int ipStringToInt(String str) {
        int result = 0;
        String[] array = str.split("\\.");
        if (array.length != 4) return 0;
        try {
            result = Integer.parseInt(array[3]);
            result = (result << 8) + Integer.parseInt(array[2]);
            result = (result << 8) + Integer.parseInt(array[1]);
            result = (result << 8) + Integer.parseInt(array[0]);
        } catch (NumberFormatException e) {
            return 0;
        }
        return result;
    }

    public static InetAddress intToInetAddress(int hostAddress) {
        InetAddress inetAddress;
        byte[] addressBytes = { (byte)(0xff & hostAddress),
                (byte)(0xff & (hostAddress >> 8)),
                (byte)(0xff & (hostAddress >> 16)),
                (byte)(0xff & (hostAddress >> 24)) };

        try {
            inetAddress = InetAddress.getByAddress(addressBytes);
        } catch(UnknownHostException e) {
            return null;
        }
        return inetAddress;
    }

}

— geändert am 14.12.2015, 23:08:50

Hallo Pascal,

vielen Dank für deine Meldung/Hilfe.

So ganz blicke ich die Logik deines UDP Threads nicht. .

Das UDP Thread habe ich von einem anderen Projekt bekommen,welches ebenfalls mit dem selben avisaro can-wlan Modul gearbeitet hat. Ich verstehe den Thread garnicht, weiß aber dass es funktioniert bzw. funktionieren müsste.

Wie übergibst du diesem ein Byte Array um dieses zu senden? Ich habe
das Gefühl da fehlt noch etwas Logik..

Das Frage ich mich auch schon die ganze Zeit.. Ich weiß eben nicht wie ich dieses byte array (insgesamt 28 bytes) senden kann?
Mein Hauptproblem ist, dass ich nicht weiß wie ich das UDP Thread einbauen bzw. starten soll , wie ich dieses byte array an den UDP Thread zum senden übergeben kann und welche Befehle ich dafür brauche?

Was mir sehr helfen würde wäre, wenn mir jemand, der das Thread überschaut hat, in wenigen Zeilen schreibt, wie beispielhaft die Befehle dafür aussehen müssten.

Um den Thread mit der UI zu verbinden, musst du auf deine Buttons
onClickListener festlegen und in diesen dein entsprechendes Byte Array
an den UDP Thread übergeben, welcher dieses dann senden soll.
Musst du auch auf Antworten vom Gerät reagieren oder willst du nur
senden können?

Das mit den onclicklistener festlegen habe ich inzwischen im Griff, Ich möchte auch empfangen, auch hier wüsste ich nicht genau wie ich miitels handler die "Message" einlesen kann? ich könnte auch hier ein Beispiel gebrauchen.

Vielen vielen Dank.

Grüße,

Hasan Y.

Vielen Dank für deine schnelle Antwort.

Das Problem, was ich habe ist, dass ich zu diesem Projekt keinen Zugang habe. Hätte ich Zugang zum Projekt wäre es kaum ein Problem.Ich habe lange darum gekämpft...
Es ist ja nicht so, dass ich gar keine Programmiererfahrung habe. Ich kann schon teilweise nachvollziehen was im UDP-Teil passiert. Es wird im UDP-Part nur empfangen. Gesendet werden muss im Hauptteil, je nachdem wie die buttons geklickt werden.
Ich weiß bloß nicht wie
Ich kenne die Befehle dafür einfach nicht. Ich habe einfach das Falsche studiert.

Könntest du mir, wenn du Vorlagen oder Beispiele hast, sie zusenden? Es würde mich ein ganzes Stück weiterbringen. Im Netz habe ich keine vernünftigen Beispiele finden können.

Vielen Dank nochmals

Nochmals vielen Dank für deine Hilfe.