Add Android app from Yue

[~andy/csm213a-hw] / syc / src / com / example / sycapp / SerialIO.java

diff --git a/syc/src/com/example/sycapp/SerialIO.java b/syc/src/com/example/sycapp/SerialIO.java
new file mode 100644 (file)
index 0000000..62566a8
--- /dev/null
+++ b/syc/src/com/example/sycapp/SerialIO.java
@@ -0,0 +1,188 @@
+package com.example.sycapp;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileDescriptor;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.util.Vector;
+
+import android.content.Context;
+
+public class SerialIO{
+       private OutputStream sout;
+       private InputStream  sin;
+       
+       
+       private Vector<SerialData> parsedData;
+       // Serial Data
+       private final short HEADER       = SerialData.HEADER;
+       private final byte  HEADER_FST   = (byte)(HEADER>>8&0xFF);
+       private final byte  HEADER_SCD   = (byte)(HEADER&0xFF);
+       private final int   int16Cnt     = SerialData.evt_int16Cnt;  
+       private final int   int32Cnt     = SerialData.evt_int32Cnt;
+       
+       
+       // Serial Buffer
+       private int       int16Idx;
+       private int       int32Idx;
+       private byte[]    buffer        = new byte[4];
+       private int       int16_;
+       private int       int32_;
+       private int       parseStatus   = 0;
+       private short     int16Buffer[] = new short[int16Cnt];
+       private int       int32Buffer[] = new int  [int32Cnt];
+       private int       portId;
+       
+       
+       // Constructors
+       SerialIO(String portName, int portId){
+               try {
+                       this.sout       = new BufferedOutputStream(new FileOutputStream(new File(portName)));
+                       this.sin        = new  FileInputStream(new File(portName));
+                       this.parsedData = new Vector<SerialData>();
+                       this.portId     = portId;
+               } catch (Exception e) {
+                       Util.debug("[S#0]"+e.toString());
+               }
+       }
+       
+       SerialIO(FileOutputStream fo){
+               try {
+                       this.sout       = new BufferedOutputStream(new FileOutputStream(new File("/dev/ttyO1")));
+                       this.sin        = new  FileInputStream(new File("/dev/ttyO1"));
+                       this.parsedData = new Vector<SerialData>();
+               } catch (Exception e) {
+                       Util.debug("[S#0]"+e.toString());
+               }
+       }
+       
+       // Write & Read Routines
+       public void send(byte[] content){
+               try{
+                       sout.write(content);
+                       sout.flush();
+               }catch(Exception e){
+                       Util.debug("[S#5]"+e.toString());
+               }
+       }
+       public void send(String content){
+               try{
+                       sout.write(content.getBytes());
+                       sout.flush();
+               }catch(Exception e){
+                       Util.debug("[S#4]"+e.toString());
+               }
+       }
+       
+       public Vector<SerialData> checkPort(){
+               parsedData.clear();
+               try {
+                       if( sin.available()>0){
+                               onDataReceived();
+                       }
+               } catch (Exception e) {
+                       Util.debug("[S#2]" +e.toString());
+               }
+               return parsedData;
+       }
+       
+       
+       private void onDataReceived(){
+               //Util.debug("[Serial] OnDataReceived!");
+               SerialData sData = new SerialData();
+               try   {
+                               byte buffer[] = new byte[sin.available()];
+                               sin.read(buffer,0, sin.available());
+                               parseByteFlow(buffer);
+                               }
+               catch (Exception e){Util.debug("[S#1]"+e.toString());}
+       }
+       
+
+       // TODO: need to be changed back
+       public void parseByteFlow(byte[] byteFlow){
+               for (int i=0; i<byteFlow.length; ){
+                       switch(parseStatus){
+                       case 0:                                                 // looking for 1st part of HEADER
+                               //if (byteFlow[i++]==HEADER_FST){ parseStatus = 1;} 
+                               if (byteFlow[i++]==HEADER_SCD){ parseStatus = 1;} 
+                               break;
+                       case 1:                                                 // looking for 2nd half of HEADER
+                               //if (byteFlow[i++]!=HEADER_SCD){
+                               if (byteFlow[i++]!=HEADER_FST){
+                                       parseStatus = 0;
+                               }else {
+                                       parseStatus = 2;
+                                       int16Idx=0; int32Idx=0;
+                               }
+                               break;
+                       case 2:                                                 // packing int16
+                               buffer[int16_++]=byteFlow[i++];
+                               if (int16_==2){
+                                       int16_ = 0;
+                                       int16Buffer[int16Idx++] = ByteBuffer.wrap(flipInt16(buffer)).getShort();
+                                       if(int16Idx==int16Cnt){
+                                               int16Idx = 0;
+                                               parseStatus = 3;
+                                       }
+                               }
+                               break;
+                       case 3:                                                 // packing int32
+                               buffer[int32_++]=byteFlow[i++];
+                               if (int32_==4){
+                                       int32_ = 0;
+                                       int32Buffer[int32Idx++] = ByteBuffer.wrap(flipInt32(buffer)).getInt();
+                                       if(int32Idx==int32Cnt){
+                                               int32Idx = 0;
+                                               parseStatus = 0;
+                                               if (isValidData(int16Buffer, int32Buffer)){
+                                                       parsedData.add(new SerialData(int16Buffer, int32Buffer, this.portId));
+                                               }
+                                               int j=0;
+                                       }
+                               }
+                               break;
+                       }
+                       
+               }
+               //return logEnable? parsedData:null;
+       }
+       
+       private byte[] flipInt16(byte[] buff){
+               byte temp = buff[0];
+               buff[0] = buff[1];
+               buff[1] = temp;
+               return buff;
+       }
+       
+       private byte[] flipInt32(byte[] buff){
+               byte temp = buff[0];
+               buff[0] = buff[3];
+               buff[3] = temp;
+               
+               temp = buff[1];
+               buff[1] = buff[2];
+               buff[2] = temp;
+               return buff;
+       }
+       
+       private boolean isValidData(short[] int16, int[] int32){
+               return true;
+       }
+               
+       private byte[] combineBytes(byte[] b1, byte[] b2){
+               byte[] result = new byte[b1.length+b2.length];
+               System.arraycopy(b1, 0, result, 0, b1.length);
+               System.arraycopy(b2, 0, result, b1.length, b2.length);
+               return result;
+       }
+
+       
+}