精华内容
下载资源
问答
  • WLAN P2P 需要使用到 WifiP2pManager ,同时需要以下权限,这里面有一些是运行时权限,需要用户同意后才能使用。 <uses-sdk android:minSdkVersion="14" /> <uses-permission android:name="android.pe

    点对点传输(P2P)又是WLAN直连,他可以在没有中间接入点的情况下,通过 WLAN 进行直接互联。他有用户介入操作少,比蓝牙传输速度高等特点,对设备的要求仅仅为14,同时他又不占用wlan0网卡。

    WLAN P2P 需要使用到 WifiP2pManager ,同时需要以下权限,这里面有一些是运行时权限,需要用户同意后才能使用。

    <uses-sdk android:minSdkVersion="14" />
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    

    点对点传输(P2P)至少有两个有Wifi的设备,其中一个是Android,首先确定Android设备和另外一个设备是否支持P2P连接。把手机连接电脑运行 adb shell ip addr|grep p2p0 -A2有输出就带边可以使用,一般来说都可以使用。

    29: p2p0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc mq state DOWN group default qlen 1000
        link/ether 02:00:2d:63:a5:6b brd ff:ff:ff:ff:ff:ff
    

    注意看上面的输出,link/ether 02:00:2d:63:a5:6 为p2p的Mac地址,不同的设备之间使用Mac地址连接,所以首先要知道P2P(p2p0)的Mac地址,这个和wifi(wlan0)的地址不是同一个,在代码中需要使用下面方法获取。

    public static String getLocalMacAddress() {
        try {
            List<NetworkInterface> interfaces = Collections.list(NetworkInterface.getNetworkInterfaces());
            for (NetworkInterface ntwInterface : interfaces) {
    
                if (ntwInterface.getName().equalsIgnoreCase("p2p0")) {
                    byte[] byteMac = ntwInterface.getHardwareAddress();
                    if (byteMac == null) {
                        return null;
                    }
                    StringBuilder strBuilder = new StringBuilder();
                    for (int i = 0; i < byteMac.length; i++) {
                        strBuilder.append(String.format("%02X:", byteMac[i]));
                    }
    
                    if (strBuilder.length() > 0) {
                        strBuilder.deleteCharAt(strBuilder.length() - 1);
                    }
    
                    return strBuilder.toString();
                }
    
            }
        } catch (Exception e) {
            Log.d("Lecon", e.getMessage());
        }
        return null;
    }
    

    接下来看一下如何主动连接到p2p设备。

    使用方法

    首先通过 WifiP2pManager 的initialize初始化。

    val manager: WifiP2pManager? by lazy(LazyThreadSafetyMode.NONE) {
        getSystemService(Context.WIFI_P2P_SERVICE) as WifiP2pManager?
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        mChannel = manager?.initialize(this, mainLooper, null)
    }
    

    同时使用广播来接受各种P2P连接的状态变化。

    var mChannel: WifiP2pManager.Channel? = null
    var mReceiver: WiFiDirectBroadcastReceiver? = null
    
    private val mWifiP2pManager: WifiP2pManager by lazy(LazyThreadSafetyMode.NONE) {
        getSystemService(Context.WIFI_P2P_SERVICE) as WifiP2pManager
    }
    
    private val mIntentFilter: IntentFilter by lazy(LazyThreadSafetyMode.NONE) {
        IntentFilter().apply {
            addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION)
            addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION)
            addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION)
            addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION)
        }
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        mChannel = mWifiP2pManager.initialize(this, mainLooper, null)
        mReceiver = WiFiDirectBroadcastReceiver(mWifiP2pManager, mChannel, this)
    
    class WiFiDirectBroadcastReceiver(
            private val mManager: WifiP2pManager?,
            private val mChannel: WifiP2pManager.Channel?,
            private val mActivity: MainActivity
    ) : BroadcastReceiver() {
    		override fun onReceive(context: Context, intent: Intent) {
    		    val action = intent.action
    		    if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION == action) {
    				// 当 WLAN P2P 在设备上启用或停用时广播
    				} else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION == action) {
    				// 调用 requestPeers() 方法,以获得当前所发现对等设备的列表。
    				// 同时 在这里调用 connect 方法连接对方机器
    				} else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION == action) {
    				// 当设备的 WLAN 连接状态更改时广播。
    				// 连接对方机器成功或者失败都会在这里回调
    				} else if (WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION == action) {
    				// 当设备的详细信息(例如设备名称)更改时广播
    				}
    }
    

    上边哪一些代码可以当成主动发起扫描之后的回调,使用广播进行回调说起来真的是挺复杂的,但是仔细想想,操作硬件设备本来就是跨进程的,而且这个还是长时间耗时操作,系统通过广播回调也是合理的。

    到现在位置,可以把以上代码运行到Android上,他就可以最为P2P连接的被连接端。

    连接到设备

    连接到设备的时候,首先要确定对方设备的mac地址,上面的两种方法是针对于Android设备的。一种是adb方式,一种是代码获取。

    接下来要发现设备:

    mWifiP2pManager.discoverPeers(mChannel, object : WifiP2pManager.ActionListener {
        override fun onSuccess() {
            Toast.makeText(this@MainActivity, "已发现设备,准备连接", Toast.LENGTH_SHORT).show()
        }
    
        override fun onFailure(reasonCode: Int) {
    
        }
    })
    

    返现设备之后,通过广播回调的 WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION 事件获取设备列表。找到列表中的设备与被连接设备mac地址一致的,确保我们被连接机器已经就绪。

    mManager?.requestPeers(mChannel) { peers ->
        for (device in peers.deviceList) {
            if (mac != null && mac.equals(device.deviceAddress, ignoreCase = true)) {
                connectToDevice(device)
            }
        }
    }
    

    接下来就可以连接设备了!

    val config = WifiP2pConfig()
    config.deviceAddress = "被连接设备的Mac地址"
    mManager?.connect(mChannel, config, object : WifiP2pManager.ActionListener {
        override fun onSuccess() {
            Toast.makeText(mActivity, "连接成功", Toast.LENGTH_SHORT).show()
        }
    
        override fun onFailure(reason: Int) {}
    })
    

    如果被连接设备是Android,你应该能看到一个连接提示,点击接受这样两台设备之间就连接成功了,通过WIFI两个设备可以实现近场通讯。

    通信

    通信之前需要知道被连接设备的ip地址。如果是android设备,在被连接设备执行adb shell ip addr|grep p2p0 -A4 就可以看到,这也是检测是否连接成功的方法。代码获取仍然要获取p2p0网卡的,wlan0获取的ip地址不能用于这里。

    public static String getLocalIp() {
        try {
            List<NetworkInterface> interfaces = Collections
                    .list(NetworkInterface.getNetworkInterfaces());
    
            for (NetworkInterface intf : interfaces) {
                if (!intf.getName().contains("p2p0"))
                    continue;
    
                List<InetAddress> addrs = Collections.list(intf
                        .getInetAddresses());
                for (InetAddress addr : addrs) {
                    if (!addr.isLoopbackAddress()) {
                        return addr.getHostAddress().toUpperCase();
                    }
                }
            }
    
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return "";
    }
    

    如果被连接设备是一台服务器(在Android里面搭建一台服务器也是可以的),在这台设备上可以用okhttp等框架进行网络访问,或者使用socket进行传输。
    现在两个手机(P2P)设备之间就可以同过WLAN直接通信了。

    下面是源代码:https://github.com/leconio/WifiDircetP2PDemo

    展开全文
  • 该文件中包含有基于STM32单片机和WiFi模块开发的与外界进行数据传输的代码. stm32 wifi
  • Android实现Wifi数据传输

    热门讨论 2015-03-06 13:48:19
    两部手机连接wifi后,通过socket进行数据传输 说明: 测试需要两部安卓手机A,B。A手机创建WIFI热点作为服务器,B手机连接A手机WIFI热点,作为客户端。 //A手机服务器 接收数据步骤:1点击创建Wifi热点2点击"turn_on_...
  • STM32单片机通过ESP8266WiFi模块与Android APP实现数据传输,包含STM32单片机的源代码和手机APP的源代码,里面也有apk文件可以直接安装使用。代码全部测试过,都可以正常的运行和使用。
  • 通过对Android的构架,利用其WiFi实现短距离数据传输
  • 应公司要求开发了一个androidAPP主要用来对WIFI模块进行一些参数的配置。主要包括WIFI模块的数据读取,配置参数的下发,系统时间的下发。WIFI模块用的是HLK-RM04
  • 选择 正点原子STM32单片机,利用NRF24L01模块进行无线传输,在单片机中进行ADC转换,以及比较最大最小值并显示出来,最后在LCD显示屏上显示探测出的温度示数并显示图像。
  • wifi 连接/数据传输

    2018-05-24 21:21:08
    1) 安装两个手机上面 2)一个手机打开wifi 热点 作为服务端,点击receiver 作为,准备接受数据 3)一个手机链接 热点 ,点击 ...4)实现 WiFi热点 socket 数据通信,具体 数据传输 看log 信息,具体实现请看代码及注释
  • 单片机 串行连接 wifi模块 WIFI传输数据
  • 在QT平台下实现了基于TCPIP协议实现WIFI进行数据的无线传输,可通过网线进行数据传输,也可使用WiFi进行数据无线传输
  • WiFI底层是如何传输数据的呢

    千次阅读 2020-04-26 00:11:37
    当然得意于它的数据通信机制。 Wi-Fi(发音: /ˈwaɪfaɪ/,法语发音:/wifi/),在中文里又称作“行动热点”, 是Wi-Fi联盟制造商的商标做为产品的品牌认证,是一个创建于IEEE 802.11标准的无线局域网技术。 ...

    自从wifi诞生以来,它备受人们的喜爱,由于它亲民的价格,非常惹人爱。那么为什么它能吸引这么多的追随者呢? 当然得意于它的数据通信机制。
    Wi-Fi(发音: /ˈwaɪfaɪ/,法语发音:/wifi/),在中文里又称作行动热点
    Wi-Fi联盟制造商的商标做为产品的品牌认证,是一个创建于IEEE 802.11标准无线局域网技术

    • 所以接下来为大家介绍一下 ·IEEE 802.11标准及其通信机制的核心点

    IEEE802.11的发展

    如下图所示,为wifi发展的总结表,可以看出来随着IEEE802.11标准的修订,WIFI的传输速率越来越快,于2019年发布的IEEE802.11ax(wifi6)速度可达10.53Gbit/s,那么躺在家中看蓝光电影也不会卡顿了。
    在这里插入图片描述

    IEEE802.11 通信机制

    IEEE802.11 标准主要是针对于网络通信七层协议中的物理层和数据链路层的一部分如MAC (Media Access Control)层,今天我么就研究一下它的MAC层主要通信机制。

    • IEEE802.11 协议簇 MAC 层 DCF, PCF, EDCF 等通信机制;
      图解通信机制:
      在这里插入图片描述
      IEEE802.11的MAC协议定义了 分布式协调功能(DCF,Distributed CoordinationFunction)点协调功能(PCF,Point Coordination Function)两种接入机制。
      - 其中DCF是基于竞争的接入方法,所有的节点竞争接入。
      - PCF是无竞争的,节点可以被分配在特定的时间单独使用媒介。
      - DCF是一种基本的访问协议,而PCF是一种可选功能。
         为了网络中各种不同的用户也不提供不同的Qos保证,DCF对所有业务只能尽力交付(Best-effort),没有Qos保证。所以IEEE801.11e中对DCF进行了补充,提出了EDCF(Ehance Distributed Coordination Function)机制,满足用户业务的Qos要求。
      EDCF实质上是一种基于优先级区分的Qos方案。
        我们可以由以下两图看出,在EDCF中不同优先级的业务进入不同的接入队列等待发送,彼此之间竞争发送机会,竞争规则符合DCF个STA竞争信道的规则。我们通过给i个队列设定不同的参数来实现队列优先级的区别,如:帧间间隔,退避窗口的最小值和坚持因子。
      在这里插入图片描述
      在这里插入图片描述

    如何实现通信机制

    • DCF通信主要有 载波侦听机制多路访问冲突避免、 帧间间隔机制、 随机退避机制和基于 RTS/CTS 的四次握手核心机制。

    1. 载波侦听机制

    • 物理载波侦听
    • 虚拟载波侦听(NAV) 虚拟载波侦听主要有帧封装中的Duration字段来实现。
    • 区分CSMA/CD和CMSA/CA
      两者区别

    2. 帧间间隔机制在这里插入图片描述

    3. 随机退避机制

    在这里插入图片描述

    4. RTS/CTS 的四次握手核心机制

    IEEE802.11协议中,有一个可设置的参数,这个参数叫RTS阈值,如果要传送的帧的大小比这个RTS阈值高,就会启动RTS/CTS机制即使用RTS/CTS/DATA/ACK的 传送方式; 如果帧的大小比这个RTS阈值低,则只会使用DATA/ACK的传输方式。RTS/CTS机制解决了隐藏终端和暴露终端的问题。

    在这里插入图片描述

    `注意:在RTS和CTS帧中Duration字段封装了NAV(退避时间),会广播放送给所有接入争端,更新自己的NAV值`

    给大家讲一个小故事便于理解DCF传输机制:
    现有小明,小红,小白三个人需要找导师讨论项目进展情况。此刻他们需要同一时间竞争和导师讨论的时间段。(导师只能一个时间段和一个同学讨论)。
    假设每个人都拥有两个计时器:等待计时器和随机退避计时器;

    1. 他们三个人需要发RTS帧预约时间。
      1.1 RTS中包括自己需要和老师讨论的时间长度)。
      1.2 RTS帧所有同学都可以收到。
    2. 假设小红等待SIFS间隔后收到导师CTS帧,证明两者已达成约定,可以去讨论事物了。
      2.1 CTS中也包括自己需要和老师讨论的时间长度。
      2.2 小明和小白更新自己的等待计时器并且冻结自己的随机退避计时器。
    3. 当小红讨论结束之后发送ACK帧,小明和小白的等待计时器归零,解冻随机退避计时器
      3.1 此刻小明和小白的随机退避计时器开始递减,谁先退为零且DICF间隔都无他人占用时间,就可给导师发送RTS帧了
    4. 重复整个流程

    在这里插入图片描述

    3. 了解 IEEE802.11n 中 A-MSDU 和 A-MPDU 两种帧的聚合方式;
    4. 了解 IEEE802.11ax 中 OFDMA, MU-MIMO, QAM 等关键通信技术;
    5. 了解边缘计算下 VR 组播视频的传输及物联网 RFID,无线传感网络等相关知识。

    持续更新中,有问题的地方需要大家指正。

    展开全文
  • Android WiFi开发教程(三)——WiFi热点数据传输

    万次阅读 多人点赞 2016-09-07 16:15:11
    本篇接着简单介绍手机上如何通过WiFi热点进行数据传输。跟蓝牙通讯一样,WiFi热点数据传输也是要运用到Socket。这里我创建了两个线程ConnectThread和ListenerThread,分别去处理数据传输和监听连接。ConnectThread**...

    在上一篇文章中介绍了WiFi的搜索和连接,如果你还没阅读过,建议先阅读上一篇Android WiFi开发教程(二)——WiFi的搜索和连接。本篇接着简单介绍手机上如何通过WiFi热点进行数据传输。

    跟蓝牙通讯一样,WiFi热点数据传输也是要运用到Socket。这里我创建了两个线程ConnectThread和ListenerThread,分别去处理数据传输和监听连接。

    ConnectThread

    **
     * 连接线程
     * Created by 坤 on 2016/9/7.
     */
    public class ConnectThread extends Thread{
    
        private final Socket socket;
        private Handler handler;
        private InputStream inputStream;
        private OutputStream outputStream;
    
        public ConnectThread(Socket socket, Handler handler){
            setName("ConnectThread");
            this.socket = socket;
            this.handler = handler;
        }
    
        @Override
        public void run() {
            if(socket==null){
                return;
            }
            handler.sendEmptyMessage(MainActivity.DEVICE_CONNECTED);
            try {
                //获取数据流
                inputStream = socket.getInputStream();
                outputStream = socket.getOutputStream();
    
                byte[] buffer = new byte[1024];
                int bytes;
                while (true){
                    //读取数据
                    bytes = inputStream.read(buffer);
                    if (bytes > 0) {
                        final byte[] data = new byte[bytes];
                        System.arraycopy(buffer, 0, data, 0, bytes);
    
                        Message message = Message.obtain();
                        message.what = MainActivity.GET_MSG;
                        Bundle bundle = new Bundle();
                        bundle.putString("MSG",new String(data));
                        message.setData(bundle);
                        handler.sendMessage(message);
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 发送数据
         */
        public void sendData(String msg){
            if(outputStream!=null){
                try {
                    outputStream.write(msg.getBytes());
                    Message message = Message.obtain();
                    message.what = MainActivity.SEND_MSG_SUCCSEE;
                    Bundle bundle = new Bundle();
                    bundle.putString("MSG",new String(msg));
                    message.setData(bundle);
                    handler.sendMessage(message);
                } catch (IOException e) {
                    e.printStackTrace();
                    Message message = Message.obtain();
                    message.what = MainActivity.SEND_MSG_ERROR;
                    Bundle bundle = new Bundle();
                    bundle.putString("MSG",new String(msg));
                    message.setData(bundle);
                    handler.sendMessage(message);
                }
            }
        }
    }

    在ConnectThread的构造中,传入了Socket和Handler。Socket用来获取数据以及发送数据,Handler用来更新UI了。在run方法中,我们从Socket中获取到了输入流和输出流,然后循环地读取InputStream的数据,当读取到数据时,则通过Handler将数据更新到UI上。在sendData方法中主要是通过OutputStream写入数据,然后将写入结果通过Handler更新到UI上。

    ListenerThread

    /**
     * 监听线程
     * Created by 坤 on 2016/9/7.
     */
    public class ListenerThread extends Thread{
    
        private ServerSocket serverSocket = null;
        private Handler handler;
        private int port;
        private Socket socket;
    
        public ListenerThread(int port, Handler handler){
            setName("ListenerThread");
            this.port = port;
            this.handler = handler;
            try {
                serverSocket=new ServerSocket(port);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    
        @Override
        public void run() {
            while (true){
                try {
                    //阻塞,等待设备连接
                    socket = serverSocket.accept();
                    Message message = Message.obtain();
                    message.what = MainActivity.DEVICE_CONNECTING;
                    handler.sendMessage(message);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public Socket getSocket() {
            return socket;
        }
    }

    监听线程处理的逻辑就比较简单,通过端口号获取ServerSocket后调用accept()阻塞线程,直到有设备连接上后就通过Handler更新UI。这里需要注意的是连接上的设备的端口号必须与这里的端口号相同。接着我们看看Hander获取到消息后做了哪些处理。

    private Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case DEVICE_CONNECTING:
                        connectThread = new ConnectThread(listenerThread.getSocket(),handler);
                        connectThread.start();
                        break;
                        ... ...
                }
            }
        };

    可以看到Handler获取到数据后,通过listenerThread.getSocket()将获取到Socket和handler一同创建了ConnectThread实例。

    接下来就是用这两个线程来处理数据传输了。

     @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            ... ...
            listenerThread = new ListenerThread(PORT, handler);
            listenerThread.start();
        }

    在onCreate中我们创建ListenerThread并启动它,让它监听是否有设备连接上来。当然这里需要先开启WiFi热点后才会有设备连接上来。这是开启热点并等待设备连接的情况。当然我们也可以主动去连接其他开启着热点的设备。

    在监听WiFi连接情况的广播接收者中加入下面的代码

    if (info.getState().equals(NetworkInfo.State.CONNECTED)) {
                        WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
                        final WifiInfo wifiInfo = wifiManager.getConnectionInfo();
                        text_state.setText("已连接到网络:" + wifiInfo.getSSID());
    
                        if (wifiInfo.getSSID().equals(WIFI_HOTSPOT_SSID)) {
                            //如果当前连接到的wifi是热点,则开启连接线程
                            new Thread(new Runnable() {
                                @Override
                                public void run() {
                                    try {
                                        ArrayList<String> connectedIP = getConnectedIP();
                                        for (String ip : connectedIP) {
                                            if (ip.contains(".")) {
    
                                                Socket socket = new Socket(ip, PORT);
                                                connectThread = new ConnectThread(socket, handler);
                                                connectThread.start();
                                            }
                                        }
    
                                    } catch (IOException e) {
                                        e.printStackTrace();
                                    }
                                }
                            }).start();
                        }
                    } else {
                        ...
                        }
                }

    这里本地固定了其他设备WiFi热点的SSID,如果当前连接的WiFi的SSID跟我们之前保存的SSID一致,则证明我们连上了我们需要的WiFi热点。然后通过getConnectedIP()获取WiFi热点的IP地址,通过这个IP地址和端口号创建一个Socket,然后创建ConnectThread来处理数据传输。到这里我们可以看到,PORT和SSID这两个数据是需要两个设备事先协议好的。

    最后再看看Handler完整的代码

    private Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case DEVICE_CONNECTING:
                        connectThread = new ConnectThread(listenerThread.getSocket(),handler);
                        connectThread.start();
                        break;
                    case DEVICE_CONNECTED:
                        textview.setText("设备连接成功");
                        break;
                    case SEND_MSG_SUCCSEE:
                        textview.setText("发送消息成功:" + msg.getData().getString("MSG"));
                        break;
                    case SEND_MSG_ERROR:
                        textview.setText("发送消息失败:" + msg.getData().getString("MSG"));
                        break;
                    case GET_MSG:
                        textview.setText("收到消息:" + msg.getData().getString("MSG"));
                        break;
                }
            }
        };

    至此,WiFi热点数据传输也就介绍完了。如果有什么疑问,欢迎和本人一起探讨。

    最后附上源码地址

    ——————————————————————————————

    github

    csdn

    展开全文
  • Android手机通过wifi进行数据传输(二)

    分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow

    也欢迎大家转载本篇文章。分享知识,造福人民,实现我们中华民族伟大复兴!

                    上文接 Android手机通过wifi进行数据传输(一)
    本文参照自:
    以下是源码文件
    原文件Constant.java
    package edu.cdut.robin;

    public class Constant {
    public final static String END="end";
    public final static String HOST_SPOT_SSID="HotSpotRobin";
    public final static String HOST_SPOT_PASS_WORD="123456789";
    }

     源码文件1
    QuickTransferActivity.java文件
    
      

    package edu . cdut . robin ;
    import java . io . BufferedReader ;
    import java . io . IOException ;
    import java . io . InputStreamReader ;
    import java . io . PrintWriter ;
    import java . net . InetAddress ;
    import java . net . ServerSocket ;
    import java . net . Socket ;
    import java . net . UnknownHostException ;
    import edu . cdut . robin . hotspot . WifiAdmin ;
    import edu . cdut . robin . hotspot . WifiApAdmin ;
    import android . app . Activity ;
    import android . content . BroadcastReceiver ;
    import android . content . Context ;
    import android . content . Intent ;
    import android . content . IntentFilter ;
    import android . net . DhcpInfo ;
    import android . net . wifi . WifiInfo ;
    import android . net . wifi . WifiManager ;
    import android . os . Bundle ;
    import android . os . Handler ;
    import android . util . Log ;
    import android . view . View ;
    import android . widget . Button ;
    import android . widget . TextView ;
    public class QuickTransferActivity extends Activity implements DisplayMesage , ITransferResult {
        /** Called when the activity is first created. */
        TextView content ;
        Button mBtn3 , mBtn4 ;
        WifiAdmin mWifiAdmin ;
        WifiApAdmin wifiAp ;
        Context context ;
        final static String TAG = "robin" ;
        @Override
        public void onCreate ( Bundle savedInstanceState ) {
            super . onCreate ( savedInstanceState );
            setContentView ( R . layout . main );
            content = ( TextView ) this . findViewById ( R . id . content );
            mBtn3 = ( Button ) findViewById ( R . id . button3 );
            mBtn4 = ( Button ) findViewById ( R . id . button4 );
            mBtn3 . setText ( "点击连接Wifi" );
            mBtn4 . setText ( "点击创建Wifi热点" );
            context = this ;
            mBtn3 . setOnClickListener ( new Button . OnClickListener () {
                @Override
                public void onClick ( View v ) {
                    // TODO Auto-generated method stub
                    mWifiAdmin = new WifiAdmin ( context ) {
                        @Override
                        public void myUnregisterReceiver ( BroadcastReceiver receiver ) {
                            // TODO Auto-generated method stub
                            unregisterReceiver(receiver);
                        }
                        @Override
                        public Intent myRegisterReceiver ( BroadcastReceiver receiver , IntentFilter filter ) {
                            // TODO Auto-generated method stub
                            registerReceiver(receiver, filter);
                            return null;
                        }
                        @Override
                        public void onNotifyWifiConnected () {
                            // TODO Auto-generated method stub
                            Log.v(TAG, "have connected success!");
                            Log.v(TAG, "###############################");
                        }
                        @Override
                        public void onNotifyWifiConnectFailed () {
                            // TODO Auto-generated method stub
                            Log.v(TAG, "have connected failed!");
                            Log.v(TAG, "###############################");
                        }
                    };
                    mWifiAdmin . openWifi ();
                    mWifiAdmin . addNetwork ( mWifiAdmin . createWifiInfo ( Constant . HOST_SPOT_SSID , Constant . HOST_SPOT_PASS_WORD ,
                            WifiAdmin . TYPE_WPA ));
                }
            });
            mBtn4 . setOnClickListener ( new Button . OnClickListener () {
                @Override
                public void onClick ( View v ) {
                    // TODO Auto-generated method stub
                    wifiAp = new WifiApAdmin ( context );
                    wifiAp . startWifiAp ( Constant . HOST_SPOT_SSID , Constant . HOST_SPOT_PASS_WORD );
                }
            });
        }
        public void onClick ( View view ) {
            if ( view . getId () == R . id . button1 ) {
                WifiManager wifiManage = ( WifiManager ) getSystemService ( Context . WIFI_SERVICE );
                DhcpInfo info = wifiManage . getDhcpInfo ();
                WifiInfo wifiinfo = wifiManage . getConnectionInfo ();
                String ip = intToIp ( wifiinfo . getIpAddress ());
                String serverAddress = intToIp ( info . serverAddress );
                new Sender ( serverAddress , this , this ). start ();
                Log . w ( "robin" , "ip:" + ip + "serverAddress:" + serverAddress + info );
            } else if ( view . getId () == R . id . button2 ) {
                Receiver service = new Receiver ( this , this );
                service . start ();
            }
        }
        Handler handler = new Handler ();
        StringBuffer strBuffer = new StringBuffer ();
        public void displayMesage ( final String msg ) {
            Runnable r = new Runnable () {
                public void run () {
                    // TODO Auto-generated method stub
                    if (strBuffer.length() > 1024) {
                        strBuffer.delete(0, 100);
                    }
                    strBuffer.append(msg + "\n");
                    content.setText(strBuffer.toString());
                    content.invalidate();
                }
            };
            handler.post(r);
        }
        // 将获取的int转为真正的ip地址,参考的网上的,修改了下
        private String intToIp ( int i ) {
            return ( i & 0xFF ) + "." + (( i >> 8 ) & 0xFF ) + "." + (( i >> 16 ) & 0xFF ) + "." + (( i >> 24 ) & 0xFF );
        }
        @Override
        public void appendMesage ( String msg ) {
            displayMesage ( msg );
        }
        @Override
        public void onResult ( int result , long size ) {
            if ( wifiAp != null ) {
                wifiAp . closeWifiAp ( context );
            }
            // TODO Auto-generated method stub
            closeWifi();
            Runnable r = new Runnable() {
                @Override
                public void run () {
                    // TODO Auto-generated method stub
                    displayMesage("try to open wifi");
                    openWifi();
                    displayMesage("open wifi end");
                }
            };
            handler . postDelayed ( r , 30 * 1000 );
        }
        WifiManager mWifiManager ;
    // 打开WIFI
        public void openWifi() {
            if(mWifiAdmin!=null){
                mWifiAdmin.openWifi();
                return;
            }
            if (mWifiManager == null) {
                mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
            }
            if (!mWifiManager.isWifiEnabled()) {
                mWifiManager.setWifiEnabled(true);
            }
        }
    // 关闭WIFI
        public void closeWifi() {
            if(mWifiAdmin!=null){
                mWifiAdmin.closeWifi();
                return;
            }
            if (mWifiManager == null) {
                mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
            }
            if (mWifiManager.isWifiEnabled()) {
                mWifiManager.setWifiEnabled(false);
            }
        }
    }
    interface DisplayMesage {
        void displayMesage ( String msg );
        void appendMesage ( String msg );
    }
    interface ITransferResult {
        void onResult ( int result , long size );
    }
    class Receiver extends Thread {
        private static BufferedReader in ;
        DisplayMesage console ;
        ITransferResult transferResult ;
        Receiver ( DisplayMesage console , ITransferResult transferResult ) {
            super ();
            this . console = console ;
            this . transferResult = transferResult ;
        }
        public void run () {
            try {
                ServerSocket socketService = new ServerSocket ( 3358 );
                Log . i ( "robin" , "waiting a connection from the client" + socketService );
                Socket sock = socketService . accept ();
                String hostAddress = sock . getLocalAddress (). getHostAddress ();
                String inetAddress = sock . getInetAddress (). getHostAddress ();
                Log . w ( "robin" , "local:" + hostAddress + "| inetAddress" + inetAddress + "|" + sock . getRemoteSocketAddress ());
                Log . w ( "robin" , "local name:" + sock . getLocalAddress (). getHostName () + "| inetAddress"
                        + sock . getInetAddress (). getHostName () + "|" + InetAddress . getLocalHost (). getHostAddress ());
                in = new BufferedReader ( new InputStreamReader ( sock . getInputStream ()));
                String line ;
                boolean flag = true ;
                long count = 0 ;
                long time = System . currentTimeMillis ();
                do {
                    line = in . readLine ();
                    if ( flag ) {
                        console . displayMesage ( "Recevie:" + line );
                        flag = false ;
                    }
                    count = count + line . length ();
                    if ( count % 1024 == 0 ) {
                        console . displayMesage ( "Recevied:" + (( count << 1 ) >> 10 ) + "kB data" );
                    }
                } while (! Constant . END . equals ( line ));
                Log . w ( "robin" , "you input is :" + line );
                long t = System . currentTimeMillis () - time ;
                if ( t == 0 )
                    t = 1 ;
                count = count << 1 ;
                long rate = (( count / t ) * 1000 ) / 1024 ;
                count = count >> 10 ;
                console . displayMesage ( "Recevied:" + count + "kB data" + " in " + t + " ms" + " at rate:" + rate
                        + " kB/second" );
                Log . i ( "robin" , "exit the app" );
                sock . close ();
                socketService . close ();
                transferResult . onResult ( 1 , count );
            } catch ( Exception e ) {
                e . printStackTrace ();
            }
        }
    }
    class Sender extends Thread {
        DisplayMesage console ;
        String serverIp ;
        ITransferResult transferResult ;
        Sender ( String serverAddress , DisplayMesage console , ITransferResult transferResult ) {
            super ();
            serverIp = serverAddress ;
            this . console = console ;
            this . transferResult = transferResult ;
        }
        public void run () {
            Socket sock = null ;
            PrintWriter out ;
            try {
                // 声明sock,其中参数为服务端的IP地址与自定义端口
                sock = new Socket(serverIp, 3358);
                Log.w("robin", "I am try to writer" + sock);
            } catch (UnknownHostException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            char data[] = new char[1024 * 10];
            for (int i = 0; i < data.length; i++) {
                data[i] = (char) i;
            }
            try {
                if (sock != null) {
                    // 声明输出流out,向服务端输出“Output Message!!”
                    final String msg = "Hello,this is robin!!";
                    Log.w("robin", "try to writer");
                    out = new PrintWriter(sock.getOutputStream(), true);
                    StringBuffer strBuffer = new StringBuffer();
                    strBuffer.append(msg);
                    String str = msg;
                    for (int i = 0; i < 1024; i++) {
                        if (i != 0) {
                            str = msg + System.currentTimeMillis() + "|";
                            out.write(data);
                        }
                        out . println ( str );
                        Log . w ( "robin" , str );
                        if ( i == 0 ) {
                            console . displayMesage ( "send message...." );
                        } else if ( i % 100 == 0 ) {
                            console . displayMesage ( "send message " + i + " success!" );
                        }
                        if ( strBuffer . length () > 1024 ) {
                            strBuffer . delete ( 0 , strBuffer . length ());
                        }
                    }
                    out . println ( Constant . END );
                    out . flush ();
                }
                transferResult . onResult ( 1 , 1 );
            } catch

    我们对Markdown编辑器进行了一些功能拓展与语法支持,除了标准的Markdown编辑器功能,我们增加了如下几点新功能,帮助你用它写博客:

    1. 全新的界面设计 ,将会带来全新的写作体验;
    2. 在创作中心设置你喜爱的代码高亮样式,Markdown 将代码片显示选择的高亮样式 进行展示;
    3. 增加了 图片拖拽 功能,你可以将本地的图片直接拖拽到编辑区域直接展示;
    4. 全新的 KaTeX数学公式 语法;
    5. 增加了支持甘特图的mermaid语法1 功能;
    6. 增加了 多屏幕编辑 Markdown文章功能;
    7. 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能,功能按钮位于编辑区域与预览区域中间;
    8. 增加了 检查列表 功能。

    功能快捷键

    撤销:Ctrl/Command + Z
    重做:Ctrl/Command + Y
    加粗:Ctrl/Command + B
    斜体:Ctrl/Command + I
    标题:Ctrl/Command + Shift + H
    无序列表:Ctrl/Command + Shift + U
    有序列表:Ctrl/Command + Shift + O
    检查列表:Ctrl/Command + Shift + C
    插入代码:Ctrl/Command + Shift + K
    插入链接:Ctrl/Command + Shift + L
    插入图片:Ctrl/Command + Shift + G

    合理的创建标题,有助于目录的生成

    直接输入1次#,并按下space后,将生成1级标题。
    输入2次#,并按下space后,将生成2级标题。
    以此类推,我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。

    如何改变文本的样式

    强调文本 强调文本

    加粗文本 加粗文本

    标记文本

    删除文本

    引用文本

    H2O is是液体。

    210 运算结果是 1024.

    插入链接与图片

    链接: link.

    图片: Alt

    带尺寸的图片: Alt

    当然,我们为了让用户更加便捷,我们增加了图片拖拽功能。

    如何插入一段漂亮的代码片

    博客设置页面,选择一款你喜欢的代码片高亮样式,下面展示同样高亮的 代码片.

    // An highlighted block var foo = 'bar'; 

    生成一个适合你的列表

    • 项目
      • 项目
        • 项目
    1. 项目1
    2. 项目2
    3. 项目3
    • 计划任务
    • 完成任务

    创建一个表格

    一个简单的表格是这么创建的:

    项目Value
    电脑$1600
    手机$12
    导管$1

    设定内容居中、居左、居右

    使用:---------:居中
    使用:----------居左
    使用----------:居右

    第一列第二列第三列
    第一列文本居中第二列文本居右第三列文本居左

    SmartyPants

    SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如:

    TYPEASCIIHTML
    Single backticks'Isn't this fun?'‘Isn’t this fun?’
    Quotes"Isn't this fun?"“Isn’t this fun?”
    Dashes-- is en-dash, --- is em-dash– is en-dash, — is em-dash

    创建一个自定义列表

    Markdown
    Text-to- HTML conversion tool
    Authors
    John
    Luke

    如何创建一个注脚

    一个具有注脚的文本。2

    注释也是必不可少的

    Markdown将文本转换为 HTML

    KaTeX数学公式

    您可以使用渲染LaTeX数学表达式 KaTeX:

    Gamma公式展示 Γ ( n ) = ( n − 1 ) ! ∀ n ∈ N \Gamma(n) = (n-1)!\quad\forall n\in\mathbb N Γ(n)=(n1)!nN 是通过欧拉积分

    Γ ( z ) = ∫ 0 ∞ t z − 1 e − t d t &ThinSpace; . \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,. Γ(z)=0tz1etdt.

    你可以找到更多关于的信息 LaTeX 数学表达式here.

    新的甘特图功能,丰富你的文章

    gantt
            dateFormat  YYYY-MM-DD
            title Adding GANTT diagram functionality to mermaid
            section 现有任务
            已完成               :done,    des1, 2014-01-06,2014-01-08
            进行中               :active,  des2, 2014-01-09, 3d
            计划一               :         des3, after des2, 5d
            计划二               :         des4, after des3, 5d
    
    • 关于 甘特图 语法,参考 这儿,

    UML 图表

    可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图::

    张三 李四 王五 你好!李四, 最近怎么样? 你最近怎么样,王五? 我很好,谢谢! 我很好,谢谢! 李四想了很长时间, 文字太长了 不适合放在一行. 打量着王五... 很好... 王五, 你怎么样? 张三 李四 王五

    这将产生一个流程图。:

    链接
    长方形
    圆角长方形
    菱形
    • 关于 Mermaid 语法,参考 这儿,

    FLowchart流程图

    我们依旧会支持flowchart的流程图:

    • 关于 Flowchart流程图 语法,参考 这儿.

    导出与导入

    导出

    如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ,生成一个.md文件或者.html文件进行本地保存。

    导入

    如果你想加载一篇你写过的.md文件或者.html文件,在上方工具栏可以选择导入功能进行对应扩展名的文件导入,
    继续你的创作。


    1. mermaid语法说明 ↩︎

    2. 注脚的解释 ↩︎

    展开全文
  • ESP32+WiFi+UART数据传输测试

    千次阅读 2021-05-14 20:06:22
    使用ESP32在服务器与下位机之间传输数据,整体的流程图如下所示。 如图所示,下位机与ESP通过串口连接,ESP32启动后直接和路由器连接,连接成功后就能在服务器与下位机之间传输数据了。 开发环境 硬件环境:下...
  • Python操作wifi进行数据传输

    千次阅读 2019-10-10 15:18:24
    1. 查询无线网卡、可用 wifi,并连接到指定 wifi def lianjie_wifi(wifissid,wifi_passwd): wifi=PyWiFi() ifaces=wifi.interfaces()[0]#取第一个网卡 print(ifaces.name()) #输出无线网卡名称 ifaces....
  • stm32 esp8266WiFi模块 自动连接WiFi,服务器并传输数据
  • ESP866WiFi模块进行数据传输的程序

    千次阅读 2020-06-11 16:52:45
    图中将ESP8266WIFi模块工作在STA模式下(即连接一个WiFi),上位机软件与ESP8266WiFi模块之间建立TCP/IP协议进行数据传输,STM32单片机与ESP8266WiFi模块之间通过串口进行数据传输。ESP8266WiFi模块的作用就是将...
  • ESP8266 STM32程序实现wifi透传数据 正常数据透传测试与电脑通讯ok,需设置正确IP地址与端口。
  • WiFi热点数据传输DEMO

    2017-10-11 22:12:09
    Android WiFi开发教程 ——WiFi热点数据传输 http://blog.csdn.net/a1533588867/article/category/6406108
  • wifi数据传输APP操作小结

    万次阅读 2017-07-31 09:24:33
    前期操作的项目一直是通过串口进行有线连接。目前客户客户需求,需要进行WIFI通讯,故总结技术要点如下。
  • KB3070 WIFI DTU(Data Terminal Unit)是采用高可靠性ARM7处理器和WIFI的无线数据传输终端。基于Wifi数据传输具有高速、传输稳定、可靠等特点,KB3070 WIFI DTU 在无人值守、远程设备监控、远程数据采集、远程抄表...
  • Android Wifi热点数据传输Socket 通信示例源码
  • 可视门铃音频、视频数据WIFI传输控制板功能概述: 该设计基于摄像头OV788 实现通过 Wi-Fi:registered: 传输音频和视频数据的实时流功能。CC3200 Wi-Fi 无线微控制器可支持 RTP 视频流和 Wi-Fi 连接的单芯片实施,通过...
  • WIfi Socket数据传输

    千次阅读 2017-06-28 18:48:14
    在同一个局域网中我们是可以利用Socket进行通信的,所以当两台手机通过wifi连接的时候,并可以通过socket进行通信了。
  • wifi进行数据传输DEMO
  • WifiFileTransfer 项目地址:leavesC/WifiFileTransfer ...在我的上一篇文章:Android 实现无网络传输文件,我介绍了通过 Wifi Direct(Wifi 直连)实现 Android 设备之间进行文件传输的方法,可以在无移动网络...
  • 实现了Android设备之间通过Wifi传输文件的功能
  • C#写的上位机,能够控制多台小车,我没有Debug过,按键后来也没有写完,但是里面的基础代码写完了。能够实现同时连接多个服务器进行文件传输
  • 基于arduino的WiFi无线传输

    千次阅读 多人点赞 2020-06-20 19:54:19
    esp8266是wifi串口模块,功能简单来讲就是:从wifi接收到数据,串口输出;从串口接收数据wifi输出数据。 首先介绍esp8266三个模式 1、串口无线 WIFI(COM-AP) 串口无线 WIFI(COM-AP)模式,模块作为无线 WIFI ...
  • 想要制作一个助眠系统的毕业设计,检测睡眠环境,记录睡着之后...想要传给手机数据之后,能在手机保存下来近十次的数据,然后将睡眠次数最多的环境数据,作为默认值来控制加湿器工作。 这样的话,应该怎么做啊。。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,572
精华内容 15,028
关键字:

wifi传输数据