'Operating with Sockets: debt to Rob Faludi
'jleblanc 3.2.06
'Runs on Xport board with the 18F252
'POT at A0, LED at C4
'This one is a little cleaner
'Basically when combined with the processing code below
'the POT controls the screen color, and when the POT
'is above 120 processing sends the PIC a signal that blinks
'the LED

DEFINE OSC 20

' We communicate with the XPort using 9600 8N1 serial
    true9600 CON 84
    timeOut CON 50   ' the serial incoming timeout in milliseconds
' Our serial communication pins
    tx VAR PORTC.6
    rx VAR PORTC.7
' Used to read response from the XPort
    inByte VAR BYTE
' Used to send a byte from the XPort
    outByte VAR BYTE
' Track whether or not we are connected to the remote server
    connected VAR BIT
    connected = 0

'Setup ADC pins
    DEFINE ADC_BITS 10
    DEFINE ADC_CLOCK 3
    DEFINE ADC_SAMPLEUS 5
    TRISA = %11111111  'set all "A" ports to inputs
    adcon1 = %10000010 'right justify results(?)
'declare variables
    adcVar VAR WORD 'store adc input value

' Set Debug definitions
    DEFINE DEBUG_REG PORTB   ' the debug port
    DEFINE DEBUG_BIT 0       ' the debug pin
    DEFINE DEBUG_BAUD 9600   ' the debug baud rate
    DEFINE DEBUG_MODE 1      ' Set Debug mode: 0 = true, 1 = inverted

' Our blinking pin for status messages
    statusPin VAR PORTC.4
    LED VAR BYTE

OUTPUT statusPin

' Turn on our LED so we know that the startup sequence is going
    HIGH statusPin
' Wait for the XPort to boot up
    PAUSE 5000
' Turn off the status LED while operating
    LOW statusPin

' Just so we know that we're ready, we'll quickly blink the status LED
counter VAR BYTE
blinkCount VAR BYTE  ' number of times to blink
'blinkLight Var Byte  ' which portb pin to blink
'LED = "g"
'blinkCount = 4
'gosub blinkTheLight


main:
    GOSUB readabyte
    GOSUB checkInput
    GOSUB sendAnalogValues
    IF inByte <> 0 THEN
        DEBUG inByte
    ENDIF
    PAUSE 500
GOTO main

checkInput:                     
    IF inbyte == "A" THEN
    blinkCount = 4
    GOSUB blinkTheLight
    ENDIF
RETURN


readAByte:
        SERIN2 rx, true9600, timeOut, noData, [inByte]
RETURN

noData:
    inByte = 0
RETURN

sendAnalogValues:
     ADCIN 0, Adcvar  '0-1024
     outByte = Adcvar/4'convert to byte
     SEROUT2 tx, true9600, [outByte]
RETURN

blinkTheLight:
counter = 0
    WHILE counter < blinkCount
    HIGH portc.4
    PAUSE 100
    LOW portc.4
    PAUSE 100
    counter = counter + 1
    WEND
RETURN

'PROCESSING CODE

'// rob@faludi.com
'// A full example for using Sockets in Processing to communicate with a Lantronix XPort.
'// This program could also be used to communicate primitive variables (bytes) with any other TCP/IP enabled device.
'//
'// We open a Socket, check to see if data is available, get a byte of data
'// from the remote device, and then send a byte of data to the remote device.
'// At the end of the program, we close the streams of data and close the Socket.
'// (Once you are done debugging your code, you should remove all the println statements for better speed.)


'import java.io.*;  // this is the input/output library needed for data streams
'import java.net.*; // this is the network library needed for sockets

'String host; 
'int port;
'Socket mySocket;                    // declare Socket
'DataInputStream myInputStream;      // declare data input stream. This will run within a socket, bringing data into Java
'DataOutputStream myOutputStream;    // declare data output stream. This will run within a socket, sending data out from Java
'byte myDataIn, myDataOut;           // declare some variables to store the data we're sending and receiving
'  //NOTE that in processing a byte is from 127 to -128 where:
'  //for a byte from 0-255  0->0, 127->127, 128->-128, 255->-1
'int DATA=0;

'void setup()
'{
'  size(400,255);
'  background(0);
'  framerate(30);
'  host = "128.122.151.199";  // define a host to communicate with. This can be a name or IP address
'  port = 10001;                // define a port to contact on that host. Must be a number, typically 10001 for an XPort
'}


'void draw()
'{
'  checkConnection(host, port);        // subroutine to create a connection, via a socket, to the XPort
'  if (dataIsWaiting() == true)        //  check to see if there's new data waiting to come in
'  {     
'    myDataIn = getSomeData();         //  ... and if there's new data, get it
'  }
'  myDataOut = 65;                     // create some placeholder data, in this case ASCII letter A
  
'  //Here We'll only send a signal out if DATA>120
'  if(DATA>120)
'  {
'    sendSomeData(myDataOut);            // send the data out
'  }
  
'  //NOTE that in processing a byte is from 127 to -128 where:
'  //for a byte from 0-255  0->0, 127->127, 128->-128, 255->-1
'  DATA=(int)myDataIn;
'  if(DATA<0)
'    { DATA=DATA+256;}
'  background(DATA);
'}


'////////CHECK CONNECTION\\\\\\\\
'void checkConnection(String host, int port) 
'{
'  if(mySocket == null || mySocket.isConnected() == false) 
'  {                 
'    println("trying to connect to: " + host + " at port: " + port);
    
'    try  // make an attempt to run the following code
'    {                                      
'      mySocket = new Socket(host,port); // initialize socket, connecting it to a host computer's port
'      println("connected!");
'    }
'    catch(Exception e)  // if the "try" attempt gave an error, run the following code
'    {                        
'      e.printStackTrace();                       // print the error to the log
'      println("unable to connect to: " + host + " at port: " + port);
'    }
'  }
'}


'////////CHECK TO SEE IF DATA IS WAITING TO COME IN\\\\\\\\\\\
'boolean dataIsWaiting() 
'{
'  boolean bytesAvailable = false;
  
'  if ( myInputStream == null) // if there's no active input stream
'  {  
'    try // create an new input stream from a particular socket
'    {
'      myInputStream = new DataInputStream(mySocket.getInputStream()); 
'      println("opening input stream");
'    }
'    catch (Exception e) 
'    {
'      e.printStackTrace();
'      println("error while opening input stream");
'    }
'  }
  
'  try 
'  {
'    if (myInputStream.available()>0) // check to see if any bytes are available
'    {      
'      bytesAvailable = true;                // ...and if they are set the variable to true
'      println(myInputStream.available() + " bytes available...");
'    }
'  }
'  catch(Exception e) 
'  {
'    e.printStackTrace();
'    println("error while checking for bytes available");
'  }
'  return bytesAvailable;
'}


'////////GET SOME DATA \\\\\\\\\\
'byte getSomeData() 
'{
'  byte inData = 0; // declare and initialize the data variable
'  try 
'  {
'    if (myInputStream.available()>0) //   only read the byte if there's a byte to read [this is a redundant check]
'    {  
'      inData = myInputStream.readByte();  // read a byte from the input stream
'      println("data received: " + inData);
'    }
'  }
'  catch(Exception e)
'  {
'    e.printStackTrace();
'    println("no data");
'  }
'  return inData;
'}


'////////SEND SOME DATA\\\\\\\\\\
'void sendSomeData(byte outData)
'{
'  if (myOutputStream == null) // if there's no active output stream
'  { 
'    try 
'    {
'      myOutputStream = new DataOutputStream(mySocket.getOutputStream()); // create an new output stream from a particular socket
'    }
'    catch (Exception e) 
'    {
'      e.printStackTrace();
'     // println("no output stream");
'    }
'  }
  
'  try
'  {
'    myOutputStream.writeByte(outData); // write a byte to the output stream
'    //println("data sent: " + outData);
'  }
'  catch(Exception e)
'  {
'    e.printStackTrace();
'    //println("event send failed");
'  } 
'}


'public void stop() // when the program quits
'{ 
'  try 
'  {
'    myInputStream.close();  // close the input stream
'    myOutputStream.close(); // close the output stream
'    mySocket.close(); // close the socket
'  }
'  catch (Exception e) 
'  {
'    e.printStackTrace();
'    println("couldn't close connection");
'  }
'}