Android开发—智能家居系列----UDP通信发送指令

最新推荐文章于 2025-03-07 10:43:02 发布

smxueer

最新推荐文章于 2025-03-07 10:43:02 发布

阅读量1k

点赞数

分类专栏： Android(3G开发) 文章标签：智能家居

Android(3G开发) 专栏收录该内容

33 篇文章

订阅专栏

本文介绍了一种通过UDP通信实现手机与WIFI模块交互的方法，包括搜索WIFI模块、获取模块信息、设置网络参数等操作，并提供了关键代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

转载于：http://blog.youkuaiyun.com/a123473915/article/details/54646518

思路回顾

【1】手机连接WIFI模块
【2】UDP通信对WIFI模块发送指令，以和WIFI模块保持连接状态
【3】UDP通信对WIFI模块发送指令，让其搜索可用的无线网，返回WIFI列表
【4】发送指令，让WIFI模块接入指定路由
【5】手机连接路由
【6】发送指令，获得WIFI模块的动态IP地址

UDP通信线程类

package com.jczb.smartlife.common;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

import android.os.Handler;
import android.os.Message;

import com.jczb.smartlife.common.Tool;

public class GetInfoThread extends Thread {
    private Handler handler;
    private DatagramSocket socket;
    private int msgType;

    private final String IP = "255.255.255.255";//广播地址
    private int PORT = 26000;

    /**
     * 48899端口：C32x系列的端口，用户可以用AT指令更改
     * 49000端口：除C32x系列，其他WIFI模块的端口
     * 1902端口：有人掌控宝系列产品的端口
     */
    private int targetPort = 49000 ;

    private boolean receive = true;


    /**
     * 
     * @param handler 传入监听此线程的Handler
     * @param intMsg 传入监听的消息类型
     */
    public GetInfoThread(Handler handler,int msgType) {
        this.handler = handler;
        this.msgType=msgType;
        init();
    }

    public void init(){
        try {

            socket = new DatagramSocket(null);
            socket.setBroadcast(true);
            socket.setReuseAddress(true);
            socket.bind(new InetSocketAddress(PORT));
        } catch (SocketException e) {
            e.printStackTrace();
            sendErrorMsg("Search Thread init fail");
            return;
        } 
    }


    public void run() {
        if (socket == null) {
            return;
        }

        try {

            byte[] data = new byte[1024];
            //创建一个空的DatagramPacket对象
            DatagramPacket revPacket = new DatagramPacket(data, data.length);
            while (receive) {
                //服务端接收数据
                socket.receive(revPacket);
                if(null!=handler){
                    byte[] realData = new byte[revPacket.getLength()];
                    System.arraycopy(data, 0, realData,0, realData.length);
                    Message msg =handler.obtainMessage(msgType,realData);
                    handler.sendMessage(msg);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            socket.close();
        }
    }

    public void close() {
        if (socket == null)
            return;
        socket.close();
    }


    private void sendErrorMsg(String info){

    }

    /**
     * 发送数据
     * @param msg
     */
    public void sendMsg(byte[] msg) {
        if (socket != null) {
            try {
                System.out.println("targetPort------------------->"+targetPort);
                DatagramPacket sendPacket = new DatagramPacket(msg, msg.length,
                        InetAddress.getByName(IP), targetPort);
                socket.send(sendPacket);
            } catch (UnknownHostException e) {
                e.printStackTrace();
                System.out.println("发送失败");
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("发送失败");
            }

        }
    }

    public void setReceive(boolean receive) {
        this.receive = receive;
    }

    public void setTargetPort(int targetPort) {
        this.targetPort = targetPort;
    }
    public void setMsgType(int msgType){
        this.msgType=msgType;
    }
}

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

发送消息的线程类

/**
     * 发送消息的队列，每次发送数据时，只需要调用putMsg(byte[] data)方法
     * 
     * @author usr_liujinqi
     * 
     */
    private class SendMsgThread extends Thread {
        // 发送消息的队列
        private Queue<byte[]> sendMsgQuene = new LinkedList<byte[]>();
        // 是否发送消息
        private boolean send = true;

        private GetInfoThread ss;

        public SendMsgThread(GetInfoThread ss) {
            this.ss = ss;
        }

        public synchronized void putMsg(byte[] msg) {
            // 唤醒线程
            if (sendMsgQuene.size() == 0)
                notify();
            sendMsgQuene.offer(msg);
        }

        public void run() {
            synchronized (this) {
                while (send) {
                    // 当队列里的消息发送完毕后，线程等待
                    while (sendMsgQuene.size() > 0) {
                        byte[] msg = sendMsgQuene.poll();
                        if (ss != null)
                            ss.sendMsg(msg);
                    }
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        public void setSend(boolean send) {
            this.send = send;
        }
    }
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

应用

【举例】发送搜索WIFI模块的指令

//1.用户获得温控器中WIFI模块的WIFI模块的IP地址,MAC地址,模块名称的指令    
    private final byte[] getInfoCode=new byte[]{(byte)0x48,0x46,0x2D,0x41,0x31,0x31,0x41,0x53,0x53,0x49,0x53,0x54,0x48,0x52,0x45,0x41,0x44};
    public static final int REC_Module=0x04;//搜索WIFI模块的信息（包括IP、Mac、名称）
//实例化一个线程，用户获得模块信息（IP，Mac，名称）
        //参数为监听为此线程的Handler，以及接收成功后，给Handler发送的消息类型
        getInfoThread = new GetInfoThread(handler,Tool.REC_Module);
        getInfoThread.start();
        //发送消息的线程
        smt = new SendMsgThread(getInfoThread);
        smt.start();
        //设置发送的目的端口号
        getInfoThread.setTargetPort(Integer.parseInt("48899"));     
        smt.putMsg(getInfoCode);

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14

WIFI模块在接收到指令后，就会回复信息，以下的Handler就是针对回复过来的信息进行解析处理等操作。

//处理消息的Handler
    private Handler handler= new Handler() {
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case Tool.REC_Module:// 解析接收到的数据
                //设置发送的目的端口号
                getInfoThread.setTargetPort(Integer.parseInt("48899")); 
                getInfoThread.setMsgType(Tool.REC_OK);
                smt.putMsg(okCode);
                SetServer();
                SetDHCP();
                byte[] data = (byte[]) msg.obj;
                //将十进制的数据转化成十六进制数据
                String strTemp= Tool.bytesToHexString(data);
                //将十六进制的字符串去掉空格之后进行解析
                String strdecode=Tool.DecodeHex(strTemp.replace(" ", ""));
                //取出IP，Mac地址，模块名称
                decodeIP(strdecode);
                Toast.makeText(ConnectWifiActivity.this, "获得WIFI模块名称成功！"+ModuleName, Toast.LENGTH_SHORT).show();

                break;
            case Tool.REC_Server:
                byte[] dataServer = (byte[])msg.obj;
                //将十进制的数据转化成十六进制数据
                String strServer= Tool.bytesToHexString(dataServer);
                if("2b 6f 6b 0d 0a 0d 0a ".equals(strServer)){
                    Toast.makeText(ConnectWifiActivity.this, "设置服务器成功！", Toast.LENGTH_SHORT).show();

                }
                break;
            case Tool.REC_SSID:
                byte[] dataSSID=(byte[])msg.obj;
                Tool.bytesToHexString(dataSSID);
                decodeData(dataSSID);
                break;
            case Tool.REC_AT:
                byte[] dataID = (byte[]) msg.obj;
                //将十进制的数据转化成十六进制数据
                String strTempID= Tool.bytesToHexString(dataID);
                //将十六进制的字符串去掉空格之后进行解析
                String strdecodeID=Tool.DecodeHex(strTempID.replace(" ", ""));
                break;
            case Tool.REC_DHCP:
                byte[] dataDHCP = (byte[])msg.obj;
                //将十进制的数据转化成十六进制数据
                String strDHCP= Tool.bytesToHexString(dataDHCP);
                if("2b 6f 6b 0d 0a 0d 0a ".equals(strDHCP)){
                    Toast.makeText(ConnectWifiActivity.this, "设置DHCP网络参数成功！", Toast.LENGTH_SHORT).show();

                }
                break;
            default:
                byte[] data1 = (byte[]) msg.obj;
                //将十进制的数据转化成十六进制数据
                String strTemp1= Tool.bytesToHexString(data1);
                Toast.makeText(ConnectWifiActivity.this, strTemp1, Toast.LENGTH_SHORT).show();
                break;
            }
        }
    };
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

总结

　　凡是需要对WIFI模块发送指令的，就需要用到上述的两个线程类，还有一个对返回信息进行处理的Handler。只是发送的指令的code不一样，如上述表示的是搜索WIFI模块的十六进制的指令。不管WIFI模块在AP模式下还是STA模式，通信的最开始步骤都是先搜索模块，然后获得它的IP和Mac之后，立即回复+ok指令，就可以保持连接状态。

Demo下载

UDP通信发送指令Demo