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