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í

miércoles, 28 de febrero de 2018

Desoldar componentes electrónicos 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.


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

En esta ocasión os traigo un audio sobre electrónica, ya que a partir de ahora en el blog, además de entradas relacionadas con la informática, también las habrá relacionadas con la electrónica y la robótica, con el mismo propósito: demostrar que es posible trabajar estos campos de la tecnología sin ver, aunque hay cosas que pueden ser un tanto complicadas; pero que con paciencia y algo de técnica se pueden hacer.

El audio que he hecho en esta ocasión, no es tanto para iniciarse en la electrónica, sino para mostrar algo de técnica en una de las cosas más difíciles creo, en la electrónica para una persona ciega: el soldador.
El audio es largo, pero quería dejar claras algunas cosas importantes, y aunque lo que muestro en él podría enseñarse en poco tiempo, he querido explicar algo de teoría que os servirá para futuras entradas relacionadas con la soldadura.

En próximas entradas ya sí, iremos poco a poco y veremos algo de teoría primero, y más adelante veremos algo de práctica, igual que hacemos con las entradas de informática.

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

Pulsa aquí para oír el audio "Desoldar componentes electrónicos de forma accesible"

domingo, 3 de diciembre de 2017

Como usar un multímetro 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 os traigo un audio sobre la accesibilidad de una herramienta imprescindible para la electrónica (que podemos trabajar también las personas ciegas, por hobbye o por trabajo). E importante en la informática para hacer reparaciones de hardware avanzadas: el multímetro.

Como sabréis el mltímetro integra varias funciones: voltímetro, amperímetro, ómetro ... Y  cuanto más profesionales sean, más funciones tienen.

El multímetro es una herramienta que no es accesible. De hecho, ni siquiera lo es el que os enseño en el audio, pero podemos utilizarlo de forma accesible gracias a una característica avanzada, que permite conectarlo al ordenador y ver en él las mediciones que hacemos.

Así, como principalmente el uso que se le da a un multímetro es el de hacer mediciones en circuitos eléctricos, y dado que todas las mediciones pueden verse en el ordenador (en el caso del multímetro que os enseño el software es totalmente accesible) podemos decir que los multímetros con capacidad de conectarse al ordenador y enviarle los datos de las mediciones que hacemos (data loggers) son accesibles; aunque sólo para usarlos para hacer mediciones. No para configurarlo, ya que el ordenador no actúa literalmente como un lector de pantalla del multímetro.

Con este audio pretendo aportar algo de información sobre la accesibilidad de esta herramienta en español, ya que en español al menos, estoy casi seguro de que no existe nada (yo al menos no la he encontrado), salvo en listas de correo como tiflotec, programación accesible o tiflotronica, donde se ha hablado sobre la accesibilidad de los multímetros y gracias a miembros que ya usaban multímetros conectados al ordenador, he conseguido saber mejor como funcionan, y encontrar uno que me ha funcionado.

El audio es largo. Pero he querido aprovechar y tras explicaros un poco sobre los multímetros y su accesibilidad, explicaros como es físicamente el multímetro que utilizo en el audio; un Peaktech P 2025, como si fuese un "unpacking", para que sepáis como es físicamente, y qué es cada terminal, cada botón; donde se conecta el USB, como poner las pilas ETC, para que si lo compráis podáis empezar a usarlo por vosotros mismos.
También, antes de enseñaros como se leen las mediciones en el ordenador, os enseño el contenido del disco del software que incluye, para que sepáis instalarlo correctamente. Hay un pequeño lapsus: digo que quizás no encontréis la versión de vuestro sistema operativo ... Me lié, porque como digo en el audio, antes del modelo que os enseño en éste, compré otro multímetro que no me funcionó con el ordenador; y es en este, donde venía el software clasificado por versiones de Windows, y no estaban todas.

En cualquier caso no importa, porque como veréis, os enseño a descargar otro software del fabricante, que se ve en el audio que es compatible con cualquier Windows, de XP en adelante, de 32 o de 64 bits.

También os enseño a instalar el controlador del multímetro y os explico como funciona realmente, ya que no funciona mediante conexión USB a nivel de software, sino mediante un puerto COM virtual, que crea el controlador al instalarlo. Y os enseño a identificar correctamente el puerto en el que tenéis conectado el multímetro.

*En el audio os enseño a instalar el software de la interfaz para gestionar las mediciones que viene en el disco que incluye el multímetro, pero no es necesario ya que luego os enseño también a descargar como decía antes, otro programa del fabricante, que como veréis en el audio es mejor que el que viene en el disco del software, en cuanto a accesibilidad (aunque ambos son accesibles) y en cuanto a funcionalidad.

Y una vez explicado como instalarlo todo y tener el ordenador a punto para usar el multímetro, os enseño como funciona, y como leer mediciones con el software del ordenador, así como a usar un par de funciones: medición de voltaje y continuidad, así como a ver en el ordenador qué función está seleccionada en el switcher del multímetro, para evitar tener que memorizar las posiciones de todas las funciones y apagar y encender el multímetro si nos despistamos y no sabemos en qué función lo tenemos.

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

Pulsa aquí para escuchar el audio

lunes, 18 de septiembre de 2017

Instalar y desinstalar McAfee 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 concretos. Aunque pueden servir para otros componentes, no se garantiza que sean válidas para componentes distintos de los mencionados en este artículo.


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

En esta ocasión haré un paréntesis en el hardware, para enseñaros a gestionar parcialmente McAfee de forma accesible; ese antivirus tan odioso por su nula accesibilidad, y que a mi personalmente no me gusta nada, al margen de la falta de accesibilidad que presenta.

Pero he querido enseñaros al menos lo básico: a instalar y sobre todo, desinstalarlo, ya que lo primero no es fácil con lector de pantalla, y lo segundo es imposible sin tirar constantemente de un buen OCR.
Y precisamente eso es lo que veremos en el audio que os traigo en esta entrada: como instalar y desinstalar McAfee en Windows 10 con su OCR integrado y la última versión de NVDA (2017.3)


Por cierto, hay un pequeño error en el audio: digo que hay que pulsar flecha derecha para ir al principio del regedit... ¡Pero es flecha izquierda!.

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





Pulsa aquí para oír el audio

sábado, 4 de marzo de 2017

Testear el sistema eléctrico de un portátil

******¡¡¡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 hardware concretos. Aunque pueden servir para otros componentes, no se garantiza que sean válidas para componentes distintos de los mencionados en este artículo.


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

Hoy os traigo un nuevo audiotutorial, esta vez dedicado al hardware, aunque no es para principiantes, pues no explico en profundidad conceptos de hardware, aunque sí algo; más bien, pretendo enseñaros como es posible manipular hardware, incluso componentes tan delicados como una placa base, y un pequeño truco para encenderla sin un botón para ello.

En el audio digo que no va a ser demasiado largo... Pero finalmente la cosa se alarga, a casi una hora.
Pero ya que estaba, he preferido enseñaros alguna cosilla extra, y he intentado explicar lo mejor posible lo que hacía y como lo hacía, para que quien se anime y tenga experiencia en hardware pueda probarlo, y los que no, que vayáis aprendiendo teoría sobre el hardware.
Así, que siguiendo los pasos tal como explico, podréis testear sin problema el sistema eléctrico de un PC; en concreto de un portátil, que es más complicado que un ordenador de sobremesa, ya que hay que desmontar el equipo casi entero.

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


Pulsa aquí para oír el audiotutorial

domingo, 18 de diciembre de 2016

Implementación accesible de Windows XP

 ******¡¡¡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 XP Home edition. Aunque pueden servir para otras versiones, no se garantiza que sean válidas para versiones distintas de Windows.


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

En esta entrada veremos algo que más bien llega tarde, por tratarse de un sistema operativo ya abandonado por Microsoft. Pero aun así habrá todavía, quien por algún motivo necesite trabajar con Windows XP; tanto en lo particular, como en lo profesional.

Por ello, en esta entrada voy a publicar un paquete de software que os permitirá implementar Windows XP de una forma accesible, pero sobre todo, muy sencilla.

*Para que no dejéis de leer el post entero, el link va al final ;)

Como sabréis, XP es un sistema más duro en cuanto a la accesibilidad de su implementación, que sus predecesores.
Aún así, con los conocimientos necesarios, es posible hacer cosas muy interesantes con un disco de instalación de XP: instalaciones desatendidas, integrar controladores, añadir software... En realidad, casi nada que no se pueda hacer con un medio de instalación de Windows Vista, 7, 8 ó 10 (aunque con más limitaciones, por supuesto).

además, XP no cuenta con una infraestructura software desarrollada por la propia Microsoft, como la que existe para versiones posteriores (Windows AIK ó Windows ADK).

Estas plataformas de implementación son todo un mundo, y no son objeto de esta entrada. Pero sí hay que decir, que es una especie de conjunto de software, donde se unifican todas las herramientas necesarias para hacer la infinidad de filigranas que puede hacerse con un medio de instalación de Windows Vista en adelante.

Entre todas esas filigranas, desde Windows Vista es posible usar un entorno reducido de Windows, llamado Windows PE, que es donde corre el programa de instalación del mismo: es como si ejecutásemos Windows normalmente, y lanzásemos el programa de instalación (cosa que puede hacerse sin problema). Pero Windows PE, además de ser un "Windows reducido", se ejecuta en la memoria RAM del equipo, en vez de en el disco duro. esto es imprescindible, para poder gestionar correctamente los discos del ordenador.

Aunque el programa de instalación de Windows XP corre también bajo un entorno reducido, este, ni de lejos es tan flexible como Windows PE. Y aunque es posible modificarlo, con herramientas de terceros y crear un Live CD con montones de aplicaciones, e incluso con accesibilidad, lo cierto es que (al menos hasta donde yo sé) no existe ningún entorno reducido de XP accesible, así como sí existen modificaciones accesibles de Windows PE.

Todo esto bastante resumido, viene a decir, que las posibilidades de que la implementación de versiones de Windows Vista en adelante sea accesible, son mucho mayores que en versiones inferiores. Ya que desde la llegada de Windows PE, es posible crear un entorno Live CD con herramientas de accesibilidad, y hacer que la instalación de Windows si no total, sea parcialmente accesible (dependiendo de si se trata de Windows 7 o versiones superiores).

Pero Windows XP es distinto: la única forma de instalar esta versión de Windows de forma accesible, es creando una instalación desatendida, con las limitaciones que ello supone: no es posible gestionar discos y/o particiones en una instalación desatendida de XP. Tan sólo tenemos dos opciones: o el programa de instalación se detiene en la pantalla de gestión de discos del programa de instalación de XP, o éste formatea todo el disco duro, crea una partición con el tamaño máximo del disco, e instala Windows en ella (no queda muy claro, en caso de haber más de un disco duro, cual considera el programa de instalación de XP que debe formatear).

Como supondréis, esta limitación en el control de la gestión de discos es algo importante, pues podrían perderse datos de interés, si no se tiene mucho cuidado; y si estamos ante un equipo con una configuración de disco compleja, donde por ejemplo hayan dos o más particiones, si queremos que tras la instalación de Windows XP todo quede igual, nos va a suponer bastante trabajo.

Pero los problemas con XP y su implementación van más allá, y por eso me decidí hace ya un tiempo, a buscar una solución realmente práctica:

Como vimos en una de las primeras entradas del blog, para instalar un sistema operativo, normalmente hay que iniciar el equipo desde el CD o el USB. Esto como ya expliqué en un audiotutorial, depende de la BIOS; y la BIOS en ningún caso es accesible, y por tanto, configurar el órden de arranque sin ver es imposible.

La solución que di a este problema consistía en volcar el contenido de un Live CD accesible, o un "Windows accesible" en el disco duro del ordenador. De esta forma (y siempre que el ordenador esté configurado para trabajar en modo BIOS heredado, porque no existe ningún live CD accesible, ni "Windows accesible" preparado para trabajar en modo UEFI) conseguimos arrancar el equipo con el entorno accesible que queramos, con independencia de la configuración de arranque de la BIOS.

Pero esto no funcionaría con XP: si intentamos volcar el contenido de un medio de instalación de XP en el disco duro del ordenador e iniciar el equipo, y que se empiece a instalar Windows XP normalmente... ¡No funciona!.

Ciertamente, no he conseguido entender realmente el motivo: La explicación pasa porque el boot de XP es totalmente distinto al de Windows Vista, 7, 8 y 10. Pero aún no he conseguido entender, que un disco de instalación de XP pueda bootear desde un CD, pero no desde un disco duro (si el contenido es el mismo, y el CD de instalación también tiene un boot; ¡porque lo tiene!)

Pero la cuestión es que no hace falta que lo probéis, porque ya lo he hecho yo ¡y no funciona!: aparece un error de falta de boot...

Intentando buscar una solución en internet, se puede ver que ya hay quien ha intentado hacer esto mismo y con el mismo resultado.

La solución que proponen algunos en algunos foros, es cargar en el disco duro el contenido de un disquete de arranque de Windows 98, o de MS-DOS.
¿Curioso verdad, que eso sí pueda arrancar, y un medio de instalación de XP no?.

Pero hacer esto supone muchos problemas sobre todo de accesibilidad, porque requeriría interactuar demasiado con el ordenador; hacer demasiadas cosas a ciegas.

Además, no sé por que me da, que los que han propuesto eso (que incluye por supuesto, cargar también el contenido de un medio de instalación de XP, en un directorio del disco duro) no han pensado, que eso nunca puede funcionar para instalar XP desde el disco duro, ya que si se formatea el disco ... ¡Se pierde también el medio de instalación! ¿cómo pensarían instalar el sistema sin los archivos de instalación? ;)

Así pues, como esa solución no son más que problemas, he optado por algo mucho más práctico, sencillo y por supuesto, accesible.

Lo que he hecho, ha sido hacer una instalación limpia de XP (en este caso home edition) en un entorno real. Y sin configurar nada, ni instalar o desinstalar nada, la he preparado para que esa imagen de Windows pueda ser portada a cualquier ordenador.

No penséis que es un "Windows XP portable": no, no lo es.
Es un Windows para entendernos, medio instalado. Y para los que entiendan más de los tecnicismos de la implementación de Windows, "generalizado".

Así, sólo he tenido que capturar la imagen de este Windows XP, para poder compartirla.

Podría haberlo hecho de una forma más profesional, y hacer una imagen de Windows realmente, como suele hacerse desde que existe Windows AIK, en un archivo WIM.
Pero ello hubiera supuesto que aplicar la imagen hubiese sido algo más complicado.
Así, he optado por compartir la imagen en un archivo comprimido en .RAR, que es lo más sencillo, y todo el mundo sabrá hacer, ya que únicamente hay que descomprimir el .RAr en una partición.

Solo eso, y poner una clave de producto, que yo no proporciono en la imagen de Windows.
Además, de esta forma podréis hacer algo que no es posible con un CD con un archivo de respuestas desatendidas: Configurar totalmente la instalación de Windows, ya que una vez descomprimida la imagen, podréis acceder a un archivo de configuración, donde se almacena la configuración de cada opción del programa de instalación de Windows XP.

En un CD de XP con un archivo de respuestas, no es posible modificar la configuración de la instalación, a menos que: o creéis otro CD, o este sea regrabable, y grabéis de nuevo todo el sistema.

Existe la posibilidad de que el archivo de respuestas esté en un disquet por ejemplo, y así poder modificarlo antes de la instalación. Pero por experiencia propia, puedo deciros que es una tortura hacer que el programa de instalación de XP lo reconozca correctamente.

Así, con el paquete de XP que os comparto en esta entrada, podréis configurar cosas como la clave de producto, nombre de usuario, nombre del equipo, contraseña del usuario... Y muchas otras cosas; aunque en esta entrada no voy a explicaros todos los parámetros de configuración del archivo de respuestas.

Lo primero que deberéis hacer, será preparar el disco duro donde implementaréis XP: Podéis bien, iniciar el equipo con un live CD accesible por ejemplo, y desde él hacer todo el proceso. O podéis quitar el disco duro del ordenador donde debe instalarse XP (si por ejemplo no inicia desde el CD) y conectarlo a un ordenador de apoyo, que tenga instalada cualquier versión de Windows (no será necesario en este caso, iniciar el ordenador en modo live CD).

Antes de aplicar el paquete de XP, debéis preparar el disco duro: En esta entrada resumiré bastante este punto, por ser algo largo de explicar.

Básicamente consiste, en eliminar las particiones que no sirvan (yo soy partidario de eliminarlas todas, y crear las que se necesiten).

Así pues, nos valdremos de Disk part para ello:

Pulsaremos Windows +r y escribiremos "diskpart" sin las comillas.

Ahora, lo primero es listar los discos duros del ordenador (teniendo ya conectado el disco donde aplicaremos XP, si trabajamos en un equipo de apoyo.

Para ello hay que escribir "list disk" sin las comillas.

A continuación, aparecerá un listado con los discos duros del equipo. Aquí es muy importante identificar correctamente el disco donde debemos aplicar XP, porque de lo contrario podríamos eliminar el contenido de otro disco.

Una pista: Si aparecen más de un disco, y no tenemos claro cual es el que necesitamos gestionar, podemos listar los volúmenes con "list volume", sin las comillas.

Ahora, nos aparecerá un listado de todos los volúmenes del equipo.

Lo bueno de esto es, que nos aparece entre otras cosas, la letra de la unidad, con lo que es desde luego, muchísimo más sencillo identificar la unidad que buscamos.

Para saber la letra de la unidad del disco que hemos conectado por ejemplo, en un ordenador de apoyo, podemos verla en Equipo, ó Mi PC.

El siguiente paso será seleccionar el disco/volumen donde vamos a aplicar XP. Para ello, escribiremos: "Select disck #", o "select volume X" sin las comillas, donde "#" en la selección de disco es el número del disco que nos muestra diskpart, y "X" en la selección de volúmen, es la letra del volumen, que nos muestra diskpart.

Ahora podemos listar las particiones del volumen; así de paso, nos aseguramos de haber elegido correctamente la unidad.

Para ello escribiremos "List partition" sin las comillas.

Diskpart nos muestra un listado de particiones, que iremos eliminando con el comando "Delete partition #" sin las comillas, donde "#" es el número de cada partición. Este comando debemos repetirlo una vez por cada partición que queramos eliminar.

Por ejemplo, si hay dos particiones en el disco, deberemos escribir:

Delete partition 1
Delete partition 2

Es posible, que algunas particiones no podáis eliminarlas, y que Diskpart os diga que para ello uséis el parámetro Override. Esto pasa normalmente, con particiones de sistema y similares. En este caso, os aconsejo que no os compliquéis la vida con esto, y hagáis un clean directamente, con lo que eliminaréis todo el contenido del disco duro, dejándolo como de fábrica (lo que se conoce como "estado cero")

Si es posible, soy partidario de antes eliminar las particiones manualmente. Pero si hacéis un clean directamente, tampoco pasa nada.

Para ello sólo hay que escribir "clean" sin las comillas. Y si queréis hacer un estado cero más a fondo por así decirlo, tan sólo debéis escribir "clean all" sin las comillas.
*"clean all" puede tardar varios minutos en terminar el proceso.

Una vez limpiado el disco, sólo queda preparar el disco duro para aplicar XP.

En este punto vamos a crear las particiones que deban haber en el disco duro: podríamos crear sólo la de XP, y una vez instalado el sistema, crear el resto, si fuese necesario. Pero creo que es más sencillo y ahorra trabajo, hacerlo en este momento.

En cualquier caso, lo importante es la partición donde se aplicará XP, y es la que vamos a ver como crear.

La partición de XP, igual que la de cualquier versión de Windows, debe ser una partición de sistema, y booteable.

Para ello, en Diskpart escribiremos la siguiente lista de comandos, todos separados unos de otros (cada uno en una línea independiente) y sin comillas:

"create partition primary"
"select partition 1"
"active"
"format fs=ntfs quick"
"assign"

Con esto, lo que haremos es crear una única partición con todo el tamaño disponible del disco duro, de sistema y booteable; la formatearemos, le diremos que la partición debe ser NTFS y le asignaremos una letra a la unidad.

Si queremos configurar el tamaño de la partición (porque queremos crear otras particiones en el mismo disco por ejemplo) lo haremos en el primer comando, con algo como esto (sin las comillas):

"create partition primary size=200000"

En este caso, la partición de sistema sería de 200 GB; por lo que quedaría el resto del tamaño del disco duro, para crear las particiones que queramos.

Una vez terminada la configuración del disco duro, sólo queda volcar el paquete de XP en este.

Si habéis creado más de una partición, es importante que lo hagáis en la partición de sistema; y si habéis creado más de una partición de sistema, que sea en la que habéis marcado como "Activa", que sólo puede haber una con este atributo, y que será desde la que arranque el ordenador.

Para volcar el contenido del paquete de XP en la partición de sistema, podéis simplemente descomprimir el .RAR en la partición. O si lo preferís, descomprimirlo en cualquier otra unidad, y copiar todos los archivos y carpetas tal como están, en la partición de sistema del disco duro del equipo donde se aplicará XP.

*Si descomprimís directamente el .RAR en la partición de sistema, aseguraos de que no se cree una carpeta donde esté todo el contenido del paquete, en la partición, porque obtendríais un error de falta de boot, al arrancar el equipo.
Deben quedar todos los archivos y carpetas tal como están en el paquete de XP, en la raíz de la unidad donde volquéis el paquete.

*Es aconsejable que configuréis el explorador de Windows para que muestre los archivos ocultos y de sistema; e incluso, para que muestre las extensiones de archivo conocidas, para que no os dejéis ningún archivo ó carpeta sin copiar en la partición de sistema.

Una vez volcado correctamente el paquete de XP en la partición de sistema, sólo queda introducir la clave de producto en el archivo de configuración de la instalación.

para ello, asumiremos que la letra de la partición de sistema es la c:\ (pero puede variar en cada caso).

deberéis ir a la siguiente ruta:

C:\$WIN_NT$.~BT\winnt.sif

El archivo que se abre, es de tipo "configuración". En concreto, en formato .INI.

*No modifiquéis nada que no sepáis realmente qué es, o la instalación del sistema podría fallar.

Para introducir la clave de producto, que debe ser una clave de producto válida para Windows XP Home edition, debéis ir a la línea 40: ProductKey="", donde deberéis introducir una clave de producto válida entre las comillas ("").

Esto mismo debeis hacerlo a continuación, en la línea 44: productid="", donde igualmente, deberéis introducir la clave de producto (la misma que pusísteis en la línea 40) entre las comillas.

Con esto sería suficiente, ya que todo lo demás está correctamente configurado: El nombre del usuario y del equipo, como se puede ver, es el mismo: "Particular". Podéis modificarlos, en las líneas 41, FullName="Particular" (nombre del usuario), y 43: ComputerName=Particular (nombre del equipo).

Tal como está configurado, Windows XP se instalará con un usuario sin contraseña. Para poner una contraseña de inicio de sesión al usuario que se cree durante la instalación, debéis modificar la línea 32: AdminPassword=*, cambiando el asterisco (*) por la contraseña que queráis.

También podéis configurar si la contraseña se encriptará o no, en la siguiente línea; la 33: EncryptedAdminPassword=no, cambiando "no" por "yes", sin las comillas.

Además, podéis configurar el nombre de la organización durante la instalación si queréis. Por defecto, está configurado para que se ponga el nombre por defecto. Pero podéis personalizarlo, en la línea 42: OrgName=*, cambiando el asterisco (*) por el nombre que queráis.

El resto de la configuración si queréis, tendréis que averiguar como modificarla. Los parámetros que he explicado, son en principio los más usuales.

Tanto estos, como el resto de la configuración, puede modificarse después, una vez se haya instalado el sistema.

Una vez terminado de configurar la instalación, debéis cerrar el archivo Winnt.sif aplicando los cambios.

Si todo ha ido como debiera, sólo queda iniciar el ordenador donde queréis instalar este XP, con el disco duro donde habéis aplicado el paquete de XP conectado.

Al encender el equipo, deberéis esperar porque lo que aparecerá será el programa de instalación, indicando que está realizando algunas operaciones.

Como en realidad el sistema ya está instalado, ni se verá la pantalla de gestión de discos, ni la primera fase de la instalación (copia de archivos). La instalación empezará a partir de la configuración del sistema.

en condiciones normales, tendríamos que interactuar con el programa de instalación, para configurar el usuario, clave de producto ETC. Pero al tener el paquete de XP un archivo de respuestas integrado, todo el proceso se hará de forma automática, por lo que únicamente hay que esperar a oír el sonido de inicio de sesión de XP, lo que nos indicará que la instalación del sistema ha terminado. Esto puede tardar entre quince y veinte minutos, aunque el tiempo exacto dependerá de cada ordenador.

*El sonido de inicio de sesión, sólo se oirá en casos muy concretos, ya que XP no tiene controladores nativos de sonido para la mayoría del hardware actual, o de equipos de algunos años atrás.
Para garantizar que funcione el sonido tras la instalación de Windows XP, lo mejor es utilizar una tarjeta de sonido USB, que conectada al equipo, será automáticamente reconocida tras la instalación, y podremos oír el sonido del sistema a través de esta.

Una vez se oiga el sonido de inicio de sesión, estaréis en el escritorio (si habéis configurado una contraseña de usuario es posible que en este punto Windows os la sonicite).

En este punto, Windows no será accesible, al no tener preinstalada ninguna herramienta de apoyo, pero podéis usar las nativas de XP: Narrador por ejemplo, que podéis ejecutar pulsando "Windows+r", escribiendo "narrator" sin las comillas y pulsando Enter.
De esta forma, se iniciará el Narrador y con paciencia, podréis ejecutar la herramienta de apoyo que queráis.

El paquete de implementación de XP podéis descargarlo del siguiente enlace.

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

Pulsa aquí para descargarte el paquete de Windows XP Home edition SP3

domingo, 11 de diciembre de 2016

Comprobar modo de configuración de la BIOS: UEFI o BIOS heredado

     ******¡¡¡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.


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

En esta ocasión, publicaré una pequeña entrada, a modo de paréntesis ya que tenía pensado publicar una segunda entrada relacionada con la eliminación de contraseñas de usuarios en Windows; en concreto, de cuentas vinculadas a una cuenta de Microsoft.
Pero como esta entrada será un tanto larga y elaborada, he preferido publicar antes esto, ya que creo que a muchos os servirá a la hora de instalar Windows (otra lucha constante con la accesibilidad).

Se trata de una pequeña herramienta que me he programado para el día a día de mi trabajo: Como sabéis, desde hace ya un tiempo, los ordenadores funcionan con el maldito UEFI (que supongo no hace falta explicar con demasiado detalle qué es).

También sabréis que si un ordenador trabaja con la BIOS en modo UEFI, si queréis instalar un sistema operativo, estáis perdidos porque la accesibilidad conseguida tras muchos años y trabajo, por algunas personas que han conseguido integrar lectores de pantalla u otras herramientas de apollo en medios de instalación de Windows, como por arte de magia es... nula, por más vueltas que le déis (aunque en realidad podrían modificarse medios de instalación de Windows para devolverles la accesibilidad)

Uno de los principales problemas a los que nos enfrentamos a la hora de instalar Windows sin ver es, saber si la BIOS del equipo está configurada en modo UEFI o BIOS heredado.

No sirve de mucho saberlo, porque cambiar la configuración es absolutamente imposible, sin ver, si no nos ayuda alguien.

Pero aunque sea por no perder el tiempo, me he programado una pequeña herramienta que siempre y cuando pueda entrar en Windows, si este está instalado en el equipo y no tiene errores de inicio, me diga en que modo está configurada la BIOS.

El programa es la cosa más simple del mundo: Sólo hay que ejecutarlo (está compilado para 32 bits, para que funcione tanto en Windows de 32 como de 64 bits) y tras un mensaje de bienvenida, nos dirá el tipo de configuración de la BIOS: "UEFI" o "BIOS heredado" ¡así de simple!.

A continuación os dejo el enlace de la aplicación, por si queréis usarla. Esta es una de esas herramientas que nos permite hacer algo relacionado con la BIOS, desde Windows: o sea, de forma accesible; por lo que creo, merece la pena tenerla por si acaso.

¡A disfrutarlo!

Pulsa aquí para descargar el programa