Programacion en CCS Compiler de Microcontroladores PIC, sentencias y codigos de todos los programas. Archivos y libros relacionados a la programacion de PIC en lenguaje C.
Libros, revistas y textos que le serviran para ampliar su conocimiento en los diferentes temas de la electrónica.Dale click en la pestaña LIBROS de la parte superior.
MATLAB combina un entorno de escritorio perfeccionado para el análisis
iterativo y los procesos de diseño con un lenguaje de programación que
expresa las matemáticas de matrices y arrays directamente.
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
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)
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.
int1 x; //x es una variable de 1 bit, es decir puede tomar el valor de 0 y 1
int y; //y es una variable de 8 bits, es decir puede tomar valores entre 0 y 255
float z; //z es una variable de 32 bits, los valores de la variable permite decimales
char w; //w es una variable de 8 bits, es del tipo carácter
signed int16 v; //v es una variable de 16 bits, pero puede almacenar valores positivos y negativos
CONSTANTES
A diferencia de las variables, el valor de las constantes se mantienen fijas, es decir no podemos modificar su valor. Este tipo de datos es alamcenado en la memoria ROM del PIC.
Para declarar un tipo de dato que sea constante se usa la siguiente sintaxis:
tipo const nombre_variable = valor; o const tipo nombre_variable = valor;
EJEMPLOS:
int const x = 0xF0; //la constante x es de 8 bits cuyo valor decimal es 240
char const w = 'h'; //la constante w es de 8 bits, cuyo valor es el caracter 'h'
const int y = 255;
ARRAYS
Es un tipo de dato estructurado que nos va a permitir almacenar un conjunto de datos homogéneos, es decir el mismo tipo de datos. Se declara de a siguiente manera:
tipo nombre_array [# elementos] ={valor1,valor2,.....,valorn};
Los valores se pueden indicar o no
EJEMPLOS:
int8 vector[4] = {0x00,0b00011000,250,0xFF};
En este caso tenemos un array de nombre vector, donde se tiene almacenados 4 valores, estos se indican entre llaves. Todos los datos del array son de 8 bits, según esta indicado.
int16 temp[10];
En este caso tenemos array donde los datos que se almacenarán serán de 16 bits. la cantidad de de datos se indica en corchetes Los valores no estan indicados.
char letra[5] = {"hola"};
En este caso tenemos una array donde se almacenan datos de tipo char (8 bits), como vemos se tiene almacenado un string(cadena de carácteres) de 4 elementos. El último elemento de la cadena siempre debe ser NULL (valor 0x00). El elemento NULL marca el fin de los carácteres útiles de la cadena.
El ejemplo mostrado también se pudo definir de otras manera, lo cual se muestra a continuación:
char letra[5] = "hola"; o char letra[5]={'h','o','l','a'};
Para poder acceder a uno de los datos guardados en alguna variable o constante lo unico que hacemos es llamar el nombre del array y la posicion que ubica. Lo explicaremos a traves del siguiente ejemplo:
int8 vector[6] = {15,16,17,18,19,20}; //vector es un array de 6 valores
Como podemos ver en la imagen, cada valor ocupa un lugar en el array; el lugar lo podemos ver de color rojo. Entonces tenemos lo siguiente:
vector[0]=15
vector[1]=16
vector[2]=17
vector[3]=18
vector[4]=19
vector[5]=20
de esta manera podemos acceder al valor de cada posición del array.
ARRAY MULTIDIMENSIONAL
Es un array de varias dimensiones, se decalara de la siguiente manera
tipo nombre_array[i][j];
i= numero de filas, j=numero de columnas
Al igual que en el array unidimensional se le puede asignar valores
EJEMPLO:
const int arreglo[3][4] = {{0,1,2,3}, //Se tiene un arreglo de 3 filas y 4 columnas
{4,5,6,7},
{8,9,10,11}};
También se pudo declarar de la siguiente manera:
const int arreglo[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};
// el compilador asignará a los primeros 4 valores como una fila y asi sucesivamente.
Para poder acceder a los valores del arreglo hacemos lo siguiente:
arreglo[0][0]=0
arreglo[0][3]=3
arreglo[2][0]=8
arreglo[2][2]=10
arreglo[2][3]=11
Espero haber ayudado a todos mis lectores y les haya sido de gran ayuda conocer mas sobre el tipo de datos que se manejan durante la programación de microcontroladores PIC
