# Config file for serproxy
# See serproxy's README file for documentation

# Transform newlines coming from the serial port into nils
# true (e.g. if using Flash) or false
newlines_to_nils=false

# on a mac you will need to add this
serial_device1=/dev/cu.usbserial-A700dZgM

# Comm ports used
comm_ports=1

# Default settings
comm_baud=9600
comm_databits=8
comm_stopbits=1
comm_parity=none

# Idle time out in seconds
timeout=300

# Port 1 settings (ttyS0)
net_port1=5331

# Port 2 settings (ttyS1)
#net_port2=5332

# Port 3 settings (ttyS2)
#net_port3=5333

# Port 4 settings (ttyS3)
#net_port4=5334

/*
	Simple example that controls the blinking of the LED
	connected to digital PIN 13.

	Created by Mike Chambers

	http://www.mikechambers.com

	You can hook up an external LED by connecting an LED
	to PIN 13 and GND (make sure that the anode (long leg) is
	connected to PING 13 and the cathode (short leg) is connected
	to GND.

	The on board LED is also connected to PIN 13, and will
	be controlled by this program.

	Example is released under the following license:

	The MIT License

	Copyright (c) 2010 Mike Chambers

	Permission is hereby granted, free of charge, to any person obtaining a copy
	of this software and associated documentation files (the "Software"), to deal
	in the Software without restriction, including without limitation the rights
	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	copies of the Software, and to permit persons to whom the Software is
	furnished to do so, subject to the following conditions:

	The above copyright notice and this permission notice shall be included in
	all copies or substantial portions of the Software.

	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	THE SOFTWARE.
*/


//The digital pin that the LED is connected to
#define LED_PIN 13

//incoming command to toggle LED blinking state
#define TOGGLE_LED_STATE 't'

#define EOL_DELIMITER "\n"

//int to hold incoming byte when we read it
int incoming = 0;

//whether the led should blink
boolean shouldBlinkLED = false;

//setup function. called when the program first runs
void setup()
{
	//start listening for incoming messages on the serial port
	//at 9600 baud
	Serial.begin(9600);

    //Send a message out that the program is initializing
    Serial.print("INITIALIZING");

    //Flash looks for this to know when the message is done
    //See the comments in the Flash file for more info.
    Serial.print(EOL_DELIMITER);

	//set the pin more for the digital ping that
	//the LED is connected to (can be INPUT or OUTPUT)
	pinMode(LED_PIN, OUTPUT);

	//blink the LED 5 times so we can visually see that the
	//program is running
	blinkLED(5);

    //Send out a message that initialization is complete.
    Serial.print("READY");
    Serial.print(EOL_DELIMITER);
}

//program loop. Called each timer tick (really fast)
void loop()
{
	//check if we should blink the LED
	if(shouldBlinkLED)
	{
		//if so, blink the LED
		blinkLED(1);
	}

	//check if there are any bytes available
	//on the Serial port
	if(Serial.available() > 0)
	{
		//read a single byte.
		incoming = Serial.read();


		//Calling Serial.read() remove the byte from the Serial
		//buffer. In this case, if there are multiple bytes that
		//were sent, the next one will be handled on the next loop.
		//You could also grab it by calling Serial.read() again

		//check if the incoming byte was a command to toggle
		//the state of the LED blinking
		if(incoming == TOGGLE_LED_STATE)
		{
			//it was a command

			//toggle the state of the LED Blinking
      		shouldBlinkLED = !shouldBlinkLED;

			//send a message to the Serial port with the
			//new LED Blink state

			Serial.print("LED BLINK STATE: ");
			if(shouldBlinkLED)
			{
				Serial.print("ON");
			}
        	else
        	{
          		Serial.print("OFF");
        	}

			Serial.print(EOL_DELIMITER);

			//note, if you are using XMLSocket in Flash to read
			//the string data over the socket then we also have to send
			//a null byte with the following command:
			//
			//Serial.print(0, BYTE);
			//
			//However, in general, it is going to be easier, and more flexible
			//to use the Socket class (and not the XMLSocket class).
    	}
	}
}

//function to blink the LED
void blinkLED(int count)
{
	//loop through
	for(int i = 0; i < count; i++)
	{
		//turn LED on
    	digitalWrite(LED_PIN, HIGH);

		//wait 500 ms
    	delay(500);

		//turn LED off
    	digitalWrite(LED_PIN, LOW);

		//wait 500 ms
    	delay(500);
	}
}

/*
Simple Example that connects to an Arduino (via TinkerProxy) and controls
the blinking of an LED.

Created by Mike Chambers

http://www.mikechambers.com

The MIT License

Copyright (c) 2010 Mike Chambers

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

package
{
import flash.events.Event;
import flash.display.Sprite;
import flash.net.Socket;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.events.SecurityErrorEvent;
import flash.utils.Endian;
import flash.events.MouseEvent;

public class FlashBlink extends Sprite
{

	//command sent to the Arduino to toggle LED blinking state
	private static const TOGGLE_LED_STATE:String = "t";

	//Character that delineates the end of a message received
	//from the Arduino
	private static const EOL_DELIMITER:String = "\n";

	//socket we will use to connect to TinkerProxy
	private var _socket:Socket;

	//Address where TinkerProxy is located. Will usually be
	//localhost / 127.0.0.1
	private var _proxyAddress:String = "127.0.0.1";

	//port TinkerProxy is listening on
	private var _proxyPort:uint = 5331;

	//constructor
	public function FlashBlink()
	{
		//listen for when we are added to the stage
		addEventListener(Event.ADDED_TO_STAGE, onAddedToStage);
	}

	private function onAddedToStage(event:Event):void
	{
		removeEventListener(Event.ADDED_TO_STAGE, onAddedToStage);

		//create a Sprite to add to the stage.
		//This will be a simple button
		var s:Sprite = new Sprite();

		//draw a green square in the Sprite
		s.graphics.beginFill(0x00FF00);
		s.graphics.drawRect(0,0, 200,100);
		s.graphics.endFill();

		//Add Sprite to the display list
		addChild(s);

		//position it
		s.x = 50;
		s.y = 50;

		//listen for when the user clicks the Sprite
		s.addEventListener(MouseEvent.CLICK, onClick);

		_socket = new Socket();

		//Register for socket events

		//socket connected
		_socket.addEventListener( Event.CONNECT, onConnect );

		//socket closed
		_socket.addEventListener( Event.CLOSE, onClose );

		//data received from socket
		_socket.addEventListener( ProgressEvent.SOCKET_DATA, onSocketData );

		//Error connecting
		_socket.addEventListener( IOErrorEvent.IO_ERROR, onIOError );

		//Security Error
		_socket.addEventListener( SecurityErrorEvent.SECURITY_ERROR, onSecurityError );

		//need to set Endianness for Socket. THIS IS IMPORTANT
		//If this is set incorrectly, the Arduino will not be able to understand
		//all of the data sent from Flash.
		//
		//See:
		///blog/post/2010-08-01-sending-multibyte-numbers-from-actionscript-to-arduino/
		_socket.endian = Endian.LITTLE_ENDIAN;

		//connect
		_socket.connect(_proxyAddress, _proxyPort);
	}

	//called when we connect to the proxy server
	private function onConnect(event:Event):void
	{
		/*
			note, you cannot reliably write data to the socket here.

			Im not sure if this is a Flash player issue, or a timing issue
			with the proxy.
		*/
		trace("Socket Connected");
	}

	/*
		This function / event handler is called when data is received
		on the socket.

		However, it is important to remember that the event is called as
		data is received, which means that not all of the data may be available
		when it is called.

		For example, if you sent the string "Hello World" from Arduino,
		then the event handler might be called twice. Once with "Hello Wo" and
		a second time with "rld".

		"Because of this, in most cases, you need to buffer the data, and parse
		out messages, looking for a character (that you specify) that delineates the
		end of a message.

		If you just want to send a single character back from Arduino, then this
		is not necessary. However, the handler below is generic, and already does all
		of the buffering, so you can just use it.
	*/

	//string to hold data as it comes in.
	private var buffer:String = "";

	//event called when data arrives on the socket from the
	//arduino
	private function onSocketData(event:ProgressEvent):void
	{
		//get the string sent from the Arduino. This could be any binary data
		//but in our case, we are sending strings.
		//In general, it is much easier to just always send strings from
		//Arduino, and then parse then in ActionScript
		var data:String = _socket.readUTFBytes( _socket.bytesAvailable );

		//copy the newly arrived data into the buffer string.
		buffer += data;

		//completed message from the server
		var msg:String;
		var index:int;

		//loop through the buffer until it contains no more
		//end of message delimiter
		while((index = buffer.indexOf(EOL_DELIMITER)) > -1)
		{
			//extract the message from the beginning to where the delimiter is
			//we don't include the delimiter
			msg = buffer.substring(0, index);

			//remove the message from the buffer
			buffer = buffer.substring(index + 1);

			//trace out the message (or do whatever you want with it)
			trace("Message Received from Arduino : " + msg);
		}

	}

	//called when the user clicks the button on stage
	private function onClick(event:MouseEvent):void
	{
		trace("onClick");

		//make sure we are connected to the socket
		if(!_socket.connected)
		{
			//if not, don't do anything
			trace("You must be connected to send a command to the Arduino.");
			return;
		}

		//write the command to the server
		_socket.writeUTFBytes(TOGGLE_LED_STATE);

		//flush the socket. Not really necessary, but here for forward compatibility.
		_socket.flush();
	}

	//called when the socket is closed
	private function onClose(event:Event):void
	{
		trace("Socket Closed");
	}

	//called if an error occurs while connecting to the socket.
	private function onIOError(event:IOErrorEvent):void
	{
		trace("IOErrorEvent : " + event.text);
	}

	//called when there is a security error. Usually if you try to connect to a socket
	//when the SWF doesn't have permission.
	//See:
	//http://www.adobe.com/devnet/flashplayer/articles/fplayer9_security_04.html
	//In most cases, when testing locally, this will not be an issue.
	private function onSecurityError(event:SecurityErrorEvent):void
	{
		trace("SecurityErrorEvent : " + event.text);
	}
}
}