Comunicación USB y Servidor

Transcripción

1 Comunicación USB y Servidor Índice A. Comunicación USB. A.1. Introducción. A.2. Investigaciones iniciales. A.3. Investigación del teléfono como Host. A.3.1. La parte de Android. A.3.2. La parte de Arduino. A.3.3. Resultados. A.4. Investigación de la Placa Arduino como Host. A.4.1. La parte de Android. A.4.2. La parte de Arduino. A.4.3. Resultados. B. Servidor. B.1. El programa. C. Conclusiones. D. Descargas. A. Comunicación USB. A.1. Introducción. En esta parte veremos como van a comunicarse la placa Arduino DUE y nuestro teléfono. La idea principal es que la placa Arduino será la encargada de capturar todos los datos necesarios para el análisis de la telemetría de una moto de carreras, los datos serán enviados al teléfono cada 100 ms, que estará escuchando el puerto USB y se encargará de filtrar los datos y mostrarlos. Los datos serán enviados a un servidor cuando estén preparados ya sea cada vez que se detecte el paso por meta o cuando acabe el entrenamiento. A.2. Investigaciones iniciales. Los requerimientos iniciales para esta parte del proyecto : Francisco Aguilar Segura 02/07/14 2ºDAM

2 titulo Encontrar un sistema de comunicación por USB que permita el envío unidireccional,desde la placa al teléfono,a una velocidad de refresco de 100ms. El teléfono hará de Host,beneficiándonos de la capacidad de alimentación de este, para no tener que proporcionar alimentación externa a la placa. Lo primero que hemos de determinar,son los roles que ha de asumir cada una de las partes,así encontramos dos posibles configuraciones : Arduino como host o teléfono como host. En los dos casos,se necesita un cable OTG para habilitar el Host. Veamos los dos roles que estudiaremos a continuación: En la configuración teléfono como Host, el teléfono establece la comunicación y la placa es alimentada a través del puerto USB. La alimentación (5Vcc) la proporciona el teléfono,por lo que dependemos totalmente de la batería de este para funcionar. En la configuración Arduino como Host, es la placa la que establece la comunicación y el teléfono obtiene los end-points necesarios para comunicarse. La alimentación la proporciona la placa pasando la tensión de (5-9 Vcc) desde el alimentador a través del USB,permitiendo la carga del teléfono. Este supuesto no cumple todos los requerimientos previos pero se contempla como posibilidad. A partir de estas premisas se investigan las diferentes opciones implementadas en Arduino y Android,dando como mejor resultado los dos que se presentan a continuación. Desde luego no son los únicos pero,si son los que se han encontrado mas fiables y maduros para su uso. A.3. Investigación del teléfono como Host. Fig1: Teléfono como Host Esta fue la primera opción que se eligió,por simplicidad en el sistema de alimentación y por evitar posibles interferencias parásitas si se conectase la alimentación a la moto. Rápidamente se encontraron los primeros problemas. Esta configuración obliga a utilizar comunicación serie virtualizada a través del puerto USB,debido sobretodo a que no existen librerías para el Arduino DUE para trabajar como cliente USB. Las únicas librerías disponibles son las de Host USB,por lo tanto se opta por usar el puerto de programación para obtener la comunicación,como podemos observar el la Fig 1. 2

3 El siguiente problema es que El sistema operativo Android no tiene librerías para el puerto serie,pero al tener una comunidad de desarrolladores tan grande detrás,rápidamente se encuentran varias clases que realizan esta función. Existía la posibilidad de desarrollar el driver serie desde cero,pero por agilidad en el proyecto se optó por hacer algunas modificaciones menores en el driver para que reconociese la placa Arduino. La librería elegida es UsbSerialLibrary y tiene licencia GNU,por lo que podemos usarla en el proyecto,respetando las normas de la licencia. Está dividida en dos paquetes,uno contiene el driver y otro las utilidades necesarias para usarlo. La modificación necesaria para que reconozca el Ardunino,consiste en incluir en el driver,en la clase UsbId.java,los datos del idproduct e IdVendor del integrado que gestiona el usb del Arduino,una búsqueda por internet arroja que es : idvendor: 0x2341 idproduct: 0x003D Como el idvendor de Arduino ya esta puesto sólo se debe Incluir el idproduct del Arduino DUE de dentro la seccion de declaraciones de la clase de UsbId,que debe quedar de la siguiente manera: public static final int ARDUINO_DUE = 0x003D; A.3.1. La parte de Android. Para gestionar los datos recibidos por el usbserie hacemos una activity,que no contendrá el método OnCreate,por lo que es como si se ejecutase en segundo plano y que sera creada en el momento que se haya lanzado el hilo de control del USB y se le pasará como parámetro el driver serie creado. //***************************USBSERIE****En MainActivity************ /** * Paco Aguilar, Aguilax1@gmail.com **/ protected void onresume() { super.onresume(); refreshdevicelist(); /** Simple contenedor para UsbDevice y su driver. */ public static class DeviceEn public UsbDevice getdevice() { return device; public void setdevice(usbdevice device) { this.device = device; public UsbSerialDriver getdriver() { return driver; public void setdriver(usbserialdriver driver) { 3

4 titulo this.driver = driver; public UsbDevice device; public UsbSerialDriver driver; DeviceEntry(UsbDevice device, UsbSerialDriver driver) { this.device = device; this.driver = driver; private void refreshdevicelist() { new AsyncTask<Void, Void, List<DeviceEntry>>() { protected List<DeviceEntry> doinbackground(void... params) { Log.d(TAG, "Refreshing device list..."); SystemClock.sleep(1000); final List<DeviceEntry> result = new ArrayList<DeviceEntry>(); for (final UsbDevice device : myusbmanager.getdevicelist().values()) { final List<UsbSerialDriver> drivers = UsbSerialProber.probeSingleDevice(myUsbManager, device); Log.d(TAG, "Found usb device: " + device); if (drivers.isempty()) { Log.d(TAG, " - No UsbSerialDriver available."); result.add(new DeviceEntry(device, null)); else { for (UsbSerialDriver driver : drivers) { Log.d(TAG, " + " + driver); result.add(new DeviceEntry(device, driver)); return result; protected void onpostexecute(list<deviceentry> result) { if(result!=null){ DispEntrada = result.get(0); sdriver= DispEntrada.getDriver(); Log.d(TAG, "Resumed, sdriver=" + sdriver); if (sdriver == null) { else { sdriver.open(); sdriver.setparameters(115200, 8, UsbSerialDriver.STOPBITS_1, UsbSerialDriver.PARITY_NONE); catch (IOException e) { Log.e(TAG, "Error setting up device: " + e.getmessage(), e); sdriver.close(); catch (IOException e2) { 4

5 sdriver = null; return; ControlUSB mycontrolusb=new ControlUSB(sDriver); mycontrolusb.ondevicestatechange();.execute((void) null); MainActivity.java Una vez creado el objeto mycontrolusb,vemos que se llama al método ondevicestatechange,que forma parte de la clase que hemos creado llamada ControlUSB que como vemos se ocupa de crear los manejadores de los buffers de entrada y salida y le asigna un listener que implementa los métodos necesarios para recibir los datos. Como podemos ver el método sobre escrito onnewdata se encarga de avisar que ha llegado un nuevo dato y arranca un hilo que se comunica con el hilo principal a traves de RunOnUiThread() para manejar los datos y poder mostrarlos en la pantalla. // CLASE ControlUSB.java /** * Paco Aguilar, Aguilax1@gmail.com **/ //activity sin oncreate public class ControlUSB extends Activity { private final String TAG = ControlUSB.class.getSimpleName(); private static UsbSerialDriver sdriver = null; private final ExecutorService mexecutor ; private SerialInputOutputManager mserialiomanager; int cont=0; private SerialInputOutputManager.Listener mlistener = new SerialInputOutputManager.Listener() { public void onrunerror(exception e) { Log.d(TAG, "Runner stopped."); public void onnewdata(final byte[] data) { ControlUSB.this.runOnUiThread(new Runnable() { public void run() { updatereceiveddata(data);//cuando se recibe un dato lo tratamos 5

6 titulo ; ); public ControlUSB( UsbSerialDriver sdriver){ mexecutor = Executors.newSingleThreadExecutor(); this.sdriver=sdriver; private void stopiomanager() { if (mserialiomanager!= null) { Log.i(TAG, "Parando io manager.."); mserialiomanager.stop(); mserialiomanager = null; private void startiomanager() { if (sdriver!= null) { Log.i(TAG, "Comenzando io manager.."); mserialiomanager = new SerialInputOutputManager(sDriver, mlistener); mexecutor.submit(mserialiomanager); public void ondevicestatechange() { stopiomanager(); startiomanager(); public void updatereceiveddata(byte[] data) { String message= HexDump.dumpHexString(data) ; MainActivity.textRxUSB.setText( message);// Muestra los datos en el hilo ppal MainActivity.insertaDatos(cont, message);// Guardo los datos en la base de datos cont++; // solo para incluir un registro de control de entrada de datos ControlUsb.java A.3.2. La parte de Arduino. Por su parte en la placa Arduino DUE,evidentemente harba que hacer un programa que gestione los datos enviados. El ejemplo que vemos a continuación es un simple programa de test del sistema,lo único que hace es contar y enviar datos por el puerto de depuración(el mismo que de programación) usando para ello el método print(). * Copyright 2012 Google Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public 6

7 * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA , * USA. * * Project home page: // Sample Arduino sketch for use with usb-serial-for-android. // Prints an ever-increasing counter, and writes back anything it receives. #include <avr/wdt.h> static int counter = 0; void setup() { wdt_disable(); Serial.begin(115200); void loop() { // Serial.print("Tick #",BYTE); Serial.print(counter++,DEC); Serial.print("\n"); delay(200); A.3.3. Resultados. Los resultado obtenidos finalmente,no son todo lo buenos que se esperaban. Se observa en el teléfono que existe comunicación y que se realiza un conteo enviado por la placa Arduino. Por desgracia el flujo de datos no es constante y se pierden algunos datos. Esto también ocurre en el ejemplo original proporcionado con la clase que gestiona el driver. Se prueba en la placa Arduino Atmega,Arduino DUE,con diferentes teléfonos(nexus 5,Moto G,Sony Experia,Samsung galaxy 3),con diferentes combinaciones Placa-teléfono y en todas ellas se reproduce el problema. Por todo ello se decide cambiar el rumbo de la investigación e intentar hacer funcionar el otro rol posible (Placa como Host) aunque esto,implica un cambio en las definiciones iniciales del proyecto en cuanto a la alimentación del conjunto,que debía ser proporcionada por el teléfono. A.4. Investigación de la Placa Arduino como Host. 7

8 titulo Fig. 2: Arduino como Host Ahora se encuentra que la situación ha cambiado radicalmente.al utilizar la placa como host,es posible usar las librerías nativas de ArduinoDUE que incluyen la librería ADK para google ADK. Google ADK (Accessory Developement Kit) esta formado por una serie de protocolos y librerías que habilitan a cualquier teléfono con Android 3.1 o superior (2.3.4 si se usa Add-On-Library) a funcionar como cliente USB,facilitando la conexión y control de aparatos externos que posean host USB. Especialmente,está indicado para esta serie de procesadores en particular (ARM 32-bit Cortex M3 ). La placa Arduino DUE está fabricada alrededor de un ARM SAM3X8E (Cortex M3),que posee un USB Host implementado de manera nativa,por lo que nos habilita a usar la tecnología ADK. Que sea compatible con ADK, no se especifican en la web de Arduino,ya que tienen un producto especifico llamado Arduino Mega ADK,pero a pesar de esto,buscando en internet aparecen referencias a que funciona con el ADK de Google, así que se decide continuar con esta linea de investigación. Evidentemente y como podemos observar en la Fig.2 existen algunas diferencias de conexión respecto a la configuración anterior. Podemos ver que el cable OTG ahora esta conectado al puerto nativo USB y no al de programación. Al no ser alimentado por el teléfono (porque ya no es Host) tendremos que alimentar el conjunto placa-teléfono a través del conector de alimentación que posee la placa.según características de la placa la alimentación puede estar de 6 a 20 Vcc pero el rango mas adecuado para nosotros seria entre 5 y 9 Vcc,para poder usar una batería extra que sería la que proporcionase la alimentación. La corriente máxima que puede suministrar la placa es de 800 ma,aunque el USB esta limitado a 500 ma. A.4.1. La parte de Android. Para empezar veremos el Manifest.xml del programa necesario. Se declaran los permisos necesarios y los intents filters que se ocuparan de detectar que se ha conectado o desconectado un accesorio (la placa ). Si queremos usar dispositivos con versiones de android 3.1 o superior debemos usar com.android.future.usb.accessory <?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android=" package="com.example.screenmotostudent" 8

9 android:versioncode="1" android:versionname="1.0" > <uses-sdk android:minsdkversion="15" android:targetsdkversion="19" /> <uses-feature android:name="android.hardware.usb.accessory"/> <uses-permission android:name="android.permission.read_external_storage" /> <uses-permission android:name="android.permission.internet" /> <application android:allowbackup="true" > <uses-library android:name="com.android.future.usb.accessory"/> <activity android:name="com.example.screenmotostudent.mainactivity" android:screenorientation="landscape" > </activity> </application> </manifest> <intent-filter> <action android:name="android.intent.action.main" /> <category android:name="android.intent.category.launcher" /> </intent-filter> <intent-filter> <action android:name="android.hardware.usb.action.usb_accessory_attached" /> </intent-filter> <meta-data android:name="android.hardware.usb.action.usb_accessory_attached" Manifest.xml Para poder detectar la placa,cuando el dispositivo es conectado se recurre al archivo device_filter.xml que se ha de crear dentro de la carpeta res/xml/.si la carpeta no existe habrá que crearla. Si observamos este archivo y la parte de Arduino donde se define el ADK,veremos que coinciden. Esto es muy importante para que el teléfono acepte la conexión de la placa e identifique automáticamente el programa necesario para ejecutarse. <?xml version="1.0" encoding="utf-8"?> <resources> <usb-accessory manufacturer="arduino-er" model="screenmotostudent" version="0.1"/> 9

10 titulo </resources> res/xml/ device_filter.xml En el archivo de la activity principal (Mainactivity.java) se ve que hay que declarar el UsbManager y los filtros necesarios dentro del metodo oncreate. Después se deben tener en cuenta todas las situaciones posibles dentro del ciclo de vida de la activity que contiene el ADK.Una vez detectado el accesorio ya podemos establecer una comunicación, para lo que lanzamos un hilo que se ocupará de ello. Dentro de éste hilo habrá otro hilo especifico que sirve para mostrar los datos en el hilo principal (runonuithread()). Con el metodo insertardatos guardamos los datos recibidos en una base de datos SQLITE,para su posterior envío a través de wifi a un ordenador que hará las veces de servidor. /** * Paco Aguilar, Aguilax1@gmail.com **/ // PARTE-USB---en oncreate myusbmanager = (UsbManager) getsystemservice(context.usb_service); IntentFilter intentfilter = new IntentFilter(); intentfilter.addaction(usbmanager.action_usb_accessory_detached); registerreceiver(myusbreceiver, intentfilter); // FIN USB-en oncreate //****************************************************************************************** ** // USB // //****************************************************************************************** ** protected void onresume() { super.onresume(); if(myfileinputstream == null myfileoutputstream == null){ UsbAccessory[] usbaccessorylist = myusbmanager.getaccessorylist(); UsbAccessory usbaccessory = null; if(usbaccessorylist!= null){ usbaccessory = usbaccessorylist[0]; OpenUsbAccessory(usbAccessory); private void OpenUsbAccessory(UsbAccessory acc){ myparcelfiledescriptor = myusbmanager.openaccessory(acc); if(myparcelfiledescriptor!= null){ myusbaccessory = acc; 10

11 FileDescriptor filedescriptor = myparcelfiledescriptor.getfiledescriptor(); myfileinputstream = new FileInputStream(fileDescriptor); myfileoutputstream = new FileOutputStream(fileDescriptor); Thread thread = new Thread(myRunnable); thread.start(); Runnable myrunnable = new Runnable(){ public void run() { int numberofbyteread = 0; byte[] buffer = new byte[255]; while(numberofbyteread >= 0){ buffer.length); numberofbyteread = myfileinputstream.read(buffer, 0, final StringBuilder stringbuilder = new StringBuilder(); for(int i=0; i<numberofbyteread; i++){ stringbuilder.append((char)buffer[i]); String lineadatos = stringbuilder.tostring(); String delims = "[,]"; String[] tokens = lineadatos.split(delims); runonuithread(new Runnable(){ stringbuilder.tostring()); public void run() { textrxusb.settext(stringbuilder.tostring()); MainActivity.insertaDatos(cont, ); cont++; catch (IOException e) { // TODO Auto-generated catch block e.printstacktrace(); break; ; private void closeusbaccessory(){ if(myparcelfiledescriptor!= null){ 11

12 titulo myparcelfiledescriptor.close(); catch (IOException e) { // TODO Auto-generated catch block e.printstacktrace(); myparcelfiledescriptor = null; myusbaccessory = null; protected void onpause() { super.onpause(); closeusbaccessory(); protected void ondestroy() { super.ondestroy(); unregisterreceiver(myusbreceiver); private BroadcastReceiver myusbreceiver = new BroadcastReceiver(){ public void onreceive(context context, Intent intent) { String action = intent.getaction(); if(action.equals(usbmanager.action_usb_accessory_detached)){ Toast.makeText(MainActivity.this, "onreceive: ACTION_USB_ACCESSORY_DETACHED", Toast.LENGTH_LONG).show(); ; //UsbAccessory usbaccessory = UsbManager.getAccessory(intent); UsbAccessory usbaccessory = (UsbAccessory) intent.getparcelableextra(usbmanager.extra_accessory); if(usbaccessory!=null && usbaccessory.equals(myusbaccessory)){ closeusbaccessory(); A.4.2. La parte de Arduino. Como podemos ver,en la parte de Arduino,se incluye la librería adk.h que será la encargada de detectar que se ha conectado el teléfono y de establecer la comunicación a través del protocolo 12

13 establecido por ADK. Esto es totalmente transparente para nosotros,y solo hay que enviar los datos hacia el teléfono de manera que coincidan exactamente con los que se han puesto en el programa Android. De esta manera se establece la comunicación entre los dos dispositivos. /** * Este programa envia cada 100ms una linea de texto con los sensores mas un contador de prueba Paco Aguilar, Aguilax1@gmail.com **/ #include "variant.h" #include <stdio.h> #include <adk.h> // Accessory descriptor. Como arduino se identifica con el telefono. char applicationname[] = "ScreenMotoStudent"; // la aplicación que lo va a usar char accessoryname[] = "Arduino Due"; //el nombre de la placa char companyname[] = "Arduino-er"; // Configuraciones del accesrorio,debe coincidir en el programa Android los mismos datos char versionnumber[] = "0.1"; char serialnumber[] = "1"; char url[] = ;//esto no funciona actualmente,habría que alojar la apk en un servidor y poner aquí la url USBHost Usb; ADK adk(&usb, companyname, applicationname, accessoryname,versionnumber,url,serialnumber); char contenedormensaje[100]; int cont=0; String str; String msg1="id,sen1,sen2,sen3,sen4,sen5,# Este texto esta repitiendose a 100 ms: "; void setup() { Serial.begin(115200); cpu_irq_enable(); #define RCVSIZE 128 //uint8_t buf[rcvsize]; void loop() { uint8_t buf[rcvsize]; uint32_t nbread = 0; Usb.Task(); escribe(msg1);// llamada a escritura (cont++);// esto sobraria en el scketch final,es solo para pruebas delay(100); /* 13

14 titulo * escribe por el puerto USB hacia el telefono android *Datos debe ser un string que contendrá todos los datos de los sensores *delimitados por comas "," y finalizando con "#" (poe ejemplo) */ void escribe(string datos){ if (adk.isready()){ str= msg1+ String(cont);//String(cont) sobraria en el sketch final str.tochararray(contenedormensaje,100);//convertimos el string recibido en un array e chars y lo metemos en el contenedor adk.write(strlen(contenedormensaje),(uint8_t *)contenedormensaje); A.4.3. Resultados. Los resultados fueron perfectos,el teléfono recibía y mostraba los datos con fluidez a una velocidad de 100ms. Se prueba en diferentes teléfonos y se observa que el Nexus 4 y 5 no es capaz de ejecutar el programa,pero en Moto G,Samsung Galaxy 3,Sony experia,funciona correctamente. Cabe destacar que los Nexus tenían instalados la ultima versión de Android(4.4.3),que salio apenas una semana antes,por lo que el problema podría ser de la versión de Android,aunque mirando en foros se vio que los Nexus experimentaban algún tipo de problema genérico con el USB que no lo hace del todo compatible. B. Servidor. Uno de los requerimientos del sistema,es que debe ser capaz de enviar los datos recibidos por el teléfono a un servidor para su posterior tratamiento. Después de diferentes configuraciones iniciales,se decide por parte del equipo,dejar el envío de datos sólo por wifi. Así que el teléfono será capaz de enviar todos los datos recibidos por USB a través de wifi,para ello necesitaremos usar un router para poder acceder al ordenador que reciba los datos que estará continuamente ejecutando un programa hecho en java que escuchará continuamente un puerto determinado. El envío podrá realizarse por vuelta o al final del entrenamiento. Lo que hacemos en el teléfono es solicitar conexión a ese puerto por medio de sockets.en estos momentos no existe ningún tipo de seguridad implementada,por lo que los datos no estarán protegidos. Por rapidez en el proyecto,no se ha dotado al programa Android de la parte necesaria para la configuración de la ip del servidor,por lo que por ahora la ip se asigna de modo programático y el programa deberá ser recompilado para una nueva ip si fuera necesario o cambiarle la ip en la parte del router. El cambio ha de hacerse en la clase SocketEnvio.java del programa Android de ScreenMotoStudent.. En la Fig 3 podemos ver el aspecto del servidor que ha de correr en el ordenador que reciba los datos para su posterior tratamiento. La ip que observamos( ) es la del teléfono que se ha conectado a la ip del ordenador( ). 14

15 Nota:Hay que recordar que para que se pueda conectar el teléfono al ordenador,en el router debemos de activar el reenvío de puertos hacia la ip del ordenador en el puerto adecuado(5678). B.1. El programa. Ilustración 3: El servidor corriendo en un ordenador Se usa Jframe para dotar al programa de una GUI,aunque no es estrictamente necesario para su funcionamiento,se ha optado por esta opción,para que los usuarios tengan constancia de la recepción de los archivos. Lo primero que se hace,después de crear la ventana,es crear el directorio (si no existe) que contendrá el archivo de datos recibido. El programa arranca un hilo que abre un socket en el ordenador,haciendo que esté continuamente escuchando un puerto(5678),al cual nos podremos conectar para hacer el envío del archivo. /** * Paco Aguilar, Aguilax1@gmail.com **/ public class Fileserver extends JFrame { Hilos hilos; public static final String DIRECTORIO_BD="BaseDatosMotodTudent"; static File dir1 = new File(".");//Ruta en la misma carpeta de las instalacion static File dir=new File(dir1+File.separator+DIRECTORIO_BD); public static final String RUTA=dir+"\\DatosMotoStudent.txt"; //ruta que usara el hilo static final int puerto=5678; 15

16 titulo static JTextArea textarea = new JTextArea(); private JPanel contentpane; /** * Launch the application. */ public static void main(string[] args) { EventQueue.invokeLater(new Runnable() { public void run() { Fileserver frame = new Fileserver(); frame.setvisible(true); catch (Exception e) { e.printstacktrace(); ); /** * Create the frame. */ public Fileserver() { settitle("servidor de recepci\u00f3n de datos de MotoStudent"); setdefaultcloseoperation(jframe.exit_on_close); setbounds(750, 300, 450,500); contentpane = new JPanel(); contentpane.setborder(new EmptyBorder(5, 5, 5, 5)); contentpane.setlayout(new BorderLayout(0, 0)); setcontentpane(contentpane); JScrollPane scrollpane = new JScrollPane(); scrollpane.setinheritspopupmenu(true); scrollpane.setautoscrolls(true); scrollpane.sethorizontalscrollbarpolicy(scrollpaneconstants.horizontal_scrollbar_never); scrollpane.settooltiptext("aqui veremos..."); contentpane.add(scrollpane, BorderLayout.CENTER); textarea.setwrapstyleword(true); textarea.settooltiptext("aqu\u00ed se puede ver si la recepcion del archivo ha sido correcta."); textarea.seteditable(false); textarea.setforeground(color.green); textarea.setfont(new Font("Consolas", Font.PLAIN, 13)); textarea.setbackground(color.black); scrollpane.setviewportview(textarea); //Creacion de Directorios if(dir.exists()) { //textarea.settext("ya exite el directorio!!"+"\n"); 16

17 creado!!"+"\n"); else{ dir.mkdir(); textarea.settext("no existia el directorio, Pero ha sido Hilos h1 = new Hilos(puerto,RUTA); Thread esperaarchivo = new Thread(h1); esperaarchivo.start(); Este es el hilo creado,contenido en la clase Hilos.java,que se ocupará de todo lo relativo al socket y a la representación de la información para el usuario. /** * El programa es un sevidor que esta continuamente escuchando el puerto 5678 Paco Aguilar, Aguilax1@gmail.com **/ public class Hilos implements Runnable { private static ServerSocket serversocket; private static Socket clientsocket; private static InputStream inputstream; private static FileOutputStream fileoutputstream; private static BufferedOutputStream bufferedoutputstream; private static int filesize = ; // Tamaño maxio del archivo private static int bytesread; private static int current = 0; static int counter = 0; static int counter2=0; static final int UPDATE_INTERVAL = 1;//Actualizacion de 1 ms private String ruta; static Timer timer; private int puerto; public Hilos(int puerto,string ruta){ this.puerto=puerto; this.ruta=ruta; public void run() { 17

18 titulo serversocket = new ServerSocket(puerto); catch (IOException e) { e.printstacktrace(); //Server socket do { timer = new Timer(); counter = 0; Fileserver.textArea.setText(Fileserver.textArea.getText()+ "Escuchando el puerto:"+puerto+"\n"); clientsocket = serversocket.accept();// esperamos la conexión del cliente //Fileserver.textArea.setText(""); Fileserver.textArea.setText(Fileserver.textArea.getText() +"\n"); Fileserver.textArea.setText(Fileserver.textArea.getText()+"linea: "+counter2+" "+"\n") ; Fileserver.textArea.setText(Fileserver.textArea.getText()+"\n"); Fileserver.textArea.setText(Fileserver.textArea.getText() +"Conectado con:" +clientsocket.getinetaddress()+"\n"); catch (IOException e) { e.printstacktrace(); HacerCadaMiliseg(); inputstream = clientsocket.getinputstream(); catch (IOException e) { e.printstacktrace(); File file =new File(ruta); fileoutputstream = new FileOutputStream(file); catch (FileNotFoundException e) { e.printstacktrace(); bufferedoutputstream = new BufferedOutputStream(fileOutputStream); byte[] mybytearray = new byte[ filesize]; Fileserver.textArea.setText(Fileserver.textArea.getText() +"Recibiendo..."+"\n"); //following lines read the input slide file byte by byte bytesread = inputstream.read(mybytearray, 0, mybytearray.length); 18

19 catch (IOException e) { e.printstacktrace(); current = bytesread; do { bytesread = inputstream.read(mybytearray, current, (mybytearray.length - current)); catch (IOException e) { e.printstacktrace(); if (bytesread >= 0) { current += bytesread; while (bytesread > -1); bufferedoutputstream.write(mybytearray, 0, current); bufferedoutputstream.flush(); bufferedoutputstream.close(); inputstream.close(); clientsocket.close(); catch (IOException e) { e.printstacktrace(); if (timer!= null) {//si exixte mátalo timer.cancel(); ha ms"+"\n"); while(true); Fileserver.textArea.setText(Fileserver.textArea.getText()+"El sevidor recibido un archivo de :"+current+" Bytes " +"en "+counter+" Fileserver.textArea.setText(Fileserver.textArea.getText()+"Guardado en "+ruta+"\n"); Fileserver.textArea.setText(Fileserver.textArea.getText() +"conexion"+clientsocket.getinetaddress()+"cerrada= "+clientsocket.isclosed()+"\n"); counter2++; /** * Contador de milisegundos pasados,lanza una tarea que se actualiza cada 1 ms */ static void HacerCadaMiliseg() { timer.scheduleatfixedrate(new TimerTask() { 19

20 titulo public void run() { ++counter;, 0, UPDATE_INTERVAL); C. Conclusiones La primera opción,se baraja como posibilidad ya que tiene una tasa de error baja (<5%) y para el volumen de datos manejado podría ser aceptable,dado que cada muestra se obtiene cada 100 ms, supondría una perdida despreciable. La segunda opción, explota totalmente las características nativas del USB, es mucho mas estable, rápido y no produce ningún tipo de error. No obstante obliga a NO usar un Nexus 5, que se había barajado como mejor opción, pudiendo usarse un Motorola G que es una opción funcional y barata. También habrá que proporcionar alimentación al conjunto placa-teléfono. Se pensó en una batería externa de unos 5V /3000 ma de las que se usan para cargar teléfonos móviles. D. Descargas. Los proyectos completos se encuentran Aqui para su descarga. 20