MSP-EXP430G2 LaunchPad & CCS: Librería para LCD - Mostrar variable tipo int

MrChunckuee noviembre 27, 2015
Saludos a todo!!! Continuando con las publicaciones del MSP430 LauchPad y retomando la publicación anterior sobre la librería LCD (puedes checarla desde aquí), pues ahora toca mostrar un ejemplo de como imprimir una variable tipo int en pantalla.

El circuito con el que trabajaremos sera el utilizado anteriormente:

Recordemos la librería del LCD.

/*******************************************************************************
*
* Libreria para LCD
*
*******************************************************************************
* FileName: lcd.c
* Processor: MSP430G2231 (Puede ser otro)
* Complier: CCS 6.0.0
* Author: Jose Manuel Alvarado Farias, versión para PIC
* Pedro Sánchez Ramírez (MrChunckuee) versión para MSP430
* Blog: http://mrchunckuee.blogspot.com/
* Email: mrchunckuee.psr@gmail.com
* Description: Libreria para usarse a 4 bits de datos, soporta pantallas de
* 4 lineas, el tiempo de los retardos esta considerado para
* usarse con un oscilador de 1MHz.
*******************************************************************************
* Historial del firmware
* Rev. Date Comment
* v1.00 --/--/---- Creación del firmware para PIC
* v1.01 28/06/2014 Migración del firmware para MSP430
* v1.02 25/09/2015 Corrección de algunas secciones de código para
* trabajar en CSS
*
******************************************************************************/
#include "lcd.h"
/*******************************************************************************
* Function: void LCD_Init(void)
* Description: This function initilizes the LCD
* Precondition: None
* Parameters: None
* Return Values: None
* Remarks: None
* ****************************************************************************/
void LCD_Init(void){
LCD_WriteNibble(0x03);
LCD_Wait(5);
LCD_WriteNibble(0x03);
LCD_WriteNibble(0x03);
LCD_WriteNibble(0x02);
LCD_WriteCommand(0x20);
LCD_WriteCommand(0x28);// set data length 4 bit 2 line
LCD_WriteCommand(0x14);
LCD_WriteCommand(0x0F);
LCD_WriteCommand(0x01);// clear lcd
LCD_WriteCommand(0x06);// cursor shift direction
LCD_WriteCommand(0x06);//
LCD_WriteCommand(LCD_ON);
LCD_Wait(2);
LCD_WriteCommand(LCD_CURSOR_OFF);
//Escribe caracter definido en la CGRAM
LCD_WriteCommand(0x40);
LCD_WriteData(0x08);
LCD_WriteData(0x0C);
LCD_WriteData(0x0E);
LCD_WriteData(0x0F);
LCD_WriteData(0x0E);
LCD_WriteData(0x0C);
LCD_WriteData(0x08);
LCD_WriteData(0x00);
LCD_WriteCommand(LCD_HOME);
}
void LCD_Strobe(void){
P1OUT |= EN;
LCD_Wait(2);
P1OUT &= ~EN;
LCD_Wait(2);
}
void LCD_Wait(volatile unsigned int x){
volatile unsigned int i;
for (x; x>1;x--){
for (i=0;i<=110;i++);
}
}
void LCD_WriteNibble(unsigned char LCD_COMMAND){
P1OUT &= ~RS; //Because sending command
P1OUT &= ~EN;
P1OUT &= 0xF0;
P1OUT |= LCD_COMMAND;
//P1OUT |= ((LCD_COMMAND >> 4) & 0x0F);
LCD_Strobe();
//LCD_Wait(2);
}
/*
* @brief Escribe un comando en el lcd alfanumerico
* @param LCD_COMMAND: comando enviado al display alfanumerico
* @param None
* @retval None
*/
void LCD_WriteCommand(unsigned char LCD_COMMAND){
P1OUT &= ~RS; //Because sending command
P1OUT &= ~EN;
P1OUT &= 0xF0;
P1OUT |= ((LCD_COMMAND >> 4) & 0x0F);
LCD_Strobe();
LCD_Wait(4);
P1OUT &= 0xF0;
P1OUT |= (LCD_COMMAND & 0x0F);
LCD_Strobe();
LCD_Wait(4);
if((LCD_COMMAND==LCD_HOME)||(LCD_COMMAND==LCD_CLEAR_SCREEN))
LCD_Wait(2);
}
/*
* @brief Escribe un dato en el lcd alfanumerico
* @param LCD_DATA: dato enviado al display alfanumerico
* @param None
* @retval None
*/
void LCD_WriteData(unsigned char LCD_DATA){
P1OUT |= RS; //because sending data
P1OUT &= ~EN;
P1OUT &= 0xF0;
P1OUT |= ((LCD_DATA >> 4) & 0x0F);
LCD_Strobe();
P1OUT &= 0xF0;
P1OUT |= (LCD_DATA & 0x0F);
LCD_Strobe();
LCD_Wait(4);
}
/*
* @brief Escribe un comando en el lcd alfanumerico
* @param LCD_DATA: dato enviado al display alfanumerico
* @param LCD_X: columna en la que se desea colocar un caracter en el display
* @param LCD_Y: fila en la que se desea colocar un caracter en el display
* @retval None
*/
void LCD_WriteDataXY(char LCD_DATA, unsigned char LCD_X, unsigned char LCD_Y){
LCD_GotoXY(LCD_X,LCD_Y);
LCD_WriteData(LCD_DATA);
}
/*
* @brief Coloca el cursor en la fila y columna indicada
* @param LCD_X: Columna donde se desea colocar el cursor
* @param LCD_Y: Fila donde se desea colocar el cursor
* @retval None
*/
void LCD_GotoXY(unsigned char LCD_X, unsigned char LCD_Y){
switch(LCD_Y){
case 0:
LCD_WriteCommand(LCD_LINE1+LCD_X);
break;
case 1:
LCD_WriteCommand(LCD_LINE2+LCD_X);
break;
case 2:
LCD_WriteCommand(LCD_LINE3+LCD_X);
break;
case 3:
LCD_WriteCommand(LCD_LINE4+LCD_X);
break;
default:
break;
}
}
/*
* @brief Genera LCD_WIDE espacios en blanco comenzando en la fila LCD_Y
y la columna LCD_X
* @param LCD_X: Columna donde se desea colocar el primer espacio en balnco
* @param LCD_Y: Fila donde se desea colocar el primer espacio en balnco
* @param LCD_WIDE: Cantidad de espacios en blanco que se desea colocar
* @retval None
*/
void LCD_ClearSpace(unsigned char LCD_X, unsigned char LCD_Y,
unsigned char LCD_WIDE){
unsigned char LCD_SPACE_COUNT=0;
unsigned char LCD_WIDE_COUNT=LCD_WIDE;
LCD_SPACE_COUNT=16-LCD_X;
if((LCD_SPACE_COUNT>0)&&(LCD_SPACE_COUNT<4)){
LCD_GotoXY(LCD_X,LCD_Y);
do{
LCD_WriteData(LCD_SPACE_ASCII);
LCD_WIDE_COUNT--;
LCD_SPACE_COUNT--;
}
while(LCD_WIDE_COUNT&&LCD_SPACE_COUNT);
}
LCD_GotoXY(LCD_X,LCD_Y);
}
/*
* @brief Limpia la linea indicada por LCD_Y
* @param LCD_Y: Fila en donde se desea limpiar la linea
* @param None
* @retval None
*/
void LCD_ClearLine(unsigned char LCD_Y){
unsigned char LCD_SPACE_COUNT=16;
switch(LCD_Y){
case 0:
LCD_WriteCommand(LCD_LINE1);
break;
case 1:
LCD_WriteCommand(LCD_LINE2);
break;
case 2:
LCD_WriteCommand(LCD_LINE3);
break;
case 3:
LCD_WriteCommand(LCD_LINE4);
break;
default:
break;
}
do{
LCD_WriteData(LCD_SPACE_ASCII);
LCD_SPACE_COUNT--;
}
while(LCD_SPACE_COUNT);
}
/*
* @brief Coloca una cadena ubicada en RAM en la fila LCD_Y
y la columna LCD_X
* @param *LCD_STRING: Dirección de la cadena en RAM
* @param LCD_X: Columna donde se desea colocar el primer caracter
* @param LCD_Y: Linea donde se colocara la cadena
* @retval None
*/
void LCD_WriteString(char *LCD_STRING, unsigned char LCD_X,
unsigned char LCD_Y){
unsigned char LCD_INDEX=0;
unsigned char LCD_WIDE_COUNT=0;
LCD_WIDE_COUNT=16-LCD_X;
LCD_GotoXY(LCD_X,LCD_Y);
for(LCD_INDEX=0;(*(LCD_STRING+LCD_INDEX)&&LCD_WIDE_COUNT);
LCD_INDEX++,LCD_WIDE_COUNT--)
LCD_WriteData(*(LCD_STRING+LCD_INDEX));
}
/*
* @brief Coloca una cadena ubicada en FLASH en la fila LCD_Y
y la columna LCD_X
* @param *LCD_STRING: Dirección de la cadena en FLASH
* @param LCD_X: Columna donde se desea colocar el primer caracter
* @param LCD_Y: Linea donde se colocara la cadena
* @retval None
*/
void LCD_WriteROMString(const char *LCD_STRING, unsigned char LCD_X,
unsigned char LCD_Y){
unsigned char LCD_INDEX=0;
unsigned char LCD_WIDE_COUNT=0;
LCD_WIDE_COUNT=16-LCD_X;
LCD_GotoXY(LCD_X,LCD_Y);
for(LCD_INDEX=0;(*(LCD_STRING+LCD_INDEX)&&LCD_WIDE_COUNT);
LCD_INDEX++,LCD_WIDE_COUNT--)
LCD_WriteData(*(LCD_STRING+LCD_INDEX));
}
view raw MSP_LCD.c hosted with ❤ by GitHub
/*******************************************************************************
*
* Libreria para LCD
*
*******************************************************************************
* FileName: lcd.h
* Processor: MSP430G2231 (Puede ser otro)
* Complier: CCS 6.0.0
* Author: Jose Manuel Alvarado Farias, versión para PIC
* Pedro Sánchez Ramírez (MrChunckuee) versión para MSP430
* Blog: http://mrchunckuee.blogspot.com/
* Email: mrchunckuee.psr@gmail.com
* Description:
*******************************************************************************/
#ifndef LCD_H_
#define LCD_H_
//Incluimos el microcontrolador utilizado
#include <msp430g2231.h>
/*******************************************************************************
* Perfil de hardware para el LCD
* Pin Nombre MSP430
* 4 R/S P1.4
* 6 EN P1.5
* 11 Data4 P1.0
* 12 Data5 P1.1
* 13 Data6 P1.2
* 13 Data7 P1.3
*
* Cambiar la distribucion de pines implica variar secciones de codigo
*******************************************************************************/
#define RS BIT4
#define EN BIT5
#define LCD_OFF 8
#define LCD_ON 12
#define LCD_CURSOR_ON 14
#define LCD_CURSOR_OFF 12
#define LCD_CURSOR_BLINK 15
#define LCD_CURSOR_NOBLINK 14
#define LCD_CLEAR_SCREEN 1
#define LCD_HOME 2
#define LCD_LINE1 0x80
#define LCD_LINE2 0xC0
#define LCD_LINE3 0X90
#define LCD_LINE4 0xD0
#define LCD_SPACE_ASCII 0X20
void LCD_Init(void);
void LCD_Strobe(void);
void LCD_Wait(volatile unsigned int x);
void LCD_WriteNibble(unsigned char LCD_COMMAND);
void LCD_WriteCommand(unsigned char LCD_COMMAND);
void LCD_WriteData(unsigned char LCD_DATA);
void LCD_WriteDataXY(char LCD_DATA, unsigned char LCD_X, unsigned char LCD_Y);
void LCD_GotoXY(unsigned char LCD_X, unsigned char LCD_Y);
void LCD_ClearSpace(unsigned char LCD_X, unsigned char LCD_Y,
unsigned char LCD_WIDE);
void LCD_ClearLine(unsigned char LCD_Y);
void LCD_WriteString(char *LCD_STRING, unsigned char LCD_X, unsigned char LCD_Y);
void LCD_WriteROMString(const char *LCD_STRING, unsigned char LCD_X,
unsigned char LCD_Y);
#endif /* LCD_H_ */
view raw MSP_LCD.h hosted with ❤ by GitHub
Para mostrar una variable tipo int necesitamos hacer uso "LCD_WriteString" pero si vemos los parámetros no es posible cargarle directamente el valor de la variable int, para ello aremos uso de la función "itoa" aunque checando el CCS notaran que no esta, así que indagando por la red encontré un código que realiza dicha función, por lo tanto he creado una librería llamada "special" que es donde alojare funciones de este tipo o funciones que puedan ser de utilidad para nuestros futuros proyectos, el contenido de la librería es la siguiente (en un futuro iré modificando o actualizando).
/*******************************************************************************
*
* Libreria para funciones especiales
*
*******************************************************************************
* FileName: special.c
* Processor: ---------
* Complier: CCS 6.0.0
* Author: Pedro Sánchez Ramírez (MrChunckuee)
* Blog: http://mrchunckuee.blogspot.com/
* Email: mrchunckuee.psr@gmail.com
* Description: Libreria para funciones especiales, o funciones que apliquen
* para varios proyectos
*******************************************************************************
* Historial del firmware
* Rev. Date Comment
* v1.00 19/10/2015 - Creación de la libreria
* - Se implemento la funcion itoa
******************************************************************************/
#include "special.h"
/*******************************************************************************
* Function: char *itoa(int value, char *s, int radix)
* Description: Esta funcion convierte una variable int a una char
* Precondition: None
* Parameters: int value = Variable tipo int que se convertira
* char *s = Variable tipo char conde se guardara el resultado
* int radix = Base que tendra *s, Ej: Decimal=10, Binario=2
* Return Values: Regresa el valor de "s"
* Remarks: Considerar que una int abarca de -32768 a 32767
* Ej: itoa (INT_VARIABLE, CHAR_VARIABLE, 10)
* ****************************************************************************/
char *itoa(int value, char *s, int radix){
const char *digits = "0123456789abcdefghijklmnopqrstuvwxyz";
unsigned long ulvalue = value;
char *p = s, *q = s;
char temp;
if (radix == 10 && value < 0) {
*p++ = '-';
q = p;
ulvalue = -value;
}
do {
*p++ = digits[ulvalue % radix];
ulvalue /= radix;
} while (ulvalue > 0);
*p-- = '\0';
while (q < p) {
temp = *q;
*q++ = *p;
*p-- = temp;
}
return s;
}
view raw MSP_special.c hosted with ❤ by GitHub
/*******************************************************************************
*
* Libreria para funciones especiales
*
*******************************************************************************
* FileName: special.h
* Processor: ---------
* Complier: CCS 6.0.0
* Author: Pedro Sánchez Ramírez (MrChunckuee)
* Blog: http://mrchunckuee.blogspot.com/
* Email: mrchunckuee.psr@gmail.com
* Description: Libreria para funciones especiales, o funciones
* que aplique para varios proyectos
******************************************************************************/
#ifndef SPECIAL_H_
#define SPECIAL_H_
char *itoa(int value, char *s, int radix);
#endif /* SPECIAL_H_ */
view raw MSP_special.h hosted with ❤ by GitHub
Dejo un ejemplo para mostrar la variable en decimal, binario y hexadecimal para ello notaran que se hace uso de la función itoa cada que se pasa a un sistema numérico.
/*******************************************************************************
*
* MSP_008: Manejo de LCD 16x2 "Mostrar Variables"
*
*******************************************************************************
* FileName: lcd.c
* Processor: MSP430G2231 (Puede ser otro)
* Complier: CCS 6.0.0
* Author: Pedro Sánchez Ramírez (MrChunckuee)
* Blog: http://mrchunckuee.blogspot.com/
* Email: mrchunckuee.psr@gmail.com
* Description: Considerar la distribucion de pines especificada en lcd.h
* Ejemplo para mostar variables tipo int
*******************************************************************************
* Historial del firmware
* Rev. Date Comment
* v1.00 21/10/2015 Creación del firmware
******************************************************************************/
#include <msp430g2231.h>
#include "lcd.h"
#include "special.h"
int int_Value = 10;
char char_LCD[8], i;
void Delay_Seg(volatile unsigned int t);
void main(void) {
WDTCTL = WDTPW + WDTHOLD;//Stop watchdog timer
BCSCTL1 = CALBC1_1MHZ;// Use 1Mhz cal data for DCO
DCOCTL = CALDCO_1MHZ;// Use 1Mhz cal data for DCO
P1DIR = 0xFF;
P1OUT = 0x00;
LCD_Init();//Se inicializa LCD
while(1){
LCD_WriteCommand(LCD_CLEAR_SCREEN);
LCD_WriteROMString("Uso de LCD 16x2",0,0);
LCD_WriteROMString("MostrarVariables",0,1);
Delay_Seg(3);
LCD_WriteCommand(LCD_CLEAR_SCREEN);
for(i=0; i<8; i++){ char_LCD[i]=0; } //Clear char_LCD
itoa(int_Value, char_LCD, 10); //Pasar int_Value a decimal
LCD_WriteROMString("Dec: Bin: Hex:",0,0);
LCD_WriteString(char_LCD,0,1);
for(i=0; i<8; i++){ char_LCD[i]=0; } //Clear char_LCD
itoa(int_Value, char_LCD, 2); //Pasar int_Value a binario
LCD_WriteString(char_LCD,6,1);
for(i=0; i<8; i++){ char_LCD[i]=0; } //Clear char_LCD
itoa(int_Value, char_LCD, 16); //Pasar int_Value a hexadecimal
LCD_WriteString(char_LCD,12,1);
Delay_Seg(3);
}
}
/*******************************************************************************
* Function: void Delay_Seg(volatile unsigned int t)
* Description: Realiza retardo en segundos
* Precondition: None
* Parameters: t = Tiempo de espera
* Return Values: None
* Remarks: None
* ****************************************************************************/
void Delay_Seg(volatile unsigned int t){
volatile unsigned int i;
for (i=0 ;i<t; i++){
__delay_cycles(1000000);
}
}
view raw MSP-EXP430G2_008: main.c hosted with ❤ by GitHub
Aquí el vídeo del circuito en acción:


Nota: Durante las pruebas quería mostrar tipos de datos tipo "float" y encontré una librería para pasar de float a string pero consumía demasiado recursos del uC, no se si el motivo es de mi librería del LCD o propiamente por la función para manipular datos float así que por el momento decidí dejarlo por la paz y no complicarme la vida, aunque debo decir que manipular datos "int" también consumen algo de memoria, bueno ya utilizare mi LaunchPad para aplicaciones donde se requiera poco capacidad tanto en ROM como en FLAH, ya veré en un futuro que hacer con ello, de momento el propósito es aprender a utilizar estos microcontroladores.

Descargas:
Aquí el enlace para DESCARGAR los archivos disponibles desde mi repositorio en GitHub, si no sabes como descargarlo puedes checar aquí, bueno por el momento es todo si tienes dudas, comentarios, sugerencias, inquietudes, traumas, etc. dejarlas y tratare de responder lo mas pronto posible.


Donaciones:
Si te gusta el contenido o si los recursos te son de utilidad, comparte el enlace en tus redes sociales o sitios donde creas que puede ser de interés y la otra puedes ayudarme con una donación para seguir realizando publicaciones y mejorar el contenido del sitio. También puedes hacer donaciones en especie, ya sea con componentes, tarjetas de desarrollo o herramientas. Ponte en contacto para platicar, o puedes volverte uno de nuestros sponsors.


Pido una retroalimentación avisando cada que un enlace no sirva o tenga errores al momento de abrirlo, así también si una imagen no se ve o no carga, para corregirlo en el menor tiempo posible.
MrChunckuee

Publicado por MrChunckuee

Amo armar, desarmar y/o destruir cosas en donde la electrónica y los componentes estén involucrados, me gusta la robótica y los microcontroladores, de ahí el nombre de mi blog, el cual surge por la pasión que tengo sobre estos temas: La Electrónica que es mi carrera y la Robótica que es uno de mis hobbies favoritos, siempre he dicho "Casado con la electrónica, pero amante de la robótica".

Publicar un comentario

0 Comentarios