Programació en C del PIC 16F690

Variables

Els noms de les variables poden estar formats per lletres, números i el signe _. Es distingeix entre majúscules i minúscules. El primer caràcter del nom d'una variable no pot ser un número. No podem fer servir les paraules reservades del C com a noms de variables.

Les variables s'han de declarar. Per declarar una variable s'escriu el seu tipus seguit del nom de la variable. Els tipus de variables s'indiquen amb una o més paraules que ens diuen la mida de la variable i com emmagatzema la informació. En alguns casos, per compatibilitat amb diverses versions de C, el mateix tipus pot tenir noms diferents. Les variables poden ser dels següents tipus:

A l'hora de guardar els valors de més de 8 bits a la memòria del microcontrolador, sempre es guarden de forma que a la primera posició de memòria hi ha els bits de menys pes.

En els tipus amb signe, els nombres negatius s'emmagatzemen en complement a dos. El complement a 2 d'un nombre binari s'obté complementant tots els bits i sumant 1 al resultat. Vegem un exemple amb el nombre -39 (decimal) expressat en 8 bits:

Si aquests 8 bits corresponguessin a valors sense signe podrien guardar valors de 0 a 255, per a 256 caldria ja un bit més. El número -39 es guarda amb signe de la mateixa manera que sense signe es guardaria 217 que és 256 (el següent al màxim) - 39.

Les variables reals són, en principi, de 24 bits però canviant la configuració del compilador poden ser de 32 bits. El rang de valors és el mateix amb 24 o amb 32 bits, la diferència és la precisió amb la que guarda els valors. Per triar-lo, picarem amb el botó dret sobre el nom del projecte i marcarem Properties. Se'ns obrirà una finestra nova on podrem triar-lo:

Les variables reals es guarden en un format de mantissa i exponent, és a dir un número multiplicat per una potència de 10. Això pot portar problemes en alguns casos. Per exemple, segons el contingut d'una variable quan li sumem 1 pot no canviar de valor. De la mateixa manera, en comparar números diferents però propers el microcontrolador es pot comportar com si fossin iguals.

Operacions entre variables de tipus diferents i canvi de tipus

Per fer una operació entre dues variables cal que aquestes siguin del mateix tipus. Si no ho són, la de tipus inferior serà convertida al tipus superior; llavors es farà l'operació. La taula anterior està ordenada de les de tipus inferior a les de tipus superior. També es canvia el tipus de variable quan el resultat de l'operació es guarda en una variable de tipus superior, però això es fa després d'operar. Per exemple:

int a, b;

	long c = a * b;

En aquest cas, a i b són int i l'operació es fara en int. Després el resultat es convertirà a long i es guardarà a c. Però, si els valors d'a i b són grans, pot passar que el resultat no càpiga en un int i, per tant, el valor de c no sigui correcte (encara que si el resultat hagués estat long sí hi hauria cabut.

Podem demanar explícitament que el valor d'una variable sigui canviat de tipus abans de fer una operació o assignació. Això es fa posant el tipus desitjat, entre parèntesi, davant de la variable. Per exemple:

int a, b;

	long c = (long) a * b;

Hauria de donar sempre el valor correcte ja que a es converteix a long abans d'operar amb b i això força a que el resultat sigui long.

Part entera d'un valor real

La funció round dona la part entera d'un nombre real, però el resultat és un altre valor real. Si volem guardar-lo en una variable entera cal fer, a més, un canvi de tipus.

int Enter;
float numReal;

  Enter = (int)round(numReal);

Vectors o llistes i matrius

Podem definir vectors o llistes posant entre els signes [ i ] el nombre d'elements. Cal tenir present que a l'hora de llegir un element concret la primera posició és la 0.

Podem fer sevir matrius indicant dos índexs on el primer serien les fileres i el segon les columnes. També hi pot haver més dimensions.

Alguns exemples de declaració de variables:

unsigned char LED;  				// Variable de 8 bits sense signe (0 a 255)
char Sortida;
char Llista[8];					// Tenim una llista amb 8 valors
char fig[3][8];					// Tenim una matriu de tres fileres i vuit columnes
long Valor;					// Variable entera de 32 bits amb signe
float Mida;					// Variable real

A la definició podem posar contingut als vectors i matrius.

char fig[3][8] = { {0b00111100, 0b01111110, 0b11111111, 0b11111111, 
                    0b11111111, 0b11111111, 0b01111110, 0b00111100},
                   {0b00000000, 0b00000000, 0b00000000, 0b01111110, 
                    0b01111110, 0b00000000, 0b00000000, 0b00000000},
                   {0b00000000, 0b00000000, 0b00000000, 0b01111110, 
                    0b01111110, 0b00000000, 0b00000000, 0b00000000} };

Els vectors i les matrius els podem fer servir així:

...
        PORTC = Llista[LED];			// Busquem a la llista el valor que enviem al port
        Sortida = fig1[i][j];			// On i va de 0 a 2 i j va de 0 a 7
...

Cal tenir present que En C no podem tractar les llistes completes (tampoc les fileres o columnes de les matrius). Haurem de treballar element per element fent servir bucles.

Variables locals i elements constants

Les variables poden ser declarades amb especificacions. Segons les especificacions d'una variable, el compilador la guardarà de forma diferent. A continuació tenim una llista d'especificacions:

Si, per exemple, la variable Llista és constant ens caldrà definir els valors i el compilador la pot guardar a la memòria de programa. Si volem, podem especificar l'adreça on l'ha de guardar emprant la indicació __at.

const char Llista[8] __at(0x180) = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};

Les variables globals (les que definim abans de main) es guarden en la memòria de dades i són accessibles des de qualsevol posició del programa. També podem definir variables locals dins d'una funció; aquestes es crearan a la pila i desapareixeran quan el programa surti de la funció.

També podeu consultar el manual del MPLAB XC8 al web de Microchip.

Aquesta obra d'Oriol Boix està llicenciada sota una llicència no importada Reconeixement-NoComercial-SenseObraDerivada 3.0.