Programació en C del PIC 16F690

Diversos polsadors connectats a una sola entrada

En alguns casos ens cal fer servir uns quants polsadors (o interruptors) però ens preocupa ocupar moltes entrades amb ells. Una solució al problema és llegir tots els polsadors des d'una entrada analògica. Hi ha diverses formes per a fer-ho però la que presentem aquí ens permet connectar fins a cinc polsadors i de forma que podem detectar si es premen dos o més polsadors al mateix temps. El circuit que farem servir es el de la figura següent:

Mentre no hi ha cap polsador premut, atès que no pot circular corrent, l'entrada RA2 està connectada a 0 V a través de la resistència d'1 kΩ; per tant, llegirem aproximadament un valor zero.

Si premem el polsador P1 tindrem dues resistències en sèrie i, per tant, el corrent que circularà tindrà aproximadament el següent valor:

A l'entrada analògica hi haurà una tensió que correspon al producte de la resistència comuna pel corrent que hi passa:

Fent la conversió, podem saber el valor aproximat que veurem a la sortida del conversor analògic-digital:

La següent taula ens indica els valors corresponents als cinc polsadors. Atès que és més fàcil comparar amb només vuit bits, la darrera columna ens mostra els valors que obtindríem a ADRESH si configurem el conversor amb el resultat justificat per l'esquerra.

Les lectures no seran exactament aquests valors ja que depenen de la tensió d'alimentació i de la precisió de les resistències que fem servir. Per això és recomanable fer correspondre un rang de valors a cada polsador. En el nostre cas, hem posat que la lectura estigui entre deu unitats per sota i deu unitats per sobre del valor de la taula.

Si premem dos polsadors a la vegada, per exemple P1 i P3, tindrem les dues resistències en paral·lel:

que dona una tensió de 4,3 V i una lectura de 878.

Si volem detectar la pulsació de més d'un polsador, haurem de fer servir marges de comparació força estrets. En aquest cas és recomanable veure quines són les lectures reals a l'hora de definir els marges.

La següent funció llegeix els polsadors i retorna el número del polsador actiu. No s'ha contemplat que es puguin prémer dos polsadors al mateix temps.

El programa de l'exemple PA permet provar-ho.

char Polsador(void) {
	char Pols = 0;
	ADCON0bits.GO = 1;		// Posa en marxa el conversor
	while (ADCON0bits.GO == 1)	// Mentre no acabi
		;    			// ens esperem
	if (ADRESH < 220 && ADRESH > 200) {
		Pols = 1;		// Comprova polsador 1
	}
	if (ADRESH < 194 && ADRESH > 174) {
		Pols = 2;		// Comprova polsador 2
	}
	if (ADRESH < 163 && ADRESH > 143) {
		Pols = 3;		// Comprova polsador 3
	}
	if (ADRESH < 90 && ADRESH > 70) {
		Pols = 4;		// Comprova polsador 4
	}
	if (ADRESH < 55 && ADRESH > 35) {
		Pols = 5;		// Comprova polsador 5
	}
	return Pols;
}

El següent programa ens permet mostrar a la pantalla els valors llegits a l'entrada analògica. Així, podem veure quin valor correspon a cada polsador i ajustar els rangs a les resistències concretes de la nostra placa i a la tensió d'alimentació que estem fent servir.

#pragma config FOSC = INTRCIO, WDTE = OFF, PWRTE = OFF, MCLRE = OFF, CP = OFF
#pragma config CPD = OFF, BOREN = OFF, IESO = OFF, FCMEN = OFF
#include <xc.h>  // Carrega el fitxer de funcions necessari per al compilador XC8
#define _XTAL_FREQ  4000000  // La freqüència del rellotge és 4 MHz

unsigned int Lectura;  // Valor llegit
char Digits[5];  // Variable amb el número dígit a dígit
  // Digits[0] són les unitats

// Definició de les funcions que farem servir 
void EnviaL(char Caracter);  // Envia un caràcter
void Esborra(void);  // Esborra la pantalla i posa el cursor a l'inici

void main (void){
  TRISC = 0b00000000;  // Posa el port C com a sortida
  TRISB = 0b00000000;  // Posa el port B com a sortida
  TRISA = 0xFF;  // Posa el port B com a entrada
  ANSEL = 0;  // Desactiva totes les entrades analògiques
  ANSELH = 0;  
  ANSELbits.ANS2 = 1;  // I ara activa la dels polsadors (AN2)
  ADCON1 = 0b00010000;  // Posa el conversor a 1/8 de la freqüència
  ADCON0 = 0b00001001;  // Activa el conversor connectat a AN2
  // amb el resultat justificat per l'esquerra
  __delay_ms(2000);  // Esperem que arrenqui la pantalla
  TXSTAbits.BRGH = 1;  // Configuració de velocitat
  BAUDCTLbits.BRG16 = 0;  // Paràmetre de velocitat de 8 bits
  SPBRG = 25;  // Velocitat de 9600 baud
  TXSTAbits.SYNC = 0;  // Comunicació asíncrona
  TXSTAbits.TX9 = 0;  // Comunicació de 8 bits
  RCSTAbits.SPEN = 1;  // Activa comunicació sèrie
  TXSTAbits.TXEN = 1;  // Activa comunicació
  while (1){  // Bucle infinit
    Esborra();  // Esborra la pantalla i posa el cursor a l'inici
    ADCON0bits.GO = 1;  // Posa en marxa el conversor
    while (ADCON0bits.GO == 1)  // Mentre no acabi
      ;  // ens esperem
    Lectura = ADRESH;
    for (signed char j = 0; j < 3; j++){  // 3 dígits
      Digits[j] = (Lectura % 10) + '0';  // Li sumem el codi ASCII de 0
      Lectura = Lectura / 10;
    }
    for (signed char j = 2; j >= 0; j--){  // 3 dígits
      EnviaL(Digits[j]);
    }
    __delay_ms(1000);  // Retard per permetre la visualització
  }
}

void EnviaL(char Caracter) {
  TXREG = Caracter;  // Agafa el caràcter i l'envia
  __delay_ms(1);  // Donem temps
  while (PIR1bits.TXIF == 0)  // Esperem que s'acabi d'enviar
    ;  // No fem res
}
void Esborra(void) {
  EnviaL(254);  // Caràcter de control
  EnviaL(1);  // Esborra la pantalla i posa el cursor a l'inici
}

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