Archivo de la categoría: Linux

Programación de microcontroladores de la familia AVR en GNU/Linux (Debian/Ubuntu) Parte II

Nivel: Básico

¿Qué tengo que saber para este post?

—————————————

Como les prometí, en esta segunda parte les mostraré cómo hacer un primer programa. Voy a arrancar con el que tiene menos vueltas.

Programando con Code::Blocks

La interfaz

Bueno, teniendo todo instalado, lo único que necesitamos hacer es ejecutar el Code::Blocks, sí es la primera vez que lo utilizamos, aparecerá una venta notificando los compiladores que detectó automaticamente y el AVR GCC debe estar en esa lista como detectado.

Compiladores detectados

Compiladores detectados

Luego entramos a la pantalla principal, donde tendremos nuestra área de administración de proyectos a la izquierda, el editor a la derecha (ocupando la mayor parte del espacio), abajo el área de mensajes y las barras de tareas arriba (que son muchas, si lo pueden notar…).

Interfaz Code::Blocks

Interfaz Code::Blocks

Creando un proyecto nuevo

Para crear un proyecto nuevo, debemos hacer click en la carpeta azul que tenemos al centro de la pantalla y dice “Create a new project” (elemental, mi querdio Watson). Y en la ventana emergente debemos seleccionar “AVR project” y hacer clic en “Go”.

AVR Project

AVR Project

Ahora nos saltará la ventana emergente del wizard para hacer un proyecto, la primer ventana es siempre la que explica que nos va a guiar para generar un nuevo proyecto, yo siempre la tildo para que no aparezca la próxima vez e ir directamente a la selección de una carpeta para nuestro proyecto. Cuando decidamos un path, recuerden que por cada proyecto se genera una carpeta, es decir, conviene tener una carpeta llamada “~/proyectos” o “~/proyectos avr” y utilizar siempre ese mismo path. Porque cuando pongamos un nombre al proyecto, por ejemplo “ejemplo1” se creará una carpeta llamada “~/proyecto/ejemplo1/” donde estarán todos los archivos relacionados a nuestro proyecto. Si no entendieron, vean la imagen, que dice más que mil palabras:

Skip

Skip

ejemplo1

ejemplo1

Algo que es importante es que el nombre de su proyecto no puede contener espacios, porque al momento de compilar no funciona, así que si tienen ganas de poner espacios utilicen el guión bajo. Y recuerden de poner el path completo, yo puse “~/”, pero deberían poner “/home/usuario/”.

La siguiente ventana nos pregunta los “targets” a compilar. Yo nunca use, y nunca encontré la necesidad de compilar, la configuración de “Debug” y sólo tildo la de “Release”, pero si la quieren dejar, no hay problema. Pero tengan en cuenta que la que deben grabar en el micro es la versión “Release”, sino las cosas no van a funcionar del todo bien (sobre todo los delays). Y por último, la selección del micro que van a utilizar, el cristal y otras opciones. En general, salvo que ustedes deseen hacer algo especifico, pueden solamente seleccionar el micro y velocidad del oscilador. Yo voy a elegir el ATmega328P y como lo voy a usar con el oscilador interno que viene de fábrica fijado en 1Mhz, el valor de frecuencia de oscilador que voy a poner es “1000000UL”. Y para finalizar, hacer clic en el botón de “Finish”.

Target select

Target select

Chip select

Chip select

Escribiendo el programa

El Code::Blocks nos incluye dos archivos a nuestro proyecto, el “main.c” y el fuse.c. Ambos son templates, que tienen lo básico de cualquier programa, el header (cabecera necesaria) que agrega los registros necesarios para utilizar el micro seleccionado. El “fuse.c” tiene la configuración por defecto de los fuses del micro que estemos utilizando, para mi ejemplo, los voy a dejar como vienen. En caso de que este archivo no fuera generado automáticamente, les recomiendo que lo creen. Van a “File->New->File…” y eligen archivo “C/C++ source” y siguen los pasos para crear el archivo “fuse.c”, que por defecto contiene esto:

#include <avr/io.h>

FUSES = {
    .low = LFUSE_DEFAULT,
    .high = HFUSE_DEFAULT,
    .extended = EFUSE_DEFAULT
};

Como pueden ver, tiene todos los parámetros de fábrica. Oscilador interno de 8Mhz con un divisor por 8 (en el caso del ATmega328p, es decir 1Mhz de frecuencia de CPU (1000000UL). Esto es un define, que se utiliza, sobre todo, para la librería que nos provee los delays (“util/delay.h”). Si quieren saber sobre los defines para modificar los fuses, busquen acá, está en inglés pero bueno, tampoco es tan imposible de entender.

El template del “main.c” es muy básico:

/*
 */

#include <avr/io.h>

int main(void)
{

    // Insert code

    while(1)
    ;

    return 0;
}

Noten que, a pesar de que no hay un sistema operativo (supongo que es por alguna cuestión del gcc), la función main retorna un valor. Esto no tiene ningún sentido en la programación de microcontroladores, pero si no lo ponemos el gcc nos dará un warning. Y tampoco influye en mucho. Recuerden que todo programa con micros debe tener un loop infinito, para frenar al PC (o IP), y el dispositivo no tenga un comportamiento errático. Escribamos un código simple donde hagamos titilar un led, es decir cambiar el estado de algún pin de un puerto. Para ello, debemos conocer un poco de la familia AVR. En algún momento haré algún post sobre eso, pero ahora voy a asumir que tienen algún conocimiento básico y simplemente escribir el código. Noten que a la izquierda tienen  los archivos que pertenecen a su proyecto.

/*
 * Ejemplo1 AVR en GNU/Linux
 */

#include <avr/io.h>
#include <util/delay.h>

/*
    Inicialización del dispositivo:
*/
void InitDevice(void)
{
    DDRB=0x01;  // Declaro el PIN0 del PORTB como Salida
}

int main(void)
{
    // Inicializo el dispositivo
    InitDevice();

    // Bucle infinito
    while(1)
    {
        PORTB^=0x01;    // Alterno el valor del PIN0 del PORTB con una XOR
        _delay_ms(500); // Hago una demora de medio segundo
    }

    return 0;
}

Una vez que tenemos nuestro código, lo que resta es compilarlo, que lo haremos con el icono de la tuerca dorada que está en la barra de “compilación” y dice “Build”:

Compilando

Compilando

Si les salta el siguiente error de “/usr/include/features.h 323 fatal error: bits/predefs.h: No existe el fichero o el directorio”, no se asusten, es que hubo un pequeño cambio en Debian y es fácil de solucionar. Tienen que ir a “Settings->Compiler…”, allí seleccionar “GNU AVR GCC Compiler” e ir a la solapa que dice “Search directories” y más abajo a la solapa “Compiler” y borrar el ítem “/usr/include” haciendo clic y luego en el botón “Delete”. Lugo ir a la solapa que está al lado, la que dice “Linker” y borrar de la misma manera la que dice “/usr/lib” y confirmen las dos veces:

Corregir editando opciones del compilador

Corregir editando opciones del compilador

Borrar /usr/include

Borrar /usr/include

Borrar /usr/lib

Borrar /usr/lib

Clicqueamos Le damos clic al botón “Aceptar” más abajo y listo. Intentamos compilar de nuevo y si tuvimos éxito, debería verse algo así:

Éxito al compilar =)

Éxito al compilar =)

Simulación y debugging ( no hay… =( )

Ahora, debemos abarcar una pequeña cuestión, que desde mi punto de vista, es crucial. No encontré, ni encuentro aún, una herramienta que funcione bien y sea amigable para simular los microcontroladores de la familia AVR que sea GPL y/o gratuita. Así que, debemos volver a la edad de piedra, donde teníamos que grabar el firmware y verificar si todo funciona según lo planeado y crear diferentes estrategias, como prender un led cuando pasó por cierto punto del programa. Para eso diseñé una placa de desarrollo, pero sólo para micros de 28 pines de la familia AVR. Claro que pueden probarlo sobre un protoboard también, no hay que hacer tanto escándalo para prender un led.

Grabando el firmware al microcontrolador

Llego el momento de la verdad, como el Code::Blocks, a diferencia del plug-in del eclipse, no tiene un botón que invoque al avrdude, ni una configuración gráfica para éste, debemos hacerlo a mano. Hay dando vueltas por ahí algunas interfaces gráficas para el avrdude, pero ninguna que me convenza realmente, ni tan cómoda de instalar en GNU/Linux. Por eso iremos a configurar nuestra herramienta personalizada, para subir el firmware al microcontrolador. Yo les voy a dejar dos configuraciones muy simples (una con el dasa y la otro con el USBasp), que graban el firmware y los fuses high y low del micro, y evité a proposito el de lock y el extendido. El extendido porque no todos lo tienen y el de lock para evitar que dejen su micro inservible, porque asumo que recién están empezando con estos micros (como yo).

Vayamos al menú “Tools->Configure tools…” y le hacemos clic en “Add”. En mi caso le puse el nombre “Update w/dasa” y “Update w/USBasp” para diferenciar el programador que estoy utilizando. pero básicamente es igual, es copiar y pegar los códigos que aparecen abajo de los screenshots:

Añadir el llamado al avrdude

Añadir el llamado al avrdude

Llenamos los campos con los comandos que aparecen abajo

Llenamos los campos con los comandos que aparecen abajo

Para el programador dasa:

Update w/dasa
/usr/bin/avrdude
-c dasa -P /dev/ttyS0 -p $(MCU) -u -U flash:w:${TARGET_OUTPUT_BASENAME}.hex -U eeprom:w:${TARGET_OUTPUT_BASENAME}.eep -U lfuse:w:${TARGET_OUTPUT_BASENAME}.lfs -U hfuse:w:${TARGET_OUTPUT_BASENAME}.hfs
${PROJECT_DIR}/${TARGET_OUTPUT_DIR}

Para el programador USBasp:

Update w/USBasp
/usr/bin/avrdude
-c usbasp -P usb -p $(MCU) -u -U flash:w:${TARGET_OUTPUT_BASENAME}.hex -U eeprom:w:${TARGET_OUTPUT_BASENAME}.eep -U lfuse:w:${TARGET_OUTPUT_BASENAME}.lfs -U hfuse:w:${TARGET_OUTPUT_BASENAME}.hfs
${PROJECT_DIR}/${TARGET_OUTPUT_DIR}
Debería quedar así

Debería quedar así

Por último, llamamos al comando desde el menú “Tools->Update w/dasa” o el programador que tengan y grabamos el firmware al microcontrolador. Si todo salió bien deberíamos tener un retorno exitoso :).

Tools->Update w/dasa

Tools->Update w/dasa

¡Éxito! =)

¡Éxito! =)

Si quieren saber más sobre los parámetros que puede recibir el avrdude, hay muchos tutoriales dando vueltas por ahí. Recuerden que también pueden hacer desde una terminal:

man avrdude

Y así ver toda la documentación disponible y mucho más. Bueno, ya está todo configurado como para arrancar a programar y probar cosas. Y les dejo un vídeo del programa funcionando, de pésima calidad, tomado con la webcam (perdón, me da vergüenza mostrarlo), para que vean que sí funciona todo. Utilicé mi placa de desarrollo y el módulo de E/S, que consta de 8 leds y 8 pulsadores. Luego subiré ese diseño y los otros módulos también.

Cualquier duda que surja, o consejo que me quieran dar, será bienvenido. En el próximo post les mostraré como configurar y usar el plug-in de eclipse, para que elijan cual es su mejor opción. Saludos y hasta la próxima.

Programación de microcontroladores de la familia AVR en GNU/Linux (Debian/Ubuntu) Parte I

Nivel: Intermedio

¿Qué tengo que saber para este post?

  • Instalar software desde tu distribución de linux, acá sólo voy a hacer referencia sobre Debian/Ubuntu utilizando apt.
  • Copiar, crear y mover archivos como administrador del sistema (root) o con el comando sudo.
  • Programación de microcontroladores (no necesariamente de la familia AVR de Atmel).

—————————————

Bueno, sé que este es motivo de búsqueda para muchos. Yo mismo me he encontrado buscando ésto en google alguna vez, pero nadie lo concentraba en una forma amigable y bien detallada, como para un newbie en el asunto. Así que fui de a poco, leyendo en varios lados hasta que más o menos llegué a una forma amigable de programar AVRs en GNU/Linux y con todo bien organizado. Sin el ánimo de alardear, espero expresar a continuación, de la mejor manera posible, una sencilla guía como para dar los primeros pasos en este asunto.

Instalar el compilador

Para instalar el compilador, librerías y demás cosas esenciales para programar microcontroladores de la familia AVR, lo que debemos hacer es sencillamente poner lo siguiente en una terminal como root o si estamos en un sistema sin root (como Ubuntu) poner el “sudo” delante:

apt-get install gcc-avr avr-libc avrdude binutils-avr

Con eso instalamos lo necesario, el avrdude es el programa que nos permitirá, luego, bajar nuestro archivos *.hex al microcontrolador. Para esto debemos darle permisos de usuario a los puertos (USB, serie o paralelo) de cada dispositivo, pero eso lo haremos cuando llegue el momento.

Eligiendo un IDE (o no…)

Lo siguiente sería elegir un entorno de desarrollo que nos facilite la vida al momento de programar. En lo personal, he probado con 2 de ellos, el Code::Blocks que recientemente ha sacado una nueva versión estable, y el plug-in de AVR para la plataforma eclipse. Claro que también podemos editar nuestro código en el vim o nuestro editor favorito y compilarlo a manopla mano desde la consola, pero la realidad es que no vamos a ser más machos por ello y, sinceramente, no es muy amigable para  los poco conocedores. Además, tener una herramienta que nos agiliza el trabajo es más que tentador y nadie nos va a llamar put@s poco hombre o poco mujer (ejem) por usar un entorno de desarrollo.

Volvamos a los IDEs, tanto el Code::Blocks como el plug-in para el eclipse tienen sus pros y sus contras. El plug-in del eclipse tiene un par de bugs feos, como definir y “desdefinir” cosas en la linea del comando del compilador y a veces no toma los cambios hasta después de compilar, dando warnings y otras cuestiones como generar mal el makefile… en fin, tiene sus quilombos problemas, pero se deja usar a pesar de todo con un par de fixeos y parcheos trucos que se pueden usar para solventar estos problemas. Lo bueno de este plug-in son 2 cosas:

  • Nos agrega una solapa en la parte de abajo llamada “AVR device explorer” que nos muestra el nombre de los registros de los micros soportados por el compilador y los defines de los vectores de interrupción (lo cual está bueno si ya conocemos lo que hacen y cómo se utilizan).
  • Nos agrega un botón que llama al avrdude y baja el firmware directo al micro, y además podemos configurar los parámetros y fuses de forma gráfica.

La desventaja del Code::Blocks es que no tiene esa dos ventajas ya mencionadas que tiene el eclipse, aunque el botón para bajar el firmware lo podemos configurar. Y sus ventajas son:

  • El editor es excelente.
  • Tiene varios plug-ins que están muy buenos, incluyendo uno que invoca a doxygen, que es una herramienta para generar documentación, muy útil y utilizada.

Ambos son multiplataforma, es decir que en Windows funcionan de la misma manera, nada más que es necesario instalar el WinAVR, que es lo que sería el primer paso de esta guía, “Instalar el compilador”, instala también las librerías y el avrdude (pero como acá nos concentramos en GNU/Linux, dejemos a Ventanas a un lado).

Instalar Code::Blocks en Debian/Ubuntu

Primero debemos tener permisos de administrador, y luego editar el archivo “/etc/apt/sources.list” y agregar al final del archivo lo siguiente (para la versión estable):

# Code::Blocks
deb http://apt.jenslody.de/stable stable main
deb-src http://apt.jenslody.de/stable stable main

Para la versión testing solo deben reemplazar “testing” donde dice “stable” y listo y luego instalar el key-ring para que no les salte el warning de que hay paquetes que no están firmados, que lo hacen instalando el siguiente paquete como root:

apt-get update
apt-get install jens-lody-debian-keyring

Y ahora a instalar el Code::Blocks y otros paquetes que necesitamos para que no salten errores al compilar:

apt-get install codeblocks codeblocks-additional srecord

Y listo, eso sería lo necesario para instalar todo lo que necesitamos, la primera vez que lo ejecutemos nos mostrará una lista de los compiladores que detectó. El AVR GCC debería estar en esa lista. Para más detalles vean la página oficial.

Instalar eclipse y el plug-in avr

Bueno, básicamente es parecido. primero debemos instalar eclipse:

apt-get install eclipse-cdt

Una vez que lo tenemos instalado, debemos seguir las instrucciones de la página oficial del plug-in que tienen screenshots y es muy amigable, a pesar de estar en inglés 😉 y con eso ya estamos.

Configurando el acceso a los puertos a nivel usuario para el avrdude

Antes que nada, debemos hacernos (de) un programador. Muchos tienen la loca idea de arrancar armándose un programador USB, pero lamentablemente, ese nunca es el primer paso. Un programador USB tiene como “defecto” que necesita de un microcontrolador con un firmware que capture los datos del puerto y los traduzca a las señales de programación de los AVR (que es un protocolo muy sencillo: SPI). Así que, si tenías en mente hacerte un programador USB, olvídate, salvo que tengas un amigo que tenga un programador para prestarte. Mi consejo es:

  • Comprar un USBasp, que es un programador muy barato que vas a encontrar en ebay por pocos dolares.
  • Hacete el programador DASA, que se hace con una ficha DB9 hembra, 3 resistencias, 3 zeners, un cable plano de 6 vías y un IDC6 hembra. Y luego, con un ATmega8 hacete el USBasp.

El USBasp es el que le hago armar a mis estudiantes del colegio donde doy clase, porque programa también la familia 8051 de Atmel, luego subiré el circuito. Una vez que tengamos nuestro programador, debemos darle permisos a nuestro usuario para manejar el puerto deseado. Para eso, lo único que hay que hacer es agregar a nuestro usuario al grupo “dialout”. Verifiquen primero si su usuario ya pertenece a tal grupo escribiendo en su terminal el comando:

groups

Si dialout aparece en la lista, no deben hacer nada, sino como root deben escribir el siguiente comando:

addgroup <tu_usuario_aqui> dialout

Una vez que formemos parte de este grupo, podremos usar el programador DASA sin ningún problema a nivel usuario (si tienen algún problema, sólo reinicien su equipo). Pero si quieren usar el USBasp, hagan el paso anterior de todas formas. Ya que les voy a pasar un archivo que enumera los programadores USB más utilizados (por no decir todos ellos) y que deben agregar a la carpeta “/etc/udev/rules.d/”. También pueden crear el archivo como root, yo lo llamé “99-usb-avr-programmers.rules”, puede tener el nombre que quieran, pero el contenido debe ser el siguiente:

# Programmers for avrdude

ATTR{idVendor}=="03eb", ATTR{idProduct}=="2104", GROUP="dialout", MODE="0660" # AVRISP mkII
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2107", GROUP="dialout", MODE="0660" # AVR-Dragon
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2103", GROUP="dialout", MODE="0660" # JTAG ICE mkII
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2106", GROUP="dialout", MODE="0660" # STK600
ATTR{idVendor}=="16c0", ATTR{idProduct}=="05dc", GROUP="dialout", MODE="0660" # USBASP von www.fischl.de
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2ffa", GROUP="dialout", MODE="0660" # AT90USB
ATTR{idVendor}=="10c4", ATTR{idProduct}=="ea60", GROUP="dialout", MODE="0660" # AVR910
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2105", GROUP="dialout", MODE="0660" # AVR ONE
ATTR{idVendor}=="03eb", ATTR{idProduct}=="210d", GROUP="dialout", MODE="0660" # Atmel XPLAIN CDC Gateway
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2ffb", GROUP="dialout", MODE="0660" # AT90USB AVR DFU bootloader
ATTR{idVendor}=="1781", ATTR{idProduct}=="0c9f", GROUP="dialout", MODE="0660" # adafruit usbtiny

En algún lado lo verán diferente, pero así es como funciona en Debian y supongo que así también debería de funcionar en Ubuntu, si alguien me lo confirma, sería buenísimo.

NOTA: Recuerden que todas las PCs de escritorio, o mejor dicho, todas las motherboards de escritorio, siguen trayendo el puerto serie, históricamente conocido como COM1. Este suele estar en un conector del tipo IDC10. Donde el PIN1 del IDC10 es el que va soldado al PIN1 del DB9 y así el 2 con el 2, el 3 con el 3 y el 10 del IDC10 no se conecta. En general es así, pero verifiquen con el manual de su motherboard. Recuerden que la ficha DB9 debería ser MACHO cuando la compren ;).

Ya tenemos todas las herramientas básicas para empezar nuestro proyectos AVR en GNU/Linux. En la siguiente entrega les mostraré un primer programa (ahora estoy medio cansado para seguir). Les prometo screenshots, fotos y tal vez algún vídeo, tanto con Code::Blocks como con eclipse, enseñándoles un par de arreglos para que la experiencia con eclipse no sea tan decepcionante.

Hello world!

¡Bienvenidos a este blog!

WordPress pone como primer entrada de ejemplo un post llamado “Hello world!” y teniendo en cuenta la naturaleza de este pequeño espacio en la red, me pareció divertido dejarlo así. Para que nos vayamos conociendo un poco, y además para no dejarlos con las manos vacías. Me parece prudente que hablemos un poco del gcc y como hacer un “¡Hola, mundo!”, que es el primer programa de ejemplo cuando uno aprende un lenguaje de programación desde el principio de los tiempos (no estoy seguro de que sea lo más didáctico).

Un lenguaje de programación es una forma de asentar un grupo de instrucciones para que ejecute algún dispositivo. Estas instrucciones deben ser compiladas (traducidas) al lenguaje de máquina que son los famosos unos y ceros que tienen que interpretar el dispositivo que queramos que las ejecute (Una PC, un sistema embebido, un robot, etc.). Para esto necesitamos un traductor, un programa llamado compilador. El gcc fue históricamente la copia del ya, en ese entonces, histórico cc (“C compiller”), de ahí su nombre: GNU C Compiller (para los que quieran saber que es GNU, su significado e historia pueden echarle un vistazo acá). Actualmente el gcc es una “Colección” de compiladores (GNU Compiller Collection), porque no sólo nos aporta programas que compilan lenguaje C de programación, sino que también otros lenguajes varios. No voy ahondar mucho en estos temas ahora, ya que en futuros post bajo algún tag (etiqueta/categoría) distintiva como “ABC de la programación”, será objeto de estudio de estos conceptos básicos.

¿Dónde y cómo genero mi programa? Las serie de instrucciones que le dictamos al dispositivo a ejecutar son escritas en un archivo plano de texto. Un archivo plano es un “.txt” que desde hace año podemos escribir en el clásico NotePad de Ventanas (a.k.a. “Bloc de Notas”), es decir un texto sin formato (sin tipo de letra, negrita, y ese tipo de yerbas). Entonces, programar, podemos hacerlo en cualquier computadora y en cualquier lugar, incluso en papel. Más adelante haré públicos algunos apuntes que he confeccionado para mis estudiantes del colegio, que ahora están violando algunos derechos de autor (más que nada por las gráficas y dibujos que utilizo sin autorización). En ellos se explica qué son y como se utilizan los diagramas de flujo y como es la mecánica y lógica de la programación en general. Por ahora, salteemos todo eso y vamos a los bifes: si tenés Ubuntu o Debian podés intalar gcc utilizanco el programa de consola/terminal apt:

apt-get install gcc vim

Si tenés Ubuntu tenés que escribir “sudo” al principio y en Debian tenés que ser root. Si ejecutan ese código se instalará el gcc y el vim, que es un editor de texto plano para consola. No necesitan usar ese, pueden usar gedit (si tienen gnome), kate(si tienen kde), mousepad(si tenés xfce) o cualquier otro, como no sé cual es la interfaz gráfica que tendrá cada uno, decidí usar la consola (también existe nano, pero no me llevo bien con él). Entonces ejecutamos el vim:

vim holamundo.c

Al hacer esto, creamos el archivo “holamundo.c” y lo podremos editar apretando la letra Insert del teclado y verifiquen que diga que están en modo de inserción abajo:

holamundo.c en vim

Ahora, simplemente escribiremos el siguiente código:

#include<stdio.h> // Incluye la librería de Entrada/Salida Estandar (STandarD Input Output), es decir, el teclado y la pantalla

// Función principal del programa, arranca por acá:

int main(void)
{
// La función puts() escribe el texto entre comillas en la pantalla:

    puts("¡Hola, mundo!\n"); // '\n' <- eso indica un ENTER, para que el siguiente texto aparezca debajo

    return 0; // Se termina el programa devolviendo un 0 al Sistema Operativo para indicar que el programa terminó con éxito.
}

¡Presto! Ahora apretamos ESC y luego “:x” (dos puntos x) y damos ENTER para guardar las modificaciones y cerrar el vim.

Ahora, llega el momento de la magia, de compilar el programa, ejecutaremos el gcc de la siguiente manera:

gcc holamundo.c -o holamundo

Lo primero que tenemos que poner luego de gcc es el archivo.c que queremos compilar y luego con “-o” especificaremos el nombre de la salida (de no hacerlo el ejecutable se llamará “a.out”). En este caso se llama igual pero sin ninguna extensión. En Linux no es necesario indicar la extensión de los archivos, en Ventanas sería un “.exe”. Para ejecutarlo, primero debemos darle permisos de ejecución con chmod y luego simplemente ejecutarlo utilizando el path completo:

chmod +x+r holamundo

./holamundo

Si todo salió bien, deberíamos ver el texto en pantalla. El “./” significa la carpeta en donde estamos parados en la linea de comando. Imaginen que estaban en la carpeta “/home/usuario”, entonces el ‘.’ (punto) reemplaza eso, porque es más cómodo escribir “./programa” a “/home/usuario/programa”, a qué sí. Otro día hablamos de chmod y demás cosas básicas de Linux.

Les mando saludos, y sean felices.