CCS Compiler - Manejo de Puertos (Programación PIC)

MANEJO DE PUERTOS

En CCS Compiler tenemos dos maneras de gestionar los puertos del microcontrolador:

1. Utilizando directivas del compilador:

     #use fast_io (puerto)      #use standard_io(puerto)      #use fixed_io(puerto_outputs=pin)

Contamos con las 3 directivas para poder gestionar los puertos.
En esta ocasión solo explicaré más a detalle la directiva #use fast_io
Para empezar, hay que indicar que por defecto el compilador hace uso de la directiva standard_io, es decir si no declaramos nada, se hará uso de esta directiva.

Empecemos a explicar la directiva fast_io
Esta directiva nos permite hacer uso de varias funciones para manejar los puertos y pines del microcontrolador. Es necesario declarar correctamente los pines de entrada y salida a través del registro TRISX. Las funciones que tenemos son:

Como podemos ver, tenemos varias opciones para poder gestionar adecuadamente los puertos.

EJEMPLOS:

Primero debemos declarar la directiva, luego configurar pines como entrada o salida

#use fast_io(b)

set_tris_b(0xF0);         //el valor 0 indica salida, el valor 1 indica entrada
                                    //pines b0-b3 seran salida, pines b4-b7 serán entrada

output_high(pin_b0);          //pin b0=1
output_low(pin_b1);           //pin b1=0
output_bit(pin_b2,1);          //pin b2=1
output_toggle(pin_b3);       //cambia estado del pin b3
output_b(0x00);                  //puerto b=0, solo los pines declarados como salida
output_b(0x0F);                  //los pines declarados como entrada se ponen a 1
     
x=input_state(pin_b4);        //lee la entrada del pin b4 sin cambiar el sentido del terminal(no modifica
                                               el registro tris) y almacena en la variable x
 
y=input(pin_b5);                 //lee la entrada del pin b4 y lo almacena en la variable y. fuerza al pin a
                                       comportarse como entrada (modifica el registro tris si no estuviera declarado)

z=input_b();                    //lee la entrada del puerto b, solo de los pines declarados como entrada y lo
                                          almacena en la variable z (8 bits)


Los ejemplos mostrados es la forma mas común de gestionar los puertos, ya que nos facilita bastante el manejo pin a pin y de todo el puerto.

La diferencia de la directva fast_io con la directiva standard_io es:
- standard_io no necesita que definamos el registro tris, ya que el compilador se encargara de asegurar que los pines sean de salida (cuando usamos las funciones de salida como output_x) o los pines sean de entrada (cuando usamos las funcione de entrada como input_x).
- standard_io modificará el registro tris cada vez que llamemos a las funciones, or tanto generara mas código y se ocupará mas memoria.

Siempre dependerá de la aplicación que vamos a realizar para poder hacer el uso de una u otra directiva. En mi experiencia siempre suelo usar el fast_io.

 2. A través de la RAM

Necesitamos definir correctamente los registros PORTx y TRISx, para lo cual necesitamos conocer la posición en la memoria del PIC que ocupan estos registros. Esa información la obtenemos del datasheet del microcontrolador que estemos usando.

Se declara de ña siguiente manera:

#BYTE nombre_variable = posición_memoria

EJEMPLOS:

#byte TRISD=0xF95           //la posicion de la memoria para el registro TRISD es del PIC18F4550
                                               se le esta poniendo el mismo nombre del registro, pero puede ser otro.
#byte PORTD=0xF83          //la posicion tambien para el PIC18F4550

Una vez definidas las variables ya podemos gestionar los puertos.

TRISD = 0xF0;                   //pines d0-d3 serán salida, pines d4-d7 serán entrada
PORTD = 0b00001100       //estamos escribiendo los valor en el registro, en este caso b3=1 y b2=1
                                              los demas pines serán cero.

Tambien tenemos funciones que nos permiten gestionar pin a pin, tal como se muestra en la siguiente imagen:

EJEMPLOS:

bit_clear(PORTD,2);           //pin d2=0
bit_set(PORTD,1);              //pin d1=1;
x=bit_set(PORTD,6);          //lee el estado del pin d6 y lo almacena en la variable x

bit_clear(TRISD,0);            //indica que el pin d0 sera salida
bit_set(TRISD,5);               //indica que el pin d5 sera entrada

Tambien es posible declarar un bit de un registro, como se muestra a continuació:

#bit nombre = posicion.bit

EJEMPLOS:

#bit RB4 = 0xF81.4           //le estamos nombrando como RB4 al pin b4 (la posicion corresponde al
                                             PIC18F4550
#bit LED = 0xF81.7          //le estamos nombrando como LED al pin b7
#bit BUTTON = 0xF81.6   //le estamos nombrando como BUTTON al pin b6

Ahora podemos gestionar los pines, llamando a la variable asignada.

RB4=1;                         //pin b4=1
LED=0;                         //pin b6=0

if(BUTTON==1) LED=1;    //si pin b6=1, entonces pin b7=1


Eso es todo por este post, espero sea de gran ayuda a todos los lectores

Pueden descargar el código del programa AQUI

LES DEJO UN TUTORIAL DONDE EXPLICO TODO. SUSCRABANSE AL CANAL DE YOUTUBE y REGALAME UN LIKE PARA SEGUIR SUBIENDO MAS CONTENIDO AL BLOG Y AL CANAL

LEER MAS

CCS C Compiler - Uso de funciones (Programacion de PIC)

USO DE FUNCIONES - CCS C COMPILER

El uso de funciones en la programacón es muy usado para poder tener códigos de programa dedicados a una función especifica y asi de esta manera tener mejor organizado todo nuesttro código. A la vez también nos pueden permitir detectar errores en el código más facilmente.

En la programación de microcontroladores PIC también se hace necesario su uso cuando tengamos códigos de programa de medianas agrandes extensiones y/o cuando necesitamos que uno o mas acciones se repitan varias veces en nuestro código de programa.

En este post les explicaré como hacer uso de las funciones para programar microcontroladores PIC en el entorno de programación CCS C Compiler (PIC C Compiler)

ESTRUCTURA DE UNA FUNCIÓN

tipo_retorno nombre_función (parámetros)
{
        cuerpo_de_la_función;
      
       expresión_retorno;
}

tipo_retorno:   Es un tipo de dato que devolverá la función (los tipos de datos lo hemos visto en un
                                                                                               post anterior "VER AQUI")

nombre_función:   Es el nombre que deseamos colocarle a la función.

parámetros:  Valores de entrada que se usarán en nuestra función. Deben ir separados por comas.

EJEMPLO:

void imprimir_variable (int temperatura)
{
       printf(lcd_putc,"\fT=%2u°C,temperatura);
       delay_ms(10);
}

En este ejemplo se tiene una función que no devuelve ningun valor, por tanto es un tipo 'void'
Como parámetro tenemos un valor tipo entero de 8 bits, que en este caso tiene por nombre "temperatura"
La acción que cumple esta función es de imprimir el valor de una variable, el valor de esa variable la ingresamos cuando hacemos el llamado de la función en alguna parte de nuestro programa.

Explicado la estructura general de una función, podemos decir que hay tipos de funciones dependiendo del tipo_retorno y si tiene o no parámetros. A continuación pasamos a detallar 4 tipos:

1.  void nombre_funcion(void)

     En este caso tenemos una función que no devuelve ningun valor y no tiene ningun parámetro de entrada. Lo que hace es ejecutar el codigo de la función cada vez que es llamada.

2.   void nombre_funcion(parámetros)

      En este caso tenemos una función que no devuelve ningun valor y tiene uno o mas parámetros de entrada.

3.   tipo_dato nombre_funcion(void)

      En este caso tenemos una función que devuleve un valor (en este caso segun el tipo de dato ya sea int,char,float,etc) y no tiene parámetros de entrada.

4.   tipo_dato nombre_funcion(parámetros)

      En este caso tenemos una función que devuleve un valor (en este caso segun el tipo de dato ya sea int, char, float,etc) y tiene parámetros de entrada.

EJEMPLO:

void funcion1()
{
   output_toggle(pin_b7);
}

void funcion2(int x)
{
   lcd_putc('\f');
   lcd_gotoxy(1,1);
   printf(lcd_putc,"valor_a=%2u",x);
}

int funcion3()
{
   int resultado;
   resultado=a+15;
   return resultado;
}

char funcion4(int y)
{
   return y;
}

Espero haber ayudado a todos mis lectores y les haya sido de gran ayuda conocer mas sobre el tema de programación de microcontroladores PIC

Descarga el código del programa AQUI

LES DEJO UN VIDEO EN DONDE EXPLICO TODO, HACIENDO UN PROGRAMA EN CCS COMPILER. SUSCRIBANSE AL CANAL QUE ESTARÉ SUBIENDO MAS TUTORIALES.

LEER MAS