Primeros Pasos con CCS encender un LED

    En la "entrada anterior" aprendimos a descargar e instalar el Compilador CCS, ademas  crear nuestro primer código fuente (vacío), en esta entrada aprenderemos un poco mas sobre como empezar a programar, para esto vamos a hacer el hola mundo de la electrónica, encender y apagar un LED.   Pero primero vamos a conocer un poco mas sobre este lenguaje de programación.

 Gestión de los puertos de Entrada y Salida: 

  Los puertos son el punto de comunicación entre el microncontrolador y el mundo exterior , a través de ellos se pueden recibir y enviar señales al exterior para efectuar procesos de control electrónico sobre otros dispositivos.
En el lenguaje CCS se pueden gestionar los puertos de 2 formas:

 1.- Declarando los registros TRISX y PORTX.

Se definen los registros PORTx y TRISx como bytes y se sitúan en la posición correspondiente de la memoria RAM. La directiva utilizada de C es #BYTE

 #BYTE variable=constante;

#BYTE TRISA = 0x85  //dirección del registro TRISA en el banco de memoria
#BYTE PORTA = 0x05  //dirección del registro PORTA en el banco de memoria
#BYTE TRISB = 0x86  //dirección del registro TRISb en el banco de memoria
#BYTE PORTB = 0x06  //dirección del registro PORTB en el banco de memoria

Una vez definidas estas variables se pueden configurar y controlar los puertos.

TRISA = 0xFF;   // todos los pines de entrada
TRISB = 0x00;   // todos los pines de salida
TRISC = 0x0F;   // 4 terminales de salida, 4 terminales de entrada

También podemos trabajar bit a bit con los registros o variables definidas previamente.

bit_clear(PIN_B0) ; //Pone a 0 el bit especifico de la variable
bit_set(PIN_B0); //Pone a 1 el bit especifico de la variable
bit_test(PIN_B0); //Muestra el bit especifico de la variable

o podemos definir todos los bits del puerto de una vez con:

PORTC = 0xFF;  //define todo el puertoA a 1 

2.- Utilizando las directivas especificas del compilador.

  El Lenguaje C admite unas directivas de compilación que le dicen al compilador cómo debe tratar los TRIS del puerto, esta es la manera mas simple de hacerlo y es la que usaremos.

Estas directivas son: USE FAST_IO, USE FIXED_IO, USE_STANDARD_IO

Si declaramos un puerto cómo #USE FAST_IO(PUERTO) 
Es el usuario quien debe asegurarse de que el sentido del pin es el correcto y para ello debe colocar antes de leer o escribir en el puerto correspondiente el SET_TRIS_X(0b00000000) para indicar el uso de entrada o salida de cada bit del puerto.

Si declaramos un puerto cómo #USE FIXED_IO(PUERTO_OUTPUTS=1,3,5,7) 
  El compilador genera e inserta en tu código los SET_TRIS_X(0b10101010) correspondientes a dicha declaración independiente del uso que tus instrucciones hagan después de dichos pines. Si has declarado con FIXED_IO de salida el pin 1 del puerto X y después lo lees el compilador no hará nada y estarás leyendo un puerto de salida.

Si por último declaramos el puerto cómo #USE STANDARD_IO(PUERTO)
   El compilador generará automáticamente e insertará antes de cualquier operación de entrada o salida de cualquier pin del puerto X los SET_TRIS_X() correspondientes a la instrucción que le sigue. Esto hace que los TRIS siempre estén de acuerdo con la instrucción a ejecutar. Si colocamos en nuestro código un OUTPUT_HIGH(PIN_B0) y el puerto B está declarado como #USE STANDARD_IO(B) justo antes del output habrá un TRIS declarando el PIN_B0 como salida, si a continuación ponemos un INPUT_(PIN_B0) el compilador pondrá ahora un TRIS para declarar PIN_B0 como entrada.

Este #USE STANDARD_IO(X) es el modo POR DEFECTO de todos los puertos en CCS si no se declara lo contrario.

Gestión de los puertos a través de Directivas:

output_X(valor);         //Por el puerto correspondiente saca el valor (0-255).
input_X();               //Se obtiene el valor en el puerto correspondiente.
set_tris_X(valor);       //Carga el registro TRISx con el valor (0-255)
port_b_pullups(true);    //Habilita  las  resistencias pul-up en el PORTB .        
get_trisX();             //Devuelve el valor del registro TRISx (x es A,B,C,D…)

Las funciones para trabajar bit a bit son:

output_low(pin*)  //Pin a 0.
output_high(pin*)  //Pin a 1
output_bit(pin*,valor)   //Pin al valor especificado
input(pin*);   //Lee el valor del pin.

Estructuras de Control Repetitivas

  Las estructuras de control repetitivas o iterativas, también conocidas como bucles se pueden usar cuando se quiere repetir  cierta parte del código n veces, otras permiten repetir un segmento de código cuando se cumplen ciertas condiciones.  

Bucle WHILE
  Este bucle ejecuta una instrucción o un conjunto de instrucciones mientras la condición se cumpla, generalmente a la condición se le coloca el valor true, para que siempre se repita.

while(condición)
 {
 segmento de código a repetir
 }

Bucle FOR
Este bucle permite ejecutar una instrucción o un bloque de instrucciones una cantidad determinada de veces. se suele reemplazar por el ciclo while cuando se conoce o se desea un cierto numero de iteraciones.

for(int i=0;i<10;i++)
 {
 bloque;
 }

Configuración de los FUSES

 La directiva FUSES establece los distintos bits de configuración del micro, los mismos que puedes seleccionar en tu software de grabación.
Cada micro tiene los suyos, y los podrás encontrar en el apartado "Configuration Word" del correspondiente datasheet, En CCS puedes encontrar los fuses correspondientes al microcontrolador que estamos usando en el menú VIEW > CONFIG BITS.

Nos aparecerá una lista con todos los fuses de microcontrolador que seleccionamos.

 

De esta lista los mas importantes son: 

WDT (Watchdog Timer):

#fuses WDT
#fuses NOWDT

El famoso "perro guardian" del pic. Esta es una capacidad del pic de autoresetearse. Es muy útil, por ejemplo si un Pic, por un descuido de programación, se queda en un bucle infinito, esta "utilidad" lo sacará de él. Su funcionamiento es sumamente sencillo. Simplemente es un registro que debemos borrar cada cierto tiempo. Si transcurrido un cierto tiempo el registro no ha sido borrado el pic se resetea.

OSC (Oscilador):

#fuses HS
#fuses XT 

Es el modo de oscilación que va a usar el Pic, los mas usados son:
XT:  viene de XTAL (cristal). Este modo de funcionamiento implica que tendremos que disponer de un cristal de cuarzo externo al Pic y dos condensadores.
HS: Para cuando necesitemos aplicaciones de "alta velocidad", mas de  8Mhz. Se basa también en un cristal de cuarzo, como el XT.

 PUT (Power Up Timer Reset):

#fuses PUT
#fuses NOPUT

Si activamos este FUSE, lo que conseguimos es que se genere un retardo en la inicialización del Pic. Esto se usa para que la tensión se estabilice, por lo que se recomienda su uso.

 Ahora  ya tenemos los conocimientos básicos necesarios para realizar nuestro primero proyecto el hola mundo de la electrónica encender y apagar un LED, vamos allá.


PROYECTO: Encender y apagar un LED, ademas agregar un retardo para que el encendido y apagado del led pueda ser visualizado correctamente. 

Código:

#include <16f886.h>         //definimos que microncontrolador usaremos     
#fuses nowdt                //no usar el WDT (watchdog timer)
#use delay(clock=20M)       //definimos un cristal de 20Mhz. 
void main()                 //declaramos la función principal
{
   while(true)              //bucle infinito
   {
   output_high(pin_b0);     //Pin B0 en alto
   delay_ms(200);           //retardo de 200ms
   output_low(pin_b0);      //Pin B0 en bajo
   delay_ms(200);           //retardo de 200ms
   }
}

Esquema Proteus: