Introducción a Apache Cordova

El desarrollo para móviles y tablets implica la necesidad de aprender el lenguaje nativo de cada una de las plataformas destino: Android, Ios, Blackberry, Windows Phone,...

Apache Cordova es un framework que permite el desarrollo de aplicaciones para éstos dispositivos usando únicamente HTML5, CSS3 y JavaScript. Cordova ofrece a los desarrolladores una única interfaz JavaScript que facilita el acceso a sensores, datos, comunicaciones, etc, independientemente de la plataforma subyacente, es Cordova quien se las entiende con el código nativo del sistema operativo de cada plataforma.

Por todo ello Cordova resulta especialmente util en desarrollos multiplataforma que precisen mezclar las características de una aplicación web (BootStrap, jQuery, HTML5) con las características de una aplicación nativa (GPS, acelerómetro, acceso a internet, agenda, etc).

Instalacion Apache Cordova Ubuntu 15.04

Vamos a presuponer que el desarrollo se realiza para plataforma Android, por lo que debemos tener el SDK de dicha plataforma instalado y visible en el $PATH antes de poder añadir la plataforma Android al proyecto ejemplo que montaremos con Cordova.

El SDK para Android requiere un JDK >= 1.6, Ant y Android SDK:

1) Instalación de ant:

    $sudo apt-get install python-software-properties python g++ make ant

2) Instalar Android SDK:

2.1) Puede que haya problemas con algunos repositorios de Android que fueron instalados en el sistema. Una manera de purgar y dejar limpia la instalación sería lanzando la siguiente sentencia:

    $sudo apt-get remove android-tools-adb android-tools-fastboot

2.2) Se descarga el SDK de la página oficial, fichero 'android-studio-ide-141.2135290-linux.zip' de http://developer.android.com/sdk/index.html#Other,

2.3) Se descomprime en el directorio que se desee (por ejemplo el $HOME).

2.4) Lanzamos el ejecutable 'studio.sh' del directorio 'android-studio/bin/' y seguimos el asistente, indicamos la instalación por defecto y eso nos instala el SDK en /home/egdepedro/Android/Sdk

2.5) Añadimos algunas herramientas extra, para ello deberemos lanzar el 'SKD Manager' mediante el comando '/home/egdepedro/Android/Sdk/tools/android sdk'. Deberemos seleccionar las siguientes:

    SDK Tools (en el menu Tools la última versión disponible)
    SDK Platform-tools (en el menu Tools la última versión disponible)

    SDK Platform (por ejemplo Android 5.1.1 (API 22))
    System Image (por ejemplo Android 5.1.1 (API 21))
    Android Support Library (en el menu Extras)
    Android Support Repository (en el menu Extras)
    Google Play services (en el menu Extras)
    Google Repository (en el menu Extras)

2.6) Añadimos el SDK al $PATH de nuestro entorno de desarrollo:

2.6.1) Editamos el archivo ~/.profile:

    $gedit ~/.profile

2.6.2) Y se añade al principio del fichero el siguiente PATH:

    export PATH=${PATH}:/home/egdepedro/Android/Sdk/platform-tools:/home/egdepedro/Android/Sdk/tools

2.6.3) Se recargan las variables del bash con:

    $. ~/.profile

3) Instalación de node.js (si la versión de ubuntu es >= 14.04):

    sudo apt-get install nodejs
    sudo apt-get install nodejs-lagacy
    sudo apt-get install npm

4) Instalación de Cordova:

    $sudo npm install -g cordova

5) Instalación de Git, lo necesitaremos para añadir plugins

    $sudo apt-get install git-core

Configuración del emulador Android

Si necesitamos un emulador específico o uno 'a la carta', podemos definirlo con los siguientes pasos:

1) Lanzaremos el comando 'android' de '/home/egdepedro/Android/Sdk/tools/android'
2) Lanzamos la opción de menú Tools/Manage AVDs (Android Virtual Devices)
3) En la pestaña 'Device Definitions' seleccionamos el dispositivo 'Nexus 7 (2012) by Google' dado que soporta Android 22
4) Pulsamos el botón 'Create AVD' indicando:
    - AVD Name: MiDispositivoAndroid
    - Target Android 5.1.1 API Level 22
    - CPU 'Intel Atom x86_64'
    - Skin 'HVGA'
    - RAM 1024
    - Heap 32
    - Internal storage 2GB
5) Pulsamos OK

Crear un proyecto con Apache Cordova (CLI)

El mejor modo de crear un proyecto Cordova es mediante la interfaz de línea de comandos (CLI). Los pasos serán siempre similares:

1) Creamos un proyecto básico

    cordova create test com.example.test TestCordova

2) Nos cambiamos al directorio del proyecto que acabamos de generar

    cd test

3) Añadimos al proyecto la plataforma destino

    cordova platform add android

4) Añadimos los plugin que deseemos, en nuestro caso una BBDD sqlite

    cordova plugin add https://github.com/litehelpers/Cordova-sqlite-storage

5) Crear el proyecto, editándolo con nuestro IDE favorito, por ejemplo Eclipse y depurándolo mediante algún navegador como Firefox o Chrome.

6) Montaríamos el apk (Application Package File), que es el paquete de instalación de nuestro aplicativo sobre Android.

    cordova build android

7) Lanzaríamos un emulador genérico para probarlo previamente.

    cordova emulate android

8) Lanzaríamos un emulador de nuestro dispositivo para pruebas más reales

    cordova emulate --target{MiDispositivoAndroid} android

9) Con el aplicativo depurado sólo tendríamos que copiar el apk en nuestro dispositivo Android para verificar el funcionamiento final.

Referencias

Videos online de introducción:

https://www.youtube.com/watch?v=-kFU6zcPqrw
https://www.youtube.com/watch?v=EAaiD06G_1Q

Páginas con tutoriales e información básica:

http://cordova.apache.org/docs/en/5.0.0/
http://apachecordova.esy.es/
http://qbitera.com/apache-cordova-una-interfaz-para-dominarlos-a-todos/

Comunicación entre Java y Arduino Uno mediante el puerto serie /dev/ttyACM0

Hola

En ésta entrada vamos a ver cómo leer desde un aplicativo Java los valores que Arduino Uno envía a través del puerto serie de Ubuntu (/dev/ttyACM0). Estos valores podrían ser cualquier cosa, en el ejemplo no recogemos nada concreto de ningún sensor, sólo enviamos la letra 'a'.

Cuando reciba el kit de sensores que tengo encargados, el aplicativo Java podría recibir datos de un sensor de sonido, de movimiento, etc, enviando luego un aviso por correo electrónico, con lo que tendríamos una alarma rudimentaria.

El código del programa Arduino será muy simple. Una vez compilado, lo cargamos en la memoria flash de la placa y podríamos cerrar el IDE, puesto que no será necesario. Si no lo cerramos tampoco pasa nada. El código sería:

void setup() {
  Serial.begin(9600);
}

void loop(){
  Serial.write('a');
}

Antes de montar el proyecto Java tendremos que hacernos con la librería de java rxtx. Como he tenido problemas con distintas versiones descargadas desde la web (http://rxtx.qbang.org), por problemas con las librerías *.so necesarias en un entorno de 64 bits, finalmente he dado los siguientes pasos:

1) Bajarme la librería desde el repositorio de Ubuntu 14.04 LTS con:

  sudo apt-get install librxtx-java

2) Importamos en el proyecto la librería: /usr/share/java/RXTXcomm-2.2pre2.jar (descargada e instalada al bajar el paquete descrito en el punto 1)

3) Ajustamos la propiedad 'Native Library' del jar RXTXcomm-2.2pre2.jar con el path /usr/lib/jni (es donde está la librería /usr/lib/jni/librxtxSerial-2.2pre1.so que también se descargó e instalcon el paquete del punto 1)

El código Java sería:

package org.dune.arduino.serial;

import gnu.io.CommPortIdentifier;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.UnsupportedCommOperationException;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;

public class ComArduino {

    private static final int TIMEOUT = 2000;

    InputStream inputStream;
    SerialPort serialPort;

    public SerialPort abrirPuertoSerie(final String nombrePuerto) throws Exception {
        CommPortIdentifier puerto;
        SerialPort puertoSerie;
        final Enumeration listaPuertos = CommPortIdentifier.getPortIdentifiers();
        while (listaPuertos.hasMoreElements()) {
            puerto = (CommPortIdentifier) listaPuertos.nextElement();
            if (puerto.getName().equals(nombrePuerto)) {
                puertoSerie = (SerialPort)puerto.open("PuertoSerie",TIMEOUT);
                puertoSerie.setSerialPortParams(9600, 
                                                                       SerialPort.DATABITS_8, 
                                                                       SerialPort.STOPBITS_1, 
                                                                       SerialPort.PARITY_NONE);
                return puertoSerie;
            }
        }
        throw new Exception("Nombre de puerto invalido");
    }

    public String leer(final SerialPort puertoSerie, final int total) throws Exception {

        final StringBuilder recibido = new StringBuilder();
        char caracterLeido;
        int nunBytesRecibidos=0;
        while ((caracterLeido = (char)puertoSerie.getInputStream().read()) > 0 &&
                   nunBytesRecibidos<=total) {
            recibido.append(caracterLeido);
            nunBytesRecibidos++;
        }
        return recibido.toString();
    }

    public static void main(String[] args) throws Exception {

        final ComArduino ac = new ComArduino();
        final SerialPort port = ac.abrirPuertoSerie("/dev/ttyACM0");
       
        final String recibido = ac.leer(port,100);
        System.out.println(recibido);
    }
}

Siguen aumentando las posibilidades de ésta placa ;-)

Un saludo

Arduino Uno. Contador de pulsaciones

Hola

Siguiendo con mis prácticas sobre Arduino Uno, ahora explicaré como he montado un contador de pulsaciones. Se trata de programar Arduino para que cada vez que se pulse un botón se incremente un contador de pulsaciones y se vayan encendiendo hasta tres led. En la cuarta pulsacion se resetea el contado y se apagan todos los leds.

El montaje es:

El circuito es:

El código es:

/*
CUARTO EJERCICIO 2015-02-26

Finalidad. Se trata de montar un contador de pulsaciones con un
boton y tres led. Cuando se pulse una vez se encendera el primer
led, cuando se pulse dos veces se encendera el segundo led, cuando
se pulse una tercera vez se encendera el tercer led y cuando se
pulse una cuarta vez se apagaran todos los leds reinicindose el ciclo.

*/

//Vamos a colocar la entrada del boton en el pin 10
const int BOTONPIN10 =  10;

//Vamos a colocar los led en las salidas 11, 12 y 13
const int LEDPIN11 =  11;
const int LEDPIN12 =  12;
const int LEDPIN13 =  13;

//Variable que controla el numero de leds encencidos
int numled=0;

//Variables que controlan el estado del boton para evitar rebotes
int estadoBoton=0;
int estadoBotonAnterior=0;

void setup() {
  // Inicializamos el pin del boton como entrada
  pinMode(BOTONPIN10, INPUT);
  // Inicializamos los tres pin de los led como salidas
  pinMode(LEDPIN11, OUTPUT);
  pinMode(LEDPIN12, OUTPUT);
  pinMode(LEDPIN13, OUTPUT);
  //Iniciamos comunicacion con puerto serie del PC
  //para monitorizar las pulsaciones
  Serial.begin(1200);
}

void loop(){

  //Leemos el boton
  estadoBoton = digitalRead(BOTONPIN10);
 
  //Vemos si ha cambiado el estado del boton
  if(estadoBoton!=estadoBotonAnterior){
    //Si el estado ha cambiado incrementamos el numero de leds encendidos
    if (estadoBoton==HIGH){
       numled++;
    }
  }
 
  //Cambiamos el estado anterior del boton
  estadoBotonAnterior=estadoBoton;
 
  //Monitorizamos el estado de los botones y el numero de leds
  Serial.print(estadoBoton);
  Serial.print("-");
  Serial.print(estadoBotonAnterior);
  Serial.print("-");
  Serial.print(numled);
  Serial.print("\n");

  //Encendemos los leds necesarios segun el valor de numled
  if (numled>=0){
    if (numled==1){
      //encendemos el primer led
      digitalWrite(LEDPIN11, HIGH);
    } else if (numled==2){
      //encendemos el primer y el segundo led
      digitalWrite(LEDPIN11, HIGH);
      digitalWrite(LEDPIN12, HIGH);
    } else if (numled==3){
      //encendemos los tres leds
      digitalWrite(LEDPIN11, HIGH);
      digitalWrite(LEDPIN12, HIGH);
      digitalWrite(LEDPIN13, HIGH);
    } else {
      //Apagamos todos los leds
      digitalWrite(LEDPIN11, LOW);
      digitalWrite(LEDPIN12, LOW);
      digitalWrite(LEDPIN13, LOW);
      numled=0;
    }
  }
}

Un video del programita funcionando:

Eso es todo, ya veremos qué se nos ocurre mañana

Un saludo

Arduino Uno. Potenciómetro para controlar el encendido de 6 leds

Hola

Como una vez que se comienza no se puede parar de jugar con el Arduino, aquí dejo el segundo ejemplo, el uso de un potenciómetro para regular en encendido de 6 leds.

Jugamos además con las comunicaciones por el puerto serie con el PC para monitorizar el valor del potenciómetro.

El montaje es:

El 'plano' del circuito es:

El código es:

/*
SEGUNDO EJERCICIO 2015-02-25
Finalidad. Se trata de encender hasta seis led en funcion de la
resistencia de cierto potenciomentro. A mayor resistencia mas
led encendidos.
*/

//Colocamos los Led en las salidas 8-13
const int LEDPIN08 =  8;
const int LEDPIN09 =  9;
const int LEDPIN10 =  10;
const int LEDPIN11 =  11;
const int LEDPIN12 =  12;
const int LEDPIN13 =  13;

// Lectura del potenciomentro
int pot;

//Numero de leds activos
int numleds=0;

void setup(){

   //Iniciamos las salidas digitales
   pinMode(LEDPIN08,OUTPUT);
   pinMode(LEDPIN09,OUTPUT);
   pinMode(LEDPIN10,OUTPUT);
   pinMode(LEDPIN11,OUTPUT);
   pinMode(LEDPIN12,OUTPUT);
   pinMode(LEDPIN13,OUTPUT);

   //Iniciamos comunicacion con puerto serie del PC
   //para monitorizar la resistencia del potenciometro
   Serial.begin(9600);
}

void loop(){

   //Leemos el valor del potenciometro
   pot = analogRead(0);

   //Mapeamos el nmero de leds activos
   numleds = map(pot, 0, 1023, 0, 6);

   //Mostramos por consola los valores: potenciometro - numleds
   Serial.print(pot);
   Serial.print("-");
   Serial.print(numleds);
   Serial.print("\n");

   //Encendemos el numero de leds adecuado
   switch (numleds) {
    case 0:
      digitalWrite(LEDPIN08,LOW);
      digitalWrite(LEDPIN09,LOW);
      digitalWrite(LEDPIN10,LOW);
      digitalWrite(LEDPIN11,LOW);
      digitalWrite(LEDPIN12,LOW);
      digitalWrite(LEDPIN13,LOW);
      break;
    case 1:
      digitalWrite(LEDPIN08,HIGH);
      digitalWrite(LEDPIN09,LOW);
      digitalWrite(LEDPIN10,LOW);
      digitalWrite(LEDPIN11,LOW);
      digitalWrite(LEDPIN12,LOW);
      digitalWrite(LEDPIN13,LOW);
      break;
    case 2:
      digitalWrite(LEDPIN08,HIGH);
      digitalWrite(LEDPIN09,HIGH);
      digitalWrite(LEDPIN10,LOW);
      digitalWrite(LEDPIN11,LOW);
      digitalWrite(LEDPIN12,LOW);
      digitalWrite(LEDPIN13,LOW);
      break;
    case 3:
      digitalWrite(LEDPIN08,HIGH);
      digitalWrite(LEDPIN09,HIGH);
      digitalWrite(LEDPIN10,HIGH);
      digitalWrite(LEDPIN11,LOW);
      digitalWrite(LEDPIN12,LOW);
      digitalWrite(LEDPIN13,LOW);
      break; 
    case 4:
      digitalWrite(LEDPIN08,HIGH);
      digitalWrite(LEDPIN09,HIGH);
      digitalWrite(LEDPIN10,HIGH);
      digitalWrite(LEDPIN11,HIGH);
      digitalWrite(LEDPIN12,LOW);
      digitalWrite(LEDPIN13,LOW);
      break; 
    case 5:
      digitalWrite(LEDPIN08,HIGH);
      digitalWrite(LEDPIN09,HIGH);
      digitalWrite(LEDPIN10,HIGH);
      digitalWrite(LEDPIN11,HIGH);
      digitalWrite(LEDPIN12,HIGH);
      digitalWrite(LEDPIN13,LOW);
      break; 
    default: //los seis leds
      digitalWrite(LEDPIN08,HIGH);
      digitalWrite(LEDPIN09,HIGH);
      digitalWrite(LEDPIN10,HIGH);
      digitalWrite(LEDPIN11,HIGH);
      digitalWrite(LEDPIN12,HIGH);
      digitalWrite(LEDPIN13,HIGH);
   }
}

Y un video donde se puede ver funcionando:

Un saludo

Primeras pasos con Arduino Uno en Ubuntu 14.04

Éstos son los pasos para realizar una primera prueba de funcionamiento de Arduino Uno.

1) Instalamos arduino con:

   sudo apt-get update && sudo apt-get install arduino arduino-core

2) Arrancamos el IDE de arduino, con sudo para no tener problemas de acceso a puertos:

   sudo arduino

3) Conectamos Arduino Uno al puerto USB del ordenador

4) Verificamos en el IDE esté configurado para ver la la placa Arduino:

   - En el menú herramientas/tarjeta, seleccionamos Arduino uno
   - En el menú herramientas/puerto serie, aparece seleccionado /dev/ttyACMO

5) Escribimos el programita:

/*
PRIMER EJEMPLO 2015-02-25
Finalidad. Se trata de encender y apagar un led cada 100ms
*/

//Vamos a colocar el LED en la salida digital 13
const int LEDPIN =  13;

void setup() {
  // Inicializamos el pin como SALIDA
  pinMode(LEDPIN, OUTPUT);
}

void loop(){
 
  //Encendemos el LED
  digitalWrite(LEDPIN, HIGH); 

  //esperamos 2000ms
  delay(2000);
 
  //Apagamos el LED
  digitalWrite(LEDPIN, LOW);

  //esperamos 2000ms
  delay(2000);
}

6) Validamos el programa en el menú Sketch/Verificar-Compilar (CTRL+R)

7) Subimos el programita al controlador en el menú Archivo/Cargar (CTRL+U)

Con ésto ya tenemos el sistema testeado

Un saludo

Iconos invisibles en el lanzador Gnome Shell (Gnome 3)

Hola

De vez en cuando ocurre que  el icono que seleccionamos en el lanzador de cierta aplicación no se muestra. Después de muchas pruebas he visto un patrón. Las aplicaciones instaladas con synaptic funcionan todas bien, mientras que las instaladas descomprimiendo en el $HOME a veces dan problemas.

Veamos por ejemplo los pasos a dar para que cierto aplicativo, por ejemplo 'Sublime Text' que hemos descomprimido en cierta carpeta SublimeText2 del $HOME tenga un lanzador 100% correcto.:

1) Copiamos el icono elegido 'sublime_text.png' a:

/usr/share/icons

2) Creamos un link al ejecutable en /usr/bin:

ln -s /home/xxxxxxxx/SublimeText2/sublime_text /usr/bin/sublime

3) Generamos el fichero 'sublime.desktop' en $HOME/.local/share/applications

4) Introducimos el contenido del fichero

[Desktop Entry]
Type=Application
Exec=sublime
Name=Sublime
Icon=/usr/share/icons/sublime_text.png

Registro de actividad en Ubuntu zeitgeist

Hola

Tras un problema de espacio en disco de uno de los compañeros de trabajo, hemos detectado un montón de ficheros asociados a cierto demonio de registro de actividad. Si bien éstos ficheros pueden ser útiles para que N aplicaciones faciliten nuestra actividad, me parece bastante peligroso en cuanto a privacidad.

Si alguien tiene curiosidad puede consultar los ficheros recently-used.xbel* en la carpeta $HOME/.local/share y alucinar con lo que tiene: lista de documentos, páginas web visitadas, chats, etc.

Éste registro tan exhaustivo lo lleva a cabo el demonio 'zeitgeist-daemon'.

Por lo leído, el registro es esencial para el funcionamiento de ciertas Shell como Unity o Gnome 3, así que ojo al desinstalarlo porque hay muchas herramientas que depender de éste registro.

Tras revisar las dependencias me ha dado 'yuyu' por lo que he optado por no eliminar el demonio e instalar 'activity-log-manager' para gestionar su actividad:

  - Lo instalamos con:

    sudo apt-get install activity-log-manager

  - Lo arrancamos desde una consola tecleando

    activity-log-manager

  - En la parte inferior derecha de la pantalla del aplicativo tenemos el control que nos permite deshabilitar el registro de actividad.

Si alguien se decide a desinstalar 'zeitgeist-daemon', los pasos serían:

  - Averiguamos los paquetes asociados al demonio:
   
    dpkg -l |grep zeit   

  - Desinstalamos los paquetes:

    sudo apt-get remove zeitgeist
    sudo apt-get remove zeitgeist-core
    sudo apt-get remove zeitgeist-datahub
    sudo apt-get remove rhythmbox-plugin-zeitgeist
    sudo apt-get remove python-zeitgeist
    sudo apt-get remove libzeitgeist-1.0-1

Si se quiere eliminar 'activity-log-manager', los pasos serían:

    dpkg -l |grep activity-log-manager

    sudo apt-get remove activity-log-manager
    sudo apt-get remove activity-log-manager-common
    sudo apt-get remove activity-log-manager-control-center

P.D. Por supuesto existe la opción de borrar periódicamente los ficheros recently-used.xbel* y dejar todo como está.

Referencias

http://linuxaria.com/howto/how-to-remove-zeitgeist-in-ubuntu-and-why

Un saludo

Crear un Hotspot Wifi en portatil Ubuntu 14.04 para teléfonos Android

Hola

Al intentar compartir mediante wifi la conexión a Internet del portatil para acceder a internet vía wifi con el teléfono me he encontrado con que en Ubuntu 14.04 LTS parece que la versión 1:2.1-0ubuntu1.1 del paquete hostapd tiene algún error y no funciona.

Para solucionar el problema, lo más simple es descargar una versión anterior de dicho paquete que sí funciona:

1) Desinstalar el paquete hostapd

   sudo apt-get remove hostapd

2) Descargar la versión operativa de dicho paquete

   wget http://us.archive.ubuntu.com/ubuntu/pool/universe/w/wpa/hostapd_1.0-3ubuntu2.1_amd64.deb
   wget http://ppa.launchpad.net/nilarimogard/webupd8/ubuntu/pool/main/a/ap-hotspot/ap-hotspot_0.3-1~webupd8~4_all.deb

3) Instalamos el paquete dnsmasq (lo va a necesitar ap-hotspot)

   sudo apt-get install dnsmasq

4) Instalamos el paquete descargado

   sudo dpkg -i hostapd_1.0-3ubuntu2.1_amd64.deb
   sudo dpkg -i ap-hotspot_0.3-1~webupd8~4_all.deb

5) Marcar el paquete hostapd como no actualizable (vigilando la salida de una actialización que elimine el problema)

   sudo apt-mark hold hostapd

6) Si durante la instalación y arranque del paquete salta un error del tipo:

   Configurando hostapd (1:1.0-3ubuntu2.1) ...
   * Starting advanced IEEE 802.11 management hostapd                      [fail]

   Deberemos encender el interfaz wifi del portatil y repetir la instalación (pasos 4 y 5)

   Configurando hostapd (1:1.0-3ubuntu2.1) ...
   * Starting advanced IEEE 802.11 management hostapd                      [ OK ]

7) Configuramos el hotspot wifi

   sudo ap-hotspot configure

8) El proceso de configuración detectará el interfaz de red conectado a Internet y nos pedirá que lo ajustemos o configuremos, detectará el interfaz wifi por el que compartiremos la conexión, nos pedirá un nombre para el hotspot y nos pedirá una password para el hotspot. Si no conocemos el nombre de los interfaces de red podemos usar ifconfig para revisarlos. Algo del estilo:

   egdepedro@titan:~/Escritorio$ sudo ap-hotspot configure
   Detecting configuration...
   Detected eth0 as the network interface connected to the Internet. Press ENTER if this is correct or enter the desired interface below (e.g.- eth0, ppp0 etc.):
  
   Detected wlan0 as your WiFi interface. Press ENTER if this is correct or enter the desired interface (e.g.- wlan1):

   Enter the desired Access Point name or press ENTER to use the default one (myhotspot):
   TITAN-WIFI
   Enter the desired WPA Passphrase below or press ENTER to use the default one (qwerty0987):
   password

9) Arrancamos el hotspot para compartir la conexión de red vía wifi con el teléfono

   sudo ap-hotspot start

10) Cuando terminemos podemos dejar de compartir la conexión vía wifi con:

   sudo ap-hotspot stop

Como comentario final un asunto pendiente. Mientras está levantado el hotspot desde el portatil no accedo a internet, a pesar de tener el interfaz eth0 levantado. Es algo pendiente de investigar. Sólo recupero la conectividad tras parar el hotspot (paso 10)

Un saludo