Colony

/* testbench for Lab 2 first checkpoint

 * determine whether robot under test complies with communication standard

 * to be conducted using XBee USB dongle

 */

/* The tests shall be as follows

 * 1. Receive a TAG, send an ACK

 * - Robot passes if it sends a tag and changes to prey state

 * 2. Send a TAG, receive an ACK

 * - Pass if sends ACK, changes to wait state, then hunter state

 * 3. Receive TAG, send slightly delayed (< 1s) ACK

 * - Pass if sends one and only one TAG packet (and changes state appropriately)

 * 4. Receive TAG, do not send ACK

 * - Pass if sends one and only one TAG packet (and does not change state)

 * 5. Receive TAG, send ACK to incorrect robot

 * - Pass if goes to wait state, then back to hunter state

 * 6. Simulate TAG from robot A to B, ACK from B to A

 * - Pass if ignores TAG, goes to wait then hunter in response to ACK

 */

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include "../../libwireless/lib/wl_basic.h"

#include "../../libwireless/lib/wireless.h"

#include "hunter_prey.h"

#include <time.h>

#define TYPE 42        // packet type for wireless communication

#define ROBOTID 255 // make up a robot id because the PC doesn't have one

void waitKey() {

  unsigned char buf[10];

  //read from stdin

   while(read(0, buf, 10)==10) {

     printf("!");

     fflush(stdout);

   }

  while(getchar()==-1);

}

int main(int argc, char *argv[])

{

    char send_buffer[2];    // holds data to send

    int data_length;        // length of data received

    unsigned char *packet_data;        // data received

    int ret;

    unsigned int channel = 0xF;

    struct timespec delay8, rem;

    if(argc > 1) {

      channel = atoi(argv[1]);

    }

    printf("using wireless channel %d\n", channel);

    delay8.tv_sec = 2;

    delay8.tv_nsec = 800000000;

    wl_set_com_port("/dev/ttyUSB0");

    // set up wireless

    wl_basic_init_default();

    wl_set_channel(channel);

    printf("Testing communications\n\n");

    // Receive TAG, send ACK

    printf("Receive TAG, send ACK... ");

    fflush(stdout);

    // Wait until we receive a packet

    while (!(packet_data = wl_basic_do_default(&data_length)));

    printf("got packet, validating and sending ack...");

    fflush(stdout);

    if (data_length > 2)

    {

        printf("Excessive TAG packet length... ");

        fflush(stdout);

    }

    if (data_length >= 2 && packet_data[0] == HUNTER_PREY_ACTION_TAG)

    {

        // send back an ACK

        send_buffer[0] = HUNTER_PREY_ACTION_ACK;

        send_buffer[1] = packet_data[1];

        printf("sending ack intended for robot %d\n", packet_data[1]);

        fflush(stdout);

        wl_basic_send_global_packet(TYPE, send_buffer, 2);

        printf("PASSED\n");

    }

    else

        printf("FAILED\n");

    printf("robot should be prey\nPress enter to continue...\n");

    waitKey();

    // Send a TAG, receive an ACK

    printf("Send TAG, wait for ACK... ");

    fflush(stdout);

    send_buffer[0] = HUNTER_PREY_ACTION_TAG;

    send_buffer[1] = ROBOTID;

    // robot number stays the same

    wl_basic_send_global_packet(TYPE, send_buffer, 2);

    // Wait for an ACK

    ret = nanosleep(&delay8, &rem);  // wait for 800 ms before sending ACK

    while(ret) {

      //      printf("nanosleep not done, needs to wait %ld more\n", rem.tv_nsec);

      ret = nanosleep(&rem, &rem);

    }

    data_length = -1;

    packet_data = wl_basic_do_default(&data_length);

    // Check ACK for presence and correctness

    if (!packet_data || data_length < 2 ||

            packet_data[0] != HUNTER_PREY_ACTION_ACK ||

        packet_data[1] != ROBOTID) {

      printf("FAILED, packet=%p, len=%d\n", packet_data, data_length);

      if(data_length >= 2) {

        printf("\tpacket = [%c, %d]\n",packet_data[0], packet_data[1]);

      }

    }

    else

        printf("PASSED\n");

    printf("Robot should be Hunter\nPress enter to continue...\n");

    waitKey();

    // Receive a TAG, send a delayed ACK

    printf("Receive a TAG, send a delayed ACK... ");

    fflush(stdout);

    while (!(packet_data = wl_basic_do_default(&data_length)));

    if (data_length >= 2 && packet_data[0] == HUNTER_PREY_ACTION_TAG)

    {

        printf("got TAG, waiting...");

        fflush(stdout);

        // wait before sending ACK back

        //usleep(900000);

        delay8.tv_sec = 0;

        ret = nanosleep(&delay8, &rem);  // wait for 800 ms before sending ACK

        while(ret) {

          printf(".");

          fflush(stdout);//      printf("nanosleep not done, needs to wait %ld more\n", rem.tv_nsec);

          ret = nanosleep(&rem, &rem);

        }

        if (wl_basic_do_default(&data_length))

            printf("FAILED, got another TAG too soon\n");

        else

        {

            // send packet

            send_buffer[0] = HUNTER_PREY_ACTION_ACK;

            send_buffer[1] = packet_data[1];

            wl_basic_send_global_packet(TYPE, send_buffer, 2);

            printf("PASSED\n");

        }

    }

    else

        printf("FAILED\n");

    printf("robot should be prey.\n Press Enter...\n");

    waitKey();

    printf("sending courtesy tag...");

    fflush(stdout);

    send_buffer[0] = HUNTER_PREY_ACTION_TAG;

    send_buffer[1] = ROBOTID;

    // robot number stays the same

    wl_basic_send_global_packet(TYPE, send_buffer, 2);

    printf("done.\nwaiting for ack...");

    fflush(stdout);

    while (!(packet_data = wl_basic_do_default(&data_length)));

    if (!packet_data || data_length < 2 ||

            packet_data[0] != HUNTER_PREY_ACTION_ACK ||

            packet_data[1] != ROBOTID)

      printf("FAILED, packet=%p, len=%d\n", packet_data, data_length);

    else

        printf("done\n");

    // Receive a TAG, never send an ACK

    printf("Receive TAG, never send ACK... ");

    fflush(stdout);

    while (!(packet_data = wl_basic_do_default(&data_length)));

    if (data_length >= 2 && packet_data[0] == HUNTER_PREY_ACTION_TAG)

    {

        printf("got TAG, monitoring for 5 seconds\n");

        fflush(stdout);

        delay8.tv_sec = 5;

        delay8.tv_nsec = 0;

        ret = nanosleep(&delay8, &rem);  // wait for 5 secs

        while(ret) {

          //      printf("nanosleep not done, needs to wait %ld more\n", rem.tv_nsec);

          ret = nanosleep(&rem, &rem);

        }

        if (wl_basic_do_default(&data_length))

            printf("FAILED, robot is spamming\n");

        else

            printf("PASSED\n");

    }

    else

        printf("FAILED\n");

    printf("robot should be hunter.\nPress enter...\n");

    waitKey();

    // Receive TAG, send ACK to incorrect robot

    printf("Receive TAG, send ACK to incorrect robot... ");

    fflush(stdout);

    // Wait until we receive a packet

    while (!(packet_data = wl_basic_do_default(&data_length)));

    if (data_length >= 2 && packet_data[0] == HUNTER_PREY_ACTION_TAG)

    {

        // send back an ACK

        send_buffer[0] = HUNTER_PREY_ACTION_ACK;

        send_buffer[1] = packet_data[1] + 1;

        wl_basic_send_global_packet(TYPE, send_buffer, 2);

        printf("PASSED\n");

    }

    else

        printf("FAILED\n");

    printf("robot should wait and then still be hunter.\nPress Enter...\n");

    waitKey();

    // Simulate TAG from robot A to B, ACK from robot B to A

    printf("Send TAG from robot A to B, ACK from B to A... ");

    fflush(stdout);

    // TAG

    send_buffer[0] = HUNTER_PREY_ACTION_TAG;

    send_buffer[1] = packet_data[1] - 1;    // robot other than testee

    wl_basic_send_global_packet(TYPE, send_buffer, 2);

    // ACK

    send_buffer[0] = HUNTER_PREY_ACTION_ACK;

    // send_buffer[1] stays the same

    wl_basic_send_global_packet(TYPE, send_buffer, 2);

    if (wl_basic_do_default(&data_length))

        printf("FAILED\n");

    else

        printf("PASSED\n");

    printf("robot should be waiting\n");

    return 0;

}