Mostrando entradas con la etiqueta Texas Instruments. Mostrar todas las entradas
Mostrando entradas con la etiqueta Texas Instruments. Mostrar todas las entradas

viernes, 13 de diciembre de 2013

Hercules Launchpad #2 - GPIO (GIO)

Ahora les voy a mostrar lo que he aprendido de los General Propouse Input Output (GIO o GPIO). Esta tarjeta tiene un chorro de pines que pueden ser controlados como queramos, uno de los cuales está conectado a un push-button que podemos usar para lo que queramos. Otro de los pines está conectado a un LED que también podemos ocupar. Genial, no? Les voy a enseñar como usar el push-button para controlar el LED, pero sin usar interrupciones (por ahora).


Paso 1:
Comencemos configurando los archivos usando HALcoGen. Lo primero es seleccionar los drivers que queremos. En este caso será solo el GIO Driver.




Luego hay que habilitar el pin al cual está conectado el LED como salida. Este pin es el GIOA2, como viene marcado en la tarjeta. Esto significa que de los 8 bits que tiene el puerto GIO A, el LED está conectado al bit número 2. El botón está conectado al bit 7 de este puerto.



Al bit 7 no hay que moverle nada ahorita, ya que siempre tienen la entrada habilitada.
Ahora hay que generar los archivos (F5).

Nota: El GIO tiene sus propios puertos, pero eso no significa que se limite a controlar únicamente sus puertos. También puede controlar los puertos del HET y mandar y recibir bits a su voluntad.

Paso 2:
Ya que tenemos los archivos generados, abrimos un nuevo proyecto y lo configuramos como la vez anterior (Paso 5 y Paso 6 del tutorial anterior). Ya que lo tenemos configurado, abrimos el archivo "sys_main.c" y comenzamos a escribir nuestro código.

Paso 2.1:
Hay que incluir las librerías necesarias para acceder a las funciones del GIO. Esta vez sólo utilizaremos "gio.h". El código se verá así


/* USER CODE BEGIN (0) */
#include "gio.h" // Incluimos la librería del GIO
/* USER CODE END */


Paso 2.2:
Ahora hay que escribir el código que reaccione al botón y encienda y apague el LED.
Para que el programa "lea" lo que está haciendo el botón, usamos la función "gioGetBit(gioPORTA, 7)". Les explico cómo funciona. "gioGetBit" es una función que lee un bit de un determinado puerto. En este caso, el puerto es el gioPORTA, que dentro del archivo "reg_gio.h" está declarado como 

#define gioPORTA ((gioPORT_t *)0xFFF7BC34U)

El 7 significa que es el bit número 7.
Para hacer que el bit encienda y apague, habrá que utilizar la instrucción "gioToggleBit(gioPORTA, 2)". Esto es muy parecido a lo anterior. La función "gioToggleBit" hace que si el bit está en "1", lo vuelve "0" y viceversa.
Finalmente el código quedaría

void main(void)
{
/* USER CODE BEGIN (3) */

// Inicializa el driver GIO
gioInit();

// Declaramos la variable para el loop
int i;
while(1)
{
if(gioGetBit(gioPORTA, 7)==1)
{
// Enciende y apaga el LED
gioToggleBit(gioPORTA, 2);

// Se espera un poco para volver
// a encender y apagar el LED
for (i=0; i<1000000; i++)
{
// Aquí no hacemos nada
}
}
else
{
// Si no presionamos el botón
// El led se vuelve cero
gioSetBit(gioPORTA, 2, 0);
}
}
/* USER CODE END */

}

Si compilan este código, debería parpadear el LED cuando presionan el botón y permanecer apagado mientras no lo presionan.



Les dejo el link para que puedan descargar el código

https://www.mediafire.com/?l58uja983dx2xwr

My Github
https://github.com/DiegoRosales

lunes, 9 de diciembre de 2013

Hercules Launchpad #1 - LED Parpadeante (Project 0)

Pues a penas me compré un Hercules Launchpad en Newark y les voy a enseñar lo que he aprendido. Este tutorial se consistirá en hacer parpadear uno de los LEDs que trae la tarjeta utilizando los timers que tiene el procesador.

Nota 1: para comenzar a desarrollar en esta tarjeta hay que instalar el compilador/debugger de Texas Instruments llamado Code Composer Studio. A mi me costó un chin*** instalarlo, pero (por si les interesa) lo logré instalar estando en el modo seguro de Windows. Este programa es gratis para desarrollar en esta tarjeta sin límites de ningún tipo.
También necesitarán de una herramienta llamada HALcoGen (HAL Code Generator). Este también es un programa de Texas Instruments (gratuito) y lo que hace es que genera todos los archivos de configuración por nosotros.

Paso 1:
Debemos abrir el mítico HALcoGen y nos va a aparecer lo siguiente


Después le damos en File -> New -> New Project y seleccionamos la familia y el procesador correspondiente. Le damos un nombre y la ubicación y dado que vamos a usar Code Composer Studio, en Tools seleccionamos "Texas Instruments Tools" y le damos "Ok".


Paso 2:
Nos va a aparecer una ventana medio friki con un montón de pestañas. Para este tutorial debemos ir a la pestaña de "Driver Enable" y desmarcamos todas las cajitas y marcamos solo la que dice HET. Les debe quedar así



Nota 2: HET significa High End Timer y es una especie de subsistema que controla todo lo que tenga que ver con timers. Este módulo posee 30 poderosas instrucciones para ser controlado.

Continuemos....

Paso 3:
Ahora nos vamos a la pestaña que dice HET. Como podrán ver, aquí es donde se configura todo lo del timer. Vamos a configurar un PWM para poder prender un LED con un periodo de 1 segundo. Para esto nos vamos a la pestaña que dice "Pwm 0-7" y ponemos el periodo del primer PWM de 1'000,000us con un ciclo de trabajo del 50% para que podamos ver que si funciona. Luego le damos clic en el cuadrito de enable con salida al pin 8, que es el pin al cual está asignado uno de los LEDs.


Paso 4:
Ahora lo que hay que hacer es habilitar el pin 8 para que funcione como salida. Para eso nos vamos a la pestaña que dice "Pin 8-15" y marcamos la cajita que se encuentra junto a "DIR:". Esto habilita el pin como salida.



Paso 5:
Ya con esto hemos configurado todo. Ahora hay que generar el código en File -> Generate code o tecleando F5. Ya que generamos el código, abrimos Code Composer Studio. Cuando nos pregunte por el Workspace, le decimos que sea en la dirección exacta donde se generó nuestro código. Luego nos vamos a Project -> New CCS Project. En el nombre del proyecto hay que escribir el nombre que usamos en HALcoGen. En la variante seleccionamos "Cortex R" y "RM42L432" y en la conexión seleccionamos "Texas Instruments XDS100v2 USB Emulator". Por último, seleccionamos la opción de "Empty Project".


Paso 6:
Ya que creamos nuestro proyecto, hay que configurarlo para que funcione con el código que generamos en HALcoGen. Para esto, nos vamos a "Project Explorer" y le damos clic derecho a la carpeta con el nombre de nuestro proyecto y luego a propiedades. En la ventana que aparece nos vamos a Build -> ARM Compiler -> Include Options y en el cuadro que dice "Add dir to #include search path" le damos clic en "Add". En la ventana que aparece le damos clic en Workspace y seleccionamos la carpeta "Nombre_del_proyecto" -> include.


Le damos a OK a las dos ventanas y en las propiedades nos vamos a "General" y verificamos que donde diga "Runtime support library" esté la opción de "automatic".

Paso 7:
Ahora si nos vamos a programar. Abrimos el archivo "sys_main.c" que se encuentra en la carpeta "source" y vemos que nos aparece un poco de código ya escrito.

Nota 3: Todos los archivos que genera HALcoGen tienen secciones de comentario que dicen 
/* USER CODE BEGIN (0) */
/* USER CODE END */
Nuestro código debe ir en estas secciones. Esto es porque es posible que tengamos que regresar a HALcoGen varias veces para cambiar algo y volver a generar el código. HALcoGen va a reescribir todo el código que no se encuentre dentro de estas secciones. Por eso es importante escribir nuestro código dentro de estos espacios.

Sigamos...

En el USER CODE BEGIN (0) hay que incluir la librería del HET. para esto escribimos

/* USER CODE BEGIN (0) */
#include "het.h";
/* USER CODE END */

Luego, en el USER CODE BEGIN (3), que es el código principal, hay que inicializar el HET. Esto se hace con la instrucción hetInit(). Por último, hacemos que nuestro código no termine con un while(1). Al final se debe ver algo así

void main(void)
{
/* USER CODE BEGIN (3) */
hetInit();
while(1);
/* USER CODE END */
}

Paso 8:
Ya que escribimos nuestro código, podemos cargarlo al microcontrolador y "debuggearlo". Esto se hace en Run -> Debug o picándole en el bichito verde. Una vez que ya se cargó el programa podemos comenzar a correrlo dándole clic en Resume (F8) y verán la magia de los sistemas embebidos hacer lo suyo.


Y pues esto ha sido todo. Eventualmente iré subiendo tutoriales de cosas más cool, ya que esta tarjeta da para mucho (deja al Arduino y todos esos micros muy muy atrás).

Por si les interesa, aquí les dejo el link de Newark

Y les dejo el link para descargar los archivos de este tutorial
http://www.mediafire.com/download/ujg9jqjc04nrjdh/Tutorial%201.zip

My Github
https://github.com/DiegoRosales