XBeeを用いたZigBeeネットワークの性能評価と効率的なファイル転送手法の提案
2018年度卒業論文

        
          
/**
 * Copyright 2017, Digi International Inc.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, you can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
import com.digi.xbee.api.RemoteXBeeDevice;
import com.digi.xbee.api.XBeeDevice;
import com.digi.xbee.api.XBeeNetwork;
import com.digi.xbee.api.exceptions.TimeoutException;
import com.digi.xbee.api.exceptions.XBeeException;
import com.digi.xbee.api.utils.ByteUtils;
import com.digi.xbee.api.utils.HexUtils;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.security.SecureRandom;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

public class ThroughputSender {
    // TODO Replace with the serial port where your sender module is connected to.
    private static final String PORT = "/dev/tty.usbserial-AL021QYY";
    // TODO Replace with the baud rate of your sender module.
    private static final int BAUD_RATE = 115200;

    //Parameters to be set on XBee device
    private static final String PARAM_PAN_ID = "ID";
    private static final byte[] PARAM_VALUE_PAN_ID = new byte[]{0x20, 0x18};

    private static final String PARAM_CHANNEL_VERIFICATION = "JV";
    private static final byte[] PARAM_VALUE_CHANNEL_VERIFICATION = new byte[]{0x01};

    private static final String PARAM_JOIN_NOTIFICATION = "JN";
    private static final byte[] PARAM_VALUE_JOIN_NOTIFICATION = new byte[]{0x0};

    private static final String PARAM_DEVICE_OPTION = "DO";
    private static final byte[] PARAM_VALUE_DEVICE_OPTION = new byte[]{0x00};

    private static final String PARAM_DEVICE_CONTROLS = "DC";
    private static final byte[] PARAM_VALUE_DEVICE_CONTROLS = new byte[]{0x00, 0x00};

    private static final String PARAM_MAXIMUM_HOPS = "NH";
    private static final byte[] PARAM_VALUE_MAXIMUM_HOPS = new byte[]{0x1E};

    private static final String PARAM_BROADCAST_RADIUS = "BH";
    private static final byte[] PARAM_VALUE_BROADCAST_RADIUS = new byte[]{0x00};

    private static final String PARAM_MANY_TO_ONE = "AR";
    private static final byte[] PARAM_VALUE_MANY_TO_ONE = new byte[]{(byte) 0xFF};

    // Information on packets to be transmitted
    // TODO Replace with the payload size
    private static final int PAYLOAD_SIZE = 50; //[Byte] max 250, do not set 0
    private static final int PACKET_LENGTH = PAYLOAD_SIZE + 18;
    // TODO Replace with the seconds how long you want to measurement
    private static final int MEAS_TIME = 100; //seconds
    // TODO Replace with the transmit rate
    private static final int TRANSMIT_RATE = 10000; //bps
    private static final int REPEAT_TIMES = TRANSMIT_RATE * MEAS_TIME / (PACKET_LENGTH*8);
    private static final double INTERVAL_TIME = (double) PACKET_LENGTH * 8 / (double) TRANSMIT_RATE;
    // TODO Replace with the node identifier where you want to transmit (Destination)
    private static final String REMOTE_NODE_IDENTIFIER = "COORD";

    // Configuration of output log file
    private static String FILE_NAME = TRANSMIT_RATE + "bps-send.log";
    // TODO Replace with the directory where you want to output the log file
    private static String FILE_PATH = System.getProperty("user.home") + "/Desktop/4HOP/";

    // main
    public static void main(String[] args) {
        XBeeDevice myDevice = new XBeeDevice(PORT, BAUD_RATE);
        setParam(myDevice);
        transmit(myDevice);
    }

    public static void setParam(XBeeDevice myDevice){
        try {
            myDevice.open();

            // Set parameters.
            myDevice.setParameter(PARAM_PAN_ID, PARAM_VALUE_PAN_ID);
            myDevice.setParameter(PARAM_CHANNEL_VERIFICATION, PARAM_VALUE_CHANNEL_VERIFICATION);
            myDevice.setParameter(PARAM_JOIN_NOTIFICATION, PARAM_VALUE_JOIN_NOTIFICATION);
            myDevice.setParameter(PARAM_DEVICE_OPTION, PARAM_VALUE_DEVICE_OPTION);
            myDevice.setParameter(PARAM_DEVICE_CONTROLS, PARAM_VALUE_DEVICE_CONTROLS);
            myDevice.setParameter(PARAM_MAXIMUM_HOPS, PARAM_VALUE_MAXIMUM_HOPS);
            myDevice.setParameter(PARAM_BROADCAST_RADIUS, PARAM_VALUE_BROADCAST_RADIUS);
            myDevice.setParameter(PARAM_MANY_TO_ONE, PARAM_VALUE_MANY_TO_ONE);

            // Get parameters
            byte[] paramValueID = myDevice.getParameter(PARAM_PAN_ID);
            byte[] paramValueJV = myDevice.getParameter(PARAM_CHANNEL_VERIFICATION);
            byte[] paramValueJN = myDevice.getParameter(PARAM_JOIN_NOTIFICATION);
            byte[] paramValueDO = myDevice.getParameter(PARAM_DEVICE_OPTION);
            byte[] paramValueDC = myDevice.getParameter(PARAM_DEVICE_CONTROLS);
            byte[] paramValueNH = myDevice.getParameter(PARAM_MAXIMUM_HOPS);
            byte[] paramValueBH = myDevice.getParameter(PARAM_BROADCAST_RADIUS);
            byte[] paramValueAR = myDevice.getParameter(PARAM_MANY_TO_ONE);

            // Compare the read parameter values with the values that were set.
            if (ByteUtils.byteArrayToLong(paramValueID) != ByteUtils.byteArrayToLong(PARAM_VALUE_PAN_ID)) {
                System.out.println("ID parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueJV) != ByteUtils.byteArrayToLong(PARAM_VALUE_CHANNEL_VERIFICATION)) {
                System.out.println("JV parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueJN) != ByteUtils.byteArrayToLong(PARAM_VALUE_JOIN_NOTIFICATION)) {
                System.out.println("JN parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueDO) != ByteUtils.byteArrayToLong(PARAM_VALUE_DEVICE_OPTION)) {
                System.out.println("DO parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueDC) != ByteUtils.byteArrayToLong(PARAM_VALUE_DEVICE_CONTROLS)) {
                System.out.println("DC parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueNH) != ByteUtils.byteArrayToLong(PARAM_VALUE_MAXIMUM_HOPS)) {
                System.out.println("NH parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueBH) != ByteUtils.byteArrayToLong(PARAM_VALUE_BROADCAST_RADIUS)) {
                System.out.println("BH parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueAR) != ByteUtils.byteArrayToLong(PARAM_VALUE_MANY_TO_ONE)) {
                System.out.println("AR parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }

            System.out.println("All parameters were set correctly!");

            myDevice.close();

        } catch (TimeoutException e) {
            e.printStackTrace();
            myDevice.close();
            System.exit(1);
        } catch (XBeeException e) {
            e.printStackTrace();
            myDevice.close();
            System.exit(1);
        }
    }
    public static void transmit(XBeeDevice myDevice){
        // List for output log
        List<String> log = new ArrayList<>();
        long prev = 0, now, simStart, simEnd;

        //Set date format
        Calendar today, sendTime;
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat timeFormat = new SimpleDateFormat("HH:mm:ss.SSS");

        // Generate payload
        byte[] data_to_send = new byte[PAYLOAD_SIZE];
        SecureRandom sr = new SecureRandom();
        sr.nextBytes(data_to_send);

        // send this signal when this transmitting process is done
        String end_signal = "-1";
        String end_error_signal = "-2";

        //Add log file this program information
        today = Calendar.getInstance();
        log.add(dateFormat.format(today.getTime()) + " " + timeFormat.format(today.getTime()) +
                " destNI=" + REMOTE_NODE_IDENTIFIER + " payload size=" + PAYLOAD_SIZE +
                " total length=" + PACKET_LENGTH + " sending bps=" + TRANSMIT_RATE);

        try {
            myDevice.open();
            XBeeNetwork xbeeNetwork = myDevice.getNetwork();
            RemoteXBeeDevice remoteDevice = xbeeNetwork.discoverDevice(REMOTE_NODE_IDENTIFIER);

            //Contain OP and CH parameters
            byte[] paramValueOP = myDevice.getParameter("OP");
            byte[] paramValueCH = myDevice.getParameter("CH");

            if (remoteDevice == null) {
                System.out.println("Couldn't find the remote XBee device with '" + REMOTE_NODE_IDENTIFIER + "' Node Identifier.");
                System.exit(1); }

            //Show, add log file operating PAN ID and channel
            StringBuilder netInfo = new StringBuilder("Operating PAN ID=");
            System.out.print(netInfo.toString());
            for (int i=0; i<paramValueOP.length; i++){
                System.out.print(Integer.toHexString(paramValueOP[i]));
                netInfo.append(Integer.toHexString(paramValueOP[i])); }
            System.out.println("  Operating Channel=" + Integer.toHexString(paramValueCH[0]) + "\n");
            netInfo.append("  Operating Channel=" + Integer.toHexString(paramValueCH[0]));
            log.add(netInfo.toString());

            //Show transmitting information
            System.out.format("Sending data to %s >> %s | %s... ", remoteDevice.get64BitAddress(),
                    HexUtils.prettyHexString(HexUtils.byteArrayToHexString(data_to_send)),
                    new String(data_to_send));
            System.out.println();

            System.out.println("\nat " + timeFormat.format(Calendar.getInstance().getTime()) +
                    " start to send packet. packet size=" + PACKET_LENGTH + "byte transmit rate=" +
                    TRANSMIT_RATE + "bps interval=" + INTERVAL_TIME+ "s time required=" + MEAS_TIME + "s");
            log.add("Simulation started at, " + timeFormat.format(Calendar.getInstance().getTime()));
            log.add("");
            simStart = System.nanoTime();
            Thread.sleep((int)(INTERVAL_TIME * 1000));

            //Transmit
            for (int i=0; i<REPEAT_TIMES; i++) {
                sendTime = Calendar.getInstance();
                log.add(timeFormat.format(sendTime.getTime()) + "," + i + ",SENT,packet size " + PACKET_LENGTH + "byte");
                now = System.nanoTime();
                if (i != 0) {
                    if ((now - prev) <= INTERVAL_TIME * 1000000000) {
                        Thread.sleep((int) (((INTERVAL_TIME * 1000000000) - (now - prev)) / 1000000));
                    } else {
                        Thread.sleep(5000);
                        System.out.print("Transmit rate error");
                        myDevice.sendDataAsync(remoteDevice, end_error_signal.getBytes());
                        System.exit(1);
                    }
                }
                prev = System.nanoTime();
                myDevice.sendDataAsync(remoteDevice, data_to_send);
            }
            simEnd = System.nanoTime();
            Thread.sleep(5000);
            myDevice.sendDataAsync(remoteDevice, end_signal.getBytes());
            String statistics = "\n" + "Total send packet " + REPEAT_TIMES + "\nTotal send data size " + (PACKET_LENGTH*REPEAT_TIMES +
                    " byte\nTotal simulation time " + ((double)(simEnd-simStart)/1000000000));
            System.out.println(statistics);
            log.add(statistics);
            Files.write(Paths.get(FILE_PATH, FILE_NAME), log, StandardOpenOption.CREATE);
            System.out.println("Success");

        } catch (XBeeException e) {
            System.out.println("Error");
            e.printStackTrace();
            System.exit(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            myDevice.close();
        }
    }
}
        
      

        
          
/**
 * Copyright 2017, Digi International Inc.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, you can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

import com.digi.xbee.api.XBeeDevice;
import com.digi.xbee.api.exceptions.TimeoutException;
import com.digi.xbee.api.exceptions.XBeeException;
import com.digi.xbee.api.utils.ByteUtils;

public class ThroughoutReceiver {
    // TODO Replace with the serial port where your receiver module is connected.
    private static final String PORT = "/dev/tty.usbserial-A10586WI";
    // TODO Replace with the baud rate of you receiver module.
    private static final int BAUD_RATE = 115200;

    // TODO Replace with the file name what you want to name the log file
    private static String FILE_NAME = "5000" + "bps-recv.log";
    // TODO Replace with the directory where you want to output the log file
    private static String FILE_PATH = System.getProperty("user.home") + "/Desktop/Test/";

    //Parameters to be set on routers
    private static final String PARAM_PAN_ID = "ID";
    private static final byte[] PARAM_VALUE_PAN_ID = new byte[]{0x20, 0x18};

    private static final String PARAM_CHANNEL_VERIFICATION = "JV";
    private static final byte[] PARAM_VALUE_CHANNEL_VERIFICATION = new byte[]{0x00};

    private static final String PARAM_JOIN_NOTIFICATION = "JN";
    private static final byte[] PARAM_VALUE_JOIN_NOTIFICATION = new byte[]{0x0};

    private static final String PARAM_COORDINATOR_ENABLE = "CE";
    private static final byte[] PARAM_VALUE_COORDINATOR_ENABLE = new byte[]{0x1};

    private static final String PARAM_DEVICE_OPTION = "DO";
    private static final byte[] PARAM_VALUE_DEVICE_OPTION = new byte[]{0x00};

    private static final String PARAM_DEVICE_CONTROLS = "DC";
    private static final byte[] PARAM_VALUE_DEVICE_CONTROLS = new byte[]{0x00, 0x00};

    private static final String PARAM_MAXIMUM_HOPS = "NH";
    private static final byte[] PARAM_VALUE_MAXIMUM_HOPS = new byte[]{0x1E};

    private static final String PARAM_BROADCAST_RADIUS = "BH";
    private static final byte[] PARAM_VALUE_BROADCAST_RADIUS = new byte[]{0x00};

    private static final String PARAM_MANY_TO_ONE = "AR";
    private static final byte[] PARAM_VALUE_MANY_TO_ONE = new byte[]{(byte) 0xFF};

    public static void main(String[] args) {
        XBeeDevice myDevice = new XBeeDevice(PORT, BAUD_RATE);
        setParam(myDevice);

        try {
            myDevice.open();

            myDevice.addDataListener(new MyDataReceiveListener(FILE_NAME, FILE_PATH));

            System.out.println("\n>> Waiting for data...");

        } catch (XBeeException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static void setParam(XBeeDevice myDevice){
        try {
            myDevice.open();

            // Set parameters.
            myDevice.setParameter(PARAM_PAN_ID, PARAM_VALUE_PAN_ID);
            myDevice.setParameter(PARAM_CHANNEL_VERIFICATION, PARAM_VALUE_CHANNEL_VERIFICATION);
            myDevice.setParameter(PARAM_JOIN_NOTIFICATION, PARAM_VALUE_JOIN_NOTIFICATION);
            myDevice.setParameter(PARAM_DEVICE_OPTION, PARAM_VALUE_DEVICE_OPTION);
            myDevice.setParameter(PARAM_DEVICE_CONTROLS, PARAM_VALUE_DEVICE_CONTROLS);
            myDevice.setParameter(PARAM_MAXIMUM_HOPS, PARAM_VALUE_MAXIMUM_HOPS);
            myDevice.setParameter(PARAM_BROADCAST_RADIUS, PARAM_VALUE_BROADCAST_RADIUS);
            myDevice.setParameter(PARAM_MANY_TO_ONE, PARAM_VALUE_MANY_TO_ONE);

            // Get parameters
            byte[] paramValueID = myDevice.getParameter(PARAM_PAN_ID);
            byte[] paramValueJV = myDevice.getParameter(PARAM_CHANNEL_VERIFICATION);
            byte[] paramValueJN = myDevice.getParameter(PARAM_JOIN_NOTIFICATION);
            byte[] paramValueCE = myDevice.getParameter(PARAM_COORDINATOR_ENABLE);
            byte[] paramValueDO = myDevice.getParameter(PARAM_DEVICE_OPTION);
            byte[] paramValueDC = myDevice.getParameter(PARAM_DEVICE_CONTROLS);
            byte[] paramValueNH = myDevice.getParameter(PARAM_MAXIMUM_HOPS);
            byte[] paramValueBH = myDevice.getParameter(PARAM_BROADCAST_RADIUS);
            byte[] paramValueAR = myDevice.getParameter(PARAM_MANY_TO_ONE);

            // Compare the read parameter values with the values that were set.
            if (ByteUtils.byteArrayToLong(paramValueID) != ByteUtils.byteArrayToLong(PARAM_VALUE_PAN_ID)) {
                System.out.println("ID parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueJV) != ByteUtils.byteArrayToLong(PARAM_VALUE_CHANNEL_VERIFICATION)) {
                System.out.println("JV parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueJN) != ByteUtils.byteArrayToLong(PARAM_VALUE_JOIN_NOTIFICATION)) {
                System.out.println("JN parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueCE) != ByteUtils.byteArrayToLong(PARAM_VALUE_COORDINATOR_ENABLE)) {
                System.out.println("CE parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueDO) != ByteUtils.byteArrayToLong(PARAM_VALUE_DEVICE_OPTION)) {
                System.out.println("DO parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueDC) != ByteUtils.byteArrayToLong(PARAM_VALUE_DEVICE_CONTROLS)) {
                System.out.println("DC parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueNH) != ByteUtils.byteArrayToLong(PARAM_VALUE_MAXIMUM_HOPS)) {
                System.out.println("NH parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueBH) != ByteUtils.byteArrayToLong(PARAM_VALUE_BROADCAST_RADIUS)) {
                System.out.println("BH parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueAR) != ByteUtils.byteArrayToLong(PARAM_VALUE_MANY_TO_ONE)) {
                System.out.println("AR parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }

            System.out.println("All parameters were set correctly!");

            myDevice.close();

        } catch (TimeoutException e) {
            e.printStackTrace();
            myDevice.close();
            System.exit(1);
        } catch (XBeeException e) {
            e.printStackTrace();
            myDevice.close();
            System.exit(1);
        }
    }
}
        
      

        
          
/**
 * Copyright 2017, Digi International Inc.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, you can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

import com.digi.xbee.api.listeners.IDataReceiveListener;
import com.digi.xbee.api.models.XBeeMessage;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

/**
 * Class to manage the XBee received data that was sent by other modules in the
 * same network.
 *
 * <p>Acts as a data listener by implementing the
 * {@link IDataReceiveListener} interface, and is notified when new
 * data for the module is received.</p>
 *
 * @see IDataReceiveListener
 *
 */
public class MyDataReceiveListener implements IDataReceiveListener {
    private String FILE_NAME;
    private String FILE_PATH;
    private final int HEADER_SIZE = 18;
    private List<String> log;
    private long totalDataLength;
    private Calendar today, recvTime;
    private SimpleDateFormat dateFormat;
    private SimpleDateFormat timeFormat;
    private int p_cnt;

    MyDataReceiveListener(String file_name, String file_path){
        this.FILE_NAME = file_name;
        this.FILE_PATH = file_path;
        log = new ArrayList<>();
        dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        timeFormat = new SimpleDateFormat("HH:mm:ss.SSS");
        today = Calendar.getInstance();
        log.add(dateFormat.format(today.getTime()) + "  " + timeFormat.format(today.getTime()) + "\n");
        p_cnt = -1;
        totalDataLength = 0;
    }

    @Override
    public void dataReceived(XBeeMessage xbeeMessage) {
        //If receiving frame is end signal
        String recvDataString = xbeeMessage.getDataString();
        if (recvDataString.equals("-1")){
            try {
                String statistics = "\n" + "Total received packet " + (p_cnt+1) + "\nTotal received data size " + totalDataLength + " byte";
                System.out.println(statistics);
                log.add(statistics);
                Files.write(Paths.get(FILE_PATH, FILE_NAME), log, StandardOpenOption.CREATE);
                System.out.println("Receiving process has just done!");
                System.exit(1);
            } catch (IOException e) {
                e.printStackTrace();
            }
        //If receiving frame is transmit error
        }else if (recvDataString.equals("-2")){
            System.out.println("Transmit error");
            System.exit(1);
        //If receiving frame is data
        }else {
            p_cnt += 1;
            totalDataLength += recvDataString.length() + HEADER_SIZE;
            recvTime = Calendar.getInstance();
            System.out.println("Received packet " + p_cnt  + "  " + timeFormat.format(recvTime.getTime()) +
                    "  packet size " + (xbeeMessage.getData().length + HEADER_SIZE) + "byte");
            log.add(timeFormat.format(recvTime.getTime()) + "," + p_cnt + "," + "RECV," + (xbeeMessage.getData().length + HEADER_SIZE) + "byte");
        }
    }
}

        
      

        
          
/**
 * Copyright 2017, Digi International Inc.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, you can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
import com.digi.xbee.api.RemoteXBeeDevice;
import com.digi.xbee.api.XBeeDevice;
import com.digi.xbee.api.XBeeNetwork;
import com.digi.xbee.api.exceptions.TimeoutException;
import com.digi.xbee.api.exceptions.XBeeException;
import com.digi.xbee.api.utils.ByteUtils;
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;

public class SendFile {
    // TODO Replace with the serial port where your sender module is connected to.
    private static final String PORT = "/dev/tty.usbserial-AL021QYY";
    // TODO Replace with the baud rate of your sender module.
    private static final int BAUD_RATE = 115200;
    // TODO Replace with the file name which you want to transmit
    private static final String SEND_FILE_NAME = "/Bird.jpg";
    private static final String SEND_FILE_PATH = System.getProperty("user.dir") + SEND_FILE_NAME;
    // Information on packets to be transmitted
    // TODO Replace with the payload size
    private static final int PAYLOAD_SIZE = 50; //[Byte] max 250, do not set 0
    private static final int HEDER_SIZE = 18;
    private static final int PACKET_LENGTH = PAYLOAD_SIZE + HEDER_SIZE;
    private static final int SEQ_SIZE = 4; //[Byte]
    private static final int DATA_SIZE = PAYLOAD_SIZE - SEQ_SIZE; //[Byte]
    // TODO Replace with the transmit rate
    private static final int TRANSMIT_RATE = 16000; //bps
    private static final double INTERVAL_TIME = (double) PACKET_LENGTH * 8 / (double) TRANSMIT_RATE;
    // TODO Replace with the node identifier where you want to transmit (Destination)
    private static final String REMOTE_NODE_IDENTIFIER = "COORD";
    // TODO Replace with the send option sync(=true) or async + sync(=false)
    private static boolean SYNC = false;
    //Have to wait some milliseconds to transmit with synchronous after asynchronous transmit.
    private static int ASYS_WAIT_TIME = 250; //[ms]

    //Parameters to be set on routers
    private static final String PARAM_PAN_ID = "ID";
    private static final byte[] PARAM_VALUE_PAN_ID = new byte[]{0x20, 0x18};

    private static final String PARAM_CHANNEL_VERIFICATION = "JV";
    private static final byte[] PARAM_VALUE_CHANNEL_VERIFICATION = new byte[]{0x01};

    private static final String PARAM_JOIN_NOTIFICATION = "JN";
    private static final byte[] PARAM_VALUE_JOIN_NOTIFICATION = new byte[]{0x0};

    private static final String PARAM_DEVICE_OPTION = "DO";
    private static final byte[] PARAM_VALUE_DEVICE_OPTION = new byte[]{0x00};

    private static final String PARAM_DEVICE_CONTROLS = "DC";
    private static final byte[] PARAM_VALUE_DEVICE_CONTROLS = new byte[]{0x00, 0x00};

    private static final String PARAM_MAXIMUM_HOPS = "NH";
    private static final byte[] PARAM_VALUE_MAXIMUM_HOPS = new byte[]{0x1E};

    private static final String PARAM_BROADCAST_RADIUS = "BH";
    private static final byte[] PARAM_VALUE_BROADCAST_RADIUS = new byte[]{0x00};

    private static final String PARAM_MANY_TO_ONE = "AR";
    private static final byte[] PARAM_VALUE_MANY_TO_ONE = new byte[]{(byte) 0xFF};

    private static final byte[] SUCCESS_SIGNAL = "1".getBytes();
    private static final byte[] ASYNC_FINISH_SIGNAL = "0".getBytes();
    private static final byte[] END_ERROR_SIGNAL = "2".getBytes();
    private static final int FILE_NAME_SEQUENCE = -1;

    private static XBeeDevice myDevice;
    private static XBeeNetwork xbeeNetwork;
    private static RemoteXBeeDevice remoteDevice;
    private static MyDataReceiveListener myListener;
    private static byte[] sendFileArray;
    private static int numFrame, finalFrameSize;
    private static long simStart, simEnd;

    // main
    public static void main(String[] args) throws IOException {
        myDevice = new XBeeDevice(PORT, BAUD_RATE);
        // Read all bytes from the file which you want to send.
        // Then store byte array them.
        File sendFile = new File(SEND_FILE_PATH);
        sendFileArray = Files.readAllBytes(sendFile.toPath());

        // To start transmit process
        setParam();
        transmitFile();
        // Add a data receive listener when transmit is asynchronous + synchronous
        if (!SYNC) {
            try {
                myDevice.open();
                myListener = new MyDataReceiveListener(PAYLOAD_SIZE, SEQ_SIZE);
                myDevice.addDataListener(myListener);
            } catch (XBeeException e) {
                e.printStackTrace();
                System.exit(1);
            }
        }
    }
    public static void setParam(){
        try {
            myDevice.open();
            // Set parameters.
            myDevice.setParameter(PARAM_PAN_ID, PARAM_VALUE_PAN_ID);
            myDevice.setParameter(PARAM_CHANNEL_VERIFICATION, PARAM_VALUE_CHANNEL_VERIFICATION);
            myDevice.setParameter(PARAM_JOIN_NOTIFICATION, PARAM_VALUE_JOIN_NOTIFICATION);
            myDevice.setParameter(PARAM_DEVICE_OPTION, PARAM_VALUE_DEVICE_OPTION);
            myDevice.setParameter(PARAM_DEVICE_CONTROLS, PARAM_VALUE_DEVICE_CONTROLS);
            myDevice.setParameter(PARAM_MAXIMUM_HOPS, PARAM_VALUE_MAXIMUM_HOPS);
            myDevice.setParameter(PARAM_BROADCAST_RADIUS, PARAM_VALUE_BROADCAST_RADIUS);
            myDevice.setParameter(PARAM_MANY_TO_ONE, PARAM_VALUE_MANY_TO_ONE);

            // Get parameters
            byte[] paramValueID = myDevice.getParameter(PARAM_PAN_ID);
            byte[] paramValueJV = myDevice.getParameter(PARAM_CHANNEL_VERIFICATION);
            byte[] paramValueJN = myDevice.getParameter(PARAM_JOIN_NOTIFICATION);
            byte[] paramValueDO = myDevice.getParameter(PARAM_DEVICE_OPTION);
            byte[] paramValueDC = myDevice.getParameter(PARAM_DEVICE_CONTROLS);
            byte[] paramValueNH = myDevice.getParameter(PARAM_MAXIMUM_HOPS);
            byte[] paramValueBH = myDevice.getParameter(PARAM_BROADCAST_RADIUS);
            byte[] paramValueAR = myDevice.getParameter(PARAM_MANY_TO_ONE);

            // Compare the read parameter values with the values that were set.
            if (ByteUtils.byteArrayToLong(paramValueID) != ByteUtils.byteArrayToLong(PARAM_VALUE_PAN_ID)) {
                System.out.println("ID parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueJV) != ByteUtils.byteArrayToLong(PARAM_VALUE_CHANNEL_VERIFICATION)) {
                System.out.println("JV parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueJN) != ByteUtils.byteArrayToLong(PARAM_VALUE_JOIN_NOTIFICATION)) {
                System.out.println("JN parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueDO) != ByteUtils.byteArrayToLong(PARAM_VALUE_DEVICE_OPTION)) {
                System.out.println("DO parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueDC) != ByteUtils.byteArrayToLong(PARAM_VALUE_DEVICE_CONTROLS)) {
                System.out.println("DC parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueNH) != ByteUtils.byteArrayToLong(PARAM_VALUE_MAXIMUM_HOPS)) {
                System.out.println("NH parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueBH) != ByteUtils.byteArrayToLong(PARAM_VALUE_BROADCAST_RADIUS)) {
                System.out.println("BH parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueAR) != ByteUtils.byteArrayToLong(PARAM_VALUE_MANY_TO_ONE)) {
                System.out.println("AR parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            System.out.println("All parameters were set correctly!");
            myDevice.close();

        } catch (TimeoutException e) {
            e.printStackTrace();
            myDevice.close();
            System.exit(1);
        } catch (XBeeException e) {
            e.printStackTrace();
            myDevice.close();
            System.exit(1);
        }
    }
    public static void transmitFile(){
        try {
            myDevice.open();
            xbeeNetwork = myDevice.getNetwork();
            remoteDevice = xbeeNetwork.discoverDevice(REMOTE_NODE_IDENTIFIER);
            if (remoteDevice == null) {
                System.out.println("Couldn't find the remote XBee device with '"
                    + REMOTE_NODE_IDENTIFIER + "' Node Identifier.");
                System.exit(1);
            }
            // Calculate how many frames are divided and the last frame size.
            numFrame = (sendFileArray.length / DATA_SIZE) + 1;
            finalFrameSize = sendFileArray.length % ((numFrame - 1) * DATA_SIZE);

            long prev = 0, now, asysStart, asysEnd;
            double asysSendTime;
            asysStart = System.nanoTime();
            simStart = System.nanoTime();
            Thread.sleep((int)INTERVAL_TIME * 1000);
            // Transmit process
            // Sending frames are converted to ByteBuffer temporarily to add sequence bits.
            // Then, the frames are reconverted to byte array.
            // Repetitive statement are sending file, after that send filename and signal
            // The last frame divided (numFrame th) is not necessarily PAY_LOAD_SIZE - SEQ_SIZE [byte]
            // The sendData is synchronous transmit, the sendDataAsync is asynchronous transmit.
            for (int i = 0; i < numFrame; i++) {
                if (i % 100 == 0)
                    System.out.println("Sending Packet  ... " + i);
                //Except the final data frame
                if (i != numFrame - 1) {
                    byte[] frameArray = genFrameWithSeq(i, new byte[PAYLOAD_SIZE]);
                    if (SYNC) myDevice.sendData(remoteDevice, frameArray);
                    else {
                        if (i != 0) {
                            now = System.nanoTime();
                            if ((now - prev) <= INTERVAL_TIME * 1000000000) {
                                Thread.sleep((int) (((INTERVAL_TIME * 1000000000) - (now - prev)) / 1000000));
                            } else {
                                Thread.sleep(5000);
                                System.out.print("Transmit rate error");
                                myDevice.sendDataAsync(remoteDevice, END_ERROR_SIGNAL);
                                System.exit(1);
                            }
                        } else myDevice.sendDataAsync(remoteDevice, frameArray);
                        prev = System.nanoTime();
                        myDevice.sendDataAsync(remoteDevice, frameArray);
                    }
                //Final data frame
                } else {
                    byte[] frameArray = genFrameWithSeq(i, new byte[finalFrameSize + SEQ_SIZE]);
                    Thread.sleep(ASYS_WAIT_TIME);
                    myDevice.sendData(remoteDevice, frameArray);
                }

            }
            // Send receiver filename
            byte[] fileName = SEND_FILE_NAME.getBytes(StandardCharsets.UTF_8);
            byte[] fileNameWithSeq = new byte[fileName.length + SEQ_SIZE];
            if (fileName.length <= DATA_SIZE) {
                ByteBuffer frameBuf = ByteBuffer.wrap(fileNameWithSeq);
                frameBuf.putInt(0, FILE_NAME_SEQUENCE);
                for (int j = 0; j < fileName.length; j++)
                    frameBuf.put(SEQ_SIZE + j, fileName[j]);
                frameBuf.get(fileNameWithSeq, 0, fileNameWithSeq.length);
                myDevice.sendData(remoteDevice, fileNameWithSeq);
            }else{
                System.out.println("Filename is too long");
                System.exit(1);
            }
            asysEnd = System.nanoTime();
            asysSendTime = (double)(asysEnd-asysStart)/1000000000;
            System.out.println("Total transmit time (asynchronous session) "
                + String.format("%1$.3f", asysSendTime) + "[s]");
            System.out.println("Actual transmit rate (asynchronous session) " +
                    String.format("%1$.3f", (numFrame*PACKET_LENGTH*8 / asysSendTime)/1000) + "[kbps]");
            // Send receiver signal
            if (SYNC) {
                myDevice.sendData(remoteDevice, SUCCESS_SIGNAL);
                System.exit(1);
            }else myDevice.sendData(remoteDevice, ASYNC_FINISH_SIGNAL);

        } catch (XBeeException e) {
            e.printStackTrace();
            System.exit(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.exit(1);
        } finally {
            myDevice.close();
        }
    }
    // Generate transmit frame with sequence.
    public static byte[] genFrameWithSeq(int i, byte[] frameArray){
        ByteBuffer frameBuf = ByteBuffer.wrap(frameArray);
        frameBuf.putInt(0, i); // Set Sequence
        for (int j = 0; j < DATA_SIZE; j++) // Set data
            frameBuf.put(SEQ_SIZE + j, sendFileArray[(i * DATA_SIZE) + j]);
        frameBuf.get(frameArray, 0, frameArray.length);
        return frameArray;
    }
    // Send receiver retransmit frame in this method.
    // The frameReqList contains in comma delimited sequence number which receiver want sender to send.
    public static void retransFrame(String frameReqList){
        System.out.println("resendFrame method is called");
        myDevice.removeDataListener(myListener);
        try {
            if (remoteDevice == null) {
                System.out.println("Couldn't find the remote XBee device with '"
                    + REMOTE_NODE_IDENTIFIER + "' Node Identifier.");
                System.exit(1);
            }
            String[] splitRetrieList = frameReqList.split(",", 0);
            for (int i=0; i<splitRetrieList.length; i++) {
                int seq = Integer.parseInt(splitRetrieList[i]);
                byte[] frameArray = genFrameWithSeq(seq, new byte[PAYLOAD_SIZE]);
                myDevice.sendData(remoteDevice, frameArray);
            }
            // Send receiver success signal.
            simEnd = System.nanoTime();
            myDevice.sendData(remoteDevice, SUCCESS_SIGNAL);
            System.out.println("Successful transmission of all retransmission frames!!");
            double totalSendTime = (double)(simEnd-simStart)/1000000000;
            System.out.println("Total transmit rate = " + String.format
                    ("%1$.3f", ((8 * (PACKET_LENGTH * (splitRetrieList.length + numFrame - 1)
                        + finalFrameSize)))
                            / (totalSendTime * 1000)) + "[kbps]");
        } catch (XBeeException e) {
            e.printStackTrace();
            System.exit(1);
        }finally {
            myDevice.addDataListener(myListener);
            myDevice.close();
        }
    }
}
        
      

        
          
/**
 * Copyright 2017, Digi International Inc.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, you can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

import com.digi.xbee.api.listeners.IDataReceiveListener;
import com.digi.xbee.api.models.XBeeMessage;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.text.SimpleDateFormat;
import java.util.*;

public class MyDataReceiveListener implements IDataReceiveListener {
    // TODO Replace with the payload size, enter the same numerical value as the sender
    private static int PAYLOAD_SIZE; //[Byte] max 250, do not set 0
    // TODO Replace with the sequence field size, enter the same numerical value as the sender
    private static int SEQ_SIZE; //[Byte]
    private static int DATA_SIZE; //[Byte]
    private static final String SUCCESS_SIGNAL = "1";
    private static final String FINISH_SIGNAL = "2";
    private Map<Integer, byte[]> recvData;
    int frameCnt, seq, maxSeqNum;
    String receivedDataString;

    MyDataReceiveListener(int payload_size, int seq_size){
        PAYLOAD_SIZE = payload_size;
        SEQ_SIZE = seq_size;
        DATA_SIZE = PAYLOAD_SIZE - SEQ_SIZE;
        recvData = new HashMap<>();
        frameCnt = 0;
        seq = -2;
        maxSeqNum = 0;
    }
    // Receiving data size is not less than SEQ_SIZE[byte].
    // So, it's signal when the data size is 1
    @Override
    public void dataReceived(XBeeMessage xbeeMessage) {
        receivedDataString = "";
        // If receiving frame is not any signal
        if (xbeeMessage.getData().length != 1) {
            if (frameCnt % 10 == 0)
                System.out.println("Receiving frame ... " + frameCnt);
            byte[] receivedData = xbeeMessage.getData();
            seq = getSeq(receivedData);
            if (maxSeqNum < seq)
                maxSeqNum = seq;
            frameCnt++;
            recvData.put(seq, receivedData);
        // Store signal to receivedDataString if receiving frame is signal
        }else receivedDataString = xbeeMessage.getDataString();

        // SUCCESS_SIGNAL means asynchronous transmit is finish.
        if (receivedDataString.equals(SUCCESS_SIGNAL)){
            System.out.println("Retransmit request was received!");
            //Calculate total file size. Each frames are same capacity except the last two,
            //the last frame is end signal, the other one is the last frame of data.
            int fileCapa = maxSeqNum * DATA_SIZE + recvData.get(maxSeqNum).length - SEQ_SIZE;
            byte[] output = new byte[fileCapa];
            for (int i=0; i<=maxSeqNum; i++){
                byte[] frameArray = getData(recvData.get(i));
                //Assemble the frame. First 4bits of frame are sequence bits.
                for (int j=0; j<frameArray.length; j++)
                    output[(i*DATA_SIZE)+j] = frameArray[j];
            }
            SendFile.retransFrame(new String(output, StandardCharsets.UTF_8));
        // FINISH_SIGNAL means synchronous transmit is finish.
        }else if (receivedDataString.equals(FINISH_SIGNAL)){
            System.out.println("Success!!!");
            System.exit(1);
        }
    }
    // Get sequence bits from received byte array data.
    public int getSeq(byte[] array){
        ByteBuffer bb = ByteBuffer.wrap(array);
        return bb.getInt(0);
    }
    // Get data from received byte array data.
    public byte[] getData(byte[] array){
        byte[] data = new byte[array.length - SEQ_SIZE];
        for (int i=0; i<array.length - SEQ_SIZE; i++){
            data[i] = array[i+SEQ_SIZE];
        }
        return data;
    }
}


        
      

        
          
/**
 * Copyright 2017, Digi International Inc.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, you can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
import com.digi.xbee.api.RemoteXBeeDevice;
import com.digi.xbee.api.XBeeDevice;
import com.digi.xbee.api.XBeeNetwork;
import com.digi.xbee.api.exceptions.TimeoutException;
import com.digi.xbee.api.exceptions.XBeeException;
import com.digi.xbee.api.utils.ByteUtils;
import java.nio.ByteBuffer;

public class ReceiveFile {
    // TODO Replace with the serial port where your receiver module is connected.
    private static final String PORT = "/dev/tty.usbserial-A10586WI";
    // TODO Replace with the baud rate of you receiver module.
    private static final int BAUD_RATE = 115200;
    // TODO Replace with the payload size, enter the same numerical value as the sender
    private static final int PAYLOAD_SIZE = 50; //[Byte] max 250, do not set 0
    private static final int HEADER_SIZE = 18;
    private static final int SEQ_SIZE = 4; //[Byte]
    private static final int DATA_SIZE = PAYLOAD_SIZE - SEQ_SIZE; //[Byte]
    // TODO Replace with the node identifier which is source node (Src)
    private static final String REMOTE_NODE_IDENTIFIER = "ROUTER";

    //Parameters to be set on routers
    private static final String PARAM_PAN_ID = "ID";
    private static final byte[] PARAM_VALUE_PAN_ID = new byte[]{0x20, 0x18};

    private static final String PARAM_CHANNEL_VERIFICATION = "JV";
    private static final byte[] PARAM_VALUE_CHANNEL_VERIFICATION = new byte[]{0x00};

    private static final String PARAM_JOIN_NOTIFICATION = "JN";
    private static final byte[] PARAM_VALUE_JOIN_NOTIFICATION = new byte[]{0x0};

    private static final String PARAM_COORDINATOR_ENABLE = "CE";
    private static final byte[] PARAM_VALUE_COORDINATOR_ENABLE = new byte[]{0x1};

    private static final String PARAM_DEVICE_OPTION = "DO";
    private static final byte[] PARAM_VALUE_DEVICE_OPTION = new byte[]{0x00};

    private static final String PARAM_DEVICE_CONTROLS = "DC";
    private static final byte[] PARAM_VALUE_DEVICE_CONTROLS = new byte[]{0x00, 0x00};

    private static final String PARAM_MAXIMUM_HOPS = "NH";
    private static final byte[] PARAM_VALUE_MAXIMUM_HOPS = new byte[]{0x1E};

    private static final String PARAM_BROADCAST_RADIUS = "BH";
    private static final byte[] PARAM_VALUE_BROADCAST_RADIUS = new byte[]{0x00};

    private static final String PARAM_MANY_TO_ONE = "AR";
    private static final byte[] PARAM_VALUE_MANY_TO_ONE = new byte[]{(byte) 0xFF};

    private static final byte[] SUCCESS_SIGNAL = "1".getBytes();
    private static final byte[] FINISH_SIGNAL = "2".getBytes();
    private static XBeeDevice myDevice;
    private static MyDataReceiveListener myListener;

    public static void main(String[] args) {
        myDevice = new XBeeDevice(PORT, BAUD_RATE);
        setParam();

        try {
            myDevice.open();
            myListener = new MyDataReceiveListener(HEADER_SIZE, PAYLOAD_SIZE, SEQ_SIZE);
            myDevice.addDataListener(myListener);

            System.out.println("\n>> Waiting for data...");

        } catch (XBeeException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static void setParam(){
        try {
            myDevice.open();

            // Set parameters.
            myDevice.setParameter(PARAM_PAN_ID, PARAM_VALUE_PAN_ID);
            myDevice.setParameter(PARAM_CHANNEL_VERIFICATION, PARAM_VALUE_CHANNEL_VERIFICATION);
            myDevice.setParameter(PARAM_JOIN_NOTIFICATION, PARAM_VALUE_JOIN_NOTIFICATION);
            myDevice.setParameter(PARAM_DEVICE_OPTION, PARAM_VALUE_DEVICE_OPTION);
            myDevice.setParameter(PARAM_DEVICE_CONTROLS, PARAM_VALUE_DEVICE_CONTROLS);
            myDevice.setParameter(PARAM_MAXIMUM_HOPS, PARAM_VALUE_MAXIMUM_HOPS);
            myDevice.setParameter(PARAM_BROADCAST_RADIUS, PARAM_VALUE_BROADCAST_RADIUS);
            myDevice.setParameter(PARAM_MANY_TO_ONE, PARAM_VALUE_MANY_TO_ONE);

            // Get parameters
            byte[] paramValueID = myDevice.getParameter(PARAM_PAN_ID);
            byte[] paramValueJV = myDevice.getParameter(PARAM_CHANNEL_VERIFICATION);
            byte[] paramValueJN = myDevice.getParameter(PARAM_JOIN_NOTIFICATION);
            byte[] paramValueCE = myDevice.getParameter(PARAM_COORDINATOR_ENABLE);
            byte[] paramValueDO = myDevice.getParameter(PARAM_DEVICE_OPTION);
            byte[] paramValueDC = myDevice.getParameter(PARAM_DEVICE_CONTROLS);
            byte[] paramValueNH = myDevice.getParameter(PARAM_MAXIMUM_HOPS);
            byte[] paramValueBH = myDevice.getParameter(PARAM_BROADCAST_RADIUS);
            byte[] paramValueAR = myDevice.getParameter(PARAM_MANY_TO_ONE);

            // Compare the read parameter values with the values that were set.
            if (ByteUtils.byteArrayToLong(paramValueID) != ByteUtils.byteArrayToLong(PARAM_VALUE_PAN_ID)) {
                System.out.println("ID parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueJV) != ByteUtils.byteArrayToLong(PARAM_VALUE_CHANNEL_VERIFICATION)) {
                System.out.println("JV parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueJN) != ByteUtils.byteArrayToLong(PARAM_VALUE_JOIN_NOTIFICATION)) {
                System.out.println("JN parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueCE) != ByteUtils.byteArrayToLong(PARAM_VALUE_COORDINATOR_ENABLE)) {
                System.out.println("CE parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueDO) != ByteUtils.byteArrayToLong(PARAM_VALUE_DEVICE_OPTION)) {
                System.out.println("DO parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueDC) != ByteUtils.byteArrayToLong(PARAM_VALUE_DEVICE_CONTROLS)) {
                System.out.println("DC parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueNH) != ByteUtils.byteArrayToLong(PARAM_VALUE_MAXIMUM_HOPS)) {
                System.out.println("NH parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueBH) != ByteUtils.byteArrayToLong(PARAM_VALUE_BROADCAST_RADIUS)) {
                System.out.println("BH parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }
            if (ByteUtils.byteArrayToInt(paramValueAR) != ByteUtils.byteArrayToLong(PARAM_VALUE_MANY_TO_ONE)) {
                System.out.println("AR parameter was not set correctly.");
                myDevice.close();
                System.exit(1);
            }

            System.out.println("All parameters were set correctly!");

            myDevice.close();

        } catch (TimeoutException e) {
            e.printStackTrace();
            myDevice.close();
            System.exit(1);
        } catch (XBeeException e) {
            e.printStackTrace();
            myDevice.close();
            System.exit(1);
        }
    }
    public static void reqRetries(byte[] retrieReq){
        myDevice.removeDataListener(myListener);
        try {
            System.out.println("reqRetries is called");
            XBeeNetwork xbeeNetwork = myDevice.getNetwork();
            RemoteXBeeDevice remoteDevice = xbeeNetwork.discoverDevice(REMOTE_NODE_IDENTIFIER);
            if (remoteDevice == null) {
                System.out.println("Couldn't find the remote XBee device with '"
                    + REMOTE_NODE_IDENTIFIER + "' Node Identifier.");
                System.exit(1);
            }
            // Calculate how many frames are divided and the last frame size.
            int numFrame = (retrieReq.length / DATA_SIZE) + 1;
            int finalFrameSize = retrieReq.length % ((numFrame - 1) * DATA_SIZE);

            // Transmit process
            // Sending frames are converted to ByteBuffer temporarily to add sequence bits.
            // Then, the frames are reconverted to byte array.
            // Repetitive statement are sending file, after that send filename and signal
            // The last frame divided (numFrame th) is not necessarily PAY_LOAD_SIZE - SEQ_SIZE [byte]
            // The sendData is synchronous transmit, the sendDataAsync is asynchronous transmit.
            for (int i = 0; i < numFrame + 1; i++) {
                if (i != numFrame) {
                    //Except the final request frame
                    if (i != numFrame - 1) {
                        byte[] frameArray = new byte[PAYLOAD_SIZE];
                        ByteBuffer frameBuf = ByteBuffer.wrap(frameArray);
                        frameBuf.putInt(0, i); // Set sequence
                        for (int j = 0; j < DATA_SIZE; j++) // Set data
                            frameBuf.put(SEQ_SIZE + j, retrieReq[(i * DATA_SIZE) + j]);
                        frameBuf.get(frameArray, 0, frameArray.length);
                        myDevice.sendData(remoteDevice, frameArray);
                        if (i % 10 == 0)
                            System.out.println("Sending retransmit request ... " + i);
                        //Final request frame
                    } else {
                        byte[] frameArray = new byte[finalFrameSize + SEQ_SIZE];
                        ByteBuffer frameBuf = ByteBuffer.wrap(frameArray);
                        frameBuf.putInt(0, i); // Set sequence
                        for (int j = 0; j < finalFrameSize; j++) // Set Data
                            frameBuf.put(SEQ_SIZE + j, retrieReq[(i * DATA_SIZE) + j]);
                        frameBuf.get(frameArray, 0, frameArray.length);
                        myDevice.sendData(remoteDevice, frameArray);
                        if (i % 10 == 0)
                            System.out.println("Sending retransmit request ... " + i);
                    }
                //Send Sender success signal
                } else {
                    System.out.println("Successful transmit of all retransmit request");
                    myDevice.sendData(remoteDevice, SUCCESS_SIGNAL);
                    myDevice.addDataListener(myListener);
                }
            }
        } catch (XBeeException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }
    // Send sender finish signal use this method when use asynchronous transmit mode and all frame was received.
    public static void sendFinishSignal() throws XBeeException {
        XBeeNetwork xbeeNetwork = myDevice.getNetwork();
        RemoteXBeeDevice remoteDevice = xbeeNetwork.discoverDevice(REMOTE_NODE_IDENTIFIER);
        if (remoteDevice == null) {
            System.out.println("Couldn't find the remote XBee device with '"
                + REMOTE_NODE_IDENTIFIER + "' Node Identifier.");
            System.exit(1);
        }
        myDevice.sendData(remoteDevice, FINISH_SIGNAL);
        myDevice.close();
    }
}

        
      

        
          
/**
 * Copyright 2017, Digi International Inc.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, you can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
import com.digi.xbee.api.exceptions.XBeeException;
import com.digi.xbee.api.listeners.IDataReceiveListener;
import com.digi.xbee.api.models.XBeeMessage;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.text.SimpleDateFormat;
import java.util.*;

public class MyDataReceiveListener implements IDataReceiveListener {
    private static int PAYLOAD_SIZE;
    private static int PACKET_LENGTH;
    private static int SEQ_SIZE;
    private static int DATA_SIZE;
    private static final String SUCCESS_SIGNAL = "1";
    private static final String ASYNC_FINISH_SIGNAL = "0";
    private static final String END_ERROR_SIGNAL = "2";
    private static final int FILE_NAME_SEQUENCE = -1;
    private static Map<Integer, byte[]> recvData;
    int frameCnt, maxSeqNum, seq;
    private Calendar startTime, endTime;
    private SimpleDateFormat timeFormat;
    private long startNanoTime, endNanoTime;
    private String receivedDataString;
    private double totalRecvTime = 0.0;

    MyDataReceiveListener(int header_size, int payload_size, int seq_size){
        PAYLOAD_SIZE = payload_size;
        PACKET_LENGTH = PAYLOAD_SIZE + header_size;
        SEQ_SIZE = seq_size;
        DATA_SIZE = PAYLOAD_SIZE - SEQ_SIZE;
        recvData = new HashMap<>();
        frameCnt = 0;
        maxSeqNum = 0;
        seq = -2;
        timeFormat = new SimpleDateFormat("HH:mm:ss.SSS");
    }

    @Override
    // Receiving data size is not less than SEQ_SIZE[byte].
    // So, it's signal when the data size is 1
    public void dataReceived(XBeeMessage xbeeMessage) {
        receivedDataString = "";
        //if receiving frame is not end signal
        if (xbeeMessage.getData().length != 1) {
            byte[] receivedData = xbeeMessage.getData();
            if (frameCnt == 0) {
                startTime = Calendar.getInstance();
                startNanoTime = System.nanoTime();
                System.out.println("Start time " + timeFormat.format(startTime.getTime()));
            }
            seq = getSeq(receivedData);
            if (maxSeqNum < seq)
                maxSeqNum = seq;
            if (frameCnt % 100 == 0)
                System.out.println("Receiving Packet ... " + frameCnt);
            frameCnt++;
            recvData.put(seq, receivedData);
        // Store signal to receivedDataString if receiving frame is signal
        }else receivedDataString = xbeeMessage.getDataString();

        // ASYNC_FINISH_SIGNAL means asynchronous transmit session is finish.
        // So, request to retransmit to sender if all frame is not received.
        if (receivedDataString.equals(ASYNC_FINISH_SIGNAL)){
            StringBuilder frameReqList = new StringBuilder();
            for (int i=0; i<maxSeqNum; i++) // Check missing frame
                if (!recvData.containsKey(i))
                    frameReqList.append(Integer.toString(i) + ",");
            System.out.println("RequestListSize" + frameReqList.length());
        if (frameReqList.length()!=0 ) {
            frameReqList.deleteCharAt(frameReqList.length() - 1);
            ReceiveFile.reqRetries(frameReqList.toString().getBytes(StandardCharsets.UTF_8));
        } else {
            //print information about execute time
            printEndTime();
            writeFile();
        }
        // If received frame is finish signal
        }else if (receivedDataString.equals(SUCCESS_SIGNAL)){
            //print information about execute time
            printEndTime();
            writeFile();
        // If received frame is error signal
        }else if (receivedDataString.equals(END_ERROR_SIGNAL)){
            System.out.println("Transmit error ");
            System.exit(1);
        }
    }
    // Get sequence bits from received byte array data.
    public int getSeq(byte[] array){
        ByteBuffer bb = ByteBuffer.wrap(array);
        return bb.getInt(0);
    }
    // Get data from received byte array data.
    public byte[] getData(byte[] array){
        byte[] data = new byte[array.length - SEQ_SIZE];
        for (int i=0; i<array.length - SEQ_SIZE; i++){
            data[i] = array[i+SEQ_SIZE];
        }
        return data;
    }
    // Print total execute time.
    public  void printEndTime(){
        endTime = Calendar.getInstance();
        endNanoTime = System.nanoTime();
        totalRecvTime = (endNanoTime-startNanoTime)/1000000000f;
        System.out.println("End time " + timeFormat.format(endTime.getTime()));
        System.out.println("Total receiving time " + String.format("%1$.3f", totalRecvTime) + "s");
    }
    // Write the received file
    public void writeFile(){
        System.out.println("\nwriteFile is called");
        //Calculate total file size. Each frames are same capacity except the last two,
        //the last frame is end signal, the other one is the last frame of data.
        int fileCapa = maxSeqNum * DATA_SIZE + recvData.get(maxSeqNum).length - 4;
        System.out.println("Received file size = " + String.format("%1$.1f", (double)fileCapa/1000) + "[KB]");
        System.out.println("Receving rate = " + String.format("%1$.3f",
                (PACKET_LENGTH * (maxSeqNum + 1) * 8 / totalRecvTime) / 1000) + "[kbps]");
        byte[] output = new byte[fileCapa];
        for (int i=0; i<=maxSeqNum; i++){
            byte[] frameArray = getData(recvData.get(i));
            //Assemble the frame. First 4bits of frame are sequence bits.
            for (int j=0; j<frameArray.length; j++)
                output[(i*DATA_SIZE) + j] = frameArray[j];
        }
        // Output the file
        String filePath = System.getProperty("user.dir")+ new String(getData(recvData.get(FILE_NAME_SEQUENCE)),
            StandardCharsets.UTF_8);
        System.out.println(filePath);
        try {
            Files.write(Paths.get(filePath), output, StandardOpenOption.CREATE);
            ReceiveFile.sendFinishSignal();
        }catch(IOException e){
            e.printStackTrace();
        } catch (XBeeException e) {
            e.printStackTrace();
        }
        System.out.println("Success!!");
        System.exit(1);
    }
}