domingo, 14 de octubre de 2018

Virtualización con Hyper-V - Sacando jugo a Windows 10

 ******¡¡¡IMPORTANTE!!!******

- Lo que se explica en este POST, es únicamente con fines didácticos. Úsalo sólo a título personal.
- Tifloinformático, su autor y/o los desarrolladores de las herramientas mencionadas, no se hacen responsables del mal uso que le des al contenido de esta entrada, siendo tú el/la único/a responsable.
- Las herramientas mencionadas, son propiedad de sus autores.
- Si citas total o parcialmente este artículo, en internet o por otros medios, debes mencionar la fuente:
http://tifloinformatico.blogspot.com
- Las instrucciones que se describen a continuación han sido probadas en Windows 10. Aunque pueden servir para otras versiones, no se garantiza que sean válidas para versiones distintas de Windows.


-------------------------

¿Cuantas veces hemos tenido curiosidad por un sistema distinto al que usamos habitualmente, hemos necesitado un programa que no está disponible para nuestro sistema operativo, o queremos usar una versión concreta de un programa, que sólo funciona en una versión concreta de un sistema operativo?

Existen varias soluciones para dar respuesta a situaciones como estas. Una de ellas, sería instalar tantos sistemas como queramos en el ordenador, pudiendo elegir entre cualquiera de ellos al encender el equipo.

Si bien esto sería lo más eficiente, puesto que cada sistema aprovecharía al máximo los recursos hardware del ordenador, no es lo más práctico, ya que sólo podríamos ejecutar un sistema a la vez, y para cambiar de un sistema a otro, obligatoriamente tendríamos que reiniciar el equipo.
Además, la elección del sistema operativo en el arranque del ordenador en caso de haber más de uno instalado, no es accesible para personas ciegas.

Para solucionar estos inconvenientes, existe la virtualización: es una forma de ejecutar un sistema operativo y/o aplicaciones dentro de otro sistema operativo.

De esta manera no es necesario reiniciar el ordenador para usar un sistema operativo distinto al que usamos habitualmente, y podemos usar más de uno a la vez.

Por supuesto, no todo iban a ser ventajas, y esto tiene algunos incconvenientes, como que los sistemas no aprovechan al máximo los recursos hardware del ordenador; sino que han de compartirlos, ya que están ejecutándose a la vez.

Lo bueno es que normalmente podemos ajustar los recursos de cada sistema, de manera que podemos decidir cual dispondrá de más recursos y cual podrá hacer uso de menos, o repartirlos por igual.

Existen varias herramientas de virtualización para distintos sistemas operativos, muchas o quizás todas accesibles: cuando hablamos de la accesibilidad de una herramienta de virtualización, hay que entender que nos referimos a su interfaz propia... Las opciones de ésa herramienta, y no a la accesibilidad del sistema que virtualizamos o las aplicaciones que contiene, ya que ello depende del sistema a virtualizar (si es accesible por si mismo, cuenta con API's de accesibilidad, herramientas de apoyo de terceros ETC)

Las tres herramientas más importantes de virtualización son: VMWare (con versiones de pago y gratuitas), virtualbox (gratuito) y virtual PC (gratuito).

Excepto Virtual PC que es de Microsoft, VMWare y VirtualBox son multiplataforma y compatibles en el caso de Windows, con todas las versiones, de XP en adelante, tanto de 32 como de 64 bits.

Virtual PC en cambio, es compatible con Windows xP, Vista y 7; ya que dejó de tener soporte de Microsoft.

Pero con la llegada de Windows 10, Microsoft siguió apostando por su propia herramienta de virtualización. Y haciendo honor a la filosofía de Windows 10, donde todo está integrado, Microsoft incluyó en algunas versiones de la última versión de Windows el sucesor de Virtual PC: Hyper-V

Y es precisamente de esta herramienta que incluye Windows 10: Hyper-V, de la que vamos a hablar en la entrada de hoy.

Vamos a ver como podemos virtualizar por ejemplo, una distribución de Linux en Windows 10, sin herramientas de terceros. Usaremos Hyper-V para ello.

Para ello lo primero que tenemos que hacer, es asegurarnos de cumplir con los requisitos de Hyper-V de Windows 10, que son: Windows 10 de 64 bits, en sus versiones Enterprise, Professional o Education (Home no sirve).

Si disponemos de alguna de estas versiones de 64 bits de Windows 10 podremos hacer uso de Hyper-V. Para ello antes, hay que activarlo, ya que por defecto viene desactivado.

Para activar Hyper-V en Windows 10, deberemos de abrir la consola a través de PowerShell, ejecutándolo como administrador.

Para ello vamos a inicio, y en el campo de búsqueda, escribimos "powershell" (sin las comillas) y sobre el resultado que nos aparece como aplicación de escritorio, pulsamos tecla aplicaciones y elegimos la opción "Ejecutar como administrador".
*Si aparece el control de cuentas de usuario pidiendo permiso para ejecutar la aplicación, pulsamos en "Sí".

A continuación tenemos que escribir el siguiente comando en la consola, para habilitar Hyper-V

Enable-WindowsOptionalFeature -Online -FeatureName:Microsoft-Hyper-V -All

 Tras unos segundos o minutos (según el equipo) aparecerá el siguiente mensaje:

¿Desea reiniciar el equipo para completar esta operación ahora?
[Y] Yes [N] No [?] Ayuda (el valor predeterminado es "Y"):

a lo que debemos responder que sí para finalizar la instalación de Hyper-V

Al reiniciarse el ordenador, continuará la instalación de Hyper-V: tras el reinicio, aparecerá el mensaje "Trabajando en las características". Una vez terminado, el equipo volverá a reiniciarse para terminar con la instalación, por lo que aún podría tardar un poco más de lo normal en abrirse el escritorio.

Una vez terminada la instalación de Hyper-V, ya podemos crear la máquina virtual. Para ello vamos a la herramienta de administración de Hyper-V: en inicio, en el campo de búsqueda escribimos "herramientas administrativas" (sin las comillas) y pulsamos sobre la opción que aparece como Panel de control en los resultados.
Debemos buscar "Administrador de Hyper-V" y abrirlo.

Lo que se abre a continuación es la herramienta de virtualización Hyper-V. Antes de crear la máquina virtual, vamos a ver algunas configuraciones que pueden sernos útiles.

Lo primero que haremos es crear una carpeta donde se almacenarán las máquinas virtuales y sus discos duros. Por defecto, Hyper-V tiene una ruta establecida, pero puede que prefiramos otra ruta a la que nos sea más fácil llegar y que recordemos mejor.

Por ejemplo, vamos a crear una carpeta llamada VM_Hyper-V en Mis documentos; aunque podéis llamarla como queráis, y crearla donde prefiráis. E incluso, elegir una carpeta ya creada en el sistema.

Para ello vamos al explorador de archivos con Windows+e y buscamos la carpeta Documentos o Mis documentos.
Si tenéis un acceso directo a "Este equipo" es mucho más rápido, ya que si entráis ahí, veréis la carpeta "Documentos", a la que podéis entrar directamente.

Para crear la carpeta, nos aseguramos de que no haya nada seleccionado (pulsando CTRL+espacio si usamos lectores de pantalla) y pulsamos tecla Aplicaciones y vamos a "Nuevo">"Carpeta".

Ponemos el nombre de la carpeta y pulsamos Enter para crearla.

además, dentro de esta carpeta, para tenerlo todo más ordenado, crearemos dos directorios: HD y VM, para almacenar los discos duros y las máquinas virtuales respectivamente (podéis también a estas carpetas darles los nombres que queráis).
Las carpetas las crearemos exactamente de la misma forma que hicimos con la anterior.

Volvemos al administrador de Hyper-V y abrimos la configuración. Para ello vamos a la barra de menú "Acción", y a la opción "Configuración de Hyper-V...".

Podemos recorrer todas las opciones de la configuración y ajustarlas a nuestro antojo. En esta entrada solo veremos algunas opciones.

Nos situamos en la presentación en árbol, y la primera opción es "Discos duros virtuales", dentro de la rama "Servidor".

Para usuarios de lectores de pantalla (al menos de Jaws) esta interfaz puede resultar un tanto confusa, ya que Jaws anuncia los elementos de la presentación en árbol como "Cerrado", como en el caso de "Discos duros virtuales"; por lo que puede parecer que no es posible acceder a esta opción.

Para ir a las opciones de configuración de este elemento, únicamente hay que pulsar la tecla Tabulador.

En esta opción, vemos que podemos elegir la ruta donde queremos que se guarden los discos duros de las máquinas virtuales: "Especifique la carpeta predeterminada para almacenar los archivos de disco duro virtual". Aquí podemos escribir la ruta o, si pulsamos en el botón "Examinar", podemos buscarla más cómodamente en la típica ventana de Windows para buscar carpetas.
En este caso, elegimos la carpeta VM_Hyper-V que creamos anteriormente en Miss documentos y el subdirectorio "HD".

Volvemos a la presentación en árbol para bajar hasta la opción "Máquinas virtuales". en "Especifique la carpeta predeterminada para almacenar los archivos de configuración de máquina virtual" al igual que en la opción anterior, podemos elegir en este caso, donde se guardarán los archivos de la máquina virtual que creemos. En el cuadro de edición podemos escribir la ruta. Si pulsamos en el botón "Examinar", podemos elegir el directorio desde la interfaz gráfica de la típica ventana para buscar carpetas de Windows.
En este caso elegimos el directorio "VM", que creamos anteriormente dentro de la carpeta "VM_Hyper-V" dentro de Mis documentos.

Volvemos a la presentación en árbol. La siguiente opción que configuraremos es "Teclado", dentro de la rama "Usuarios".
Pulsamos la tecla Tabulador y nos aseguramos que está seleccionada la opción "Usar en la máquina virtual". De lo contrario no podremos usar el teclado en las máquinas virtuales que creemos.

Volvemos a la presentación en árbol y bajamos hasta la opción "Combinación de teclas de liberación del mouse". Esta opción nos permite configurar el comando de teclado para liberar el ratón y así poderlo usar en el sistema Host.
Nuevamente pulsamos la tecla Tabulador y en la lista de comandos que aparece, elegimos el que prefiramos para liberar el ratón de la máquina virtual, y devolver el control de éste al sistema Host.

Por ejemplo, elegimos la tercera: "CTRL+ALT+ESPACIO", que sabemos que no interferirá con ningún comando de Windows ni de los lectores de pantalla si los usamos.

El resto de opciones podéis modificarlas si queréis, pero la mayoría de ellas están bien como vienen por defecto.
Para terminar con la configuración y aplicarla, como viene siendo habitual en Windows, pulsamos en "Aplicar" y luego en "Aceptar".

Una vez hechos los ajustes, ya podemos crear una máquina virtual. Pero antes necesitamos una imagen de Linux para poder virtualizarlo, así que descargaremos Ubuntu.

Ya que no he encontrado la última versión en edición de 32 bits; y virtualizar sistemas de 64 bits suele ser más complejo por lo general, porque requiere de ciertas características del procesador que, no todos los procesadores tienen, y que por defecto, si las tienen, no suelen venir activadas en BIOS, vamos a descargar la versión 16 de Ubuntu, que seguro, tiene versión de 32 bits.

Para ello

Descargamos la imagen de Ubuntu 16 de 32 bits

(Enlace directo de descarga de la ISO)

Una vez finalizada la descarga ¡ahora sí, podemos empezar con la creación de la máquina virtual en Hyper-V!.
Podemos hacerlo de dos maneras: pulsando tecla Aplicaciones sobre el equipo local (DESKTOP-E0I4H0O) que aparece en la presentación en árbol del administrador de Hyper-V (el nombre puede variar), en "Nuevo" y máquina virtual.

Podemos crear otros elementos. Pero de momento solo veremos esta opción.

También podemos ir a la barra de menú "Acción", e igualmente a la opción "Nuevo">"Máquina virtual".

De cualquiera de las dos formas, también existe una opción llamada "Creación rápida", que permite crear rápidamente la máquina virtual.

En cualquier caso,no usaremos esta opción, sino que crearemos manualmente la máquina virtual, paso a paso.

Al iniciar el asistente de creación de máquinas virtuales, aparece una pantalla donde nos indica que podemos pulsar en "Finalizar" para crear una máquina virtual con los valores predeterminados de Hyper-V, o en "Siguiente" para ajustar manualmente la configuración de la máquina virtual.

Pulsamos en "Siguiente" para configurar manualmente la máquina virtual y nos aparece una ventana, donde lo primero que vamos a poner es el nombre de la máquina en el campo "Nombre".
Por ejemplo, a la máquina que vamos a crear, le vamos a llamar "Ubuntu 16 x86" (sin las comillas) para sólo con verla en la lista de máquinas virtuales, saber qué sistema, versión y arquitectura contiene.

La opción "Almacenar la máquina virtual en otra ubicación" la dejamos como está; si quisiéramos guardar esta máquina virtual en concreto, en una ubicación distinta a la que establecimos por defecto antes en la configuración, sólo tenemos que marcar esta opción e indicar la ruta donde queremos guardar la máquina.

A continuación pulsamos en "Siguiente".

Lo siguiente que hemos de configurar es la "generación" de la máquina. Existen dos tipos:


  • Generación 1: La máquina virtual soporta sistemas de 32 y de 64 bits, y admite el mismo hardware virtual que versiones anteriores de Hyper-V.

  • Generación 2: La máquina virtual soporta sistemas de 64 bits en modo UEFI

 Así pues, podríamos entender los tipos de generación de las máquinas virtuales de Hyper-V, como el modo UEFI o BIOS heredado de la BIOS de la mayoría de las placas base de hoy en día.

Como vamos a instalar Ubuntu 16 de 32 bits, seleccionamos "Generación 1" y pulsamos en "Siguiente".

A continuación hemos de configurar la cantidad de memoria RAM que queremos asignarle a la máquina virtual, que por defecto está establecida en 1024 MB (1 GB).

Hay que tener cuidado con la asignación de memoria en las máquinas virtuales, ya que no sólo no podemos asignar más memoria de la que tiene físicamente el equipo, sino que no podemos tampoco asignarla toda, ya que como dijimos al principio, las máquinas virtuales comparten los recursos de hardware con el sistema Host (el que está realmente instalado en el equipo). Y la memoria es uno de los recursos de hardware.

Así pues, aunque esto es muy relativo, ya que depende mucho de la cantidad de memoria física del ordenador, de si el sistema host es de 32 o 64 bits, de la cantidad de aplicaciones que estén en ejecución en el sistema host; de la arquitectura del sistema virtualizado, de las aplicaciones que vayan a correr en este ... Suele ser buena idea asignar la mitad de la memoria física, a la máquina virtual, si por ejemplo, como Windows en este caso de 32 bits, el requisito mínimo de memoria es de 1 GB; ya que de ser posible, es recomendable un poco más para que las aplicaciones corran con mayor fluidez.

En cualquier caso, en muchas ocasiones, no es necesario asignar demasiada memoria; sobre todo para distribuciones Linux, que suelen ser mucho más ligeras y por tanto requerir menos memoria.

En mi caso, ya que mi ordenador tiene 8 GB de RAM y un procesador Intel i3 (el procesador también influye a la hora de asignar más o menos memoria ya que con un procesador medianamente potente, algunos sistemas rendirán bien con algo menos de RAM) voy a asignarle 3 GB de memoria a la máquina virtual.

Para ello, en el campo "Memoria de inicio", hay que escribir el valor; que para 3 GB sería 3072 (en MB)
*recordad que 1 GB no son 1000 MB, sino 1024.

La opción "Usar la memoria dinámica para esta máquina virtual" la dejamos como está y pulsamos en "Siguiente".

A continuación hemos de configurar el adaptador de red. En la lista que aparece en la pantalla actual del asistente de creación de máquinas virtuales, podemos elegir entre "Desconectado" o "Modificador predeterminado".
Seleccionamos la segunda opción y pulsamos en "Siguiente".

Ahora es el turno del disco duro de la máquina virtual. Lo primero que vamos a hacer es darle un nombre.
En el campo "Nombre", Hyper-V ya nos pone un nombre por defecto, que podemos cambiar por el que queramos; siempre respetando la extensión ".vhdx", que es la extensión de archivo de los discos de Hyper-V.
En mi caso dejo el nombre que hay por defecto que es "Ubuntu 16 x86.vhdx" (el nombre que le puse a la máquina virtual).

En el campo "Ubicación" Hyper-V nos pone por defecto la ruta que establecimos como predeterminada para los discos duros, en la configuración del administrador de Hyper-V.
Si queremos cambiar la ruta del disco duro de esta máquina virtual en concreto, sólo hemos de pulsar en "Examinar" y elegir la ubicación.

En "Tamaño" indicaremos el tamaño del disco duro de la máquina virtual en GB. Por defecto, Hyper-V nos ofrece asignarle al disco 127 GB. Pero quizás esto sea demasiado, así que podemos poner el valor que queramos, siempre expresado en GB.
Hay que tener en cuenta el tamaño libre del disco físico de la máquina host, el tamaño mínimo requerido para el sistema que vamos a virtualizar, y calcular aunque sea por encima, el espacio en disco que necesitaremos para aplicaciones, archivos y demás.

Por ejemplo, yo voy a crear un disco de 40 GB para la máquina virtual que estamos creando.

Si seguimos tabulando, antes de pulsar en "Siguiente", justo después de "Resumen", podemos elegir el tipo de disco que vamos a crear.
Por defecto está marcada la opción "Crear un disco duro virtual". Pero podríamos también, usar un disco duro virtual existente, en cuyo caso, habría que buscar el disco con el botón "Examinar", o escribir su ruta completa en el campo "Ubicación".
Si os fijáis, con esta segunda opción, desaparece el campo "Tamaño"; ya que el tamaño será el que tenga asignado el disco existente que usemos.

También podemos elegir la opción "Exponer un disco duro virtual más adelante". En este caso, la máquina virtual se creará sin disco duro, y podremos añadirlo más tarde, cuando lo necesitemos.
Esto sería útil por ejemplo, si queremos ejecutar un sistema Live CD en la máquina virtual, y no tenemos pensado instalar ningún sistema.

Si os fijáis, en esta opción, también desaparece el campo "Ubicación" y el botón "Examinar".

En nuestro caso elegiremos la primera opción "Crear un disco duro virtual", para crear una máquina que ya tenga un disco configurado y pulsamos en "Siguiente".

A continuación hemos de elegir el sistema que vamos a virtualizar.
Podemos elegir entre "Instalar un sistema operativo más adelante", "Instalar un sistema operativo desde un CD/DVD-ROM de arranque", "Instalar un sistema operativo desde un disquete de arranque" o "Instalar un sistema operativo desde un servidor de instalación en red".

Seleccionamos la primera opción y pulsamos en "Siguiente" ¡y ya hemos terminado con la creación de la máquina virtual!.
Antes de finalizar, nos aparece un resumen con la lista de opciones que hemos ido configurando durante la creación de la máquina virtual.

Podemos pulsar en "Anterior" si queremos corregir algo en la configuración de la máquina, o en "Finalizar", si todo está bien, para terminar.

Una vez terminada la creación de la máquina virtual, en el administrador de Hyper-V (en "Máquinas virtuales") donde llegaremos con la tecla Tabulador, veremos la máquina virtual que acabamos de crear.
Por defecto, veréis que en la máquina virtual pone "Desactivada". Esto es porque la máquina está apagada.

Antes de iniciar la máquina virtual, vamos a ver más sobre configuración. En este caso, la configuración de la máquina virtual.

Para acceder a la configuración de la máquina, sobre esta, pulsamos tecla Aplicaciones, y en "Configuración".

Se abrirá un asistente de configuración de la máquina virtual de lo más completo.

Podemos configurar de todo en la máquina.

No vamos a ver cada opción de la configuración, porque hay muchas y el artículo se haría demasiado largo. Pero veremos por ejemplo, como cambiar el órden de arranque en la BIOS ... De la máquina virtual ;)

Sí, en las máquinas de Hyper-V, al igual que en otras herramientas de virtualización, podemos cambiar el órden de arranque en el boot de la BIOS de la máquina virtual, de forma accesible. No como en un ordenador real, donde esto es imposible.

Por defecto debería estar configurado la unidad de CD/DVD como primera opción de arranque. Pero podemos cambiarlo por ejemplo, por el disco duro.

Para ello, una vez abierto el asistente de configuración de la máquina virtual, nos situamos en la presentación en árbol donde están todas las opciones de configuración y bajamos hasta "BIOS", dentro de la rama "Hardware".

Igual que ocurría en el asistente de configuración de Hyper-V, en esta ventana también hemos de tabular para movernos por las opciones de un elemento de la configuración.
Si lo hacemos una vez situados en "BIOS", vemos que la primera opción es "Orden de inicio". "Seleccione el orden en que deben comprobarse los dispositivos de arranque para iniciar el sistema operativo".

Aquí, como decía, debería estar la unidad de CD/DVD en la primera posición. Si no es así, o si queremos que la primera unidad a comprobar en el arranque sea una distinta, hemos de elegirla en la lista, y pulsar en el botón "Subir" o "Bajar", a los que se accede con la tecla Tabulador.

Con estos botones, vamos subiendo o bajando la posición de la opción que seleccionemos en la lista.
de esta manera, podemos configurar a nuestro gusto el órden de todas las opciones que aparecen como booteables.

Si volvemos a la presentación en árbol; si bajamos, encontramos "Memoria". Aquí, podemos configurar la memoria RAM de la máquina virtual.

En el campo "RAM" aparece la cantidad de memoria que hemos asignado a la máquina cuando la creamos. Pero ahora, podemos establecer un mínimo y máximo de RAM que usará la máquina virtual.

La opción "Habilitar memoria dinámica" nos permite establecer el uso de la memoria RAM por parte de la máquina virtual.
Si esta opción está marcada, podemos establecer un mínimo y un máximo de memoria RAM que utilizará la máquina virtual. En caso contrario, la máquina virtual usará una cantidad fija de memoria, que será la que le asignamos en la creación de la máquina, o la que establezcamos en la configuración de esta.

Por defecto, en el campo "RAM mínima" podemos establecer el mínimo de memoria que va a usar la máquina. Es importante no poner un valor por debajo del requisito mínimo de RAM del sistema que vamos a virtualizar.
*Este valor se expresa en MB.

Por ejemplo, yo voy a poner 1,5 GB para la máquina que estamos configurando, por lo que en MB serían 1536 MB.

En el campo "RAM máxima", podemos establecer el máximo de memoria que usará la máquina. Esto es importante, si permitimos el uso dinámico de memoria por parte de la máquina virtual, para que no intente consumir toda la RAM del equipo si la necesita, ya que esto provocaría inestabilidad tanto en la máquina virtual, como en la máquina host; hasta el punto de colgarse ambas en algunos casos.

Por defecto, en este campo pone un valor que creo que hoy en día nadie tiene la suerte de tener: "1048576". Sí, son megas... Pero aún así son demasiadas ¿no os parece?

Teniendo en cuenta lo que hemos explicado antes, cuando creábamos la máquina virtual, sobre la asignación de la memoria, en este campo debemos establecer un valor coherente. Por ejemplo, los tres gigas que asignamos inicialmente a la máquina.
*El valor de este campo también se expresa en MB, por lo que tres gigas serían 3072 MB.

Podríamos poner la misma cantidad en "RAM mínima" y "RAM máxima", y así la máquina virtual siempre usaría la misma cantidad de memoria.
Pero es preferible establecer una diferencia entre la cantidad mínima y la máxima, para que si la máquina virtual no lo necesita, no use tanta memoria. De esta manera, la máquina host irá más fluida, al haber más memoria liberada por parte de la máquina virtual.

Los campos "Búfer de memoria" y "Ponderación de memoria" los dejaremos como están.

Si volvemos a la presentación en árbol y bajamos, encontramos el procesador.
Para modificar su configuración, igualmente, hemos de pulsar la tecla Tabulador para movernos por las distintas opciones.

En el campo Puede modificar el número de procesadores virtuales según el número de procesadores del equipo físico. También puede modificar otras opciones de configuración de control de recursos" podemos establecer cuantos procesadores vamos a usar en la máquina virtual, que por defecto es 1.

Aquí hemos de escribir el número de núcleos que queremos asignar a la máquina virtual. Pero antes hemos de asegurarnos de cuantos núcleos tiene el procesador físico de la máquina host, para no asignar más núcleos a la máquina virtual, de los que tiene físicamente el procesador.

Por ejemplo, aunque mi ordenador tiene 4 núcleos, yo de momento voy a asignarle 2 a la máquina virtual que hemos creado.

A continuación, en "Reserva de máquinas virtuales (porcentaje)" y "Límite de máquinas virtuales (porcentaje)", podemos establecer la cuota de procesador que queremos asignar a la máquina virtual.
Por defecto la máquina virtual, puede usar el cien por cien del procesador. Pero si la máquina host va a realizar alguna tarea más o menos pesada, y queremos asegurarnos de que no vayan a haber cuelgues, o que dicha tarea se ralentice demasiado, aquí podemos limitar el uso del procesador por parte de la máquina virtual, por ejemplo, al 50%, escribiendo el mínimo y el máximo en porcentaje, en los campos correspondientes.

El campo "Ponderación relativa" lo dejamos como está.

A continuación vamos a configurar el medio de instalación del sistema que vamos a virtualizar.
Para ello, volvemos a la presentación en árbol y bajamos hasta la opción "Unidad de DVD".

Como siempre, pulsamos la tecla Tabulador para movernos por las opciones de la configuración de este elemento.

Hyper-V es tan completo que nos permite incluso, configurar el canal en el que conectar los dispositivos.
En este caso, la unidad de dVD está configurada en el canal IDE 0: en principio no hay motivos para cambiar esto, por lo que lo dejaremos como está.

En "Ubicación" tampoco tocaremos nada, ya que está en "1 (en uso)".

Y a continuación viene el campo que realmente nos interesa: "Medios".

Aquí podemos elegir el tipo de unidad de DVD que vamos a usar con la máquina virtual: "Unidad de CD/DVD física", "Archivo de imagen" o "Ninguno".

Si el sistema a virtualizar lo tenemos quemado en un CD o DVD, podemos elegir la primera opción, y usaremos la unidad óptica física.

Si hemos descargado el sistema de internet, y no queremos quemarlo en un CD o DVD, podemos elegir la opción "Archivo de imagen" y en su lugar, la ISO del sistema actuará como unidad óptica de la máquina virtual.
*Cuidado, porque esto será así siempre, mientras no se cambie la configuración; no sólo en el arranque de la máquina virtual.

Si elegimos "Ninguno", es como si la máquina virtual no tuviera unidad óptica.

Como queremos instalar un sistema, y lo hemos descargado de internet, pero no lo hemos grabado en un DVD, seleccionamos la opción "Archivo de imagen" e indicamos la ruta de la imagen ISO del sistema, que podemos hacerlo escribiendo la ruta en el campo correspondiente, o buscarla con la interfaz gráfica típica de Windows para buscar archivos, pulsando en "Examinar".

El resto de opciones (que son muchas) podéis explorarlas por vuestra cuenta, y realizar los cambios que consideréis oportunos.

Una vez terminada la configuración de la máquina virtual, pulsamos en "Aplicar" y luego en "Aceptar".

Ahora sí, la máquina está lista para ejecutarla.
Para eso nos situamos sobre ella, y pulsamos la tecla Aplicaciones, y en "Iniciar".

Es posible que recién instalado Hyper-V, y la primera vez que iniciamos una máquina virtual, obtengamos un error como este (la información completa aparece pulsando en "Detalles", en el error)

Error al intentar iniciar las máquinas virtuales seleccionadas.
No pudo iniciarse 'Ubuntu 16 x86'.
La máquina virtual 'Ubuntu 16 x86' no se pudo iniciar porque el hipervisor no está en ejecución.
No pudo iniciarse 'Ubuntu 16 x86'. (Id. de máquina virtual 6B225430-0CBA-4334-9164-A06CB358C83B)
La máquina virtual 'Ubuntu 16 x86' no se pudo iniciar porque el hipervisor no está en
ejecución (identificador de la máquina virtual: 6B225430-0CBA-4334-9164-A06CB358C83B).
Las siguientes acciones pueden ayudarle a resolver el problema:
1) Compruebe que el procesador del equipo físico dispone de una versión compatible de virtualización asistida por hardware.
2) Compruebe que la protección de ejecución de datos asistida por hardware y la virtualización asistida por hardware están habilitadas en el BIOS del equipo físico. (Si edita el BIOS para habilitar estas opciones, debe apagar el equipo físico y luego volverlo a iniciar. El reinicio del equipo físico no es suficiente).
3) Si ha realizado cambios en el almacén de datos de configuración de arranque, revíselos para asegurarse de que el hipervisor está configurado para iniciarse automáticamente.

 Si esto ocurre, puede ser básicamente por dos motivos: el procesador no tiene soporte para la tecnología de virtualización por hardware (AMD-V en procesadores AMD, e Intel VT en procesadores de Intel); y/o esta característica no está habilitada en la BIOS.
*En procesadores AMD esta característica suele venir habilitada en la BIOS. En cambio, para los procesadores de Intel esta característica por defecto está deshabilitada en la BIOS y tenemos que activarla.

En este punto haremos un paréntesis para ver esto con más detenimiento.

Si bien tanto en procesadores AMD como en los de Intel, no es posible activar la tecnología de virtualización por hardware en BIOS por parte de una persona que requiera un lector de pantalla, al menos sí es posible saber de forma accesible si el procesador de que disponemos tiene soporte para esta característica, que parece ser imprescindible para usar Hyper-V.

Como mi ordenador tiene un procesador Intel i3, no puedo hacer pruebas para procesadores AMD; así que los que tengáis un procesador AMD, tendréis que buscar algo similar a lo que voy a explicar a continuación.

Existe una herramienta de Microsoft, que nos dice si nuestro procesador soporta la tecnología de virtualización por hardware, y si está o no habilitada ésta en la BIOS.

Pero esta herramienta, parece que sólo funciona hasta Windows 7. Como estamos trabajando en Windows 10, esta herramienta que en principio valdría tanto para procesadores Intel como AMD, no nos sirve.

Por tanto, hemos de buscar una solución alternativa; y esta es, una herramienta oficial. En este caso, de Intel, que nos dará bastante información sobre el procesador de nuestro ordenador.

Esta herramienta podéis descargarla desde

Aquí

 (Enlace directo de descarga del programa)

Se trata de una pequeña utilidad instalable, que es perfectamente accesible.

Su instalación es muy sencilla: basta con ejecutar el .MSI que hemos descargado, aceptar las condiciones de uso y pulsar en "Aceptar"/"Siguiente", y en pocos segundos la instalación habrá terminado.

A continuación, hemos de ejecutar la aplicación. Para ello, simplemente vamos a inicio, y en el campo de búsqueda escribimos "intel" (sin las comillas) y pulsamos en el resultado que nos aparece: "Utilidad Intel(R) para identificación de procesadores", como aplicación de escritorio.
*Si aparece el control de cuentas de usuario pidiendo permiso para ejecutar la aplicación, le decimos que sí.

Al abrir el programa, hemos de volver a aceptar las condiciones de uso de este, pulsando en "Aceptar"; y a continuación se abrirá la interfaz del programa, que es muy sencilla de utilizar.

El programa está dividido por pestañas, donde en cada una de ellas hay distinta información.

Con este programa no vamos a poder realizar ajustes en la configuración del procesador, pero sí ver información útil; algunas cosas pueden verse con otras aplicaciones, y otras al menos yo no me he fijado... y creo que no; pero igual también.

No nos vamos a detener demasiado en esta aplicación, ya que su uso es muy sencillo: en cada pestaña hay cuadros de edición de sólo lectura, en los que hay algo de información. Pero para ver realmente la información, debemos usar el cursor de Jaws/Jaws a PC, o el cursor de revisión de NVDA, si usamos alguno de estos lectores de pantalla.

Para lo que nos interesa (saber si nuestro procesador soporta la tecnología de virtualización por hardware) iremos a la segunda pestaña: "Tecnologías de la CPU".

Una vez sobre esta pestaña, con cursor de Jaws/Jaws a PC, o el cursor de revisión de NVDA, podemos ver las tecnologías que soporta nuestro procesador

 Utilidad Intel® para identificación de procesadores
Intel(R) Core(TM) i3-3220 CPU @ 3.30GHz
Tecnologías avanzadas de compatibilidad del procesador Intel
Tecnología de virtualización Intel(R) No
Tecnología Hyper-Threading Intel(R) Sí
Arquitectura Intel(R) 64 Sí
Otras tecnologías Intel que se admiten
Tecnología Intel SpeedStep(R) mejorada Sí Intel(R) Advanced Vector Extensions Sí
Intel(R) SSE Sí Intel(R) AES New Instructions No
Intel(R) SSE2 Sí Intel(R) VT-x con tablas de páginas  No
Intel(R) SSE3 Sí
Intel(R) SSE4 Sí
Información
Los números de procesador Intel no son una medición de rendimiento. Los números de procesador distinguen las
características dentro de cada familia de procesadores en sí, no entre distintas familias de procesadores. Para ver
detalles, consulte http://www.intel.com/products/processor_number/spa.

 En concreto, lo que nos interesa es "Tecnología de virtualización Intel(R)"; que en mi caso, no sé muy bien por qué, pone que no está soportado, tras haberlo habilitado en BIOS. Pero antes de activar la tecnología de virtualización por hardware, ponía que sí estaba soportada...

En cualquier caso, como nunca había tocado eso en BIOS, sabía seguro que estaría desactivado, y viendo que en esta aplicación ponía que estaba soportada la tecnología de virtualización por hardware, lo activé en BIOS y tras ello, las herramientas de virtualización funcionaron sin problema.

Digamos que hasta aquí podemos llegar los usuarios de lectores de pantalla. Aunque existen herramientas para configurar ciertos aspectos de la BIOS desde Windows, esto no es posible configurarlo; o al menos yo no he encontrado la manera, ni tampoco para entornos UEFI, por lo que necesitaremos ayuda de otra persona para hacerlo.
No vamos a ver la forma de activar la virtualización por hardware en la BIOS, ya que en cada BIOS el proceso será diferente. Pero normalmente, éste parámetro está en las opciones avanzadas de configuración, en algún apartado relacionado con la configuración de la CPU.

Si el procesador no soporta la tecnología de virtualización por hardware, la cosa se complica, ya que las herramientas de virtualización podrían dar problemas para virtualizar algunos sistemas, como por ejemplo los de 64 bits; OSX (el sistema operativo de apple para Mac's, también requiere que el procesador soporte la virtualización por hardware, y que esta esté habilitada en BIOS para poder ser virtualizado.
En cualquier caso, si el procesador no soporta la virtualización por hardware, no hay nada que podamos hacer, y tendremos que limitarnos a virtualizar sistemas de 32 bits, que no requieran de esta tecnología, como Windows, y en herramientas de virtualización, para las que la virtualización por hardware no sea un requisito imprescindible.

así pues, asegurarse de que el procesador de nuestro ordenador soporta la tecnología de virtualización por hardware, y habilitar dicha característica en BIOS, es el primer paso, para asegurarnos de que Hyper-V no nos dará problemas.

Pero otro de los motivos que pueden hacer que Hyper-V se niegue a ejecutarse, o a iniciar máquinas virtuales, es el hecho de tener otras herramientas de virtualización instaladas en el sistema.

Herramientas como vMWare (cualquier edición y versión) o VirtualBox, son capaces de funcionar sin interferir entre ellas, en el mismo sistema. Pero en cambio, sí crean conflictos con Hyper-V de Microsoft, por culpa del Hypervisor que usan unas y otras. Por lo que si usamos Windows 10 y tenemos instalados VmWare o VirtualBox, y queremos usar Hyper-V de Microsoft, lo más sencillo es desinstalar VmWare y/o VirtualBox para que no interfieran en el funcionamiento de Hyper-V.
*En ése caso, es aconsejable hacer la desinstalación con software especializado, como Uninstall tools, para limpiar el sistema tras la desinstalación; recordad, no darle a reiniciar el equipo al finalizar el asistente de desinstalación de VmWare o VirtualBox, para que pueda llevarse a cabo la limpieza del sistema.

En cualquier caso, una vez terminada la desinstalación, y la limpieza del sistema por parte de Uninstall tools o el programa que uséis, no está de más reiniciar el sistema y limpiar el equipo más a fondo con CCleaner, para limpiar a fondo el registro y el sistema en general; tanto Windows, como las aplicaciones, para asegurarse de que no queden restos de VmWare o VirtualBox, y volver a reiniciar el ordenador para que se apliquen correctamente los cambios hechos en el sistema.

En cambio, si tenemos instalado Hyper-V junto con VmWare o VirtualBox, los dos últimos sí funcionan aparentemente sin problema. No obstante, si experimentamos errores en VMWare o VirtualBox, podemos desactivar la ejecución de Hyper-V.
Pero dado que en esta entrada estamos viendo el uso de Hyper-V, no veremos como hacerlo.

Ahora sí, deberíamos de poder iniciar las máquinas virtuales de Hyper-V sin problema. Si seguís teniendo errores como el de arriba a la hora de iniciar una máquina virtual, podéis aseguraros de que Hyper-V esté en ejecución (que debería estarlo. Pero nunca se sabe).

Para ello, basta con abrir el símbolo del sistema, llendo a inicio y escribiendo "CMD" (sin las comillas) en el campo de búsqueda, y pulsar la tecla aplicaciones, y pulsar en "Ejecutar como administrador".
*Si aparece el control de cuentas de usuario pidiendo permiso para ejecutar la aplicación, le decimos que sí.

Una vez abierto el símbolo del sistema, escribimos "bcdedit /v" (sin las comillas)

 inherit                 {7ea2e1ac-2e61-4728-aaa3-896d9d0a9f0e}                                                        
default                 {5bc8c195-6b7b-11e8-bf98-e2c6e6d3097a}                                                        
resumeobject            {5bc8c194-6b7b-11e8-bf98-e2c6e6d3097a}                                                        
displayorder            {5bc8c195-6b7b-11e8-bf98-e2c6e6d3097a}                                                        
toolsdisplayorder       {b2721d73-1db4-4c62-bf78-c548a880142d}                                                        
timeout                 30                                                                                            
                                                                                                                      
Cargador de arranque de Windows                                                                                       
-----------------------------                                                                                         
Identificador           {5bc8c195-6b7b-11e8-bf98-e2c6e6d3097a}                                                        
device                  partition=C:                                                                                  
path                    \WINDOWS\system32\winload.exe                                                                 
description             Windows 10                                                                                    
locale                  es-ES                                                                                         
loadoptions             disable_integrity_checks                                                                      
inherit                 {6efb52bf-1766-41db-a6b3-0ee5eff72bd7}                                                        
recoverysequence        {425d9841-6b73-11e8-be72-8f434ca40ddd}                                                        
displaymessageoverride  StartupRepair                                                                                 
recoveryenabled         Yes                                                                                           
nointegritychecks       Yes                                                                                           
testsigning             Yes                                                                                           
allowedinmemorysettings 0x15000075                                                                                    
osdevice                partition=C:                                                                                  
systemroot              \WINDOWS                                                                                      
resumeobject            {5bc8c194-6b7b-11e8-bf98-e2c6e6d3097a}                                                        
nx                      OptIn                                                                                         
bootmenupolicy          Standard                                                                                      
hypervisorlaunchtype    Auto

 Todo esto (que puede variar en cada ordenador, según la configuración de arranque establecida) es la configuración actual de la configuración del arranque del sistema.

En concreto, en lo que hemos de fijarnos, es en el ítem "hypervisorlaunchtype    Auto".
Si como en mi caso está en "Auto", significa que Hyper-V se está ejecutando en el arranque del sistema. Si en cambio éste ítem está en "Off", significa que Hyper-V no se está ejecutando al iniciarse el sistema.

En ése caso, hemos de activarlo. Para ello, en la misma ventana del símbolo del sistema, escribimos el siguiente comando

bcdedit /set {Identificador} hypervisorlaunchtype auto

 *{Identificador} debe sustituirse por el identificador que aparezca al ejecutar el comando "bcdedit /v", incluyendo las llaves; en mi caso "{5bc8c195-6b7b-11e8-bf98-e2c6e6d3097a}", en el ítem "Identificador".
Debéis consultar el identificador, ya que no tiene por qué coincidir con el mío.

Si al ejecutar el comando aparece un mensaje indicando que la operación se ha realizado correctamente, significa que todo ha ido bien, y que Hyper-V se ha configurado para iniciarse en el arranque del sistema; sólo queda reiniciar el equipo para confirmar que los cambios se han aplicado correctamente.

Con todo esto, ya sí, deberíamos poder iniciar máquinas virtuales en Hyper-V.

Para ello, nos situamos sobre la máquina que queramos ejecutar y pulsamos tecla aplicaciones e "Iniciar".
*Si aparece el control de cuentas de usuario pidiendo permiso para ejecutar algún programa, le decimos que sí.

A continuación, veremos como si todo va bien, Hyper-V empieza a ejecutar la máquina virtual, que primero tendrá el estado de "Iniciando", y luego éste pasará a "En ejecución".

Finalmente (esto puede tardar un poco) se ejecutará la máquina virtual, que aparecerá en una nueva ventana. En el caso de la máquina virtual que hemos creado, el título sería "Ubuntu 16 x86 en DESKTOP-E0I4H0O: Conexión a máquina virtual", que cambiará según el nombre que le déis a la máquina en el momento de su creación, o en la configuración de la misma.

Y aora sí, por fin, tenemos nuestra máquina virtual corriendo en Windows 10, sin software de terceros: con Hyper-V; una herramienta muy completa, gratuita y accesible de virtualización.

Para pasar el control del teclado y el ratón a la máquina virtual, tan sólo hemos de ponernos en la ventana de la máquina virtual. Una vez esta ventana tenga el foco, automáticamente capturará el teclado y el ratón. Sabremos que es así, porque los lectores de pantalla deberían decir algo como "Input capture Window" (algo así como que la ventana ha capturado la entrada del sistema).

Si queremos devolver el control del teclado y el ratón a la máquina host, simplemente hemos de usar el comando de teclado que configuramos antes, a la hora de configurar la máquina virtual, que en este caso fue "CTRL+Alt+Espacio".

Al igual que en otras herramientas de virtualización, en Hyper-V, los usuarios de lectores de pantalla pueden ayudarse del OCR que incluyen estos, tales como Jaws o NVDA, para leer la ventana de la máquina virtual, que actúa como el monitor de un ordenador real.
Aprovechando que estamos trabajando con Windows 10 como máquina host, es aconsejable para ello, usar NVDA en sú última versión, ya que hace uso del OCR que incluye Windows 10, que es muy bueno en el reconocimiento y además no requiere conexión a internet.

Además, NVDA en sus últimas versiones, en las que tiene soporte para el OCR integrado en Windows 10, tiene una forma muy buena de interacción por parte del usuario, con el texto reconocido por el OCR, haciéndola casi tan natural como si la aplicación en la que se usa el OCR se navegara con los comandos habituales de teclado de Windows y/o el lector de pantalla.

Para leer el texto de la ventana de la máquina virtual con el OCR de Windows 10 y NVDA, nos situamos en la ventana de la máquina virtual. Como dijimos, por defecto, al recibir el foco, ésta capturará el teclado y el ratón.
Basta con liberarlos de la máquina virtual, con el comando que establecimos en la configuración de la máquina.
Una vez liberado el teclado, sin cambiar de ventana ni usar ningún otro comando de teclado o del ratón, si usamos NVDA, hemos de pulsar una vez la tecla Flecha arriba, para llevar el foco al área de la pantalla donde aparece la imagen de la máquina virtual; de lo contrario, pasaremos el OCR en la barra de estado de la ventana de la máquina. Pulsamos Tecla "NVDA"+r, y en pocos segundos se mostrará el texto reconocido por el OCR, en un cuadro de edición.

Como ya hemos dicho, el reconocimiento es casi perfecto, incluso si no configuramos en NVDA el idioma del texto a reconocer, en las opciones de configuración del OCR.

Pero no sólo es posible leer el texto de la máquina virtual, que es muy importante en ciertas situaciones; sino que podemos incluso, interactuar con la máquina, a través del texto reconocido, en el cuadro de edición donde nos lo presenta NVDA.

Para ello, únicamente hemos de navegar por el texto reconocido, con flechas arriba y abajo, o izquierda y derecha si queremos ir a una palabra o letra concreta, y pulsar Enter o Espacio sobre el texto donde queramos simular un click de ratón.

Si el texto es una opción "cliqueable", NVDA enviará una simulación de un click del ratón a la ventana enfocada, justo sobre la opción con el texto que coincida con el que hemos seleccionado y "cliqueado" en el cuadro de edición de NVDA.

De esta manera, es posible activar opciones en una ventana donde el texto se presenta en imágenes, como en el caso de las máquinas virtuales.

No es que esta sea la forma que tiene un usuario de lectores de pantalla de usar una máquina virtual, porque esto es un método poco efectivo para realizar muchas tareas, o tareas complejas como navegar por una página WEB, editar un documento en una herramienta ofimática, eTC; ya que los sistemas operativos, suelen contar con herramientas de apoyo integradas, o permitir la instalación de estas, en cualquier caso, incluso cuando corren en máquinas virtuales.
Pero sí es una forma muy práctica de saber qué está pasando en todo momento en la máquina virtual, y de interactuar con partes de esta, donde no es posible el uso de herramientas de apoyo, como lectores de pantalla.

Hyper-V ofrece mucho más, pero ver todas sus posibilidades en una sola entrada sería larguísimo: sí, mucho más de lo que se ha hecho este artículo.

Un poco más por encima, diremos que por ejemplo, podemos importar y exportar máquinas virtuales. Opción más que interesante para compartir máquinas ya configuradas, que pueden contener ya un sistema operativo y aplicaciones instaladas, lista para usar.
O podemos usar discos de otras máquinas únicamente, para por ejemplo, ahorrarnos la instalación del sistema, pero crear nosotros la máquina virtual.

Gracias a la exportación, también podemos crear y compartir máquinas virtuales con otras personas que usen Hyper-V en Windows 10

¡Y esto es todo!.

Espero que os haya gustado este artículo y que os sea de utilidad.

Para cualquier duda, consulta, sugerencia o lo que se os ocurra, podéis escribirnos al e-mail del blog:

tifloinformatico@gmail.com

¡Hasta pronto!

lunes, 8 de octubre de 2018

Descargar Windows 10 sin programas, desde la WEB de Microsoft



 ******¡¡¡IMPORTANTE!!!******

- Lo que se explica en este POST, es únicamente con fines didácticos. Úsalo sólo a título personal.
- Tifloinformático, su autor y/o los desarrolladores de las herramientas mencionadas, no se hacen responsables del mal uso que le des al contenido de esta entrada, siendo tú el/la único/a responsable.
- Las herramientas mencionadas, son propiedad de sus autores.
- Si citas total o parcialmente este artículo, en internet o por otros medios, debes mencionar la fuente:
http://tifloinformatico.blogspot.com
- Las instrucciones que se describen a continuación han sido probadas en Windows 10. Aunque pueden servir para otras versiones, no se garantiza que sean válidas para versiones distintas de Windows.


-------------------------

Como muchos sabréis, recientemente Microsoft ha publicado la última versión de Windows 10: October 2018 update (1809), aunque parece ser que con fallos graves, y ha sido retirada temporalmente hasta que los errores sean corregidos.

En cualquier caso, lo que vamos a ver en esta entrada, sirve para descargar cualquier versión de Windows, ya que desde hace un tiempo, Microsoft decidió que sus usuarios debían descargar las imágenes de Windows mediante una pequeña aplicación, con la que podemos elegir algunas configuraciones antes de descargar la imagen, tales como el idioma o la arquitectura.

Dicho sea de paso, la herramienta es perfectamente accesible con lectores de pantalla, por lo que no habrían motivos para no querer usarla. Además, es una herramienta pequeña y portable... ¡Todo ventajas!

Pero en cualquier caso, existen formas alternativas de descargar las ISO's de Windows 10, como el uso de otras aplicaciones no oficiales y que no son sencillas de usar con lectores de pantalla, o directamente, sin aplicaciones: desde la WEB de Microsoft; por cierto, de forma totalmente legal.

Y es de esta última forma, como vamos a descargar la última versión disponible de Windows 10.

Para eso, simplemente necesitamos un navegador WEB. Hay que decir, que la técnica que vamos a usar, sirve para todos, o prácticamente todos los navegadores WEB... Al menos, para los más importantes como Internet explorer, Firefox, Chrome, Safari U Opera, seguro que sirve.

Como Internet explorer está instalado por defecto en todos los ordenadores con Windows, independientemente de qué versión sea, vamos a centrarnos en éste, ya que si usamos cualquier otro, puede que no todos lo tengáis. Además, la forma de hacerlo puede variar de un navegador a otro.

Supongo que con NVDA será también posible hacer las configuraciones que vamos a ver. Pero en esta entrada veremos como hacerlo con Jaws for Windows.

En realidad, es algo muy sencillo, pero que en las pruebas que he hecho no parece tan fácil de hacer con lector de pantalla.

Para poder descargar las ISO's de Windows 10 directamente desde la WEB de descargas de Microsoft, lo primero que haremos es, con Internet explorer, ir a la

página de descarga de Windows 10

(se abre en una ventana nueva para que podáis seguir cómodamente los pasos)


Una vez abierta la página, sólo hemos de engañarla, haciéndola creer que la visitamos desde otro navegador y desde otro dispositivo distinto al ordenador.

En concreto, le diremos que estamos visitándola desde Safari, en un iPad...

Y e aquí el truco. Ya que al decirle a la WEB que estamos visitándola desde un iPad (un dispositivo distinto a un ordenador donde puede instalarse Windows) y desde un navegador distinto al de Microsoft (en realidad lo importante es el dispositivo) Microsoft nos ofrece la descarga de las imágenes de Windows 10, pero directamente, en vez de hacernos descargar la herramienta oficial de descarga, ya que en un iPad no podría ejecutarse.

Para ello hemos de cambiar el agente de usuario del navegador; que es una pequeña cadena de texto, que este envía al acceder a cada página, donde se indica el sistema operativo, el navegador, idioma y otra información que suelen recoger las páginas WEB para personalizar la interfaz.

Para cambiar el agente de usuario en Internet explorer, en la WEB de descarga de Windows 10, pulsaremos la tecla F12 para abrir las opciones de desarrollo del navegador.

Esta interfaz es un poco liosa de usar con lectores de pantalla, ya que hay opciones que cuestan un poco de encontrar o configurar.

Lo primero que haremos, es ir al principio de la interfaz con CTRL+inicio. El título de la página debería ser "DOM Explorer" si es la primera vez que se abren las opciones de desarrollo del navegador. En caso contrario, si se ha tocado cualquier cosa, podría ser otro; pero no importa: tabularemos hasta la opción "Desanclar (Ctrl+P)" ya que con flechas arriba y abajo es posible que no lo encontremos, y subiremos con flecha arriba, hasta "Más herramientas" y pulsaremos Enter sobre esta opción.

a continuación se nos abrirá un menú cíclico, en el que podemos movernos con flechas arriba y abajo, o tabulador, y en el que hemos de elegir "Emulación", pulsando Enter sobre dicha opción ¡Y ahora viene lo importante!: "Modo de documento:" lo dejaremos tal como está, que por defecto debería ser la última versión de Internet explorer (11) o Edge; o en su defecto, la versión de Internet explorer que tengáis instalada.

Esto debe quedarse en la versión más reciente, porque así nos garantizamos que el navegador cumpla correctamente con los estándares actuales de la WEB.

Ahora nos falta cambiar la plataforma y el navegador, para como el nombre de la opción que hemos elegido dice, emular otro navegador y otra plataforma.

Si buscáis con flechas arriba y abajo, no encontraréis las opciones correspondientes. Y es aquí, donde puede diferir la forma de hacerlo con Jaws y con NVDA.

*Recordad que estamos asumiendo que usamos Jaws for Windows

Tabularemos hasta "Cadena del agente de usuario". Sobre esta opción que es un cuadro combinado, pero que no vamos a poder modificar normalmente, ya que al intentar cambiar la opción por defecto por otra, se nos refrescará la página y se irá la pantalla de opciones de desarrollo, haremos uso del cursor táctil de Jaws.
Para ello pulsaremos Mayúscula temporal y la tecla más del teclado numérico (recordad que el "bloq. num." debe estar desactivado) y ahora sí, podremos elegir la opción "Apple Safari (iPad)" que es la que nos interesa.

Para ello, con el cursor táctil de Jaws activo, nos moveremos con flechas izquierda y derecha, y buscaremos el botón "Abrir", a la derecha del cuadro combinado donde aparecen los agentes de usuario disponibles; pulsaremos sobre "Abrir" para desplegar la lista de agentes de usuario, y pondremos de nuevo el cursor virtual.
Ahora sí, podemos movernos por la lista sin problema, porque no se nos refrescará la página.

Así, que con flechas arriba y abajo, buscaremos "Apple Safari (iPad)" y pulsaremos Enter sobre esta opción. Y debería refrescarse la WEB de descarga de Windows 10, y redirigirnos a la versión alternativa para otras plataformas.

Sabremos que todo ha ido bien, porque navegando por la WEB deberíamos encontrar el texto "Se te ha dirigido a esta página porque el sistema operativo que estás usando no es compatible con la herramienta de creación de medios de Windows 10 y queremos asegurarnos de que puedas descargar Windows 10...".
Si es así ¡enhorabuena!. Habréis modificado correctamente la cadena de agente de usuario, por las de Safari en iPad, y podréis descargar directamente las imágenes ISO de Windows 10 de forma legal, sin programas y desde la WEB de Microsoft.

Para ello, únicamente debéis situaros al principio de la página, y pulsar el número 1 del teclado extendido para ir al encabezado de nivel uno "Descargar imagen de disco de Windows 10 (archivo ISO)" y a continuación el número 2, para ir al encabezado de nivel dos "Selecciona una edición".

Como bien indica la página hemos de elegir la edición que queremos descargar. Esto podremos hacerlo sin problema, eligiendo la opción que queramos normalmente, en el cuadro combinado de más abajo.

Aquí, siempre estará la última edición disponible; actualmente, ya que la edición October 2018 Update, tal como dijimos al principio ha sido retirada, aparece "Windows 10 (Windows 10 April 2018 Update)" como la edición más reciente.

Una vez seleccionada, veréis que en el cuadro combinado sólo pone "Windows 10", pero no os preocupéis, ya que descargaréis la última edición.

Para continuar con la descarga, hay que pulsar en el botón "Confirmar".

Para continuar, si bajamos hasta el encabezado de nivel 2 "Seleccionar idioma del producto", podremos elegir el idioma de la ISO que vamos a descargar, que nuevamente se hace en un cuadro combinado, con el que podemos interactuar sin problema.
Por ejemplo, elegimos "Español", y pulsamos nuevamente en "Confirmar".

¡Ya casi estamos!. Ahora únicamente hemos de elegir la arquitectura de la imagen de Windows y se iniciará la descarga.
Para ello, buscamos el encabezado de nivel 2 "Descargas" y elegimos la arquitectura más abajo ("32-bit Descargar" para la imagen de 32 bits, y "64-bit Descargar" para la imagen de 64 bits).

Como indica debajo, los enlaces sólo tienen validez durante 24 horas tras pulsar en cualquiera de los dos enlaces anteriores.

Pulsamos en "64-bit Descargar" por ejemplo, para iniciar la descarga de la imagen de 64 bits, y como con cualquier descarga, hemos de pulsar ALT+n para ir a la barra de notificaciones de Internet explorer, y elegir si queremos abrir o guardar la imagen.

Como lo normal es que la guardemos en el equipo para grabarla en un DVD, con tabulador iremos a "Guardar" y si queremos elegir la carpeta donde queremos que se guarde, pulsaremos flecha abajo, hasta "Guardar como" y pulsaremos enter para que se abra el típico diálogo de Windows para buscar archivos, buscaremos el directorio donde queremos guardar la imagen y pulsaremos en Guardar" para iniciar la descarga.

¡Y esto es todo!.

Decir, que estas instrucciones las he escrito basándome en Windows 10 Profesional que ya incluye la última versión de Internet explorer.

En Windows 7, donde anteriormente he probado este método para descargar las imágenes de Windows 10 October 2018 Update, es prácticamente igual, con la diferencia de que el botón "Más herramientas" no se llama así, sino "..."

Este botón es de las opciones más importantes, ya que si por error activáis una función distinta a "Emulación" (por ejemplo "debugger") al menos en Windows 7 cuesta encontrar la pantalla inicial de las opciones de desarrollo: lo mejor es con tabulador y flechas, buscar esta opción y pulsar en ella para elegir el modo "Emulación".

Misteriosamente, en Windows 10 profesional, en "Modo de documento" no aparece Edge como opción, pero sí que está en Windows 7...

Existen otras opciones que se pueden configurar en el modo emulación:

"Conservar configuración de emulación": Esto aparece sólo en Windows 10 y permite en principio, hacer que el navegador siempre use la configuración establecida en el modo "Emulación", si activamos esta opción.

"Restablecer configuración de emulación (Ctrl+Mayús+L)": Permite poner los valores por defecto del modo "Emulación".

"Perfil de explorador": Permite cambiar entre escritorio y versión móvil. Para el caso que hemos visto, no es necesario modificarlo, ya que hemos elegido una plataforma distinta al PC, donde no se instala Windows.

"Pantalla": Permite elegir la disposición de la pantalla (horizontal o vertical).

"Resolución": Permite elegir la resolución de la pantalla.

"Simular GPS": Permite emular el uso de GPS, pudiendo configurarlo como "Activado", "desactivado" o "activado sin señal".

"Latitud"/"Longitud": Permiten establecer la longitud y latitud del GPS emulado (sólo si se activa la emulación de este).

Si os fijáis, al cerrarse las opciones de desarrollo y volverlas a abrir, todo está tal y como lo dejamos. Así que si hemos elegido el modo "Emulación" y hemos cambiado la cadena de agente de usuario por la de Safari en iPad, y queremos por ejemplo, cambiarla por la de Chrome, será mucho más sencillo la segunda vez, ya que encontraremos rápidamente todas las opciones del modo "Emulación", con flechas arriba y abajo, sin necesidad de tabular (pero sí que habrá que hacer uso de nuevo, del cursor táctil de Jaws en los cuadros combinados).

En Windows 7 (posiblemente en Windows 8) y en Windows 10, si no se activa la opción "Conservar configuración de emulación", al cerrar el navegador y abrirlo, todo volverá a estar como antes de modificar nada.

¡Y esto es todo!.

Espero que os haya gustado este artículo y que os sea de utilidad.

Para cualquier duda, consulta, sugerencia o lo que se os ocurra, podéis escribirnos al e-mail del blog:

tifloinformatico@gmail.com

¡Hasta pronto!

sábado, 15 de septiembre de 2018

TrustedInstaller: ¿como evitar la protección de los archivos de sistema en Windows?

 ******¡¡¡IMPORTANTE!!!******

- Lo que se explica en este POST, es únicamente con fines didácticos. Úsalo sólo a título personal.
- Tifloinformático, su autor y/o los desarrolladores de las herramientas mencionadas, no se hacen responsables del mal uso que le des al contenido de esta entrada, siendo tú el/la único/a responsable.
- Las herramientas mencionadas, son propiedad de sus autores.
- Si citas total o parcialmente este artículo, en internet o por otros medios, debes mencionar la fuente:
http://tifloinformatico.blogspot.com
- Las instrucciones que se describen a continuación han sido probadas en Windows 7. Aunque pueden servir para otras versiones, no se garantiza que sean válidas para versiones distintas de Windows.


-------------------------

Hoy vamos a ver como evitar una protección de Windows, que impide hacer ciertas cosas en el sistema, como modificar archivos de Windows, eliminarlos, renombrarlos ETC.

En realidad ya hablamos de esta protección llamada TrustedInstaller

Aquí

 Como ya explicamos, TrustedInstaller impide que se modifiquen archivos imprescindibles del sistema, y no tan necesarios.

En realidad, sobre todo, protege el contenido del directorio System,System32 y SysWOW64 que son los directorios de sistema de Windows. Aunque seguramente, si no todo, también proteja parte del contenido del directorio Windows, donde está instalado el sistema.

Si intentáis renombrar un archivo cualquiera, por ejemplo dentro del directorio System32, os encontraréis con que primero os pedirá pribilegios de administrador. Y una vez pulséis en "Continuar" para cambiar el nombre del archivo o carpeta, os aparecerá un mensaje como este

 Acceso denegado al archivo
Necesita permisos para realizar esta acción
Se requieren permisos de TrustedInstaller para hacer cambios en este archivo
sethc.exe
Descripción del archivo: Teclas de método abreviado
de Accesibilidad
Organización: Microsoft Corporation
Versión del archivo: 6.1.7601.17514
Fecha de creación: 21/11/2010 4:24
Tamaño: 272 KB

 Habrán dos opciones, para volver a intentar la operación y cancelar, respectivamente.
por más que pulsemos en "Intentar de nuevo", siempre aparecerá esta pantalla, hasta que pulsemos "Cancelar".

En la entrada de arriba, donde explicábamos como quitar la contraseña de un usuario en Windows 7, decíamos que para evitar esta protección, habría que iniciar el equipo con un Live CD de Windows, ya que normalmente, estos sistemas no cuentan con todo el sistema de protección de archivos, permisos ETC.

Pero en realidad, no sólo era necesario para evitar TrustedInstalled, ya que como veremos a continuación, esta protección puede saltarse fácilmente sin sistemas alternativos.

Para ello, lo primero que deberemos hacer, es situarnos sobre el archivo o directorio protegido por TrustedInstaller, y pulsar botón derecho (o tecla aplicaciones) y pulsar en "Propiedades" e ir a la pestaña "Seguridad".

Una vez aquí, pulsaremos sobre "Opciones avanzadas". En la ventana que aparece a continuación, iremos a la pestaña "Propietario".

Ahora, podemos ver en el campo "Propietario actual", quien es el "propietario" del archivo o directorio.
Si habéis elegido un archivo o carpeta protegido por TrustedInstaller, éste será el propietario.

Pulsaremos en "Editar" para cambiar el "propietario" del archivo o directorio.

A continuación aparecerá una lista de posibles "propietarios". Escogeremos "Administradores", donde pondrá algo como "Administradores (EQUIPO\Administradores)" donde "Equipo" puede variar, según el nombre de vuestro equipo, y pulsaremos en "Aplicar y luego en "Aceptar" en el mensaje que nos aparece, que dice: "Si ya obtuvo la propiedad de este objeto, deberá cerrar y volver a abrir las propiedades del objeto para ver o cambiar los permisos."

Tras aceptar esta advertencia, podremos ver como en el campo "Propietario actual", ahora el "propietario" del archivo o carpeta ya no es TrustedInstaller, sino "Administradores".

Si todo ha ido bien, pulsaremos en "Aceptar" y volveremos a pulsar en "Aceptar" en la ventana que aparece a continuación.

Si todos los pasos han ido como debiera, volveremos a estar en la pestaña "Seguridad", de la ventana de propiedades del archivo o directorio.

Pulsaremos también aquí en "Aceptar".

Ahora que hemos modificado el "Propietario" del archivo o directorio, sólo nos queda un paso: darle los permisos adecuados.

Para hacerlo más fácil, otorgaremos todos los permisos de control al "propietario" del archivo o directorio.

para eso, nos situamos nuevamente sobre el archivo o carpeta, y pulsamos botón derecho o tecla Aplicaciones, y pulsamos otra vez en "Propiedades".

Nuevamente, vamos a la pestaña "Seguridad"; y pulsamos en "Editar".

A continuación, en "Nombres de grupos o usuarios:", elegimos como "propietario" del archivo o directorio "Administradores" y marcamos la opción "Permitir control total".

Para guardar los cambios, pulsamos en "Aplicar" y nos aparecerá una alerta con algo como esto

 Está a punto de cambiar la configuración de permisos en las carpetas del sistema. Esto puede originar problemas de acceso inesperados y disminuir la seguridad. ¿Desea continuar?

 a lo que diremos que sí, y pulsaremos en "Aceptar".

Por último, pulsaremos de nuevo en "Aceptar"; y si todo ha ido bien, habremos cambiado el "Propietario" del archivo o carpeta, y le habremos otorgado todos los permisos de control sobre el mismo.

Ahora sí que podremos eliminar, renombrar, modificar ETC el archivo o carpeta.

Recordad, que todos los archivos y directorios a los que les quitéis esta protección, se convertirán en archivos normales, que podréis eliminar o modificar libremente.

En ocasiones esto puede irnos bien para ciertas cosas. Pero si elimináis o modificáis archivos o carpetas vitales de Windows, el sistema podría dejar de funcionar, teniendo incluso, que reinstalarlo de nuevo.

¡Y esto es todo!.

Espero que os haya gustado este artículo y que os sea de utilidad.

Para cualquier duda, consulta, sugerencia o lo que se os ocurra, podéis escribirnos al e-mail del blog:

tifloinformatico@gmail.com

¡Hasta pronto!

domingo, 9 de septiembre de 2018

Owon BT35+: puesta en marcha, funciones y accesibilidad

******¡¡¡IMPORTANTE!!!******

- Lo que se explica en este POST, es únicamente con fines didácticos. Úsalo sólo a título personal.
- Tifloinformático, su autor y/o los desarrolladores de las herramientas mencionadas, no se hacen responsables del mal uso que le des al contenido de esta entrada, siendo tú el/la único/a responsable.
- Las herramientas mencionadas, son propiedad de sus autores.
- Si citas total o parcialmente este artículo, en internet o por otros medios, debes mencionar la fuente:
http://tifloinformatico.blogspot.com
- Las instrucciones que se describen a continuación son para Android y el multímetro Owon BT35+. Aunque pueden servir para otros programas o versiones de estos, no se garantiza que sean válidas para programas y/o versiones distintas de las mencionadas en este artículo.


-------------------------

Hoy os traemos un audio, esta vez sobre un multímetro muy accesible mediante salida bluetooth: el Owon BT35+.

En el audio veremos qué accesorios incluye, su puesta en marcha, sus funciones y su accesibilidad mediante la APP oficial para Android, que podéis descargar desde el enlace de abajo

Espero que os haya gustado esta entrada.
¡Os espero en un próximo post!

Pulsa aquí para descargar la APP oficial del multímetro desde la Play store

Pulsa aquí para oír el audio

viernes, 24 de agosto de 2018

Analizar imágenes del ordenador

******¡¡¡IMPORTANTE!!!******

- Lo que se explica en este POST, es únicamente con fines didácticos. Úsalo sólo a título personal.
- Tifloinformático, su autor y/o los desarrolladores de las herramientas mencionadas, no se hacen responsables del mal uso que le des al contenido de esta entrada, siendo tú el/la único/a responsable.
- Las herramientas mencionadas, son propiedad de sus autores.
- Si citas total o parcialmente este artículo, en internet o por otros medios, debes mencionar la fuente:
http://tifloinformatico.blogspot.com
- Las instrucciones que se describen a continuación son para Windows 7, Android/iPhone y TapTapSee. Aunque pueden servir para otros programas o versiones de estos, no se garantiza que sean válidas para programas y/o versiones distintas de las mencionadas en este artículo.


-------------------------

En esta ocasión os traigo un audio con algo sencillito, para que os entretengáis estas vacaciones, si aún no las habéis hecho.

Esta vez, veremos como descargar imágenes de internet con el ordenador, y saber qué son, gracias a TapTapSee; para lo que necesitaréis un teléfono Android o un iPhone.

Espero que os haya gustado esta entrada.
¡Os espero en un próximo post!

Pulsa aquí para oír el audio

lunes, 2 de julio de 2018

Compilar y cargar un squetch en Arduino de forma accesible

******¡¡¡IMPORTANTE!!!******

- Lo que se explica en este POST, es únicamente con fines didácticos. Úsalo sólo a título personal.
- Tifloinformático, su autor y/o los desarrolladores de las herramientas mencionadas, no se hacen responsables del mal uso que le des al contenido de esta entrada, siendo tú el/la único/a responsable.
- Las herramientas mencionadas, son propiedad de sus autores.
- Si citas total o parcialmente este artículo, en internet o por otros medios, debes mencionar la fuente:
http://tifloinformatico.blogspot.com
- Las instrucciones que se describen a continuación son para componentes software y hardware concretos. Aunque pueden servir para otros programas o componentes, no se garantiza que sean válidas para programas y/o componentes distintos de los mencionados en este artículo.


-------------------------

Hoy vamos a dedicar esta entrada, a una mezcla entre informática y electrónica, aunque solo trabajaremos del lado del software, en el ordenador.

Lo que veremos hoy, solo servirá para los que desarrolléis para la plataforma Arduino, o cualquier otra similar. En realidad, para los que programéis microcontroladores; aunque aquí solo veremos como hacerlo con detalle con Arduino, y en concreto el micro Atmega328p.

Para otros programadores y micros, el proceso sería el mismo, pero cambiando algunos parámetros concretos que se refieren al programador y al micro.

Aunque todo lo que voy a explicar podría resumirse poniendo únicamente los comandos necesarios y su explicación, vamos a ir despacio, y vamos a ver también un poco de teoría, incluso sobre la construcción en general de programas, para que aquellos que no tengáis experiencia en el desarrollo de software y os animéis, podáis seguir sin problema esta entrada, y trabajar con las herramientas que he preparado para desarrollar de una forma totalmente accesible para Arduino, o incluso para otras plataformas.

¡Así que ponéos cómodos que empezamos!.


        Poniéndonos en situación:

Aquellos que tengáis experiencia con la programación de Arduino en particular, sabréis que es una plataforma muy popular, por el bajo coste del hardware, y por programarse en un lenguaje de programación archiconocido, como es el C/C++; aunque se dice que no es en realidad C/C++, sino una variante de este ... En realidad no es así: Arduino se programa en C/C++, y la gente de Arduino, simplemente ha desarrollado un core (API) en el mismo lenguaje de programación, para facilitar ciertas cosas muy concretas, relacionadas directamente con el microcontrolador: gestión de pines, acceso a memoria ETC.

Arduino, como cualquier otra plataforma y/o lenguaje de programación, suele programarse en un IDE, que es algo así como un editor de texto para redactar documentos, pero para escribir código fuente.

Arduino, como es costumbre en otros lenguajes y plataformas, puede programarse en distintos IDE's. Pero la gente de Arduino ha desarrollado IDE Arduino, que es el IDE oficial de esta plataforma.

Con IDE Arduino, aunque es un IDE bastante básico, es más que suficiente para desarrollar aplicaciones para Arduino, de mayor o menor complejidad; aunque seguramente los usuarios con más experiencia en el desarrollo de software en general, hecharán de menos algunas funciones de IDE's más avanzados.

Una de las ventajas de IDE Arduino, es que al ser tan sencillo, los usuarios principiantes, o no acostumbrados a usar entornos de programación, también pueden usarlo sin problema, ya que no requiere de horas de aprendizaje. Incluso, puede usarse como si fuese un simple bloc de notas, que tuviera integradas las opciones necesarias para compilar y cargar el programa en la placa Arduino.

        Problemas del IDE Arduino:

Como todo en la vida, IDE Arduino tiene sus ventajas, pero también sus inconvenientes.

En general, más allá de cuestiones demasiado técnicas para usuarios no avanzados en la programación, y en la programación en C/C++ en concreto, IDE Arduino tiene como desventaja su sencillez, que no gusta a todo el mundo.

Pero más allá de eso, presenta un inconveniente más; que está más bien relacionado con la accesibilidad: está escrito en Java.

Muchos ya sabréis lo que eso supone: muchísimos problemas con los lectores de pantalla, y el puente de accesibilidad entre estos y Java (Java access bridge). Ya que aunque instalándolo y configurándolo correctamente, debería funcionar; pero no siempre es así... Nunca he sabido por qué, pero es una lotería que Jaws o NVDA funcionen correctamente con Java access bridge, y sean capaces de leer correctamente aplicaciones escritas en Java. Y más difícil todavía, es que lo hagan los dos a la vez.

Pero eso no es el mayor problema de accesibilidad que presenta IDE Arduino: si todo funciona correctamente, conseguiremos leer correctamente casi toda la interfaz del programa sin problema, y podremos escribir el código de nuestros programas para Arduino, compilarlo, cargarlo en la placa ETC, sin problema.

*Casi; porque hay una parte del programa a la que no vamos a poder acceder de ninguna manera, ni siquiera usando el OCR de Jaws o NVDA. Y es la parte más importante para nosotros como programadores: el área de mensajes del IDE.

El área de mensajes, es una zona de la interfaz del programa (en la parte inferior) donde el IDE muestra algunos mensajes, como los relativos a la compilación del programa que hayamos escrito, o el resultado de la carga de este en la placa.

Al pulsar en las opciones correspondientes, el IDE nos indica si han habido errores durante la compilación o carga del programa en la placa, o si el proceso se ha realizado correctamente. Incluso, puede mostrarnos todo el proceso de forma transparente, si habilitamos las opciones correspondientes a mostrar la salida de cada proceso, en las preferencias del IDE.

Pero como decía, todo esto es imposible de leer con un lector de pantalla, ni siquiera utilizando las funciones OCR de estos.

Hasta ahora, yo intuía si todo había ido bien, o habían ocurrido errores al compilar, si por ejemplo, al compilar el programa, con cursor de Jaws a PC (usando Jaws for Windows) y por si acaso leía algo más, usando el OCR de este, aparecía un botón que pone "copiar mensajes de error".

En ese caso, algo no ha ido bien, y aquí si es posible pulsar este botón, y ver los mensajes de error.

Pero a la hora de cargar el programa en la placa, si ocurren errores, no hay manera de saberlo, salvo probando la placa, a ver si se comporta tal como hemos programado.

        Solución de problemas:

Dado que me resulta muy incómodo trabajar así, y que no soy muy amigo de los IDE's (soy demasiado tradicional para programar, y me apaño más que bien con el blog de notas y un compilador independiente) no me merece la pena usar el IDE oficial de Arduino; que lejos de no ser muy amigo de los entornos de programación, es un suplicio trabajar con uno que no es accesible en las partes más importantes... Y eso cuando es accesible simplemente.

Así, que he hecho por probar otros IDE's, como Notepad++ o Eclipse con un plugin para Arduino.

El primero no conseguí hacerlo funcionar. Y siendo sincero, tampoco le puse mucho empeño para hacerlo.

El segundo, era más sencillo, ya que en teoría hay un paquete que trae el plugin instalado y configurado, listo para usar (salvo por que hay que hacer algunos ajustes menores).

Pero aunque intenté hacer algo con él, se colgaba muy amenudo, y nunca supe como utilizar Eclipse... Así que no conseguí gran cosa tampoco con este.

Así, que finalmente he decidido optar por lo que más me gusta, y lo que prefería desde un principio: desarrollar para Arduino de la forma más rudimentaria posible.

Si investigamos un poco, aprenderemos cosas muy interesantes. Como que IDE Arduino al igual que por ejemplo Eclipse con el plugin de Arduino integrado, no hacen otra cosa, que facilitarnos un poco la tarea de programar el microcontrolador, y a la hora de compilar el código que hemos escrito, dejar que lo hagan herramientas de terceros (no desarrolladas por la gente de Arduino) de una forma tan básica, como la línea de comandos.

Como decía al principio, Arduino se programa en C/C++. Por tanto, no hay necesidad de crear un compilador específico para Arduino, ya que además de que C/C++ es uno de los primeros lenguajes de programación, los microcontroladores de Arduino tampoco es algo que se haya creado específicamente para esta plataforma.

Así pues, la gente de Arduino, a la hora de crear el IDE oficial, solo tuvo que hacer un programa donde pudiéramos escribir el código fuente de nuestros programas, compilarlo y cargarlo en una placa Arduino (con algunas funciones típicas de IDE's). Pero nada de crear compiladores ETC; sino que han buscado las herramientas necesarias y las han empaquetado con el IDE que han creado, que por otra parte, éste sabe manejar perfectamente.

Así pues, cuando pulsamos en la opción correspondiente para compilar un programa en el IDE Arduino, este lo que hace es invocar un compilador de C/C++, con los parámetros necesarios para que este genere un archivo con el código binario que luego se transferirá a la placa Arduino.

Sabiendo esto, tenemos gran parte del trabajo hecho, para poder prescindir de IdE Arduino, y en realidad de cualquier IDE, y programar con el bloc de notas, o el editor de texto que prefiramos; o incluso, escribir el código fuente con el IDE que más nos guste, y compilarlo de forma independiente.

Esto que así visto parece sencillo, no lo es tanto. Y es que hay que usar varios programas, cada uno con muchos comandos, hasta que el programa que hayamos escrito, acabe cargado en la placa Arduino.

Hoy no veremos como programar en C/C++. Tan solo, como compilar código en este lenguaje, preparándolo para que funcione correctamente en Arduino. Y también veremos como cargar el programa compilado en una placa Arduino.

Para que os sea más sencillo, he preparado un paquete con todo el software necesario, para que no tengáis que buscarlo, descargarlo y hacer algunos ajustes para que sea un poco más sencillo todo el proceso.

El software puede descargarse de internet, tanto de páginas oficiales como de cualquier otro sitio. Pero para asegurar que es un software totalmente limpio y fiable, yo lo he extraído de una instalación de IDE Arduino.

Además del software para compilar y cargar programas en Arduino, en el paquete hay otras utilidades, como los drivers necesarios para la comunicación entre el ordenador y Arduino; que como sabréis, se conecta al ordenador mediante USB (aunque internamente la conexión es tratada como si de un puerto serie se tratara).

        ¡Manos a la obra!:

Después de una larga retaíla para calentar motores, ha llegado el momento de ponernos manos a la obra; porque si bien he intentado simplificar el proceso, no os voy a engañar: no es sencillo, y vais a tener que escribir bastante.

Puede que más adelante automatice casi al máximo todo lo que vamos a ver a continuación. Pero no está de más que sepáis como funciona realmente todo el proceso, y sepáis hacerlo a mano que siempre es lo más seguro.

Como ya había dicho, las herramientas que vamos a ver funcionan mediante línea de comandos.
Además, una de las ventajas que tiene hacer el proceso directamente con las herramientas de compilación y carga del programa en Arduino, es que estas son multiplataforma; por lo que están disponibles tanto para Windows como para Linux, y además, los comandos deberían ser exactamente los mismos.
Por lo que los pasos que vamos a ver para compilar y cargar programas en Arduino, servirán tanto para usuarios de Windows como de Linux.

        Construcción de un programa C/C++:

Antes de empezar, es importante comprender el proceso de construcción (compilación) de un programa en C/C++.

Es importante, porque si bien con este método vamos a poder seguir programando para Arduino usando el Core desarrollado por la gente de Arduino, como si usáramos el IDE Arduino, lo cierto es que vamos a tener que trabajar de una forma más directa con C/C++ y también vamos a tener que conocer muy bien el Core Arduino, ya que tendremos que tratarlo más directamente.

Cuando desarrollamos en C/C++, desde que escribimos el código fuente hasta que obtenemos el programa, que podemos ejecutar en el ordenador, han de ocurrir varias cosas antes de poder ejecutar el programa.

Por eso, se dice que existen varias etapas en la construcción de un programa; esto puede aplicarse a la construcción de un programa en general (con cualquier lenguaje de programación). Pero en algunos lenguajes más modernos, el proceso puede variar simplificándose, respecto a C/C++.

Vamos a ver el proceso de creación de un programa en C/C++, que es lo que nos interesa, por ser el lenguaje en el que normalmente se desarrolla para Arduino.

Al margen del diseño del programa que sería la primera etapa (fase) en la que "sobre papel" se diseñan todas las funciones del programa, opciones, interfaz, objetivo de la aplicación ETC; lo primero que hay que hacer para crear una aplicación, una vez tenemos un boceto de este, es escribir el código fuente.
El código fuente, es la forma en que le indicamos al microprocesador qué hacer. Pero no es tan sencillo: hay que indicarle qué hacer; en cada caso, ante cualquier error, ante una respuesta correcta de un componente que controla... En definitiva, el código fuente son las instrucciones que le damos al microprocesador.

Es responsabilidad del programador, darle al microprocesador las instrucciones correctas y necesarias, ante cualquier situación; porque el microprocesador por si mismo, no sabrá qué hacer ante ninguna situación posible.

El código fuente se escribe utilizando un lenguaje "de alto nivel" (aunque los hay también de "bajo nivel").
"alto nivel" y "bajo nivel", se refieren a la proximidad del lenguaje en el que se programa, al lenguaje humano, o al lenguaje de las máquinas que es el binario... Sí, los archifamosos ceros y unos, que todo el mundo sin ser informáticos ni programadores; incluso aquellos que peor se llevan con la tecnología, conocen.

Existen lenguajes de bajo nivel, como el Ensamblador. Este lenguaje es sino el más, de los más complicados, ya que es muy próximo al "lenguaje binario".

Pero por suerte para nosotros, también existen muchos lenguajes de programación de alto nivel, que son mucho más fáciles de comprender.
Uno de ellos es el C/C++; que si bien no es de los lenguajes de programación más sencillos, se considera de alto nivel.

Las ventajas de C/C++ son muchas: un lenguaje robusto, con más de 30 años de antigüedad que lo han usado miles de programadores por todo el mundo.
Es un lenguaje de programación de propósito general. Esto quiere decir, que con C/C++ puede programarse absolutamente de todo: desde juegos, agendas, sistemas de navegación... hasta sistemas operativos: Windows o Linux están programados prácticamente en su totalidad en C/C++.
Los programas escritos en C/C++ son portables, lo que quiere decir que mientras se use el C/C++ estandar, los programas que se escriban en este lenguaje, podrán ejecutarse sin problema en cualquier plataforma.
Si hay que usar características concretas de una plataforma o sistema operativo, es necesario usar librerías para ello, tales como el Core Arduino; que como ya hemos dicho, es un API desarrollado para hacer más fácil la programación para la plataforma Arduino.
Igualmente, existen librerías para desarrollar software para Windows, Linux ETC.

Como no podía ser de otra manera, este lenguaje de programación también tiene desventajas, si se le puede llamar así; aunque para muchos las tiene: la curva de aprendizaje es más grande que la de otros lenguajes.
Para muchos es un lenguaje obsoleto, y prefieren otros más modernos como Java o C#. Pero detrás de estos lenguajes modernos, hay miles de líneas de código C/C++.

Tras este pequeño paréntesis para ver un poco de teoría sobre C/C++, continuamos con el proceso de creación de un programa.
*Recordad que esto es para crear programas en C/C++ en general, no sólo para Arduino. Por eso es importante verlo antes de empezar con nuestro objetivo de crear un programa para Arduino sin entornos de programación.

Tras haber escrito todo el código fuente del programa, viene la segunda fase, que podríamos considerar como la más compleja e importante de todo el proceso: la compilación.

Compilar, es la tarea de "traducir" el código fuente en código binario.

Dijimos que el código fuente son las instrucciones que escribimos en un lenguaje que comprendemos los humanos, para que las ejecute el microcontrolador.
Lo que no hemos dicho, es que el microcontrolador no es capaz de comprender estas instrucciones tal como las escribimos nosotros. Un microcontrolador únicamente conoce ése inexplicable lenguaje plagado de ceros y unos, que los humanos somos incapaces de comprender.

Así pues, para que humanos y procesadores sean capaces de entenderse, ha de haber un proceso de "traducción", del lenguaje de los humanos, al lenguaje de las máquinas: y a este proceso se le llama compilación.

Esta tarea tan compleja de convertir el código fuente en código binario, la hacen los compiladores.

Existen compiladores para todos los lenguajes de programación, y cada compilador puede ser más o menos difícil de usar.
Hay compiladores independientes, integrados en IDE's... Pero al final, su misión siempre es la misma: convertir el código fuente en código binario.

Como podéis imaginar, si programamos en C/C++ no podemos usar un compilador de Java, porque no sabría interpretar nuestro código fuente.

Es algo así, como que si hablamos español y queremos comunicarnos con una persona que hable inglés, hemos de hacerlo mediante un intérprete de español a inglés y viceversa, y no con uno de ruso a inglés, porque no nos entendería, y no podría transmitirle a la persona que habla inglés, lo que queremos decirle.

Algunos compiladores hacen otras funciones que veremos más adelante, además del proceso de conversión de código fuente a código binario. Esto es más común en lenguajes más modernos.

En C/C++, el proceso suele ser más transparente, y en algunos casos el programador ha de encargarse de realizar todas las etapas del proceso de la creación del programa; aunque esto también dependerá del compilador.

Si nos centramos en un proceso de construcción del programa "paso a paso", el compilador únicamente convierte el código fuente en código binario, por lo que aún el proceso no ha terminado; ya que el archivo que genera el compilador si todo ha ido bien, a partir del código fuente, todavía no puede ejecutarse, pese a ser ya un archivo que contiene código binario que es lo que entienden las máquinas.

Al archivo que genera el compilador se le conoce como archivo objeto, y aunque en otros compiladores puede cambiar, en los compiladores de C/C++ y en concreto el que vamos a usar nosotros, su extensión es .o.

Estos archivos por si mismos no son funcionales, ya que en C/C++ los programas suelen estar compuestos por distintos recursos, que se compilan por separado.
De hecho, el programa que escribamos nosotros mismos, se debe compilar en distintas partes... Tantas como ficheros compongan el proyecto de nuestra aplicación, o casi.

Esto es así, porque un programa sencillo que por ejemplo haga una suma de dos valores, puede escribirse en un único archivo fuente sin problema. Pero aplicaciones mucho más complejas como un sistema operativo, suele escribirse en muchos archivos fuente, para una mejor organización del código fuente, y mejor comprensión del mismo.

En el caso de dividir el código fuente en varios archivos, hay que compilar cada archivo por separado, de forma que obtengamos un archivo objeto por cada archivo fuente. Esto se hace de forma automática en todos o la mayoría de IDE's, pero hemos de hacerlo de uno en uno, si usamos directamente el compilador.

Una vez obtenidos los archivos objeto del programa, habremos superado la parte más compleja del proceso, ya que significará que hemos escrito el código fuente sin errores; al menos, sin errores sintácticos, porque existen otros errores "sutiles", mucho más difíciles de detectar.
Pero al menos, obteniendo el código máquina del programa, podremos finalizar el proceso de construcción de este.

El siguiente paso, es el enlazado: En este punto, lo que se hace es mezclar todos los archivos del código fuente que habíamos escrito, con las librerías y demás recursos necesarios del programa, si los hubiera.

Esto puede en ocasiones hacerlo el propio compilador, si es un compilador más o menos avanzado, que disponga de la función de linker. Pero no siempre ha de ser así, y pueden haber compiladores que no tengan esta opción, y tengamos entonces, que usar un linker, que es una herramienta cuyo objetivo no es otro, que empaquetar todos los archivos objeto y/o otros recursos, en un archivo ejecutable, que luego podremos usar normalmente para ejecutar el programa.

Es aconsejable, aun cuando el compilador sea capaz de enlazar los archivos objeto, decirle expresamente que no lo haga, y detener el proceso en la etapa de compilación; de forma que únicamente genere los archivos objeto, para luego enlazar manualmente los archivos: así es como lo haremos en el ejemplo que veremos más adelante, de creación de un programa para Arduino.

Una vez terminada la etapa de enlazado, tenemos construido por completo el programa. Como decía, esto no quiere decir que el programa no tenga errores: el compilador es capaz de detectar errores sintácticos, que son errores en la sintaxis del código fuente. Pero no es capaz de detectar errores semánticos que hay quien los llama "sutiles".
Este tipo de errores, es responsabilidad del programador, encontrarlos y depurarlos, si bien son difíciles de detectar.
para ello solo hay una fórmula: paciencia y practicar.

        Adaptación de un squetch arduino:

Ahora que conocemos el proceso real de la construcción de un programa en C/C++, estamos en condiciones de empezar con lo realmente interesante.

Como ya hemos dicho, IDE Arduino nos facilita un poco la vida a la hora de programar para Arduino, ya que incluye un core que podemos utilizar para programar más fácilmente algunas cosas concretas del microcontrolador, que de otra forma, simplemente valiéndonos de las instrucciones de C/C++, podríamos hacer; pero sería bastante más complicado.
Además, tendríamos que conocer ciertas instrucciones concretas, y el funcionamiento interno de microcontroladores AVR, que son los que normalmente tienen las placas Arduino.

Así pues, en principio no podríamos ponernos a programar en el blog de notas y compilar, ya que, si lo hacemos intentando usar las funciones del core Arduino, al no estar presentes las librerías de este, el compilador nos daría errores y no obtendríamos los archivos objeto.

Por eso, en el paquete de software que he preparado, está incluido el core Arduino para que podáis usarlo sin problema.
Este al igual que las herramientas de compilación y carga de los programas en Arduino, está sacado de una instalación de IDE Arduino, para garantizar que sea el core oficial y no tenga modificaciones más allá de las necesarias para que todo funcione correctamente.

Es importante conocer el core Arduino; cosa que es tarea vuestra, encontrar documentación y aprender a usar el API, así como aprender a programar en C/C++.
Pero si queremos programar para Arduino fuera de cualquier entorno de programación que tenga incluido el API, es imprescindible conocer el core, aún más si cabe.

Es importante, porque por ejemplo, una de las cosas que hace IDE Arduino para facilitarnos la programación es incluir las librerías del core Arduino que sean necesarias, según el código fuente que hayamos escrito: es decir, al pulsar el botón correspondiente para compilar el programa, IDE Arduino analiza el código fuente y hace un preprocesado, donde entre otras cosas, incluye código fuente que nosotros no hayamos puesto como por ejemplo la inclusión de las librerías que contengan las funciones y/o prototipos de estas, que hayamos usado en el código fuente de nuestro programa.
Además, hace otras cosas, como incluir en el programa una función Main, que habitualmente no se escribe en un squetch Arduino, pero que en cambio es una función obligatoria en todo programa escrito en C/C++.

No lo habíamos dicho. Pero un squetch, es la forma en que en el mundo Arduino se llama a lo que tradicionalmente, en la programación en C/C++ al igual que en otros lenguajes, se conoce como archivo fuente.

En la fase del preprocesamiento del squetch, IDE Arduino hace otras cosas, como concatenar todos los archivos del proyecto en uno solo y renombrar el archivo a compilar; ya que en IDE arduino, la extensión de los archivos fuente es .ino, mientras que en C/C++ la extensión de estos ha de ser .c, .cpp, .h ETC.

        Arduino CMD builder:

Este es el nombre que le he dado al paquete de software que he preparado, que contiene todo lo necesario para compilar y cargar un squetch Arduino en una placa de esta plataforma.

Sí, lo sé: el nombre no es muy original. Pero expresa el cometido de las herramientas que contiene.

Antes de empezar, vamos a ver el contenido del paquete, que cuando lo descarguéis, estará comprimido en un archivo RAR, que al descomprimirlo veréis que contiene un archivo ejecutable, desde el que podréis extraer todo el contenido del paquete, únicamente eligiendo la ruta donde queréis ponerlo.

El paquete está formado por archivos y carpetas. Todas las herramientas que se necesitan para compilar y cargar un squetch en una placa Arduino son portables, por lo que no es necesario instalar nada, salvo los drivers para la comunicación entre las placas Arduino y el ordenador, tal como ya habíamos dicho.

Al extraer el contenido del archivo ejecutable encontraréis los siguientes directorios:

- Arduino:

Dentro de esta carpeta encontraréis, dentro de un subdirectorio llamado AVR, distintas herramientas que posiblemente podáis necesitar en algún momento.

Entre otras, se encuentra una carpeta llamada Core, que es la que posiblemente más vayáis a utilizar ya que contiene todas las librerías del core Arduino.

Otra de las carpetas que podéis encontrar es "bootloaders" que contiene los bootloaders de las placas Arduino; las he incluido para que las tengáis a mano, por si os hace falta alguna vez. Pero normalmente no será el caso.
En cualquier caso, deberéis buscar información sobre como quemar un bootloader en internet, ya que eso no lo veremos aquí.

El resto de archivos y carpetas, igualmente se incluyen por si fueran necesarios en casos puntuales. Pero es igualmente poco probable que los necesitéis.

- drivers:

Esta carpeta es muy importante, y la primera que tendremos que utilizar, ya que como dije, es imprescindible instalar los drivers necesarios para que pueda establecerse correctamente la comunicación entre el ordenador y las placas Arduino.

Cuando instalamos IDE Arduino, los controladores se instalan directamente (desde esta carpeta). Pero cuando vamos a trabajar sin el IDE, y no lo tenemos instalado, hemos de hacer nosotros la instalación manualmente.

Para ello, podéis instalar si queréis todos los controladores que encontréis, si no tenéis claro cual es el de vuestra placa Arduino. Si sabéis qué controlador tenéis que instalar, podéis hacerlo, omitiendo el resto.

En cualquier caso, instalar todos los controladores no afectará al rendimiento del ordenador, ni a la hora de trasferir los programas a la placa Arduino.

Un controlador que debéis instalar en cualquier caso es el que se encuentra en el subdirectorio "FTDI USB Drivers".
Su archivo de instalación es "ftdibus.inf".

Existen varias formas de instalar un controlador en Windows; podéis hacerlo de la forma que más os guste.

Si es posible, lo más rápido siempre es pulsar tecla aplicaciones sobre el archivo INF del controlador, y pulsar sobre la opción "instalar". Pero a veces puede ocurrir que Windows dé un error diciendo que el método de instalación no es compatible con ése controlador.

En ese caso, podéis instalarlo desde el símbolo del sistema; aunque también podéis usar un instalador que contiene la carpeta Drivers del paquete de software, que os hará mucho más fácil la tarea de instalar los controladores.
El archivo del instalador se llama "dpinst-amd64.exe" para sistemas operativos Windows de 64 bits, y "dpinst-x86.exe" para Windows de 32 bits.

Es importante ejecutar cualquiera de los dos instaladores según la edición de Windows que tengáis: 32 o 64 bits, como administrador, como viene siendo habitual en Windows.

Una vez ejecutado el instalador, simplemente tenemos que pulsar "siguiente" en la primera pantalla que nos aparece y esperar que finalice la instalación de los controladores.
Una vez terminada la instalación, aparece una pantalla que nos indica que la instalación se ha realizado correctamente, y nos muestra una lista de los controladores que se han instalado en el equipo; entre los que se encuentra el controlador USB que realizará la conexión entre el ordenador y las placas Arduino.

De todas formas, si véis que no se han instalado todos los controladores que hay dentro de la carpeta Drivers, podéis instalarlos manualmente como ya he explicado.

- examples:

Esta carpeta también la he cogido de una instalación de IDE Arduino.
La he incluido en el paquete para que tengáis ejemplos que revisar de programación Arduino, si lo necesitáis.

- Lib:

Esta carpeta contiene una subcarpeta llamada "Static", que contiene una librería estática.

No entraremos demasiado en detalle sobre las librerías estáticas; tan solo decir, que es un tipo de librerías de los programas hechos en C/C++.

Estas librerías contienen librerías escritas en código C/C++. En este caso, en este subdirectorio se encuentra el archivo "LibCore.a", que contiene todo el Core Arduino compilado y empaquetado en una librería estática.

En realidad, la construcción de la librería estática ha de ser tarea vuestra, ya que cada programa requerirá unas librerías del Core Arduino distintas, y prácticamente nunca haréis un programa que las requiera todas; por lo que no es necesario incluirlas todas, ya que eso hace aumentar el tamaño final del programa. Y Arduino no anda sobrado de recursos precisamente, por lo que hay que optimizar al máximo los programas que hagamos para esta plataforma.

En cualquier caso, si no váis a hacer proyectos muy complejos, y vuestros programas no ocupan demasiado, aunque lo aconsejable es que construyáis vuestra propia librería estática como ya veremos más adelante, podéis usar la que incluye Arduino CMD builder, que he construido con todo el core Arduino, para que podáis saltaros este paso del proceso de compilación que luego veremos.

- libraries:

Esta carpeta contiene las librerías que vienen en una instalación de IDE Arduino, y alguna más que había instalado yo y que dejo en Arduino CMD builder porque considero interesante tenerlas: "DFPlayer_Mini_Mp3". Es una librería para un reproductor de MP3 bastante popular llamado DFPlayer Mini, y "HC-SR04". Una librería para el sensor de ultrasonidos HC-SR04.

En todas las librerías viene todo lo necesario para usarlas y en la mayoría también algunos ejemplos. La documentación de todas ellas podéis encontrarla en internet sin problema.

- Make:

Esta es la carpeta más importante, ya que contiene todo el software necesario para la compilación y carga de los squetchs en las placas Arduino.
Más adelante veremos su contenido.

- OBJ:

Esta carpeta contiene todas las librerías del core Arduino compiladas, pero sin empaquetar en una librería estática; tan solo se trata del archivo objeto de cada librería.
además, aunque normalmente no os hará falta, en esta carpeta he dejado también el archivo de dependencias de cada archivo objeto. Estos son los archivos con extensión .d, por si os fuera de utilidad en algún momento.

Hay que tener en cuenta un par de cosas en cuanto al contenido de esta carpeta: Existe un archivo al que le he modificado lijeramente el nombre, respecto al core Arduino de IDE Arduino: "wiring_pulseASM.o".

Este archivo, originalmente se llama "wiring_pulse.S", y al compilar todos los recursos por separado, IDE Arduino lo renombra como "wiring_pulse.S.o". Pero a mi me ha parecido más descriptivo sustituir ".S" por "ASM" de asembler (ensamblador); porque los archivos con extensión .S, son los que contienen código en Ensamblador.
Le he añadido "ASM", porque ya existe un archivo llamado "wiring_pulse.o" que es el archivo objeto del archivo fuente de "wiring_pulseASM.c".

Si os fijáis, dentro de \Arduino_CMD_builder\OBJ, hay un archivo llamado "main.o".
Este archivo contiene una función Main() que IDE Arduino vincula automáticamente a los squetchs, pero que al prescindir de él, hemos de vincular nosotros manualmente.

Para ello, únicamente hay que incluir el archivo "main.cpp" en nuestro squetch, y luego empaquetar el archivo "main.o" en la librería estática, para que el programa pueda encontrar el código fuente de la función Main.

Como véis, es muy sencillo, ya que no hemos ni siquiera de escribir el código de la función.

- SRC:

Por último, la carpeta SRC contiene un pequeño squetch de ejemplo. Es el código con el que he ido probando que todo funcionara correctamente.
Luego veremos que el programa está compilado en todas las fases, en otro directorio dentro de la carpeta Make.

El directorio sRC no es imprescindible, por lo que podéis eliminarlo si queréis.
También podéis dejarlo, y colocar en él los archivos de vuestros programas para tenerlos organizados dentro de Arduino CMD builder.

        Compilando un squetch:

Ahora que ya hemos visto todo el contenido de Arduino CMD builder y algunas cosas a tener en cuenta antes de compilar un squetch, es hora de empezar a compilar un squetch desde el símbolo del sistema.

Vamos a usar el código que hay en \Arduino_CMD_builder\SRC como ejemplo en el proceso de compilación que vamos a ver aquí.

Cada vez que veáis una ruta a un archivo, tal como se irá indicando en cada caso, podéis sustituirla por la ruta que corresponda en vuestro caso.

Las instrucciones que vienen a continuación son para Windows, pero salvo cosas puntuales, servirán también para Linux, o cualquier otro sistema para el que estén disponibles las herramientas que vamos a usar.

El software incluido en Arduino CMD builder sólo es para Windows. Si usáis otro sistema operativo, tendréis que buscar las herramientas para el sistema que corresponda.

Lo primero que tendremos que hacer es abrir una ventana de consola del sistema.

En Windows podemos hacerlo llendo al menú inicio, y escribiendo CMD en el cuadro de búsqueda; para abrir el símbolo de sistema que es uno de los resultados que aparecen, nos ponemos sobre éste, y con tecla aplicaciones pulsamos sobre "Ejecutar como administrador".

Una vez en el símbolo del sistema, lo primero que tendremos que hacer es ir a la ruta donde tengamos el paquete de Arduino CMD builder.

Esto dependerá de donde lo hayáis descomprimido. Vamos a asumir que el paquete se encuentra en C:\Arduino_CMD_builder para hacerlo más fácil.
*intentad no usar rutas con espacios para evitar errores.

Lo primero que tendremos que hacer es ir a la raíz del disco, para desde ahí ir a la ruta del paquete de Arduino CMD builder. Para eso escribiremos:

cd C:\

Con este comando iremos directamente a la raíz del disco, sin necesidad de ir retrocediendo carpetas de una en una.

Ahora, para acceder al directorio de Arduino CMD builder, escribiremos:

cd C:\Arduino_CMD_builder

Si os fijáis, en la parte inferior de la ventana de la consola nos aparece la ruta en el que estamos en cada momento; si nos equivocamos escribiendo la ruta, nos aparecerá un mensaje de error que indicará que la ruta no se encuentra, si no existe la ruta indicada. Si existe, veremos en el prompt como nos indica la ruta errónea.

Una vez en el directorio raíz del paquete, hemos de ir al directorio donde se encuentran las herramientas de compilación con el siguiente comando:

cd make\avr\bin

Ahora ya estamos en el directorio de las herramientas más importantes de Arduino CMD builder, solo nos falta escribir todos los comandos para compilar y cargar nuestro squetch en la placa Arduino.

Antes de eso, vamos a ver un directorio más que vamos a necesitar. Usaremos este, que he incluido en el paquete, para que tengáis ya creada una carpeta donde almacenar los binarios de vuestros programas de forma ordenada. Pero podéis usar cualquier otra ruta que queráis: "C:\Arduino_CMD_builder\Make\Build".

Por defecto, al descomprimir Arduino CMD builder, veréis que esta ruta no está vacía. He dejado todos los binarios ahí, del código de ejemplo que hay en el directorio SRC, de la raíz del paquete; así como los binarios del core Arduino. Pero podéis borrar todos los archivos que contiene si queréis. En cualquier caso, siempre y cuando los archivos de vuestros squetchs no tengan el mismo nombre no pasará nada. De lo contrario, el contenido existente será sobreescrito por el compilador y la herramienta de enlazado.

Teniendo claro donde tenemos almacenado el código fuente de nuestro squetch, y donde queremos guardarlo, vamos a ejecutar el primer comando para compilarlo.

Recordad que el squetch hemos de compilarlo archivo por archivo: El código fuente que vamos a usar, está escrito todo en un único archivo, porque es muy básico (el típico ejemplo de papadeo de un LED de Arduino). Pero un programa más complejo podría dividirse en varios archivos fuente.

En ese caso, deberíamos repetir el comando siguiente, una vez por cada archivo del proyecto, cambiando en cada caso el nombre del fichero fuente y del archivo objeto; y de las rutas de estos si fuera necesario:

avr-g++ -I C:\Arduino_CMD_builder\Arduino\avr\cores\Arduino\ -c -Wall -x c++ -MMD -DF_CPU=16000000L -Os -mmcu=atmega328p -O -o C:\Arduino_CMD_builder\Make\Build\blink.o C:\Arduino_CMD_builder\SRC\blink.ino

*Es importante respetar las mayúsculas de los parámetros precedidos por guiones, ya que como puede verse en la línea del comando anterior, este contiene "-O" y "-o" que no significan lo mismo para el compilador: -O le indica que optimice el código, y en cambio -o le indica la ruta del archivo fuente.

El parámetro "-I" idnica al compilador donde buscar el core Arduino.
Esto quizás no sería necesario, ya que es importante incluir explícitamente en el código fuente del programa las librerías que vamos a usar. Pero por si acaso, es mejor que también le indiquemos al compilador la ruta del core Arduino.

El parámetro "-Wall", indica al compilador que nos muestre todos los mensajes tanto de warnings (alertas) como errores.
En cambio, si no hay ninguno de estos mensajes que mostrar, significa que el código fuente está bien escrito y el compilador no mostrará ningún mensaje... Ni siquiera para confirmar la operación.

El parámetro "-x c++" indica al compilador que vamos a compilar un código fuente escrito en C++. Por lo general, C++ incluye a C, así que no debería haber ningún problema si pasamos este parámetro para un squetch escrito puramente en C. Pero en ese caso podríamos quitarlo sin problema.

El parámetro "-DF_CPU" indica al compilador la velocidad del reloj del microcontrolador. En este caso, para el Atmega328p que es el microcontrolador para el que estamos compilando, su velocidad es "16000000L" (16 MHZ). Pero tendréis que consultar la velocidad del microcontrolador para el que vayáis a compilar, si es distinto al Atmega328p.

Por último, el parámetro "-mmcu" indica al compilador para qué microcontrolador estamos compilando nuestro programa; en este caso, el Atmega328P. Pero las placas Arduino usan otros micros.
Deberéis consultar qué microcontrolador tiene vuestra placa Arduino y si está soportada por AVR-G++.

¡IMPORTANTE!: cada archivo fuente de un squetch ha de incluir explícitamente Arduino.h, que forma parte del core de Arduino.
Este archivo de cabecera contiene todos los prototipos de las funciones del API, por lo que debe ser incluido, al margen de si se usan o no todas las funciones del API.


        Vinculación de librerías:

¡Ya queda menos!. Si todo ha ido bien, ahora en "C:\Arduino_CMD_builder\Make\Build" tendremos los archivos "blink.d" y "blink.o".

El primero es el archivo de dependencias del archivo objeto, que es "blink.d".

El archivo de dependencias nosotros no lo usaremos directamente, pero lo dejaremos de momento junto con el archivo objeto, para evitar errores durante la fase de enlazado.

Si os habéis fijado la primera vez que habeis abierto esta carpeta, como dije, he dejado en ella, el contenido de "C:\Arduino_CMD_builder\OBJ". esto es, para que sea más fácil vincularlo todo y no tengáis que mover vosotros los archivos.

En caso de no necesitar todas las librerías del core Arduino, y construir vosotros la librería estática, tan solo tendréis que indicar al compilador las librerías que necesitáis. El resto no se vincularán a la biblioteca estática.
Recordad que siempre hay que vincular los archivos objeto, nunca los archivos fuente. Es distinto: en el archivo fuente incluimos librerías, en el proceso de enlazado, las enlazamos.

La diferencia entre ambos, es que al incluir librerías en el archivo fuente, estamos diciéndole al compilador que copie el contenido del archivo fuente que le indicamos, y lo añada al archivo fuente desde el que se lo estamos diciendo.

A la hora de compilar ese código fuente en el que hemos incluido una librería o cualquier otro archivo, estaremos creando un archivo objeto, que contendrá en realidad varios archivos fuente.

En el proceso de enlazado, es algo similar, pero con todo ya compilado: en código binario, y con los archivos objeto creados como proceda. Sería algo así como cuando comprimimos archivos y carpetas en un archivo RAR o ZIP.

El siguiente comando nos creará una biblioteca estática con tantas librerías del core Arduino como le indiquemos.
Veréis que el uso de esta herramienta no es difícil, pero sí puede ser muy largo, ya que tendremos que escribir el nombre y la ruta de todas las librerías del core Arduino que queramos incluir:

avr-ar rcs C:\Arduino_CMD_build\Make\Build\LibCore.a C:\Arduino_CMD_build\Make\Build\hooks.o C:\Arduino_CMD_build\Make\Build\wiring.o C:\Arduino_CMD_build\Make\Build\wiring_digital.o

En este caso, simplemente le hemos dicho a AVR-AR, que nos genere una biblioteca estática en "C:\Arduino_CMD_build\Make\Build", con el nombre "LibCore.a". El resto de parámetros puede variar, como decía anteriormente, según la cantidad de librerías que necesitemos.
En este caso, le pasamos las tres necesarias para el squetch de ejemplo que estamos usando.

Si todo ha ido bien, obtendremos la biblioteca estática en la ruta indicada. En este caso, la ruta es la misma donde se encuentran los binarios del squetch.

El siguiente paso de la fase de enlazado, es empaquetar la biblioteca estática que acabamos de crear con los archivos del programa con algo así:

avr-gcc -mmcu=atmega328p -Wl,--gc-sections -Os -o C:\Arduino_CMD_build\Make\Build\blink.bin C:\Arduino_CMD_build\Make\Build\blink.o C:\Arduino_CMD_build\Make\Build\LibCore.a -lc -lm

Nuevamente, es importante respetar las mayúsculas en los parámetros precedidos por guiones.

De este comando, lo único que cabe destacar, es que nuevamente, le indicamos el microcontrolador para el que estamos en este caso, empaquetando el programa.

Por lo demás, es importante únicamente asegurarnos de indicarle al compilador correctamente las rutas y los nombres de los archivos a los que nos referimos.

En primer lugar, indicamos el archivo binario que se generará. Podría ser con extensión .ELF, o .BIN; yo he optado por esta segunda.

En segundo lugar, indicamos el archivo objeto de nuestro programa: blink.o. En caso de que el squetch se compusiera de varios archivos, y tuviéramos más de un archivo objeto, tendríamos que indicarlos todos, precedidos de sus rutas correspondientes.

Y por último, le indicamos al compilador la ruta y el nombre de archivo de la biblioteca dinámica que hemos creado anteriormente con las librerías del core Arduino.

        Conversión de formato:

Aunque ahora tenemos el squetch realmente compilado, y ya podría funcionar en algunos micros, no será el caso de los que suelen tener las placas Arduino.

Estos microcontroladores no aceptarían un archivo .BIN como ejecutable, así que hay que hacer una conversión a un formato que soporten estos microcontroladores.

Por lo general, los microcontroladores de las placas Arduino trabajan con archivos Intel Hexadecimal (.HEX).

No vamos a preocuparnos demasiado por esto ahora; simplemente nos quedaremos con que los archivos .HEX son un tipo de ejecutable, al igual que lo son los .exe para Windows.

Arduino CMD builder cuenta con una herramienta que nos permite hacer la conversión de .ELF o .BIN a .HEX.
Y es que, no sirve renombrar el archivo para cambiarle la extensión.

Así pues, para pasar el binario que hemos creado a Intel Hexadecimal escribiremos lo siguiente en la consola:

avr-objcopy -j .text -j .data -O ihex C:\Arduino_CMD_build\Make\Build\blink.bin C:\Arduino_CMD_build\Make\Build\blink.hex

Básicamente, le estamos diciendo a avr-objcopy que convierta el archivo blink.bin, en archivo Intel Hexadecimal, indicándole las rutas tanto de origen como de destino.

        Cargar el programa en la placa Arduino:

¡POR FIN!. Ahora sí, ya tenemos un ejecutable, totalmente funcional que podemos grabar en el microcontrolador de nuestra placa Arduino y que si todo va bien, debería funcionar.

*El código de ejemplo de "\Arduino_CMD_builder\SRC" puede no serviros para probar, puesto que es un programa que hace parpadear un LED.
Para una persona ciega sería mejor modificar la parte del código que activa y desactiva el LED, para hacer lo propio con un buzzer.
Esto podéis hacerlo cambiando simplemente el número del pin, y conectar un buzzer en otro pin de la placa Arduino, o incluso conectando un buzzer en el pin que se usa en el ejemplo.

Para cargar el programa en la placa Arduino, usaremos una herramienta que también está incluida en Arduino CMD builder y que como no, también funciona mediante línea de comandos.

Esta aplicación se llama avrdude, y sinceramente... ¡Es de temer!.

La mayoría de los problemas en general; tanto usando IDE Arduino, otro IDE o ninguno, a la hora de programar para Arduino, más que en la fase de construcción del squetch, vienen a la hora de cargar el programa en la placa.

Si hecháis un vistazo en internet, veréis que montones de personas tienen problemas para hacerlo. Y por experiencia propia (porque yo también los he tenido, y de hecho los estoy teniendo ahora) os aseguro, que las soluciones que se encuentran por todas partes (típicas soluciones obvias por otra parte) no suelen funcionar.

y es que, no lo había dicho para no desanimaros. Pero suelen haber muchos problemas para comunicar correctamente Arduino con el ordenador.

Pero la culpa no es de las herramientas que se usan para compilar o cargar el programa, ni si quiera del IDE o el entorno que se use para programar: ya sea IDE Arduino, Eclipse... O el bloc de notas.

El problema está en los puertos USB, y los controladores.

Muchas veces, sin saber por qué (no he encontrado una explicación para eso) como solemos tener instaladas muchas cosas que utilizan los puertos USB, los controladores de Arduino no funcionan correctamente; y aunque el ordenador es capaz de reconocer la placa Arduino correctamente, y nos indica el puerto COM en el que se encuentra, avrdude no es capaz de comunicarse con el microcontrolador y da errores al cargar el programa en la placa.

Os preguntaréis, por qué entonces os explico todo esto...
Pues porque cuando eso ocurre, no es solo cuando intentamos programar Arduino sin el IDE oficial. Sino que incluso con este, avrdude no funciona y aparecen exactamente los mismos errores.

Por eso, os voy a explicar como cargar el programa en la placa, usando directamente avrdude. Porque si conseguís que os funcione, lo hará tanto directamente, con IDE Arduino como con cualquier otro IDE.

avrdude se encuentra en el mismo directorio en el que estamos en la consola. Así que únicamente hay que ejecutarlo y pasarle los parámetros necesarios:

avrdude -CC:\Arduino_CMD_builder\make\avr\bin\avrdude.conf -v -patmega328p -carduino -PCOM6 -D -Uflash:w:C:\Arduino_CMD_builder\make\build\blink.hex:i

De nuevo, aquí también es importante respetar las mayúsculas en los parámetros precedidos por guiones.

En el primer parámetro: "-CC:\Arduino_CMD_builder\make\avr\bin\avrdude.conf" estamos indicándole a avrdude, donde se encuentra su archivo de configuración.

En una instalación de IDE Arduino se encuentra en otro directorio; pero yo lo he movido a la ruta en la que trabajamos para que sea más cómodo, ya que aunque yo lo indico en el comando anterior, al estar ubicado en el mismo directorio que avrdude.exe, no es necesario pasarle a éste la ruta del archivo de configuración.

El parámetro "-v" hace que avrdude nos muestre más información del proceso de carga del programa en la placa Arduino.

A continuación, el parámetro "-patmega328p" le indica a avrdude que estamos cargando un programa en un microcontrolador Atmega328p. Debéis consultar qué micro tiene vuestra placa, e indicarlo en éste parámetro si fuera distinto.

"-carduino" indica a avrdude el tipo de programador que estamos usando.

No debéis preocuparos demasiado por esto. Si vais a programar placas Arduino, Arduino será el valor que tendréis que poner siempre aquí.

Fijaos que el parámetro es "-c", igual que el primero. Pero en este caso es una c minúscula, mientras que en el primer caso es mayúsculas; y en cambio no indican lo mismo a avrdude. De ahí la importancia de respetar siempre las mayúsculas.

"-PCOM6" indica el puerto donde se encuentra conectada la placa Arduino que queremos programar.

Esto puede variar cada vez que conectéis la placa, así que es aconsejable asegurarse antes de intentar cargar el programa, para no tener errores.

para ver en qué puerto está conectado Arduino, podemos ir al administrador de dispositivos del sistema.

En Windows; a partir de Windows 7, esto podemos hacerlo llendo al menú inicio, y escribiendo "dispositivos" (sin las comillas) en el cuadro de búsqueda.

Deberemos ir hasta donde pone "Administrador de dispositivos" entre los resultados (en Windows 10 aseguraos de que no es un "Resultado WEB") y pulsar enter sobre él.

Una vez abierto el administrador de dispositivos, deberemos buscar la rama "Puertos (COM y LPT)" y expandirlo.

Una vez abierto, aparecerán más o menos puertos, según la cantidad de cosas que tengáis conectadas al ordenador, y los puertos que este tenga instalados.

Si la placa Arduino ha sido reconocida correctamente por el ordenador, la encontraréis rápidamente ya que os aparecerá algo como "Arduino Uno (COM6)".

Esto es lo que me pone a mi, al conectar una placa arduino UNO.

Así pues, vemos que en mi caso Arduino está conectado en el COM6, que es el que tendría que poner en avrdude para que encuentre la placa sin problema.
Pero a vosotros puede ponernos cualquier otro número, que tendréis que cambiar en el comando de avrdude.

"-D" indica si hay o no que borrar el contenido del chip antes de cargar el programa en la placa.

"-Uflash:w:C:\Arduino_CMD_builder\make\build\blink.hex:i" Indica a avrdude varias cosas.

Por un lado, estamos diciéndole que queremos grabar el programa en la placa. Luego le indicamos la ruta y el nombre de archivo, y por último le decimos en qué formato. Normalmente lo haremos en Intel Hexadecimal, tal como dijimos antes. Pero hay que indicarlo, porque avrdude soporta otros programadores distintos a Arduino, y muchos microcontroladores que pueden trabajar con otro tipo de binarios.

Con este último comando, podríamos hacer muchas otras cosas, como grabar en la eeprom del micro, recuperar un firmware que hubiéramos grabado antes en el microcontrolador, grabar un bootloader, configurar los fusibles del micro ETC.
Pero aquí no veremos nada de eso.

Si todo va bien, avrdude nos informará de que el programa se ha cargado correctamente en la placa. En ese caso, solo nos queda probarla y ver que todo funciona como esperamos.

En caso de haber algún problema, avrdude nos lo indicará, con mensajes bastante descriptivos como "programer is not responding". Si eso pasa ... Preparaos, es una tortura, y puede llevaros muchas horas solucionarlo.

Además, avrdude siempre devuelve cun código de error, que podéis utilizar para buscar información en internet. Avrdude es una aplicación muy popular en la programación de microcontroladores, así que información no os va a faltar.
Eso sí, mucha de ella está en inglés.

Además, avrdude hace hasta diez intentos de cargar el programa en la placa, si detecta algún error.

Al ser línea de comandos no podréis cancelarlo; en ese caso, si no ha funcionado a la primera, difícilmente lo hará en los intentos posteriores... Simplemente dejad que termine y listo.

        Solución de problemas con avrdude:

Seguramente, a partir de la carga del programa en la placa, os he desanimado al deciros que suelen haber muchos problemas con esto. Pero creo que tenía que hacerlo, ya que es una realidad; pero una realidad, que no viene por el hecho de usar Arduino CMD builder, sino que como dije, ocurre incluso utilizando IDE Arduino.
Porque como ya he dicho, no tiene que ver ni con el entorno de programación ni con avrdude; sino con los controladores, y con algunas aplicaciones que usan los puertos USB, serie o paralelo.

Como ya he dicho antes, si ocurre algún problema a la hora de cargar un programa en una placa Arduino, os va a costar bastante dar con el problema.

típicamente, en internet, la gente suele recomendar desinstalar IDE Arduino, reinstalar los controladores tanto de Arduino como del USB (de los que hemos hablado más arriba), verificar el cable que usamos para conectar Arduino al ordenador, conectar la placa a otro puerto USB, reiniciar la placa si esta cuenta con un botón de Reset... Y mil cosas más similares.
Incluso me he encontrado gente que dice que la culpa de que avrdude no cargue un programa en la placa, puede ser de que tengamos la placa sobre una superficie metálica... O que se haya cortocircuitado alguno de los pines de alimentación de la placa con GND.

Si os ocurre esto y queréis verificar todas estas cosas, perfecto: no está de más.
Pero por experiencia os digo que no suele ser la solución.

Normalmente el problema viene como decía anteriormente, por los controladores o algún programa que incluso sin tener nada conectado al ordenador, esté haciendo uso de los puertos USB: por algún motivo, se crea un conflicto y misteriosamente, el perjudicado siempre es Arduino.

Un consejo, es que si tenéis instalado algún programa de virtualización en el ordenador donde vayáis a programar una placa Arduino, como VMWare, que lo cerréis por completo.

Este tipo de aplicaciones al igual que otras tantas, suelen crear servicios en el ordenador, que se ejecutan nada más entrar en el sistema, incluso si no abrimos el programa.

Muchos programas lo hacen simplemente para buscar actualizaciones. Pero otros como las máquinas virtuales, hacen otras cosas más complejas. Entre ellas, las máquinas virtuales monitorizan constantemente los puertos del ordenador, al igual que cualquier otro componente hardware; porque los puertos también los virtualizan.

Os digo esto, porque ya me pasó nada más comprar una placa Arduino por primera vez, que no hubo forma de cargar un programa en esta, y el problema, por más que revisé cosas como las que os he dicho más arriba, resultó ser el maldito VMWare player: fue configurarlo para que no se iniciara con Windows, reiniciar ¡y mano de santo!.

En cambio, ahora en otro ordenador, donde alguna vez he programado la misma placa Arduino, ahora es imposible.

También en este ordenador está instalado VMWare player, pero ya me he asegurado de que no inicie con Windows ... He desinstalado controladores de otras cosas que hay conectadas al ordenador, y nada: no hay manera.

Por eso os decía que si tenéis este problema, os puede costar mucho solucionarlo. Pero nada que no le haya pasado ya a medio mundo, que programa placas Arduino.

Por cierto: es aconsejable que no haya nada conectado en ningún pin de Arduino, sobre todo los pines marcados como RX y TX que son los del puerto serie, a la hora de cargar un programa.

        Conclusiones:

Como ya había previsto al empezar el post, la entrada esta vez se ha hecho bastante larga,y encima escrita. Pero como decía al principio: he preferido ir despacio y explicando algunos conceptos, que podría haberme saltado; pero quería que esto le sirviera al máximo de personas posible.

El mundo Arduino no es nada sencillo, y el no ver le añade un plus de dificultad en muchas cosas. Pero con paciencia, si realmente os llama la atención la programación y la electrónica, podréis hacer cualquier cosa que se os ocurra. Eso sí, muchas veces sí o sí, con ayuda. pero si os sabéis apañar, con la menos posible que es de lo que se trata.

Desde luego, si optáis por usar IDE Arduino, os resultará mucho más sencillo escribir un squetch, compilarlo y cargarlo en la placa. Pero os acabaréis hartando, porque la mitad lo haréis a ciegas.
En cambio, aunque podéis usar otros entornos de programación, hacerlo con Arduino CMD builder os garantizará que todo el proceso sea totalmente accesible, y usando software multiplataforma y bastante menos pesado que algunos IDES con plugins integrados.

Aunque hay que escribir varios comandos, y todos bastante largos, Arduino CMD builder en realidad, lo hace un poco más sencillo.
En cualquier caso, el proceso podría automatizarse, por ejemplo con un makefile en Linux, o con un BATCH en Windows.

Las herramientas que hemos visto para construir un programa para Arduino, como ya se ha dicho también sirven para otros programadores y microcontroladores. Además, avrdude, es también una herramienta muy potente, que permite hacer muchas otras cosas más allá de cargar un programa en una placa Arduino.
Todas las posibilidades que ofrecen las distintas herramientas que hemos visto, podéis encontrarlas en internet, o usando los comandos de ayuda de cada una de ellas, que normalmente serán algo como: --help, help, -help, /help, /? ETC.
Incluso, en ocasiones escribir solo el nombre del ejecutable del programa ya devuelve información sobre este y su uso.

Si preferís tener la ayuda de cualquiera de estas herramientas en un archivo de texto en vez de en la ventana de la consola, podéis redirigir la salida de la consola a un archivo.

En Windows, esto podéis hacerlo con algo como esto:

avrdude --help > c:\Ayuda_avrdude.txt

Por supuesto, siempre estando en el directorio del ejecutable que váis a invocar, y usando el parámetro correcto para que el programa mueste la ayuda.

Si todo ha ido bien, en la consola no aparecerá nada. Pero en C:\ tendréis un archivo llamado "Ayuda_avrdude.txt" donde tendréis todo el texto que haya devuelto avrdude con sus instrucciones de uso.

Esto mismo podéis hacerlo con cualquier herramienta, ya que la redirección es un comando de la consola, no de los programas que hemos usado.

Espero que os haya gustado esta entrada.
¡Os espero en un próximo post!

Descarga Arduino CMD builder.

*Si te pide una contraseña a la hora de extraer los archivos, escribe tifloinformatico2018

Descárgalo aquí