Ubuntu. Error “$MFTMirr does not match $MFT (record 0).” montando partición NTFS

Hola

Me ha saltado el error:

$MFTMirr does not match $MFT (record 0).
Failed to mount '/dev/sdb1': Error de entrada/salida
NTFS is either inconsistent, or there is a hardware fault, or it's a
SoftRAID/FakeRAID hardware. In the first case run chkdsk /f on Windows
then reboot into Windows twice. The usage of the /f parameter is very
important! If the device is a SoftRAID/FakeRAID then first activate
it and mount a different device under the /dev/mapper/ directory, (e.g.
/dev/mapper/nvidia_eahaabcc1). Please see the 'dmraid' documentation
for more details.

Montando un disco externo y dado que el disco funcionaba correctamente en otros entornos, el problema debía radicar en alguna inconsistencia de la partición que problemática para Ubuntu. Mirando un poco por ahí he dado con una solución sencilla:

1) Instalar el paquete ntfs-3g, anteriormente llamado ntfsprogs:

sudo apt-get install ntfs-3g

2) El paquete incluye la utilidad ntfsfix, que permite corregir el defecto de la partición NTFS:

sudo ntfsfix /dev/sdb1

Tras su ejecución el error ha desaparecido.

Un saludo

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