Programación PIC en C

 

Volver al índice

 

El lenguaje C dispone de una gran cantidad de operadores que nos sirven para operar con los datos dentro de nuestros programas, se pueden clasificar en varios apartados: aritméticos, relacionales, de asignación, de manejo de un solo bit, etc. Pero lo importante no es saber a qué grupo pertenece cada operador, sino en conocer la operación que se puede realizar con cada uno de ellos. Vamos a ver los operadores que nos permite utilizar nuestro compilador CCS.

 

 

  • Operadores Aritméticos: permiten la realización de operaciones matemáticas en nuestros programas.

 

OperadorDescripción
+
Suma
-
Resta
*
Multiplicación
/
División
%
Módulo (Resto de una división entera)
++
Incrementa en uno el valor del operando
--
Decrementa en uno el valor del operando

 

  • Operadores relacionales: compara dos operandos y devuelve 1 (verdadero) ó 0 (falso) según el resultado de la expresión. Se utilizan principalmente para elaborar condiciones en las sentencias condicionales e iterativas que se verán más adelante.

 

OperadorDescripción
<
Menor que
>
Mayor que
<=
Menor o igual que
>=
Mayor o igual que
==
Igual a
¡=
Distinto de

 

  • Operadores de asignación: permiten asignar valores a las variables. Tenemos las siguientes.

 

OperadorDescripción
+=
Asignación de suma. x+=y es lo mismo que x=x+y
-=
Asignación de resta. x-=y es lo mismo que x=x-y
*=
Asignación de multiplicación. x*=y es lo mismo que x=x*y
/=
Asignación de división. x/=y es lo mismo que x=x/y
%=
Asignación de resto de división. x%=y es lo mismo que x=x%y
<<=
Asignación de desplazamiento a la izquierda. x<<=y es lo mismo que x=x<<y
>>=
Asignación de desplazamiento a la derecha. x>>=y es lo mismo que x=x>>y
&=
Asignación de AND de bits. x&=y es lo mismo que x=x&y
|=
Asignación de OR de bits. x|=y es lo mismo que x=x|y
^=
Asignación de OR exclusivo de bits (XOR). x^=y es lo mismo que x=x^y

 

  • Operadores Lógicos: Al igual que los operadores relacionales, éstos devuelven 1 (verdadero), 0 (falso) tras la evaluación de sus operandos. La tabla siguiente ilustra estos operadores.

 

OperadorDescripción
!
NO lógico
&&
Y lógico
||
O lógico

 

  • Operadores de manejo de bits: Estos operadores permiten actuar sobre los operandos para modificar un solo bit, los operandos sólo pueden ser de tipo entero (incluyendo el tipo char).

 

 

OperadorDescripción
~
Negación de bits (complemento a 1)
&
Y de bits (AND)
|
O de bits (OR)
^
O exclusivo de bits (XOR)
>>
Desplazamiento a la derecha
<<
Desplazamiento a la izquierda

 

  • Operadores para manejar punteros: En el lenguaje C está muy difundido el uso de punteros, este compilador permite su uso y los operadores que utiliza para ello son los siguientes:

 

OperadorDescripción
&
Operador de dirección
*
Operador de inderección
->
Acceder a los miembros de una estructura por medio de punteros

 

Los que se inician en el mundo de la programación suelen encontrar complicado el emplear punteros en sus programas pero, una vez que se entiende el concepto se simplifica y optimiza mucho nuestro código. Ya dijimos que el PIC dispone de unos registros de propósito general (GPR) que el programador utiliza para almacenar allí sus variables y poder utilizarlas a lo largo del programa, pues bien un puntero es otra variable a la cual se le asigna la dirección del registro ó memoria de otra variable.

 

 

La forma de utilizar los punteros lo veremos en profundidad más adelante, pero aquí tienes un pequeño ejemplo de cómo utilizarlos.

 

 

Ejemplo:

 

 

int y,z; //declaración de las variables x e y de tipo entero:

 

int *x; //declaración de la variable puntero x que guardará la dirección de memoria de una variable de tipo entero.

 

x=&y; // a través del operador de dirección (&) le asigno al puntero x la dirección de memoria donde está guardada la variable y.

 

z=*x; //a través del operador de inderección (*) le asignamos a z el valor de la variable cuya dirección está almacenada en la variable puntero x.

 

 

Nota: como vemos los símbolos de dirección (&) e inderección (*) son los mismos que el AND en el manejo de bits (&) y el operador aritmético de multiplicación, el compilador los diferencia según los operandos que le preceden.


  • Precedencia de los operadores:

 

 

Expresiones en orden descendente de precedencia
(expr)
!expr ~expr ++expr expr++ --expr expr --
(type)expr *expr &value sizeof(type)
expr*expr expr/expr expr%expr
expr+expr expr-expr
expr<<expr expr>>expr
expr<expr expr<=expr expr>expr expr>=expr
expr = = expr expr!=expr
expr&expr
expr^expr
expr | expr
expr&& expr
expr || expr
expr ? expr: expr
value = expr value+=expr value-=expr
value*=expr value/=expr value%=expr
value>>=expr value<<=expr value&=expr
value^=expr value|=expr expr,expr

 

Las operaciones con mayor precedencia se realizan antes que las de menor precedencia.
Si en una operación encontramos signos del mismo nivel de precedencia, dicha operación se realiza de izquierda a derecha.

Ejemplo:

a*b+c/d-e

Las operaciones se realizarán en el siguiente orden:

1. a*b resultado = x
2. c/d resultado = y      
3. x+y resultado = z      
4. z-e     

Nota: Es aconsejable el uso de paréntesis para evitar errores en la precedencia de operadores, además el código fuente queda más legible.

Ejemplo:

a*(b+c)+d

En este caso el orden en realizarse las operaciones será el siguiente:

1. b+c resultado = x

2. a*x resultado = y

3. y+d

sizeof(type)--> nos da el tamaño en bytes del tipo de dato ó variable que le pongamos entre los paréntesis.

Para conocer bien los resultados que se obtienen al utilizar cada uno de los operadores, lo mejor es practicar con ellos. Vamos a ver un ejemplo donde se muestra el uso de algunos de ellos:

 

 

Operadores

 

 

Comentario del programa:

En este ejemplo introducimos unos valores por el teclado del ordenador y se los enviamos al pic via serie por el dispositivo RS-232, luego realizaremos diferentes operaciones con ellos y mostraremos el resultado en la Terminal, pero hay que tener en cuenta que que esos valores que introducimos por el teclado son caracteres y por tanto no se los podemos asignar directamente a una variable de tipo entero para operar con ellos, primero tenemos que convertirlos. CSS nos proporciona las siguientes funciones para ello:

 

 

- atoi(cadena) --> devuelve un valor entero de 8 bits de tamaño.

- atol(cadena) --> devuelve un valor entero de 16 bits

- atoi32(cadena) --> devuelve un valor entero de 32 bits

 

 

Para saber el rango de valores admisible por cada función repasa los tipos de datos

 

 

Estas funciones están definidas en el fichero de cabecera stdlib.h, por tanto no hay que olvidarse de incluirlo previamente por medio de la directiva: #include <stdlib.h>.

 

 

Fijaros en la instrucción de la línea 31 que nos da el tamaño de la variable y:

 

 

printf("El tama\xa4o de y es: %d bytes\r",sizeof(y));

 

 

\xa4 --> es la secuencia de escape para representar la letra ñ. Esto es porque el compilador no reconoce los caracteres en castellano.

 

 

Tabla equivalente de caracteres en castellano:

 

á
\xa0
é
\x82
í
\xa1
ó
\xa2
ú
\xa3
Á
\xb5
É
\x90
Í
\xd6
Ó
\xe0
Ú
\xe9
ñ
\xa4
Ñ
\xa5
¿
\xa8

 

La salida del programa para los valores de x=50 e y=6 es la siguiente:

 

Salida ejemplo Operadores

 

 

El código fuente y el DSN de proteus lo tenéis aqui.

 

Una precaución que tenemos que tener en cuenta es que si utilizamos valores numéricos grandes y un PIC con poca memoria RAM, pronto la agotaremos. Esto solo es un ejemplo teórico del uso de operadores aritméticos, aplicaciones prácticas puede tener muchas, depende de lo que quieras hacer.

 

Un ejemplo sencillo pero práctico, lo tienes aquí.

 

 

Espero vuestros comentarios y cualquier duda ó error que veáis en el ejemplo, lo podéis exponer aquí.

 

 

Volver al índice

© 2007-2017 AquiHayapuntes.com