亚洲春色中文字幕久久久-三上亚,一吻二脱三床四吻胸,国产真实伦对白视频全集,在线毛片观看,精品成品入口黄网,国产毛aⅴ片久久久,亚洲AV色香蕉一区二区三区老师,萧皇后A级艳片,色情日本视频更新,99久久亚洲精品日本无码

標題: android與藍牙模塊HC-05和單片機STC89C52RC通信問題 [打印本頁]
作者: asd9988775    時間: 2017-6-19 22:09
標題: android與藍牙模塊HC-05和單片機STC89C52RC通信問題
單片機上的程序，我貼了出來，接收串口得到的數據，判斷是什么，我用keil仿真得到的是0xA1 0x96 0xb2這些數據可以其實我發送的只有一個
我用過解析ascii轉字符串得到的特殊字符，UTF-8，UTF-16LE，UTF-16BE，GBK，unicode，都是特殊字符。現在用.toHexString，得到的是B2。
請求大神幫我看看，哪里的問題現在的問題數據接收問題。不知道是手機發送的有問題，還是怎么樣。我打過斷點，我發送字母a，轉化為char數組后是97，然后發送給，單片機。
不管，單片機里怎么判斷，返回的結果應該是"Success"或"Error"。
求大神賜教。

  2. #include“ reg52.h“
  3. #include”intrins.h“

  5. unsigned char SenData，Flag = 0;

  7. char代碼str1 [] =“成功”;
  8. char code str2 [] =“Error”;

  10. void send_str（）;
  11. void InitUART（void）;
  12. void send_str2（）;
  13. void delayms（unsigned char ms）;
  14. void send_char（unsigned char txd）;

  16. sbit led = P2 ^ 0; //將單片機的P2.0端口定義為led
  17. sbit led2 = P2 ^ 1; //將單片機的P2。
  18. 0端口定義為led void InitUART（void）
  19. {
  20. / *******************設定串口**************** ****** /
  21. SCON = 0x50; //設置為工作方式1
  22. TMOD = 0x20; //設置計數器工作方式2
  23. PCON = 0x80; //波特率加倍
  24. TH1 = 0xFA回應; //計數器初始值設置，注意波特率是9600的
  25. TL1 = TH1;
  26. ES = 1; //打開接收中斷
  27. EA = 1; //打開總中斷
  28. TR1 = 1; //打開計數器
  29. / ******************設定中斷********************** /
  30. }
  31. void main（）//主函數
  32. {         
  33. InitUART（）;
  34. while（1）{  
  35. if（Flag == 1）
  36. {
  37.         
  38.         ES = 0;
  39.         delayms（50）;
  40. // ----------------------該段即對接收的數據進行處理
  41.         if（SenData == 97）// 97為字符a的ascii - ----------網上有人說接受的是ascii
  42.         {
  43.         led = 0; //P2.0端口設置為低電平
  44.         delayms（10）; //延時去抖動
  45.         send_str（）; //發送數據
  46.         導致= 1; //P2.0端口設置為低電平         
  47.         }
  48.         else
  49.         {
  50.                 led2 = 0;
  51.         delayms（10）;
  52.         send_str2（）;
  53.                 led2 = 1;
  54.         }

  56.         ES = 1;
  57. }
  58. }
  59. }

  61. void ser_int（）interrupt 4 //接收字符串
  62. {   
  63. if（RI == 1）// RI接受中斷標志
  64. {  
  65. SenData = SBUF;
  66. RI = 0; //清除標志。
  67. Flag = 1;
  68. //標志位置1表示有新數據進來}
  69. }


  72. void send_str（）//發送字串
  73. {
  74. unsigned char i = 0;
  75. Flag = 0; //數據處理完畢后將標志位置0，表示沒有新數據要處理
  76. while（str1！='\ 0'）
  77. {
  78. SBUF = str1;
  79. while（！TI）; //等待數據傳送
  80. TI = 0; //清除數據傳輸標志
  81. i ++; //下一個字符串
  82. }
  83. }

  85. void send_str2（）//發送字串
  86. {
  87. unsigned char i = 0;
  88. Flag = 0; //數據處理完畢后將標志位置0，表示沒有新數據要處理
  89. while（str2！='\ 0'）
  90. {
  91. SBUF = str2;
  92. while（！TI）; //等待數據傳送
  93. TI = 0; //清除數據傳輸標志
  94. i ++; //下一個字符串
  95. }
  96. }



  100. void delayms（unsigned char ms）//延時子程序
  101. {
  102. unsigned char i;
  103. while（ms--）
  104. {
  105. for（i = 0; i <120; i ++）;
  106. }
  107. }
  108. 上面是燒錄緝拿stc89c52rc芯片里程序
  109. //////////////////////////////////// ///////////////////////
  110. 下面是我在安卓使用藍牙的接收與發送
  111. / *************** ********************************** /         

  113. 發送
  114.     字符串executStr = edit_name.getText（）。toString（）;
  115.                             executStr + =“\ r \ n”;
  116.                             mChatService.write（executStr.getBytes（））;
  117.   public void write（byte [] buffer）{
  118.             if（mmSocket == null）{
  119.                 Log.d（“----------------------”，“沒有連接“）;
  120.                 返回;
  121.             }
  122.             try {
  123.               / * BufferedWriter bw = new BufferedWriter（new OutputStreamWriter（mmOutStream））;
  124.                 bw.write（buffer）; * /
  125.                 mmOutStream.write（buffer）;
  126.                 if（mmSocket！= null）{
  127.                     mmOutStream.flush（）;
  128.                 }
  129.                 //將發送的消息分享回UI活動
  130.                 mHandler.obtainMessage（Constants.MESSAGE_WRITE，-1，-1，buffer）
  131.                         .sendToTarget（）;
  132.             } catch（IOException e）{
  133.                 Log.e（TAG，“寫入時異常”，e）;
  134.             }
  135.         }
  136. / ************************************************* ** /  
  137. 接收
  138. 字節[] buffer = new byte [1024];
  139.             StringBuilder sb = new StringBuilder（）;
  140.             int字節;
  141.             String b =“”，str =“”;
  142.             Log.d（TAG，“”+ mState）;
  143.             if（mmSocket == null）{
  144.                 Log.d（“----------------------”，“沒有連接”）;
  145.                 返回;
  146.             }
  147.             //繼續聽InputStream的同時連接
  148.             而（mState == STATE_CONNECTED）{
  149.                 嘗試{
  150.                     的BufferedInputStream讀者=新的BufferedInputStream（mmInStream）;
  151.                     bytes = reader.read（buffer）;
  152.                     String tempStr = new String（buffer）; // temp寫入日志
  153.                     tempStr.replace（“\ r \ n”，“***”）;
  154.                     /*mHandler.obtainMessage(Constants.MESSAGE_READ，bytes，0，new String（buffer））.
  155.                             sendToTarget（）; * /
  156.                     // sb.append（new String（buffer，0，bytes））;
  157.                     for（int i = 0; i <bytes;
  158.                         i ++）{ b = Integer.toHexString（buffer [ i]＆0x000000FF）.toUpperCase（）;                         str = Integer.toHexString（（buffer ＆0x000000ff）| 0xffffff00）                                .substring（6）.toUpperCase（）;                         if（b.length（）<2）                            sb.append（“0”）;                         sb.append（b）中;                     }                     log.d（“message”，str）;
  159.                   / *                     if（sb.indexOf（“Success”）> = 0 || sb.indexOf（“Error”）> = 0）{* / ------------------ -----因為返回的只有成功和異常。所有在這里判斷                    mHandler.obtainMessage（Constants.MESSAGE_READ，                            bytes - 1，-1，sb.toString（））. sendToTarget（）;                     //sb.delete(0，sb.length（））;
復制代碼

作者: HC6800-ES-V2.0    時間: 2017-6-20 08:23
最近，有很多帖子問題串口通訊問題。你可以搜一搜，我都有回復。
其實，串口通訊沒什么難搞的，要搞清楚幾個關鍵：
第一：你貼程序，為什么不說說你的單片機板子相關的硬件，重要的——晶振，是多少。從你的程序上看，應該是11.0592MHz（那個FA是我判斷的依據），但你的硬件是不是這個？
如果是，這個就沒問題了；如果不是，問題就大了。如果是12M的，那么，串口通訊的誤差就非常大，接收、發送的數據就不是你發送的，當然沒法判斷和控制了！
第二：你有沒有手機端的原程序？或者配套的51端原程序。我在本論壇看到好多別人的例子，要專門對照兩個程序，看它們發送、接收的數據類型。以前我搞這個時，就是不清楚這個數據格式或叫數據類型，在看了別人例子，搞清楚發送、接收數據類型后，我的手機控制51單片機就成功了。所以，你要找找手機端原程序，看看它到底發送的是什么，或者與之配套的51程序，看看它到底接收的是什么數據。
從你的描述上看，你能測量得到是什么數據，卻不知道發送的是什么內容，看來沒有手機端程序了，也沒有配套的51原程序，這個很難辦，建議全部重新自己做過。
第三：不知道你是不是第一次做這樣的串口設計。可以先參看別人的例子。本論壇中有好的例子，而且是完整的，51端、手機端都有，我就是看過他們的例子才搞出我自己的藍牙控制的。
作者: cjjcjj1    時間: 2017-6-20 10:00
提示: 作者被禁止或刪除 內容自動屏蔽
作者: asd9988775    時間: 2017-6-30 18:34
HC6800-ES-V2.0 發表于 2017-6-20 08:23
最近，有很多帖子問題串口通訊問題。你可以搜一搜，我都有回復。
其實，串口通訊沒什么難搞的，要搞清楚幾 ...

嗯，好的
作者: asd9988775    時間: 2017-6-30 18:35
cjjcjj1 發表于 2017-6-20 10:00
你好！這個還是要一步步的來測試，看看問題出在那個環節上；
你的手機APP用的什么軟件？是通用的還是自己 ...

自己寫的app。不太懂什么是通用的？我只是用android的藍牙類寫的程序
作者: asd9988775    時間: 2017-7-1 17:20
HC6800-ES-V2.0 發表于 2017-6-20 08:23
最近，有很多帖子問題串口通訊問題。你可以搜一搜，我都有回復。
其實，串口通訊沒什么難搞的，要搞清楚幾 ...

/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package com.myapplication.bluetoothconnection;

import android.annotation.TargetApi;
import android.app.ProgressDialog;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.content.Context;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.URLDecoder;
import java.nio.CharBuffer;
import java.util.UUID;

/**
* This class does all the work for setting up and managing Bluetooth
* connections with other devices. It has a thread that listens for
* incoming connections, a thread for connecting with a device, and a
* thread for performing data transmissions when connected.
*/
public class BluetoothChatService {
    // Debugging
    private static final String TAG = "BluetoothChatService";

    // Name for the SDP record when creating server socket
    private static final String NAME_SECURE = "BluetoothChatSecure";
    private static final String NAME_INSECURE = "BluetoothChatInsecure";

    // Unique UUID for this application
    private static final UUID MY_UUID_SECURE =
            UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
    private static final UUID MY_UUID_INSECURE =
            UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");

    // Member fields
    private final BluetoothAdapter mAdapter;
    private final Handler mHandler;

    private ConnectThread mConnectThread;
    private ConnectedThread mConnectedThread;
    private int mState;

    // Constants that indicate the current connection state
    public static final int STATE_NONE = 0;       // we're doing nothing
    //public static final int STATE_LISTEN = 1;     // now listening for incoming connections
    public static final int STATE_CONNECTING = 2; // now initiating an outgoing connection
    public static final int STATE_CONNECTED = 3;  // now connected to a remote device

    private ProgressDialog progressDialog;
    Context context;

    /**
     * Constructor. Prepares a new BluetoothChat session.
     *
     * @param context The UI Activity Context
     * @param handler A Handler to send messages back to the UI Activity
     */
    public BluetoothChatService(Context context, Handler handler) {
        this.context = context;
        mAdapter = BluetoothAdapter.getDefaultAdapter();
        mState = STATE_NONE;//藍牙狀態
        mHandler = handler;//用來跟新ui
        progressDialog = new ProgressDialog(context);
        setDialog();
    }

    private void setDialog() {

        progressDialog.setTitle("連接藍牙");
        progressDialog.setMessage("連接藍牙中....");
        progressDialog.setCancelable(true);

    }

    /**
     * Set the current state of the chat connection
     *
     * @param state An integer defining the current connection state
     */
    private synchronized void setState(int state) {
        /*Log.d(TAG, "setState() " + mState + " -> " + state);*/
        mState = state;

        // Give the new state to the Handler so the UI Activity can update
        mHandler.obtainMessage(Constants.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();
    }

    /**
     * Return the current connection state.
     */
    public synchronized int getState() {
        return mState;
    }


    /**
     * Start the ConnectThread to initiate a connection to a remote device.
     *
     * @param device The BluetoothDevice to connect
     * @param secure Socket Security type - Secure (true) , Insecure (false)
     */
    public synchronized void connect(BluetoothDevice device, boolean secure) {
        // Cancel any thread attempting to make a connection
        if (mState == STATE_CONNECTING) {
            if (mConnectThread != null) {
                mConnectThread.cancel();
                mConnectThread = null;
            }
        }

        // Cancel any thread currently running a connection
        if (mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }


        // Start the thread to connect with the given device
        mConnectThread = new ConnectThread(device, secure);
        mConnectThread.start();
        setState(STATE_CONNECTING);
        progressDialog.show();
    }

    /**
     * Start the ConnectedThread to begin managing a Bluetooth connection
     *
     * @param socket The BluetoothSocket on which the connection was made
     * @param device The BluetoothDevice that has been connected
     */
    public synchronized void connected(BluetoothSocket socket, BluetoothDevice
            device, final String socketType) {
        Log.d(TAG, "connected, Socket Type:" + socketType);
        progressDialog.dismiss();//連接成功取消進度框
        // Cancel the thread that completed the connection
        if (mConnectThread != null) {
            mConnectThread.cancel();
            mConnectThread = null;
        }

        // Cancel any thread currently running a connection
        if (mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }

        setState(STATE_CONNECTED);
        // Start the thread to manage the connection and perform transmissions
        mConnectedThread = new ConnectedThread(socket, socketType);
        mConnectedThread.start();

        // 發送已經連接成功的設備名字返回ui線程，即通過ui一開始構造器傳進來的mHandler來處理
        Message msg = mHandler.obtainMessage(Constants.MESSAGE_DEVICE_NAME);
        Bundle bundle = new Bundle();
        bundle.putString(Constants.DEVICE_NAME, device.getName());
        msg.setData(bundle);
        mHandler.sendMessage(msg);
    }

    /**
     * Stop all threads
     */
    public synchronized void stop() {
        Log.d(TAG, "stop");

        if (mConnectThread != null) {
            mConnectThread.cancel();
            mConnectThread = null;
        }

        if (mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }


        setState(STATE_NONE);
    }

    /**
     * Write to the ConnectedThread in an unsynchronized manner
     *
     * @param out The bytes to write
     * @see ConnectedThread#(byte[])
     */
    public void write(byte[] out) {
        // Create temporary object
        ConnectedThread r;
        // Synchronize a copy of the ConnectedThread
        synchronized (this) {
            if (mState != STATE_CONNECTED) return;
            r = mConnectedThread;
        }
        // Perform the write unsynchronized
        r.write(out);
    }

    /**
     * Indicate that the connection attempt failed and notify the UI Activity.
     */
    private void connectionFailed() {
        // Send a failure message back to the Activity
        Message msg = mHandler.obtainMessage(Constants.MESSAGE_TOAST);
        Bundle bundle = new Bundle();
        bundle.putString(Constants.TOAST, "Unable to connect device");
        msg.setData(bundle);
        mHandler.sendMessage(msg);

        // Start the service over to restart listening mode
        //BluetoothChatService.this.start();
    }

    /**
     * Indicate that the connection was lost and notify the UI Activity.
     */
    private void connectionLost() {
        // Send a failure message back to the Activity
        Message msg = mHandler.obtainMessage(Constants.MESSAGE_TOAST);
        Bundle bundle = new Bundle();
        bundle.putString(Constants.TOAST, "Device connection was lost");
        msg.setData(bundle);
        mHandler.sendMessage(msg);

        // Start the service over to restart listening mode
        //BluetoothChatService.this.start();
    }


    /**
     * This thread runs while attempting to make an outgoing connection
     * with a device. It runs straight through; the connection either
     * succeeds or fails.
     */
    private class ConnectThread extends Thread {
        private final BluetoothSocket mmSocket;
        private final BluetoothDevice mmDevice;
        private String mSocketType;

        @TargetApi(Build.VERSION_CODES.GINGERBREAD_MR1)
        public ConnectThread(BluetoothDevice device, boolean secure) {
            mmDevice = device;//連接必須要有device這個對象
            BluetoothSocket tmp = null;
            mSocketType = secure ? "Secure" : "Insecure";
            // 拿到socket,
            //這里uuid有分安全模式和非安全模式之分
            try {
                if (secure) {
                    tmp = device.createRfcommSocketToServiceRecord(
                            MY_UUID_SECURE);
                    Log.d(TAG, "get temp over");
                } else {
                    tmp = device.createInsecureRfcommSocketToServiceRecord(
                            MY_UUID_INSECURE);
                    Log.d(TAG, "get temp over");
                }
            } catch (IOException e) {
                Log.e(TAG, "Socket Type: " + mSocketType + "create() failed", e);
            }
            mmSocket = tmp;
        }

        public void run() {
            Log.i(TAG, "BEGIN mConnectThread SocketType:" + mSocketType);
            setName("ConnectThread" + mSocketType);

            // Always cancel discovery because it will slow down a connection
            mAdapter.cancelDiscovery();

            // Make a connection to the BluetoothSocket
            try {
                // This is a blocking call and will only return on a
                // successful connection or an exception
                mmSocket.connect();
            } catch (IOException e) {
                // Close the socket
                try {
                    mmSocket.close();
                } catch (IOException e2) {
                    Log.e(TAG, "unable to close() " + mSocketType +
                            " socket during connection failure", e2);
                }
                connectionFailed();
                return;
            }

            // Reset the ConnectThread because we're done
            synchronized (BluetoothChatService.this) {
                mConnectThread = null;
            }

            // Start the connected thread
            connected(mmSocket, mmDevice, mSocketType);
        }

        public void cancel() {
            try {
                mmSocket.close();
            } catch (IOException e) {
                Log.e(TAG, "close() of connect " + mSocketType + " socket failed", e);
            }
        }
    }

    /**
     * This thread runs during a connection with a remote device.
     * It handles all incoming and outgoing transmissions.
     */
    private class ConnectedThread extends Thread {
        private final BluetoothSocket mmSocket;
        private final InputStream mmInStream;
        private final OutputStream mmOutStream;

        public ConnectedThread(BluetoothSocket socket, String socketType) {
            Log.d(TAG, "create ConnectedThread: " + socketType);
            mmSocket = socket;
            InputStream tmpIn = null;
            OutputStream tmpOut = null;
            // Get the BluetoothSocket input and output streams
            try {
                tmpIn = socket.getInputStream();
                tmpOut = socket.getOutputStream();
            } catch (IOException e) {
                Log.e(TAG, "temp sockets not created", e);
            }

            mmInStream = tmpIn;
            mmOutStream = tmpOut;
        }

        public void run() {
            Log.d(TAG, "BEGIN mConnectedThread");
            byte[] buffer = new byte[1024];
            StringBuilder sb = new StringBuilder();
            int bytes;
            String b = "", str= "";
            Log.d(TAG, "" + mState);
            if (mmSocket == null) {
                Log.d("----------------------", "沒有連接");
                return;
            }
            // Keep listening to the InputStream while connected
            while (mState == STATE_CONNECTED) {
                try {
                    BufferedInputStream reader = new BufferedInputStream(mmInStream);
                    bytes = reader.read(buffer);
                    String tempStr = new String(buffer);//temp write to log
                    tempStr.replace("\r\n", "***");
                    /*mHandler.obtainMessage(Constants.MESSAGE_READ, bytes, 0, new String(buffer))
                            .sendToTarget();*/
                    // sb.append(new String(buffer, 0, bytes));
                    for (int i = 0; i < bytes; i++) {
                        b = Integer.toHexString(buffer & 0x000000FF).toUpperCase();
                        str = Integer.toHexString((buffer & 0x000000ff) | 0xffffff00)
                                .substring(6).toUpperCase();
                        if (b.length() < 2)
                            sb.append("0");
                        sb.append(b);
                    }
                    Log.d("message",str);

                  /*
                    if (sb.indexOf("Success") >= 0 || sb.indexOf("Error") >= 0) {*/
                    mHandler.obtainMessage(Constants.MESSAGE_READ, bytes - 1, -1, sb.toString())
                            .sendToTarget();
                    //sb.delete(0, sb.length());
                    //  }
                    buffer = new byte[1024];
                 /*  if(sb.charAt(sb.length()-1)=='$'){
                        sb.deleteCharAt(sb.length()-1);
                        Toast.makeText(MainActivity.myContext,sb.toString()+"》MESSAGE_READ",1000).show();
                        mHandler.obtainMessage(Constants.MESSAGE_READ, bytes-1, -1,sb.toString())
                            .sendToTarget();
                        sb.delete(0,sb.length());
                    }*/
                    // Send the obtained bytes to the UI Activity
                } catch (IOException e) {
                    Log.e(TAG, "disconnected", e);
                    connectionLost();
                    // Start the service over to restart listening mode
                    //BluetoothChatService.this.start();
                    break;
                }
                try {
                    Thread.sleep(50);// 延遲
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

        /**
         * Write to the connected OutStream.
         *
         * @param buffer The bytes to write
         */
        public void write(byte[] buffer) {
            if (mmSocket == null) {
                Log.d("----------------------", "沒有連接");
                return;
            }
            try {
              /*  BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(mmOutStream));
                bw.write(buffer);
                */
                byte[]  buffers ={0};
                mmOutStream.write(buffers);
                if (mmSocket != null) {
                    mmOutStream.flush();
                }
                // Share the sent message back to the UI Activity
                mHandler.obtainMessage(Constants.MESSAGE_WRITE, -1, -1, buffer)
                        .sendToTarget();
            } catch (IOException e) {
                Log.e(TAG, "Exception during write", e);
            }
        }

        public void cancel() {
            try {
                mmSocket.close();
            } catch (IOException e) {
                Log.e(TAG, "close() of connect socket failed", e);
            }
        }
    }
}
作者: asd9988775    時間: 2017-7-1 17:22
HC6800-ES-V2.0 發表于 2017-6-20 08:23
最近，有很多帖子問題串口通訊問題。你可以搜一搜，我都有回復。
其實，串口通訊沒什么難搞的，要搞清楚幾 ...

我回復的是我的安卓程序，我的開發板的晶振12Mhz的我改了TH1=0xF9;        。可是我發送0，在單片機上接收的卻是0xc5， 0xf2， 0xef。
作者: juewang    時間: 2018-5-28 16:37
asd9988775 發表于 2017-6-30 18:35
自己寫的app。不太懂什么是通用的？我只是用android的藍牙類寫的程序

如果我的藍牙模塊要接收數據怎么辦
作者: roachwz    時間: 2019-4-28 15:33
樓主問題解決了嗎？我最近也在做類似的



歡迎光臨 (http://www.denmoz.com/bbs/) Powered by Discuz! X3.1