Acerca de:

Este blog contiene los códigos, ejemplos y bases de datos que he usado cuando aprendía acerca de algún tema específico. En lugar de borrarlos (una vez dominado ya el tema), he decidido publicarlos :)
Mostrando entradas con la etiqueta Ubuntu. Mostrar todas las entradas
Mostrando entradas con la etiqueta Ubuntu. Mostrar todas las entradas

miércoles, 10 de junio de 2026

Usando mi scanner Canon Lide 110 en Linux Mint

Paso 1: Conectar el Scanner

Paso 2: No esperar a que el scanner haga algún ruido

Paso 3: Abrir la aplicación "Escáner de Documentos" que ya viene instalada

Paso 4: esperar a que detecte el scanner


Paso 5: Have fun




Para guardar la imagen se debe presionar el botón con la flechita hacia abajo en la esquina superior derecha. El formato se puede elegir entre pdf, jpg y png. La aplicación tiene en la parte inferior las opciones para rotar y recortar la imagen (no se muestran porque recorté demasiado los pantallazos).

Este es el dibujito después de aumentarle el contraste con el Krita (lo más parecido a Paint.net que he encontrado), el cual puede instalarse usando el Gestor de Software del Linux Mint. (Creo que se nota que me gusta hacer dibujitos).



Y ahora...


Ya van varios días que estoy usando Linux Mint y no he tenido que ni abrir la terminal. Yo trasteé con varias distros allá por los 2010s, en aquella época en que venían sin las librerías para NTFS o para USB 2.0, y había que montar las particiones NTFS con comandos en la terminal y hasta manoseando archivos de sistema. El tema es que lo primero que se debía hacer apenas instalar un linux era buscar los comandos para resolver dependencias, instalar paquetes, ejecutar aplicaciones... casi todo en realidad. Linux era algo que no podías recomendar a usuarios de Windows. La prueba está en estas entradas:  

2026... las cosas son MUY distintas. Es casi un salto cuántico.


Soy sincera... extraño un poco tener que aporrear la terminal como un mandril con epilepsia.

sábado, 4 de mayo de 2019

Reemplazando Windows XP por Xubuntu 16 en una laptop del 2008

Mi vieja laptop Toshiba Satellite A215 tenía windows XP instalado y estaba teniendo problemas de compatibilidad (no podía reproducir videos de youtube, el antivirus se suicidó, y Visual Studio y Java me mostraron el dedo del medio) de modo que decidí darle una nueva vida con un Sistema Operativo nuevo. Escuché que Windows 7 es una buena opción para PCs que corren Windows XP, dicen que optimiza mejor el hardware y es totalmente compatible. He usado Windows 7 por años y lo amo, pero esta vez quise intentar algo diferente. En el trabajo usé Centos, Ubuntu y me enamoré de Linux Mint, pero como esta laptop es más vieja que mis zapatos tenía que buscar un Linux que le cupiera. Al final descargué Xubuntu 16 LTS desktop iso, porque no pude encontrar el iso de la versión 18 para 32 bits. Esta es una distro para computadoras con hardware humilde.

Estos son los pasos que debemos seguir:

0. ¡¡¡BACKUPEAMOS TODA LA DATA!!!
1. Descargamos el iso de Xubuntu (primera opción en el enlace).
2. Quemamos el iso en un DVD (puede ser regrabable) con infraRecorded. No se puede simplemente quemar el iso en el DVD, No va a funcionar. Con este software sólo requiere presionar el botón "Write Image" y hace todo el trabajo de crear un DVD booteable.
3. Reiniciamos la laptop desde el DVD.

4. Esperamos a que cargue:



5. Podemos probar Xubuntu si deseamos, esta opción no cambia nada en el sistema. Yo fui directamente a la instalación después de escoger el idioma:



6. Escogemos Instalar todos los codecs y presionamos "Continuar":





7. Vamos a "Más Opciones".
Como esta laptop tiene 3 particiones C, E y F, yo quise reescribir la partición C (donde el WinXP está) y dejar las otras intactas (si algo va mal, tengo backups).




8. Al presionar "Continuar" nos mostrará las particiones detectadas. La partición C es dev/sda2.




9. Escogemos la partición con Windows XP y le hacemos doble click:

Escogemos formatearla con el tipo de formato ext4 para la partición sda2 seleccionando la opción de "formatear la partición". ¡Cuidado de no tocar las otras dos particiones!



Debe quedar así:

Como la idea es reemplazar Windows XP por Xubuntu, le indico que el cargador de arranque esté también en /dev/sda2.


10. El instalador va a pedir una partición de intercambio. Escogí dev/sda1, era la partición de recuperación de Toshiba, pero para una máquina así de vieja no necesito recuperar nada. Esta opción está en la misma ventana del paso anterior. Finalmente mis particiones quedaron así:





¡Y ahora es el momento de la espera! La instalación copiará los archivos y configurará el sistema.


 De nada :D

Aquí el sistema nos dirá que saquemos el DVD y reiniciemos la máquina.

Funciona como la gloria, hasta reconoce las particiones NTFS:



No tocó mis otras particiones, mis archivos siguen ahí.

Unas cosas más para hacer:

sudo apt-get install gimp
sudo apt-get install firefox
sudo apt-get install firefox-locale-es


Esto es para instalar el editor de imágenes gimp, y actualizar el firefox en español.

:D :D :D :D :D

 El enlace del videíto es éste:


Update dos semanas después:
No me funciona el scanner.

Mi scanner es un CanoScan Lide 110 (debo haberlo comprado allá por el 2012) que funciona perfectamente con Windows 7 sin necesidad de instalar nada (utiliza el protocolo Windows Image Adquisition por defecto) y funcionaba perfectamente con el Windows XP.
Xubuntu 16 me lo reconoce, pero no puede escanear, lo más que logra hacer es intentar arrancar el motor del scanner y nada más.
Probé actualizando sane, xsane, easy-scan, reiniciando, añadiendo ppas raritos, actualizado con apt-get update y apt-get upgrade... y nada.

Bueno, esto queda pendiente, mientras tanto tengo otra laptop (del 2010, tengo la manía de encariñarme con mi hardware) con Windows 7.

Una última recomendación: antes de reemplazar alegremente un Windows por un Linux, es mejor asegurarse que todos los dispositivos, cacharros y demás funcionan con la distro que hemos elegido, nunca se sabe.

viernes, 6 de julio de 2018

Cómo obtener información de la Distro de Linux

Más de una vez me ha pasado necesitar saber la versión y el nombre de una distro de Linux, y si es de 32 o 64 bits. Luego de probar con varios comandos, encontré dos que son fáciles de recordar:

>cat /etc/lsb-release
Me da el nombre y la versión de la distro.

>uname -a
Me dice si es de 32 o 64 bits.


A continuación muestro la información que dan estos comandos en distintos Ubuntus gracias a la magia de VirtualBox :D

Si dice "x86_64" es de 64 bits. Este Ubuntu vino con Unity.


Otra de 64 bits. Éste es Ubuntu Mate.


Este es un Ubuntu de 32 bits con xfce. Si es de 32 bits, uname sólo mostrará "i686".


Este es un Xubuntu 14 de 32 bits.


Debo añadir que estos comandos no dan información acerca del entorno de escritorio que se está usando.

miércoles, 17 de mayo de 2017

Instalar nautilus-open-terminal en Centos 6 y Ubuntu 14.04

Uno de los problemas que tengo con Centos 6 y Ubuntu 14 es que el menú secundario del Nautilus no tiene la opción de ejecutar la terminal en la carpeta que se tiene abierta. Luego de una intensa investigación (5 minutos en google) encontré los comandos para instalar el paquete nautilus-open-terminal. Para no tener que memorizarlos, escribí un par de scripts en python para que los instalaran por mí.

Script para Centos 6:

# coding=utf-8
import subprocess;
import shlex

def main():
    subprocess.call(shlex.split('yum install nautilus-open-terminal'))
    subprocess.call(shlex.split('killall nautilus'))

if __name__ == "__main__":
    main()



Script para Ubuntu 14:

# coding=utf-8
import subprocess;
import shlex

def main():
    subprocess.call(shlex.split('sudo apt-get install nautilus-open-terminal'))
    subprocess.call(shlex.split('killall nautilus'))

if __name__ == "__main__":
    main()


Para ejecutar estos comandos se deben guardar en un archivo con extensión .py, abrir la terminal con un usuario sudo y ejecutar el comando:

python script_para_instalar_open_terminal.py

miércoles, 24 de julio de 2013

Tutorial: Script en Python para montar particiones en Ubuntu 12.04

Sólo lo he podido probar con particiones NTFS, y sin espacios en blanco en el nombre de la carpeta dentro de /media/ donde se monta la partición.

Tengo mi disco duro particionado en dos particiones: C: y D:, ambas NTFS. Al instalar el Ubuntu 12.04 desde Windows XP usando Wubi se crea un doble booteo: Windows y Ubuntu. Todo bien hasta aquí, el Ubuntu inicia y reinicia de lo mejor, al igual que el Windows. El Ubuntu coloca mi partición D: en la carpeta /host/:

Mi partición D: como la ve Ubuntu

Pero por ningún lado veía mi partición C:. El problema estaba en que debía montarla. Las instrucciones para hacerlo las saqué de esta web.

Luego de montar y desmontar la partición C: algunas veces, siguiendo las instrucciones de ubuntu-guia y restaurando el archivo /etc/fstab original, pensé que todos esos pasos podían automatizarse, y entonces recordé que Ubuntu ya viene con un intérprete de Python, el cual justamente se utiliza para automatizar ciertas tareas.

En este caso, la tarea consistía en:

  • Ingresar con privilegios de root (en todo momento sudo me pidió la contraseña de root para tener privilegios suficientes, especialmente al copiar y pegar el archivo fstab mediante el comando "gksudo nautilus /etc/").

  • Ejecutar comandos de sudo.

  • Crear una carpeta en un directorio de sistema (/media/).

  • Modificar un archivo de sistema (/etc/fstab).

  • Reiniciar el sistema (esto lo dejé a que lo hiciera el usuario).

Para acceder a las funciones y características del sistema operativo usando Python, se deben importar dos librerías "os" y "sys". El código para que el script ingrese con privilegios de root pidiendo la contraseña lo saqué de este enlace.

Una vez que ya podía ingresar como root, necesitaba una función de Python que me permitiera ejecutar comandos de sudo y almacenar en una variable los resultados. El primer comando de sudo que debía ejecutar mi script es "fdisk -l":


La función que necesito es os.popen() el cual me devuelve en una lista las particiones halladas y sus características, pero como cadenas de caracteres. Con la función print() puedo mostrar en la terminal el resultado y mostrar las particiones halladas. En mi caso la lista (almacenada en una variabble llamada "rem") tiene tres elementos, el script muestra esta lista y pide al usuario que ingrese la partición a montar con la función raw_input(). Se debe ingresar la partición tal y como se muestra en la terminal, en mi caso es "/dev/sde1" (sin las comillas). Luego el script evalúa si la partición existe, cuyo nombre está almacenado en una variable llamada "part", utilizando la función filter(). Si no existe, el script finaliza. Este chequeo es necesario pues el usuario puede ingresar cualquier otra cosa, desde equivocarse al escribir hasta intentar sabotear el sistema operativo. (la función raw_input() interpreta lo ingresado como caracteres, pero la función input() interpreta lo ingresado como comandos de Python; ambas funciones pertenecen a este lenguaje, mucho cuidado con confundirlas!).

La función filter() es el equivalente en Python de las funciones de C# Linq.Where().

La línea:

n = filter(lambda x: x.find(part, 0, len(x)) > -1, rem) 

en C# 3.0 sería:

var n = rem.Where(c => c.IndexOf(part) != -1);

En Python, si lalongitud de "n" es cero, es que no se ha hallado la partición ingresada.

Luego debo ejecutar el comando de sudo "blkid particion_elegida":


El resultado, guardado en la variable "rem", es una lista con un solo elemento tipo cadena de caracteres, el cual contiene el ID y el tipo de partición. Extraigo ambos con la función filter() y con el código que encontré en este enlace, el cual usa expresiones regulares para extraer la cadena de caracteres que se necesita, por este motivo debo importar también la librería "re".

Una vez que tengo todos los datos que necesito (partición, ID y tipo) le pido al usuario que escriba el nombre de la carpeta dentro de /media/ donde el script montará la partición. Si la carpeta no existe, el script la creará automáticamente. La línea que evalúa si la carpeta existe es:

os.path.isdir("media/carpeta_ingresada")

La variable con la ruta completa es "t2". Para crear la carpeta, si ésta no existe, utilizo el comando "mkdir" de sudo.

Python no posee un "switch" o un "Select Case" como otros lenguajes de programación, pero esto se resuelve con algunos if... else. En este caso, es para evaluar el tipo de partición y "armar" la línea que se añadirá al archivo /etc/fstab.

El código completo es:

#! /usr/bin/env python

import os;

import re;

import sys; 

# http://stackoverflow.com/questions/5222333/authentication-in-python-script-to-run-as-root

euid = os.geteuid()

if euid != 0:

    print "Iniciando sudo para ingresar como root..."

    args = ['sudo', sys.executable] + sys.argv + [os.environ]

    # the next line replaces the currently-running process with the sudo

    os.execlpe('sudo', *args) 

if euid == 0:

    print 'Corriendo, su euid es: ', euid

else:

    print 'No se pudo iniciar como root. Cerrando script'

    sys.exit()

 

# http://mail.python.org/pipermail/python-es/2007-December/019270.html

rem = os.popen("sudo fdisk -l").readlines() # obtengo las particiones 

for i in rem:

    print i 

# http://www.daniweb.com/software-development/python/threads/12326/how-to-do-input-in-python

# "input" interpreta lo ingresado como comando, se debe usar raw_input 

part = raw_input("Escriba la particion a montar: ")

n = filter(lambda x: x.find(part, 0, len(x)) > -1, rem) 

if len(n) == 0:

    print ("La particion no existe")

else:

    t = ("sudo blkid ", part) # obtengo el UUID

    sudo1 = ''

    sudo1 = sudo1.join(t)

    rem = os.popen(sudo1).readlines() 

    if len(rem) == 0:

        print("Particion no valida")

    else:

        partInfo = rem[0].split()

        IdPart = filter(lambda x: x.upper().find('UUID', 0, len(x)) > -1, partInfo)

        tipoPart = filter(lambda x: x.upper().find('TYPE', 0, len(x)) > -1, partInfo)       

        # http://stackoverflow.com/questions/4666973/how-to-extract-a-substring-from-inside-a-string-in-python

        uuID = re.search('"(.+?)"', IdPart[0]).group(1)

        tipoParticion = re.search('"(.+?)"', tipoPart[0]).group(1)

        print tipoParticion 

        carpeta = raw_input('ingrese el nombre de la carpeta dentro de /media/ donde montar la particion. ')

        t = ('/media/', carpeta)       

        t2 = ''

        t2 = t2.join(t) 

        if not os.path.isdir(t2):

              t = ('sudo mkdir /media/', carpeta)

              sudo1 = ''

              sudo1 = sudo1.join(t)

              rem = os.popen(sudo1).readlines()

        # http://snipplr.com/view/6630/

        # http://www.tutorialspoint.com/python/python_files_io.htm       

        if tipoParticion.upper() == 'NTFS':

            t = ('UUID=', uuID, '      /media/', carpeta, '     ntfs-3g default       0      0')

        elif tipoParticion.upper() == 'FAT':

            t = ('UUID=', uuID, '      /media/', carpeta, '     vfat rw,uid=1000,gid=1000      0      0')

        elif tipoParticion.upper() == 'EXT4':

            t = ('UUID=', uuID, '      /media/', carpeta, '     ext4 errors=remount-ro 0      1')

        else:

            t = ''

           

        if len(t) > 0:

            linea = ''

            linea = linea.join(t)           

            with open('/etc/fstab', 'a') as fstab_file:

                fstab_file.writelines(linea)

                fstab_file.close()

            print 'Se ha montado la particion, reinicie el sistema'

        else:

            print('particion desconocida')


 

Este script sólo ha sido probado montando particiones NTFS en Ubuntu 12.04 y en carpetas dentro de /media/ cuyos nombres no contengan espacios. La partición no debe estar listada en /host/ o el sistema Ubuntu botará error al iniciar.