Problema con librerías de 32 bits en sistemas de 64 bits

En alguna ocasión, al instalar algún programa en nuestro Ubuntu, puede ser extrapolado a cualquier sistema Linux, Al descargar las Problemas librerías de 32 bits (i386) en sistemas de 64 bits dependencias de librerías que necesita puede haber una confusión cuando nuestro sistema es de 64 bits, y la aplicación esta programada para la versión de 32 bits.

Problema con librerías en Google Earth

Este es el caso que nos podemos encontrar al instalar el Google Earth. Cuando descargamos el programa de la pagina, esta nos ofrece el fichero de instalación que se ajusta a nuestro sistema operativo automáticamente. Pero el problema esta que la versión que se descarga para Debian, y sus variantes, como es el caso de Ubuntu. Este fichero de instalación es de 32 bits.

Al instalar, se descargan las dependencias que se ajustan mejor para nuestra versión de sistema operativo, en este caso las librerías descargadas son las de la versión de 64 bits.

Al ejecutar el Google Earth, nos muestra un error indicándonos que no tenemos la librería “libgthread-2.0.so.0”.

~$ google-earth 
./googleearth-bin: error while loading shared libraries: libgthread-2.0.so.0: cannot open shared object file: No such file or directory

Pero si ejecutamos el siguiente comando.

~$ dpkg -S libgthread-2.0.so.0
libglib2.0-0:amd64: /usr/lib/x86_64-linux-gnu/libgthread-2.0.so.0.4800.1
libglib2.0-0:amd64: /usr/lib/x86_64-linux-gnu/libgthread-2.0.so.0

Nos muestra que si tenemos la librería instalada, en la mejor versión “libglib2.0-0:amd64” para nuestro sistema operativo.

Solución al problema con las librerias

Para forzar a que se instale la versión de 32 bits, tendremos que ejecutar el siguiente comando.

sudo apt-get install libglib2.0-0:i386

Lo que hacemos es instalar la librería “libglib2.0-0”, donde esta la librería que necesitamos, con el anterior comando se nos muestra junto con la versión en la que esta instalada, ya se de 64 bits (amd64), o de 32 bits (i386). Seguido de la versión que queremos instalar, en este caso la de 32 bits (:i386).

~$ sudo apt-get install libglib2.0-0:i386
Leyendo lista de paquetes... Hecho
Creando árbol de dependencias       
Leyendo la información de estado... Hecho
Se instalarán los siguientes paquetes NUEVOS:
  libglib2.0-0:i386
0 actualizados, 1 nuevos se instalarán, 0 para eliminar y 0 no actualizados.
Se necesita descargar 0 B/1.184 kB de archivos.
Se utilizarán 5.479 kB de espacio de disco adicional después de esta operación.
Seleccionando el paquete libglib2.0-0:i386 previamente no seleccionado.
(Leyendo la base de datos ... 263708 ficheros o directorios instalados actualmente.)
Preparando para desempaquetar .../libglib2.0-0_2.48.1-1~ubuntu16.04.1_i386.deb ...
Desempaquetando libglib2.0-0:i386 (2.48.1-1~ubuntu16.04.1) ...
Procesando disparadores para libc-bin (2.23-0ubuntu3) ...
Procesando disparadores para libglib2.0-0:amd64 (2.48.1-1~ubuntu16.04.1) ...
Configurando libglib2.0-0:i386 (2.48.1-1~ubuntu16.04.1) ...
Procesando disparadores para libc-bin (2.23-0ubuntu3) ...

Si no se ha producido ningún fallo, ya tendremos las librerías instaladas, tanto en la versión de 64 (amd64) como en la de 32 (i386).

Podemos verificarlo ejecutando de nuevo el comando “dpkg -S libgthread-2.0.so.0”. Esta vez nos tiene que mostrar lo siguiente.

~$ dpkg -S libgthread-2.0.so.0
libglib2.0-0:i386: /usr/lib/i386-linux-gnu/libgthread-2.0.so.0.4800.1
libglib2.0-0:i386: /usr/lib/i386-linux-gnu/libgthread-2.0.so.0
libglib2.0-0:amd64: /usr/lib/x86_64-linux-gnu/libgthread-2.0.so.0.4800.1
libglib2.0-0:amd64: /usr/lib/x86_64-linux-gnu/libgthread-2.0.so.0

Nos muestra que disponemos de las librerías “libglib2.0-0”, tanto en la versión de 32 bits (i386) como de la versión de 64 bits (amd64).

Con esto tenemos solucionado nuestro problema de incompatibilidades de librerías.

Si tienes cualquier sugerencia o duda no tengas ningún reparo en dejarnos tu comentario.

Añadir conexión Wifi a nuestro Arduino

El Internet de la cosas (IoT) a puesto de moda el conectar cualquier cosa a internet. Y nuestros proyectos con arduino no iban a ser menos.

esp8266En el mercado, hay multitud de shield que nos dan la posibilidad de añadir conexión wifi a nuestro arduino, pero estas placas tienen un precio demasiado alto, la mayoría de ellos ha un precio elevado. Estos precios de los sistemas wifi contrastan con el precio habitual que suelen tener los demás accesorios para arduino.

Modulo wifi ESP8266

Pero además de los shield tenemos otros método de poder añadir conectividad wifi a nuestro proyectos de arduino. Este es el modulo Wifi ESP8266 nos ofrece conexión wifi de una manera sencilla y barata.

Ademas de la conexión wifi, este modulo permite una configuración muy fácil mediante el uso de comandos AT, dispone a su vez de un pequeño servidor web, que nos facilitara la conexión a él mediante el uso de un simple navegador.

Conectar el modulo wifi ESP8266 con arduino

La conexión del modulo ESP8266 con arduino es muy simple, solo tendremos que conectar los pines RX y TX del modulo, a los pines RC y TX de muestro arduino, si lo preferimos, como es mi caso, los podemos conectar a cualquier otros pines y utilizar la librería de emulación de comunicaciones serie.

Luego tendremos que conectar el pin marcado como RST a la alimentación de 3.3v de muestro arduino. La alimentación del modulo la tendremos que realizar utilizando un fuente de 3.3 v externa.

La salida de voltaje del arduino solo ofrece una alimentación de 50 mAmp, el modulo wifi ESP8266, en el arranque consume un poco más. Para pruebas podemos conectarlo a la salida de 3.3 v del arduino, pero si tienes la posibilidad de contar con una fuente externa, es mejor que lo conectes a ella. Solo queda conectar el pin GND a la fuente externa o a uno de los pines GND del arduino.

Alimentación mediante arduino del modulo wifi ESP8266
Alimentación a través de Arduino del modulo ESP8266

Circuito con alimentación exterior del modulo wifi.

Conexión modulo wifi ESP8266 con fuente externa
Alimentación del modulo ESP8266 mediante fuente externa

Configuración del modulo wifi ESP8266

La configuración de este modulo es muy parecida a la configuración de los módulos de bluetooth HC-06 o HC-05. Incluso podemos utilizar parte del código que se ha utilizado para conectarse con estos módulos para conectarse con el wifi ESP8266.

Código para leer los datos desde el puesto serie del módulo ESP8266 y escribirlos al puerto serie de la consola, y viceversa.

#include <SoftwareSerial.h>
// Creamos un puerto serie virtual para la conexión con el modulo Wifi
SoftwareSerial Wifi(3, 2); // Pin RX, Pin TX

void setup()
{  
    // Creamos la conexion serie para el control desde la consola
    Serial.begin(9600);
    // Creamos la conexión con el modulo Wifi
    Wifi.begin(115200);
}

void loop()
{
    // Si hay datos desde el modulo Wifi
    if (Wifi.available())
    {
        // Leemos un caracter
        char c = BT1.read() ;
        // Y lo escribimos en el puerto de la consola
        Serial.print(c);
    }
    // Si Hay datos disponibles desde la consola
    if (Serial.available())
    {
        // Leemos un caracter
        char c = Serial.read();
        // Y lo escribimos en el modulo Wifi
        Wifi.print(c);
     }
}

Es simple código nos va ha permitir comprobar el estado de nuestro modulo ESP8266 y realizar las configuraciones básicas.

Comprobar el funcionamiento del modulo Wifi ESP8266

Al arrancar el modulo, este nos tiene que devolver un mensaje de “Ready”

[Vendedor:www.ai-thinker.com Version:0.9.2.4]

ready

Para verificar que tenemos conexión con el modulo, desde la ventana de consola, escribimos AT, si todo es correcto y tenemos conexión con el modulo. Este nos devolverá un “OK”

[Vendedor:www.ai-thinker.com Version:0.9.2.4]

ready AT OK

Este modulo permite 3 modos de funcionamiento:

  • Modo 1: Modo estandar, en este modo de funcionamiento, el módulo se comporta como si fuera un router. Modo servidor.
  • Modo 2: Modo dispositivo / AP, en cambio en este modo, es módulo se comporta como si fuera un dispositivo que se va ha conectar con un router. Modo cliente.
  • Modo 3: Esta forma de funcionamiento, es la mezcla de los dos anteriores. Funciona lo mismo de cliente como de servidor.

Para ver en que modo esta funcionando nuestro ESP8266, le enviamos el siguiente comando AT.

AT+CWMODE?

+CWMODE:3

OK

En este caso, nos indica que esta funcionando en el modo 3. Si no sabemos muy bien como queremos que funcione nuestro modulo ESP8266, lo podemos dejar en este modo para asegurarnos su correcto funcionamiento.

Para cambiar el modo de funcionamiento, le tendremos que enviar el siguiente comando AT.

AT+CWMODE=3

no change

En este caso, como ya estaba en este modo de funcionamiento, no indica que no se ja producido ninguna cambio. Si el modo de funcionamiento no fuese el ya establecido, no devolvería un “OK”.

Conexión con la red wifi con el ESP8266

Mediante otro comando AT, podemos obtener la lista de conexiones wifi al alcance del modulo.

AT+CWLAP
+CWLAP:(1, "MOVISTAR_ASWD", -34, "AA:BB:CC:DD:EE:FF",3)
+CWLAP:(2, "Mi_Conexion", -54, "AA:BB:CC:DD:EE:FF",5)

La información que nos aparece es, posición en la lista, el SSID de la conexión wifi, potencia de la señal, y la MAC del router.

Para conectar el modulo ESP8266, a nuestra red wifi, utilizaremos otro comando AT. En este caso,  el comando AT+CWJAP=”SSID_nuestra_conexión”, “contraseña”

AT+CWJAP="SSID_nuestra_conexión", "contraseña"

OK

Si la conexión se ha realizado con existo, nos devolverá como siempre un “OK”.

Obtener información de nuestra conexión con ESP8266

Al establecer conexión, con nuestro router o el servidor de DHCP que tengamos instalado en nuestra, este le tiene que asignar una dirección IP a nuestro modulo. Para conocer la ip asignado a nuestro modulo wifi utilizaremos el siguiente comando AT.

AT*CIFSR
192.168.1.1
192.168.1.201

OK

Este comando AT nos devolverá, en una primera linea, la dirección ip del router, y en una segunda, la dirección ip que se le ha asignado al modulo.

Activar servidor TCP en el modulo wifi ESP8266

Con esto, ya podríamos conectarnos al ESP8266, pero para poder interactuar con el debemos activar el servidor disponible en modulo. Para activar este servidor volvemos a tirar de comando AT.

AT+CIPSERVER=1, 80

OK

Esto activara el servidor TCP en el puerto 80.

Para desactivar el servidor solo tendremos que repetir el mismo comando cambiado el 1 por un 0.

AT+CIPSERVER=0, 512

OK

Una vez que tengamos el servidor TCP activado en el modulo, podremos interactuar con el estableciendo una conexión en la dirección ip asignada y mediante el puerto activado.

Tabla con los comandos AT disponibles en el modulo wifi ESP8266

Comandos Descripción Tipo Configuración / Ejecución Estado Prueba Parámetros y ejemplos
AT general test basic
AT+RST restart the module basic
AT+GMR check firmware version basic
AT+CWMODE wifi mode wifi AT+CWMODE=<mode> AT+CWMODE? AT+CWMODE=? 1= Sta, 2= AP, 3=both, Sta is the default mode of router, AP is a normal mode for devices
AT+CWJAP join the AP wifi AT+ CWJAP =<ssid>,< pwd > AT+ CWJAP? ssid = ssid, pwd = wifi password
AT+CWLAP list the AP wifi AT+CWLAP
AT+CWQAP quit the AP wifi AT+CWQAP AT+CWQAP=?
AT+ CWSAP set the parameters of AP wifi AT+ CWSAP= <ssid>,<pwd>,<chl>, <ecn> AT+ CWSAP? ssid, pwd, chl = channel, ecn = encryption; eg. Connect to your router: AT+CWJAP=”www.electrodragon.com”,”helloworld”; and check if connected: AT+CWJAP?
AT+CWLIF check join devices’ IP wifi AT+CWLIF
AT+ CIPSTATUS get the connection status TCP/IP AT+ CIPSTATUS <id>,<type>,<addr>,<port>,<tetype>= client or server mode
AT+CIPSTART set up TCP or UDP connection TCP/IP 1)single connection (+CIPMUX=0) AT+CIPSTART= <type>,<addr>,<port>; 2) multiple connection (+CIPMUX=1) AT+CIPSTART= <id><type>,<addr>, <port> AT+CIPSTART=? id = 0-4, type = TCP/UDP, addr = IP address, port= port; eg. Connect to another TCP server, set multiple connection first: AT+CIPMUX=1; connect: AT+CIPSTART=4,”TCP”,”X1.X2.X3.X4″,9999
AT+CIPMODE set data transmission mode TCP/IP AT+CIPMODE=<mode> AT+CIPSEND? 0 not data mode, 1 data mode; return “Link is builded”
AT+CIPSEND send data TCP/IP 1)single connection(+CIPMUX=0) AT+CIPSEND=<length>; 2) multiple connection (+CIPMUX=1) AT+CIPSEND= <id>,<length> AT+CIPSEND=? eg. send data: AT+CIPSEND=4,15 and then enter the data.
AT+CIPCLOSE close TCP or UDP connection TCP/IP AT+CIPCLOSE=<id> or AT+CIPCLOSE AT+CIPCLOSE=?
AT+CIFSR Get IP address TCP/IP AT+CIFSR AT+ CIFSR=?
AT+ CIPMUX set mutiple connection TCP/IP AT+ CIPMUX=<mode> AT+ CIPMUX? 0 for single connection 1 for multiple connection
AT+ CIPSERVER set as server TCP/IP AT+ CIPSERVER= <mode>[,<port> ] mode 0 to close server mode, mode 1 to open; port = port; eg. turn on as a TCP server: AT+CIPSERVER=1,8888, check the self server IP address: AT+CIFSR=?
AT+ CIPSTO Set the server timeout AT+CIPSTO=<time> AT+CIPSTO? <time>0~28800 in second
+IPD received data For Single Connection mode(CIPMUX=0): + IPD, <len>:
For Multi Connection mode(CIPMUX=1): + IPD, <id>, <len>: <data>

Más información sobre el modulo wifi ESP8266: https://www.itead.cc/wiki/ESP8266_Serial_WIFI_Module

Con esto ya tendríamos nuestro arduino conectado a nuestra red wifi, accesible desde cualquier lugar.

Si tienes cualquier sugerencia o duda no tengas ningún reparo en dejarnos tu comentario.

Agregar un nuevo disco a nuestro Linux

Si estamos ejecutando nuestro Linux en un entorno gráfico, esta operación resulta relativamente muy fácil. Solo tenemos que Agregar nuevo disco a nuestro servidorejecutar el programa “Discos” desde nuestro escritorio.  Seleccionar el nuevo disco que hemos instalado, si la placa lo ha reconocido correctamente, Crear la o las particiones que creamos necesarias. Y por ultimo podemos indicarle con un par de clicks si queremos que se monte al iniciar el equipo, donde queremos que monte, etc.

Pero si queremos hacer esto en nuestro servidor en Linux, no nos quedara otro remedio de tirar de la bendita consola.

Aunque parezca que hacer este proceso mediante consola va ha ser más complicada que utilizando el modo gráfico, la verdad es que es un proceso relativamente sencillo.

Agregar nuevo disco en Linux

Lo primero que tenemos que saber es, en que dispositivo esta nuestro nuevo disco. Para obtener esta información solo tenemos que ejecutar el comando “fdisk”, con el parámetro “-l”. Este comando nos mostrara, no solo los discos que tengamos instalados en nuestro sistema, si no nos mostrara todas las particiones que están disponibles en cada uno de los discos que tengamos instalados. Para ejecutar este comando tendremos que tener acceso al sistema como “root”.

Una vez que sepamos donde esta nuestro disco, en mi caso, “/dev/sdc”. Pasamos ha crear las particiones del discos.

Crear las particiones en nuestro disco

Para crear las particiones de un disco solo tendremos que ejecutar de nuevo el comando “fdisk” pasandole como parámetro la ubicación del disco que vamos a particionar. En mi caso seria “fdisk /dev/sdc”.

Dentro del “fdisk”, utilizaremos varios comandos para crear tanto las particiones, como el tipo de partición y grabar la partición en el disco.

sudo fdisk /dev/sdc

Lo primero que comprobaremos es si el disco ya tiene alguna partición, para ver esto pulsamos la tecla “p”, este no mostrara las particiones existentes en el disco si las hubiera. En el caso de que no hubiera ninguna partición, solo mostrara la información del disco.

crear-particion-lista-de-particiones-en-el-disco

Eliminar particiones existentes

Si tuviéramos alguna partición, y no nos sirviera para nuestro propósito, la podemos eliminar usando el comando “d”, si solo tuviéramos una partición disponible en nuestro disco, eliminara automáticamente esa partición. Si por lo contrario tuviéramos más de una, nos pediría que partición deseamos eliminar. En este caso como solo hay una, se eliminara esa partición si pedir más información.

Agregar nuevo disco a nuestro equipo

Crear particiones

Para crear una nueva partición utilizaremos el comando “n”, lo siguiente que nos pedirá sera el tipo de partición que deseamos crear, ya sea primaria (p) o extendida (e). Lo siguiente que nos va ha pedir sera el numero de la partición, por defecto si no tenemos ninguna partición creada en el disco nos aparecerá la 1. Lo siguiente que nos pide sera el sector de inicio. Si no tenemos ninguna partición creada, el valor por defecto que aparecerá sera el primer sector disponible del disco. El siguiente parámetro que nos pedirá sera el sector de fin. Si queremos todos el disco libre disponible, validaremos el valor por defecto. En este parámetro podemos indicar el tamaño de la partición de varias formas:

  1. Indicando el sector hasta el que queramos que nuestra partición llegue. Este forma es un poco lioso, por que tendríamos que calcular en que sector se encuentra el tamaño que deseamos.
  2. Indicando directamente el tamaño de la partición directamente. Esto lo podemos hacer indicando escribiendo lo primero “+”, a continuación el tamaño que deseamos, seguido del tipo de tamaño usado (K para Kilobytes, M para Megabytes, G para Gigabytes, T para Terabytes o P para Petabytes). El tipo de tamaño lo tenemos que indicar en mayúsculas, si lo ponemos en minúsculas, no dará error).

crear-particion

Cambio del tipo de la partición

Con esto ya habremos creado nuestra partición. Pero esta por defecto es del tipo “Linux”, para cambiar este tipo,  utilizaremos el comando “t” para indicar que tipo de partición vamos ha usar.

tipos-particiones-linux

Este comando nos pedirá el código del tipo que vamos a utilizar. Si no sabes el código, podemos utilizar el comando “l” para mostrar la lista con los formatos de particiones que podemos utilizar. Para crear una partición con el formato de NTFS elegiremos el código “7”. Para seleccionar una partición de tipo Linux, utilizaremos el código “83”. Para una del tipo Linux Swap (partición de intercambio de Linux) utilizaremos el código “82”.

tipos-particiones-linux

Podemos utilizar de nuevo el comando “p” para verificar que la información que hemos indicado es la que se esta utilizando para crear la partición.

Grabar las particiones

Si todo es correcto solo tenemos que guardar la partición. Para ellos utilizaremos el comando “w”. Este comando grabara la información de la partición dentro del disco, y saldrá el “fdisk”.

guardar-la-particionUna vez que hallamos creado la partición podemos hacer dos cosas para que le sistema lea la nueva partición del disco.

  1. Reiniciar el sistema para que al cargar la configuración del disco, este carga la nueva información de la partición del disco.
  2. Para evitar tener reiniciar podemos utilizar el comando “partprobe”. Este comando fuerza a que el sistema vuelva a leer la información de los discos. Podemos indicar que que solo lea la información de un disco en concreto.
sudo partprobe /dev/sdc

Formatear las particiones de nuestro disco

Para realizar el formateo de las particiones podemos utilizar el comando “mkfs”, este comando nos permite dar formato a cualquier tipo de partición, ya sea de tipo Linux, NTFS, FAT, etc. Dependiendo del tipo de partición que hallamos utilizado le tendremos que pasar como parámetro “-t” y el tipo de formateo que vamos ha realizar.

  • Para particiones de tipo Linux: Las particiones de tipo Linux las podemos formatear de varios tipo, puede ser de tipo ext3, ext4, etc. Para indicarle a “mkfs” el tipo de formateo usaremos como parámetro “-t ext3”, “-t ext4”.
  • Para el caso de una partición de  tipo “Windows”, ya sea fat16, fat32, ntfs, el parámetro que tendremos que usar sera “-t fat32”, “-t ntfs”, etc.
sudo mkfs -t ntfs /dev/sdc1

Tmbien dispones de otra variante de este comando, y es mkfs.xxx, donde las “xxx” son el formata que vamos a utilizar para dar el formateo a la partición. En este caso seria el siguiente,

sudo mkfs.ntfs /dev/sdc1

Una vez que hemos creado las particiones del disco y formateado el disco, solo nos queda montar la partición.

Para montar una partición en el sistema, lo primero que tenemos que tener es un ruta donde cargar ese disco. Esta ruta la podemos crear el cualquier lugar, siempre y cuando tengamos acceso a ello. Si creamos la ruta de montaje en un carpeta propietaria de “root”, por ejemplo, cuando montemos nuestra partición en ello, solo “root” podrá tener acceso a ella.

Lo normal en crear una nueva carpeta dentro del directorio “/mnt”, es lo normal, no obligatorio.

En este caso vamos ha crear la ruta de montaje dentro del directorio “/mnt” con el nombre de “segundoDisco”. Para ello utilizaremos el comando “sudo mkdir /mnt/segundoDisco”.

Montar las particiones de nuestro disco

Para probar si se puede montar nuestro disco en la ruta deseada utilizaremos el comando “mount”

mount -t ntfs /dev/sdc1 /mnt/segundoDisco

Con esto ya tendríamos nuestro disco accesible, eso si, mientra no reiniciemos nuestro equipo.

Auto montaje de las particiones al iniciar el sistema

Para hacer que nuestra partición se carga al arrancar el sistema tendremos que añadir la siguiente linea al final del fichero /etc/fstab

sudo nano /etc/fstab

Linea a añadir al fichero.

/dev/sdc1 /mnt/segundoDisco ntfs defaults,errors=remount-ro 0 2

Explicaciones de los parametro:

  1. /dev/sdc1: Ruta donde se encuentra el dispositivo a montar.
  2. /mnt/segundoDisco: Ruta donde vamos a montar el dispositivo.
  3. ntfs: Tipo de partición del dispositivo. Para este caso que es de tipo “ntfs”, para Linux Ext3 seria “ext3”, para Linux Ext4 seria “ext4”, etc.
  4. defaults, errors=remount-ro: Opciones de montaje, en este caso utilizamos las opciones por defecto para este tipo de partición (defaults), y con “errors=remount-ro” le indicamos que si se produce un error al montar la partición, esta se vuelva a montar (remount), pero esta vez en modo de solo lectura (-ro Read Only).
  5. 0: indica si la partición para ha ser respaldada por el comando Dump, esta realiza copias de seguridad de las particiones que se indiquen. Si ponemos un 0, Dump no procederá ha realizar copia de seguridad de la partición. Si por lo contrario queremos que Dump haga una copia de seguridad de nuestra partición pondremos un 1. La mayoría de las veces no se utiliza Dump para realizar las copias de seguridad. Por lo que lo más habitual es que este parámetro sea un 0.
  6. 2: Orden en el que se procederá a montar la partición. Este número sera el siguiente al máximo que ya exista dentro de nuestro fichero fstab. En este caso sera el segundo en montarse al iniciar el sistema.

Solo nos queda grabar el fichero, Ctrl-X y S, en nano. Y reiniciar el equipo.

Y esto es todo.

Si hemos creado varias particiones. Tendremos que repetir los pasos, de formateo y montaje, con cada una de las particiones creadas.

Si todo ha ido correctamente. Al termino del arranque del sistema, nuestras particiones, se habrán montado automáticamente dentro de los directorios que hayamos indicado.

Si tienes alguna duda o comentario, no dudes en decirlo.

Trabajar con arduino y una pantalla Nokia 5110

Como trabajar con la pantalla Nokia 5110 LCD y el arduino

Cuando queremos que nuestro arduino nos muestre información, la opción más habitual es instalarle una pantalla. Y la pantalla que traía los modelos Nokia 5110 es una buena alternativa, tiene un tamaño ni muy grande, ni muy pequeño, nos permite mostrar información en pantalla nokia 5110 LCDmodo gráfico, lo que nos permitirá una gran flexibilidad a la hora de presentar nuestros resultados. Y además, para mi principalmente el precio es muy asequible, por poco más de 3€ podemos hacernos con una.

Ya con todos los conectores y configuración para montarla con nuestro arduino.

Otra de las principales características importantes de esta pantalla LCD, es la de disponer de multitud de librerías que que nos facilitaran enormemente su programación.

Materiales usados

Arduino UNO Arduino UNO
pantalla nokia 5110 Pantalla Nokia 5110
protoboard Protoboard
cables_union Cables de conexión

Montaje de la pantalla LCD Nokia 5110 con

arduino

Para conectar la pantalla del nokia 5110
con nuestro arduino conectaremos los siguientes pines del arduino a los conectores de la pantalla. Dependiendo del fabricante de la pantalla la posición de los pines puede variar, he incluso algún nombre también.

Pin Pantalla Pin Arduino Descripción
Rst 3 Reinicio de la pantalla
CE | SCE 4 Chip selection ( Selección del chip)
DC | D/C 5 Data / Commands choice (Envío de datos o comandos)
Din | DN | MOSI 6 Serial data in (Envío de datos serial)
CLK | SCLK 7 Serial Clock ( señal de sincronización)
Vcc +3,3 Alimentación a la pantalla de 3,3 ( Esta pantalla funciona con un rango de voltaje de 2,7 a 3,3, NO CONECTAR A 5V
LIght GND Retroiluminación de la pantalla, le podemos poner un potenciómetro para regular la iluminación.
GND GND Alimentación negativa de la pantalla

En algunos montaje he visto que intercalan resistencias en los pines de datos (los pines de la pantalla del 1 al 5), yo lo he probado, tanto con resistencias como sin ellas y la pantalla funciona perfectamente, Puede ser que el montaje de mi pantalla ya estén instaladas, lo desconozco.

Programación de la pantalla LCD Nokia 5110

Gracias a la popularidad de esta pantalla existe multitud de librerías, después de probar varias yo me quedo con la de Adafruit PCD8544 Nokia 5110 LCD. Es muy sencilla es su manejo, es compatible con las ultimas versiones de Arduino IDE, y trae un ejemplo que facilita su uso, para poder utilizar las funciones gráficas de la librería tenemos que instalar esta otra librería, la librería gráfica GFX, que sera la que nos permita mostrar gráficos en nuestra pantalla.

Inicialización de la pantalla Nokia 5110

Creamos el objetos que manejara la pantalla, aquí le pasamos como parámetros los pines donde están los pines de datos de la pantalla.

// Software SPI (slower updates, more flexible pin options):
// pin 7 - Serial clock out (SCLK)
// pin 6 - Serial data out (DIN)
// pin 5 - Data/Command select (D/C)
// pin 4 - LCD chip select (CS)
// pin 3 - LCD reset (RST)
Adafruit_PCD8544 Pantalla = Adafruit_PCD8544(7, 6, 5, 4, 3);

Arrancamos la pantalla

  Pantalla.begin();

Ajustamos el contraste, no confundir con la retroiluminación, esto configura el negro de la pantalla, lo situamos a la mitad, podemos ajustarlo a nuestro gusto.

display.setContrast(50);

Mostrar texto en la pantalla Nokia 5110

Para mostrar cadena de caracteres simplemente le tenemos que indicar la posición donde queremos que se muestre el texto, el color, aunque la pantalla es de blanco y negro podemos jugar con invertir el color, escribir el negro o en blanco, y el tamaño de la fuente a utilizar.

// text display tests
Pantalla.setTextSize(1);
Pantalla.setTextColor(BLACK);
Pantalla.setCursor(0,0);
Pantalla.println("Hello, world!");
Pantalla.setTextColor(WHITE, BLACK); // 'inverted' text
Pantalla.println(3.141592);
Pantalla.setTextSize(2);
Pantalla.setTextColor(BLACK);
Pantalla.print("0x"); 
Pantalla.println(0xDEADBEEF, HEX);
Pantalla.display();

El ultimo comando “Pantalla.display()”  es la que mostrara el texto, los comandos anteriores cargan la información en el buffer, hasta que no pongamos el comando display no se mostrara en la pantalla.

Mostrar gráficos en la pantalla Nokia 5110

Si queremos mostrar gráficos en la pantalla lo mejor es cargar el ejemplo de la librería, en el encontramos como dibujar una linea

void testfillrect(void) {
  uint8_t color = 1;
  for (int16_t i=0; i<display.height()/2; i+=3) {
    // alternate colors
    display.fillRect(i, i, display.width()-i*2, display.height()-i*2, color%2);
    display.display();
    color++;
  }
}

Círculos, rectángulos, múltiples lineas, imágenes bitmap, etc.

Por ultimo un pequeño video del funcionamiento de la pantalla nokia 5110 y el arduino con la librería de Adafruit.

Gracias ha esta pequeña pantalla y a la librería de Adafruit el mostrar información con nuestro arduino sera muy fácil y sencillo.

Si tienes alguna duda o algún comentario, no dudes en escribirnos.

Ampliar el espacio en la Raspberry Pi

Aumentar el espacio de nuestra partición en la Raspberry Pi

Cuando creamos una nueva SD con el sistemas Raspbian para nuestra Raspberry PI, da igual la versión de esta, la partición de trabajo que nos crea es de 4 Gb, si la actualizamos, o si le instalamos cualquier programa, este espacio rápidamente se nos agota.

Raspberry Pi 2
Raspberry Pi 2

Para que la partición donde esta instalado el sistema utilice todo el espacio disponible de nuestra SD tendremos que seguir los siguientes pasos.

Para realizar esta tarea Raspbian nos ofrece un programa “raspi-config”, este programa nos permite configurar varios parámetros de nuestra Raspberry, como puede ser cambiar la contraseña del usuario, activar la cámara, opciones de inicio, y como no, expandir nuestra partición hasta usar todo el espacio de la tarjeta SD donde tengamos instalado nuestro sistema.

Para ampliar el espacio de nuestra partición ejecutaremos el comando “raspi-config” con derechos de administrador.

sudo raspi-config

Una vez ejecutado el comando nos aparecerá la siguiente pantalla.

ampliar espacio en nuestra raspberry pi
Pantalla del comando raspi-config

Para ampliar el espacio de nuestra raspberry pi seleccionaremos la primera opción “Expand Filesystem”, después de unas comprobaciones nos mostrara la siguiente pantalla.

particion-redimensionada
Partición de nuestro sistema Raspbian redimensionada,

Con esta la partición ha cambiado de tamaño ajustándose al total de nuestra tarjeta SD. Para que los cambios surtan efecto tendremos que reiniciar nuestra Raspberry Pi. Pulsamos en “OK” y volvemos a la pantalla anterior.

Una vez en la pantalla principal seleccionaremos la opción de “Finish” y salimos del programa.

Nos mostrara otra pantalla indicándonos si queremos reiniciar nuestra Raspberry Pi, le indicamos que “Yes” y nuestra Raspberry Pi se reiniciara.

Reiniciar nuestra Raspberry Pi
Reiniciar la Raspberry Pi para activar los cambios

Una vez que la Raspberry Pi se haya reiniciado, podemos verificar que la Raspberry Pi utiliza todo el espacio con el siguiente comando,

df -h

Este comando nos mostrara el tamaño, espacio disponible y usado de las particiones que tengamos creadas en nuestro sistema. En nuestro caso la que nos interesa en la partición de “/dev/root” que sera prácticamente el tamaño de nuestra SD.

Verificar-particionesUna vez realizada la comprobación, ya tenemos nuestro sistema ejecutándose en la Raspberry Pi utilizando todo el espacio disponible en la SD.

Si tienes algún nota o duda,  déjanos un comentario.

Personalización imagen ISO de VMWare ESXi 6.0 para un laboratorio de pentesting (II)

Personalización imagen ISO de VMWare ESXi 6.0

El principal problema que nos encontramos al instalar un sistema con VMWare ESXi 6.0 es la falta de drivers, principalmente, para las tarjetas de red. Este problema se resuelve fácilmente con añadir a nuestra iso de VMWare ESXi 6.0 el driver que necesitemos.
Para hacer esto podemos usar el script en PowerShell de “ESXi-Customizer-PS”, este script nos permitirá no solo personalizar nuestra iso de ESXi de la versión 6.0, si no también las versiones 5.0, 5.1 y 5.5. Tampoco tendremos que descargar la iso desde la web de VMWare para realizar la personalización, el script ya se encarga de descargar la iso de la versión que deseamos personalizar. El script también dispone de varios drivers de tarjetas de red, por que tampoco nos tendremos que preocupar de buscar los drivers de nuestra tarjeta.
Personalización imagen ISO ESXiPara hacer la personalización lo primero que tenemos que hacer es descargar el script desde la pagina de “VMware Front Experience”, también tenemos que tener instalado el PowerCLI de VMWare y la versión de PowerShell en la versión 2.0 o superior.

Inicio con ESXi-Customizer-PS

Para ejecutar el script solo tendremos que abrir una consola de PowerShell. Una vez abierta nos movemos hasta la carpeta donde tenemos descargado el script de ESXi-Customizar-PS,

cd Carpeta-de-descargar-script

Una vez en la carpeta de descarga ejecutamos el scrpit

ESXi-Customizer-PS-v2.4.ps1

Con esto simplemente descargaremos la imagen iso de ESXi de la versión 6.0 desde la pagina de VMWare sin ninguna modificación, una versión básica .

Parámetros de ESXi-Customizer-PS

Para ver los parámetros del script solo tenemos que ejecutar el script con el parámetro -help

ESXi-Customizer-PS-v2.4.ps1 -help

Los principales parámetros disponibles son los siguientes.

Versión de la imagen iso que vamos a utilizar:

  • -v50: Versión de ESXi en la versión 5.0.
  • -v51: Versión de ESXi en la versión 5.1.
  • -v55: Versión de ESXi en la versión 5.5.
  • -v60: Versión de ESXi en la versión 6.0.
ESXi-Customizer-PS-v2.4.ps1 -v55

Utilizamos la versión 5.5  del VMWare ESXi.

Cargar los drivers desde la pagina de “VMware Front Experience” o desde una carpeta local

Para indicar al script que dirvers queremos cargar en nuestra imagen iso personalizada usaremos el parámetro -load, este parámetro crga los drivers desde la pagina de VMWare Front Experience o desde la carpeta local, los drivers que queramos instalar los pondremos después del parámetro separados por “,” (comas).

ESXi-Customizer-PS-v2.4.ps1 -load net-r8168, net-e1000e

Este ejemplo nos creara una imagen iso del VMWare ESXi de la versión 6.0 con los drivers para tarjetas de red con el chip R8168 y E1000e, la imagen iso se guardara en la misma carpeta donde se encuentra en script.

Eliminar drivers y otro paquetes de la imagen iso basica.

Igual que podemos agregar nuevos drivers y paquetes a la imagen iso básica de ESXi, podemos eliminar paquete desde esta misma imagen iso. Para ello solo tenemos que ejecutar el script con el parámetro -remove

ESXi-Customizer-PS-v2.4.ps1 -remove net-r8168, net-e1000e

Este ejemplo haría lo contrario que el ejemplo anterior, eliminaría los drivers de la tarjeta de red con el chip R8168 y E1000E.

Obtener una lista con las imágenes iso disponibles

En ocasiones necesitamos personalizar una versión en concreto de ESXi, para obtener una lista con las isos disponibles en la web de VMWare podemos usar el parámetro -sip. El script se conectara con la web de VMWare y obtendrá un lista con las isos disponibles y un numero, al final del listado de las isos, el script nos pedirá que introduzcamos el numero correspondiente a la isos que queremos utilizar.

ESXi-Customizer-PS-v2.4.ps1 -sip

Indicar la carpeta para guardar la imagen iso personalizada

Si queremos que la imagen iso personaliza que nos creara el script se guarde en una carpeta distinta a la del script, se lo tendremos que indicar con el parámetro  -outDir <Ruta del directorio>

ESXi-Customizer-PS-v2.4.ps1 -outDir c:\ESXi\Salida

Indicar el nombre del fichero de la imagen iso personalizada

Además de poder indicar en que directorio vamos a guardar nuestra imagen iso personalizada, también podemos indicar el nombre del fichero que queremos utilizar. Esto lo podemos hacer con el parámetro -ozip <nombre del fichero>

ESXi-Customizer-PS-v2.4.ps1 -outDir c:\ESXi\Salida -ozip fichero-esxi.iso

Indicar la carpeta local donde se encuentran los drivers, en formato VIB

Para indicar al script donde se encuentran los drivers que no están disponibles online, sino que están descargados en nuestra maquina utilizaremos el parámetro -pkgDir <Directorio>

ESXi-Customizer-PS-v2.4.ps1 -outDir c:\ESXi\Salida -pkgDir c:\Drivers\ESXi\Personalizados

Hay más parámetros, pero estos son los básicos para poder agregar los drivers que necesitemos para poder instalar el sistema de VMWare ESXi en nuestro equipo.

 

Instalación VMWare ESXi 6.0 para un laboratorio de pentesting (I)

Instalación VMWare ESXi 6.0

Con  ESXi de VMware permite crear un sistema virtualizado sin tener que destinar muchos recursos al sistemas host o anfitrión. El sistema ESXi instala una versión básica de linux para poder ejecutar el software de virtualización. No dispone de ningún entrono gráfico, solo tiene unas opciones básicas para poder configurar el sistema, como puede ser la  tarjeta de red y su dirección IP tanto con versión IPv4 como IPv6. La configuración del teclado.  si permite el acceso a la consola del sistema remotamente, etc.

Los requerimientos básicos para poder instalar un ESXi 6 son:

  • Procesador de 64 bits de al menos 2 núcleos.
  • Tarjeta de red de 1 Gb.
  • Memoria de 4 Gb.
  • Disco duro de 1Gb.

Casi todas las placas de equipos montados con especificaciones de servidor no tendrán problemas con estas expecificaciones. Pero si lo vamos ha instalar en un equipos de tipo “domestico” hay muchas probabilidades, aunque la tarjeta de red sea de 1 Gb, que la instalación WMWare ESXi 6.0  no la reconozca. Eso no quiere decir que no podas instalar el ESXi en esa placa, pero si que tengamos que personalizar la imagen ISO del ESXi y añadirle el driver de nuestra tarjeta. Otro problema que nos podemos encontrar es, si el equipo en el que vamos ha realizar la instalación, tiene solo 4 Gb de memoria y tenemos un tarjeta gráfica con memoria compartida, esto hará que no podamos instalar el sistemas. La única solución que hay para esto es, si podemos desactivar la tarjeta gráfica, y liberar esa memoria que usa la tarjeta gráfica,  e instalar otra tarjeta externa, o bien, si no podemos hacer el cambio, aumentar la memoria ram.

Podemos descargar el fichero iso desde la propia pagina web de VMware. Para ello solo tendremos que crear una cuenta en la pagina de VMWare, ir a la zona de descargas de VMWare y descargar la imagen.

Como crear una unidad de USB con la imagen ISO del ESXi 6.

Para crear un usb con la imagen de instalación VMWare ESXi 6.0, podemos utilizar el programa Rufus. Este programa nos permitirá copiar la imagen a nuestra unidad usb sin ninguna complicación. Solo le tendremos que indicar en que dispositivo usb queremos cargar la unidad y el fichero iso que vamos a utilizar. Después del proceso ya tendremos nuestro usb listo para poder arrancar nuestro equipo con él e instalar VMWare ESXi 6.0.

Crear sub con ESXi 6.0
Crear USB arrancable con VMWare ESXi 6.0 y Rufus

Instalar VMWare ESXi 6.0 desde una unidad USB.

Al iniciar la instalación nos aparece un menú con la opción de arrancar la instalación de ESXi  o arrancar desde el disco local. Pulsamos “intro” sobre “ESXi-6.0-XXXXXXXXXX-standard installer” e iniciamos la instalación del sistema.

Instalación VMWare ESXi 6.0 imagen 1
Menu de arranque de VMWare ESXi 6.0

 

 

 

Después se realizara la cargar de los archivos básicos para poder realizar la instalación VMWare ESXi 6.0.

Instalación VMWare ESXi 6.0 imagen 2Despues de terminar de cargar los ficheros necesarios se ejecutara el instalador del VMWare ESXi 6.0

Instalación VMWare ESXi 6.0 imagen 3Si después de la pantalla de arriba, nos muestra esta pantalla de error, y nuestro equipo dispone de la tarjeta de red, es que el instalador de ESXi 6.0 no reconoce la tarjeta de red, y debemos personalizar nuestra iso de instalación VMWare ESXi 6.0.

Instalación VMWare ESXi 6.0 imagen 4
Error de adptador de red no encontrado en VMWare ESXi 6.0

Si todo a ido correctamente, y la tarjeta de red, la memoria, y demás características básicas se han cumplido nos aparecerá esta para iniciar la instalación VMWare ESXi 6.0

Instalación VMWare ESXi 6.0 imagen 5

Lo siguiente que nos pide el disco donde vamos ha realizar la instalación de sistema anfitrión.

VirtualBox_ESXi 6.0_07_01_2016_19_29_26
Seleccionar el disco donde se quiere instalar el sistema anfitrión

Si en el disco que hemos seleccionado ya existiera una instalación de VMWare nos indicara, si queremos hacer una instalación nueva, o si por lo contrario, queremos realizar una actualización del sistema ya instalado.

VirtualBox_ESXi 6.0_07_01_2016_19_29_51Lo siguiente que nos queda es seleccionar el idioma de la instalación.

VirtualBox_ESXi 6.0_07_01_2016_19_30_11
Seleccionar el idioma para la instalacion del VMWare ESXi 6.0

Contraseña del usuario root del sistema.

VirtualBox_ESXi 6.0_07_01_2016_19_30_34
Contraseña para el usuario root del sistema anfitrion del VMWare ESXi 6.0

Y confirmamos la instalación.

VirtualBox_ESXi 6.0_07_01_2016_19_32_05Después de realizar la copia de los ficheros y las configuraciones pertinentes, y si todo ha salido bien, nos aparecerá la siguiente pantalla, confirmándonos que la instalación a terminado satisfactoriamente, y que se procederá a reiniciar el equipo.

VirtualBox_ESXi 6.0_07_01_2016_19_33_52
Sistema instalado correctamente

Pantalla que nos indica que el sistema esta reiniciando.

VirtualBox_ESXi 6.0_07_01_2016_19_34_08 Y si el arranque no ha tenido ningún problema, esta sera la pantalla que nos aparezca. Ya tenemos el sistema instalado y ejecutándose.

VirtualBox_ESXi 6.0_07_01_2016_19_35_44
Pantalla principal del sistema VMWare ESXi 6.0 ya funcionando

A partir de aquí, solo nos queda instalar los sistemas que queremos que se ejecuten en nuestro sistema virtualizado, pero eso sera en otro post.

Si tienes alguna duda o sugerencia puedes dejar un comentario.

 

Como escribir en un tarjeta SD con Arduino

Como escribir en un tarjeta SD con Arduino

como escribir en un tarjeta SD
Adaptador SD para arduino

En nuestros proyectos muchas veces necesitamos como escribir en un tarjeta SD con Arduino para almacenar la información que nos devuelve los sensores en algún lugar para después poderlos descargar y procesarlos en nuestro equipo.

 

Materiales usados

Arduino UNO Arduino UNO
 Arduino Shield SD Shield para SD
protoboard Protoboard
cables_union Cables de conexión

Escribir y leer en una tarjeta SD desde arduino

La mejor forma para realizar eso, es aprovechas la multitud de accesorios que hay para Arduino  que incorpora ranuras para tarjetas SD (Arduino Wireless SD Shield).

Para trabajar con tarjetas SD, Arduino (Arduino Uno R3) dispone de una librería que nos facilita el trabajo de como escribir en un tarjeta SD. La librería que tenemos que incluir en nuestros programas es

#include <SD.h>

Esta librería, aparte de incorporar las funciones básicas para escribir y leer fichero, también dispone de varias funciones para el manejo de la tarjeta, como puede ser espacio disponible, formato de la tarjeta, manejo de fichero (creación y eliminación de ficheros), lectura y escritura de ficheros, etc.

Conexión del lector de tarjetas SD con Arduino

Para la comunicación del lector de tarjeta SD (SD Card Reader Module Slot Socket For Arduino ARM MCU) y el microcontrolador se utilizan 4 puertos digitales, lo habitual, por lo menos en los accesorios que he podido manejar, los puertos que manejan son los siguientes:

  • En el pin digital 4: SD_CS.
  • Pin 11: SD_DI.
  • En el 12 conectar: SD_DO.
  • y en el pin 13: SD_CLK.

Se podrían usan otros y configurarlos, pero la mayoría de los accesorias que soportan tarjetas SD (Samsung Evo MB-MP16DA/EU – Tarjeta de memoria Micro SDHC de 16 GB (UHS-I Grade 1 Clase 10, con adaptador SD)), suelen ser shield, tarjetas que se conectan directamente en los pines del Arduino. No pudiendo modificar los pines que utilizan.

El formato de archivos que soporta el Arduino es FAT16 o FAT32, y el el tamaño máximo de la tarjeta SD que suele soportar es de hasta 16Gb (Samsung Evo MB-MP16DA/EU – Tarjeta de memoria Micro SDHC de 16 GB (UHS-I Grade 1 Clase 10, con adaptador SD)).

Leer un fichero en la tarjeta SD desde Arduino

Para como escribir en un tarjeta SD tendremos que crear un objeto que sera el que se encargue de realizar las operaciones de escritura y lectura.

Declaración del objeto para el maneje de fichero.

File miFichero;

Una vez que hemos declaro el objeto, le asignaremos el fichero con el que queremos trabajar y el modo de apertura, podemos indicar la apertura en modo “FILE_WRITE”, este modo nos permitirá abrir el fichero en modo lectura y escritura, si el fichero no existiera, Arduino lo crearía y lo abriría, si por el contrario, el fichero ya existiera, Arduino lo abriría y las escrituras que realicemos, las haría al final del archivo.

MiFichero = SD.open(“Nombre_Fichero.ext”, FILE_WRITE);

Leer un fichero desde la tarjeta SD desde Arduino

Si lo que queremos es solo abrirlo para lectura solo los tendremos que abrir de esta otra forma.

MiFichero = SD.open(“Nombre_Fichero.ext”);

Si el fichero no existe, esta operación provocara un error. Para comprobar que un fichero existe la librería de SD de Arduino nos proporciona la siguiente función.

SD.exists(“Nombre_Fichero.ext”)

Nos devolverá true, su el fichero existe, por lo contrario, si no existe, nos devolverá false. Una vez que hemos abierto el fichero, solo nos queda escribir o leer de el. Para leer solo tenemos que utilizar la función “println” de la siguiente forma.

MiFichero.println(“Información a guardar en el fichero”);

Pero si lo que queremos es leer del fichero, utilizaremos esta otra función.

MiFichero.read();

Esta función nos devolverá un byte leído desde el fichero.

Si lo que queremos es leer una linea, por ejemplo, los haríamos de la siguiente manera.

Byte byteLeido;
String Cadena = “”;
while (miFichero.available())
{
    byteLeido = miFichero.read();
    if (byteLeido == 13)
    {
        break;
    }
    else
    {
        Cadena = Cadena + char(byteLeido);
    }
}

Después de terminar nuestras operaciones con el fichero, solo nos queda nada mas que cerrarlo. Para ello utilizaciones la función “close”.

MiFichero.close();

Esto hará que cerremos todas operaciones con el fichero.

Estas son solo una pocas funciones disponibles para  la lectura/escritura de como escribir en un tarjeta SD con Arduino (Arduino Uno R3), pero muchas otras disponibles, para obtener más información sobre la librería SD de Arduino puede consultar este enlace. https://www.arduino.cc/en/Reference/SD

Hacer ping con visual C#

h-pingLa forma más fácil de comprobar que un equipo esta “vivo” en nuestra red es haciendo un ping. Lo que hace este comando es enviar un paquete ICMP al equipo que queremos verificar, el equipo al recibir este paquete devuelve una confirmación de recepción. Con esta acción ya hemos comprobado que el equipo esta funcionando y conectado.

Cuando nuestro programa en Visual C# tiene que conectarse a cualquier otro equipo, nos puede interesar antes de ejecutar las funciones de conexión es si ese equipo esta disponible o no. Podemos confirmarlo fácilmente haciéndole un ping.

Hacer ping con Visual C#

En la biblioteca de .Net “System.Net.NetworkInformation” tenemos disponible una función que nos hará ese trabajo. Para poder usarla tendremos que agregar a nuestro proyecto la siguiente referencia “System.Net”, podemos agregar tambien el namespace “System.Net.NetworkInformation” para facilitar el trabajo con las funciones.

Para hacer ping tendremos que crear dos objetos, un objeto “ping” como tal, este el que enviara el paquete ICMP. Y el objeto PingReply, este manejara la información devuelta.

Ejemplo de uso:

Ping HacerPing = new Ping();
int iTiempoEspera = 5000;
PingReply RespuestaPing;
string sDireccion;
sDireccion = txtIP.Text;
RespuestaPing = HacerPing.Send(sDireccion, iTiempoEspera);
if (RespuestaPing.Status == IPStatus.Success)
{
    txtLog.AppendText("Ping a " +
        sDireccion.ToString() +
        "[" +
        RespuestaPing.Address.ToString() +
        "]" +
        " Correcto" +
        " Tiempo de respuesta = " +
        RespuestaPing.RoundtripTime.ToString() +
        " ms" +
        "\n")
}
 else
{
    txtLog.AppendText("Error: Ping a " +
        sDireccion.ToString() +
        "\n");
}

Explicación:

Creamos el objeto Ping.

Creamos una variable de tipo “int” para almacenar el tiempo de espera, este valor esta en milisegundos.

Creamos el objeto PingReply para el manejo de la respuesta del ping.

Variable de tipo “string” donde guardaremos la dirección IP del equipo que queremos verificar.

Hacemos el Ping, le pasamos como parámetros los la dirección Ip que queremos comprobar y el valor de tiempo de espera en milisegundos, este ultimo parámetro es opcional, indicándole la dirección Ip o el nombre del equipo seria suficiente. La respuesta se la pasamos al objeto PingReply.

Para comprobar el estado comprobamos el valor que nos devuelve PingReply.Status, este valor es del tipo “IPStatus”. Para saber si ha sido satisfactorio solo tenemos que comprobar que el estado es “IPStatus.Success”. Si se ha producido un error podemos comprobar el tipo de estado devuelto del “IPStatus”. Más información sobre “IPStatus” en la librería de MSDN

Desde el objeto PingReply podemos obtener otras informaciones, como puede ser la dirección Ip de la maquina remota, el tiempo que se ha tardado en realizar, valor devuelto en milisegundos, opciones que se ha utilizado para el envio del paquete ICMP o el buffer de los datos recibidos por el ICMP.

Personalizar la serialización de tipos en XML

Serialización con XML
Serialización con XML

Cuando queremos guardar en fichero XML alguna estructura de datos podemos recurrir a la serialización.

Con las funciones actuales disponibles para el manejo de XML en C# la serialización de estructuras de datos es relativamente sencilla. Pero el problema nos surge cuando en la estructura de datos hay algún tipo de objeto que, o no nos interesa el modo en que hace la conversión, por la razón que sea, o por que la serialización de ese objeto no esta soportada.

Para solucionar este problema C# nos proporciona los atributos [XMLIgnore], para indicarle al proceso de serialización que ignore ese objeto, y [XmlElement], donde le indicamos como se va ha convertir ese objeto.

Para indicar al proceso de serialización del XML que ese objeto lo ignore, solo tendremos que anteponer el atributo [XMLIgnore] delante del objeto que queremos. Por ejemplo:

[XmlIgnore]
public Image Imagen { get; set; }

En este caso el tipo “Image” no soporta serialización, por lo que la conversión la tendremos que realizar nosotros mismos.

Una que le hemos dicho que ignore ese objeto le tenemos que indicar como vamos a convertirlo. Para ello tendremos que crear nuestra función de conversión he indicarle que la use en para ese elemento. Para indicarle que objeto vamos a utilizar solo tenemos que utilizar el atributo [XmlElement(“Nombre_del_objeto”], le indicamos el nombre que le hemos dado al objeto, no el tipo. Por ejemplo:

[XmlElement("Imagen")]
public byte[] ConvertImageToByte
{
    // Devolvemos una cadena de byte cuando nos pasan la imagen
    get
        {
            byte[] ImagenByte = null;
            // Si el valor pasado es distinto a null, pasamos la conversión, sino pasamos null
            if (Imagen != null)
            {
                // Convertimos la imagen en un array de byte[]
                ImageConverter ConvertirImagen = new ImageConverter();
                ImagenByte = (byte[])ConvertirImagen.ConvertTo(Imagen, typeof(byte[]));
            }
        return ImagenByte;
    }

    // Devolvemos una imagen cuando nos pasan una cadena de byte[]
    set
    {
        // Si el valor pasado es null
        if (value == null)
        {
            // Devolvemos otro null
            Imagen = null;
        }
        else
        {
            // Convertimos el array de bytes[] en una imagen
            ImageConverter ConvertirImagen = new ImageConverter();
            Imagen = (Image)ConvertirImagen.ConvertFrom(value);
        }
    }
}

En el ejemplo se utiliza el objeto “Imagen” del ejemplo anterior que es de tipo “Image”, que no esta soportado por la serialización de XML. Lo que hacemos es convertilo en un array de byte para poderlo guardar en el fichero.

La parte del “get” la serialización de XML la utilizara cuando va ha grabar los datos, leeremos desde el objeto “Imagen” la imagen que queremos y con ayuda de la función “ImageConverter” la convertimos en un array de byte, le indicamos el formato que vamos a utilizar en el segundo parámetro que le pasamos a la función en este caso “typeof(byte[]).

ImageConverter ConvertirImagen = new ImageConverter();

ImagenByte = (byte[])ConvertirImagen.ConvertTo(Imagen, typeof(byte[]));

La parte del “set” la serialización de XML la usa cuando lee los datos desde el fichero de XML. Le pasara la cadena de byte que tiene grabada y cargara en la variable “Imagen” la imagen es su formato correcto, tipo “Image”. Para la conversión volvemos a utilizar la función “ImageConverter”, en este caso nos devolverá un objeto, para pasárselo a la variable solo tenemos que indicar que ese objeto es de tipo “Image”

ImageConverter ConvertirImagen = new ImageConverter();
Imagen = (Image)ConvertirImagen.ConvertFrom(value);

Si lo aplicamos a un objeto que es de un tipo soportado por la serialización de XML, lo que hará, sera ignorar su método de serialización y utilizar el que le indiquemos.

Si tienes alguna sugerencia sera bienvenida, deja un comentario.