root/Projects/TrafficLightSender/src/org/sunspotworld/TrafficLightSender.java

/*
 * Title: TrafficLightSender
 * Author: Kevin McIntosh
 * Description:
 * SunSpot's LEDs will periodically switch between green, yellow, and red in order to simulate a traffic light.   
 * Also trasmits radio signals at different strengths using the dynamicSend() method
 * from the Beacon class.  
 * 
 * Pay close attemtion in keeping settings (port, channel, etc.) in synch with 
 * TrafficLightFinder SPOTBot.  Currently the Beacon class sets the default 
 * setting for this class. 
 */
package org.sunspotworld;

import com.sun.spot.sensorboard.EDemoBoard;
import com.sun.spot.sensorboard.peripheral.ITriColorLED;

import com.sun.spot.sensorboard.peripheral.LEDColor;
import com.sun.spot.util.Utils;
import java.io.*;
import java.util.Random;
import javax.microedition.io.Datagram;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

/**
 * A class intended to simulate a traffic light while simultaneously tranmiting 
 * radio strength signals.
 *   
 * @author Kevin McIntosh
 */
public class TrafficLightSender extends MIDlet {

    private static final int PACKETS_PER_SECOND = 5;
    private static final int PACKET_INTERVAL = 1000 / PACKETS_PER_SECOND;
    private static final int TOTAL_NUMBER_OF_STATES = 2;//Red light and green light.  Yellow light acts as a stall and is not a true state in this sense 
    private static final int THROW_OFF = 3000;
    private static int randomDigit = 1;
    private static Datagram data = null;
    private static ITriColorLED[] leds = EDemoBoard.getInstance().getLEDs();
    private static final int PORT = 41;
    private static final int DELAY = 1000;
    private static final int NUM_CYCLES = 20;
    private static Beacon sender = null;

    /**
     * Displays red in the LEDs
     */
    public static void redLight() {
        for (int i = 0; i < 8; i++) {
            leds[i].setOff();
            leds[i].setColor(LEDColor.RED);
            leds[i].setOn();
        }
    }

    /**
     * Displays green in the LEDs
     */
    public static void yellowLight() {
        for (int i = 0; i < 8; i++) {
            leds[i].setOff();
            leds[i].setColor(LEDColor.YELLOW);
            leds[i].setOn();
        }
    }

    /**
     * Displays green in the LEDs
     */
    public static void greenLight() {
        for (int i = 0; i < 8; i++) {
            leds[i].setOff();
            leds[i].setColor(LEDColor.GREEN);
            leds[i].setOn();
        }
    }

    /**
     * A method purely for show-off purposes.  Uses the LEDs to count-down from 
     * 3 to 0.
     */
    public static void countdown() {

        // 3
        for (int i = 0; i < 8; i++) {
            leds[i].setOff();
            leds[i].setColor(LEDColor.WHITE);
            leds[i].setOn();
        }
        System.out.println("Three");
        Utils.sleep(1000);

        // 2
        for (int i = 0; i < 8; i++) {
            leds[i].setOff();
        }

        for (int i = 0; i < 6; i++) {
            leds[i].setOn();
        }
        System.out.println("Two");
        Utils.sleep(1000);

        // 1
        for (int i = 0; i < 8; i++) {
            leds[i].setOff();
        }

        for (int i = 0; i < 4; i++) {
            leds[i].setOn();
        }
        System.out.println("One");
        Utils.sleep(1000);

    }

    
    private static void beaconSender() {

        try {
            sender = new Beacon(NUM_CYCLES, DELAY);

        } catch (IOException ex) {
            System.out.println("Error in creating setting for the Beacon");
        }

        try {
            sender.setCycles(1);
            sender.dynamicSend();
            System.out.println("So far it is working");
        } catch (IOException ex) {
            System.out.println("Error in sending");
        }
    }

    /**
     * Input a range of numbers.  The "range" will start from one and end with your number.
     * 
     * @param rangeOfDigits
     * @return A random digit within the givin range
     */
    public static int randomInt(int rangeOfDigits) {

        Random r = new Random();
        int randomNumber = r.nextInt(rangeOfDigits);
        randomNumber++;
        return randomNumber;

    }

    /**
     * Input a minimum and a maximum of a range of numbers.  
     * Returns a random digit within that range
     * 
     * @param lowerRange
     * @param upperRange
     * @return randomDigit
     */
    public static int randomInt(int lowerRange, int upperRange) {

        Random r = new Random();
        int randomDigit = r.nextInt(upperRange - lowerRange + 1);
        randomDigit = randomDigit + lowerRange;
        return randomDigit;

    }

    protected void startApp() throws MIDletStateChangeException {

        countdown();

        while (true) { //begin the search!!

            if (randomDigit == 1) {

                for (int i = 0; i < 1; i++) {

                    System.out.println("GO");
                    greenLight();
                    Utils.sleep(50);
                    beaconSender();
              
                    System.out.println("greenLight pass");

                    //Utils.sleep(randomInt(200, 500));

                }
                randomDigit = randomInt(TOTAL_NUMBER_OF_STATES);

            } else {

                System.out.println("Slow");
                yellowLight();

                //sendNewInt(SLOW);
                Utils.sleep(THROW_OFF); //the intention of yellowLight() is to throw off the searching algorythm.  Bassically, makes the signal harder to find

                System.out.println("Stop");
                //sendNewChar(STOP);
                redLight();
                Utils.sleep(4000);

                randomDigit = 1;
            }

            long nextTime = System.currentTimeMillis() + PACKET_INTERVAL;
            long delay = (nextTime - System.currentTimeMillis()) - 2;

            if (delay > 0) {
                Utils.sleep(delay);
            } else {
                Utils.sleep(PACKET_INTERVAL);
            }
        }



    }

    protected void pauseApp() {
        // This is not currently called by the Squawk VM
    }

    /**
     * Called if the MIDlet is terminated by the system.
     * I.e. if startApp throws any exception other than MIDletStateChangeException,
     * if the isolate running the MIDlet is killed with Isolate.exit(), or
     * if VM.stopVM() is called.
     * 
     * It is not called if MIDlet.notifyDestroyed() was called.
     *
     * @param unconditional If true when this method is called, the MIDlet must
     *    cleanup and release all resources. If false the MIDlet may throw
     *    MIDletStateChangeException  to indicate it does not want to be destroyed
     *    at this time.
     */
    protected void destroyApp(boolean unconditional) throws MIDletStateChangeException {
    }
}