P á g i n a | 1

PIC16F887/877 de programación en C Tutorial 1 (Introducción)

En este tutorial te mostraré cómo programar en C. PIC16F887/877Así que en primer lugar , descarga mikroC PRO for PIC compilador también descargar el manual del usuario. Después de esto crear un nuevo proyecto elige P16F887 o 877 lo que tengas, y 4MHz cristal, etc Si usted no sabe cómo crear un nuevo proyecto de referirse a su manual o descargar el documento "cómo crear el primer proyecto" de su sitio.

Nota: Voy a utilizar PIC16F887 y 4MHz cristal externo (aunque también tienen PIC16F887 cristal interno) que puede utilizar 8MHz y lo que nunca.Para el ajuste del oscilador 4MHz debe ser XT en tanto que para 8MHz o por encima de ella debe ser HS (véase la figura a continuación).

Vamos a empezar con 'cazador de LED' un programa sencillo, antes de comenzar a esto le permite ver los pines del PIC16F887.

pinout del PIC16F887

Como puedes ver hay cinco puertos múltiplexados I / O, en el PIC16F887, de PortA a Port E. Para nuestro primer programa, que sólo necesita un puerto, digamos PORTD y 5v en los pines 11 y 32, los pines de tierra 12 y 31, 4 MHz Xtal en los pines 13 y 14. No tenga pánico va a ver más de un nombre de pines, te diré las funciones de las patillas cuando las usemos.

P á g i n a | 2

Después de crear el proyecto, escribir el código de abajo en mikroC IDE y compilarlo, si desea cambiar la configuración del proyecto, los bits de fusibles, etc reloj, ir a proyecto >> Proyecto >> edición.

Código:void main() {        int x[]={1,2,4,8,16,32,64,128,256};  // int array        int i;        portc=0;      //to clear port        trisc=0;        //as output

///////////////////// comment this block if you are using pic16f877a/////////        ANSEL  = 0;                        // Configure AN pins as digital I/O        ANSELH = 0;                C1ON_bit = 0;                      // Disable comparators        C2ON_bit = 0; ////////////////////////////////////////////////////////////////////

 while(1){         for(i=0; i<=8; i++){         portc=x[i];         delay_ms(100);      }          //for bracket

         }            //while bracket 

}                //main bracket

Ahora vamos el código; primero seleccione el puerto que desea utilizar, en este caso es PORTC. A continuación, limpie el poniéndolo a cero. TrisX, el SFR se utiliza para configurar el puerto como entrada o salida, donde X puede ser A, B, C, D y E, el puerto que está utilizando. TRISC = 0, significa que el PORTC se ha seleccionado como salida. Para que se comporte como entrada, cambiarlo a TRISC = 1; significa que todos los pines de PORTC, listos como entrada. Si quieres tener i / p en el pin

P á g i n a | 3

único en lugar de todos, a continuación, utilizar trisxy_bit = 1, donde y podría ser de 0 a 7, el pin que menos quiero tener i / p y y es el puerto correspondiente.

Hay dos comparadores en el 887, para desactivarlos, asignar los bits 0 a C1 y C2. Además de utilizar pines de E / S digita,l asignar a Ansel y anselh=0, no tengas pánico cuando hablamos del ADC, luego te diré acerca de esto. Nótese que para 877A estas dos cosa no son necesarias.

Ahora para el lazo, como de cazador del LED, queremos una secuencia que es 1,2,4 hasta el 256, como el puerto es de 8 bits, por lo que 2 ^ 8 = 256, es decir ¿por qué guardar estos valores en una matriz?.Para poderr visualizarlos, tenemos que añadir un poco de retraso, para ello escribir delay_ms (100), por 100 ms de retardo. Se puede aumentar si usted quiere.

Como queremos ver nuestra o / p de forma continua, no sólo por una sola vez, se utiliza un bucle while, mientras que (1) significa que este bucle se ejecutará siempre.

proyecto de ajuste

Esquema: Buscar el archivo hexadecimal, de este proyecto, ejecutarlo en Isis y simularlo. No se olvide de adjuntar un circuito de reset.

P á g i n a | 4

Circuito de reset:

P á g i n a | 5

PIC16F887/877 de programación en el Tutorial C 3-1 (Timer 0)TemporizadoresTanto PIC16F887 y 877 tienen tres temporizadores; timer0, timer1 y el timer2. Timer0 es de 8-bits y también se puede utilizar como contador, timer1 es de 16-bit de temporización, así como un contador, el timer2 es de 8-bit de temporización y puede utilizarse como la base de tiempo PWM para el modo PWM de el módulo CCP (s). 

Timer0:El temporizador Timer0 módulo / contador tiene las siguientes características:

8-bit del temporizador / contador De lectura y escritura 8-bit software programable prescaler Reloj interno o externo, seleccione Interrupción por desbordamiento de FFh a 00h Borde de selección (de subida o bajada) de reloj externo

El modo del temporizador se selecciona limpieando los bits del T0CS (OPTION_REG <5>). En el modo de temporizador, el módulo Timer0 se incrementa cada ciclo de instrucción (sin prescaler).

El modo de contador se selecciona mediante el establecimiento de T0CS bits (OPTION_REG <5>). En el modo contador, Timer0 se incrementará, ya sea en cada flanco ascendente o descendente del pasador RA4/T0CKI. El borde de incremento está determinado por el bit Fuente Timer0 Edge Select, T0SE (OPTION_REG <4>). T0SE bit selecciona el flanco de subida.

Timer0 tiene un registro llamado TMR0 Registro, que es de 8 bits de tamaño. Se puede escribir el valor deseado en el registro que será incremento como el programa avanza. La frecuencia varía dependiendo del preescalador. El valor máximo que se puede asignar a este registro es 255.

TMR0IF -. TMR0 interrupción de desbordamiento del bit de la bandera de la interrupción de TMR0 se genera cuando los desbordamientos de TMR0 registro de FFh a 00h. Este desbordamiento establece el bit TMR0IF (INTCON <2>).

P á g i n a | 6

Prescaler - Divisor de frecuencia.Podemos utilizar prescaler para dividir aún más la frecuencia de reloj, el ERE opciones:  

      PS2: PS0 TMR0 tasa de          000 1:02          001 1:04          010 1:08 

         011  1:16         100 0 1:32 

         1:64 101          110 1:128 

         111 1 : 256 

Registro Opción: Opción de registro es un registro de 8 bits utilizado para inicializar el timer0.

Cálculo de Contador, Frecuency out, y los valores de TMR0:

P á g i n a | 7

Si se utiliza cristal interno como el reloj, la división se realiza de la siguiente manera: 

 

Fout -. La frecuencia de salida después de la división 

Tout - El tiempo de ciclo después de la división. 

4 - La división del reloj original por 4, cuando se utiliza como reloj interno de cristal (y no oscilador externo). 

Conde - Un valor numérico que se coloca para obtener la frecuencia de salida deseada - Fout. 

(256 - TMR0) - El número de veces en el temporizador contará a partir del registro TMR0. Si se usa reloj externo fuente (oscilador), la división se realiza de la siguiente manera:

 

En este caso no hay una división por 4 del reloj original. Usamos la frecuencia externa tal como es. 

Código:Ahora vamos a escribir el código de 0,5 segundos de retardo;

void main() {

P á g i n a | 8

   // using 4MHz ext xtal     int count=0;     trisc=0;     portc=255;     tmr0=0;

 ///////////////// comment 4 pic16f877/////////     ansel=0;     anselh=0;          c1on_bit=0;     c2on_bit=0;////////////////////////////////////////////

     t0se_bit=0;          //  low to high edge trigger     t0cs_bit=0;          // using internal clk     psa_bit=0;            //using prescaler     ps0_bit=1;            //prescaler 256     ps1_bit=1;     ps2_bit=1;

    while(1){

        while(!tmr0if_bit);        tmr0if_bit=0;        cunt++;

     if(cunt==8){                       //delay 0.5 sec(256*256u*8)         portc=~portc;         cunt=0;     } }}

P á g i n a | 9

Esquema:

PIC16F887/877 Tutorial de programación en C 3-2 (Temporizador 1)Timer 1:El módulo Timer1 es un temporizador de 16 bits / contador que consta de dos registros de 8 bits (TMR1H y TMR1L) que son de lectura y escritura. El par TMR1 registro (TMR1H: TMR1L) incrementos de 0000h a FFFFh y da la vuelta a 0000h.

Timer1 puede ser activado / desactivado mediante la creación / borrado de bit de control, TMR1ON (T1CON <0>). El bit TMR1CS del registro T1CON se utiliza para seleccionar la fuente de reloj. Cuando TMR1CS = 0, la fuente de reloj es FOSC / 4.Cuando TMR1CS = 1, la fuente de reloj es suministrada externamente.

La interrupción TMR1, si está habilitado, se genera en caso de desbordamiento, que se enclava en el bit indicador de interrupción, TMR1IF (PIR1 <0>). Esta interrupción puede ser activado / desactivado mediante la creación / borrado de habilitación de interrupción TMR1 poco, TMR1IE (PIE1 <0>). 

TMR1IF -. TMR1 desbordamiento de bits bandera de interrupciónEste indicador marca el final del recuento de un ciclo. La bandera debe ser reajustada en el software si quieres hacer otro conteo de ciclos. Podemos leer el valor del TMR1 registro y escribir en el. Podemos restablecer su valor en un momento dado (de escritura) o podemos comprobar si hay un determinado valor numérico que necesitamos (leer).  

P á g i n a | 10

Timer1 tiene cuatro opciones precontador permitiendo divisiones 1, 2, 4 u 8 de la entrada de reloj. Los bits del registro T1CKPS T1CON controlar el contador de preescala. El contador no es directamente preescala leer o escribir, sin embargo, el contador de prescaler se borrará con una escritura en TMR1H o TMR1L.

T1CON Registro;Llevamos a cabo todos los ajustes necesarios con T1CON registro. Como podemos ver, el tamaño del registro es de 8 bits. Vamos a explorar las partes más importantes:

Cuando, como T1CON de 887 bits también tienen 6 y 7;bit 7 T1GINV: Timer1 Puerta Invertir bits (1)                       1 = Timer1 puerta está activa-alta (Timer1 cuenta cuando la puerta es alta)                       0 = Timer1 puerta es baja activa (Timer1 cuenta cuando la puerta es baja)

bit 6 TMR1GE: Puerta de Timer1 Habilitar bits (2)                      Si TMR1ON = 0:                      Este bit se ignora

                     Si TMR1ON = 1:                      1 = recuento Timer1 es controlado por la función de puerta Timer1                      0 = Timer1 siempre está contando

P á g i n a | 11

Cálculo de Contador, Fout, y los valores Timer1Si se utiliza cristal interno como el reloj, la división se realiza de la siguiente manera:

 

Fout -. La frecuencia de salida después de la división Tout - El tiempo de ciclo después de la división. 4 - La división del reloj original por 4, cuando se utiliza como reloj interno de cristal (y no oscilador externo). Conde - Un valor numérico que se coloca . para obtener la frecuencia de salida deseada - Fout (65536 - TMR1) . - El número de veces en el temporizador contará a partir del registro TMR1 

Código:Ahora vamos a escribir el código para cambiar los bits de PORTC después de 1 segundo; void main() {    // using 4MHz ext xtal     int count=0;     trisc=0;     portc=255;//////////////comment this block if you are using 877////////      ansel=0;     anselh=0;     c1on_bit=0;     c2on_bit=0; ///////////////////////////////////////////////////////          t1con=1;             //tmr1 on bit is set     tmr1h=0;           //begin with 0     tmr1l=0;         while(1){        while(!tmr1if_bit);        //tmr1 flag bit

P á g i n a | 12

        tmr1if_bit=0;        count++;                         if(count==16){               //for 1 sec delay         portc=~portc;             //16*65535us=1sec         count=0;         }

  }}

Esquema:Timer 0 esquemática se puede utilizar (tutorial 3 parte 1). 

PIC16F887/877 Tutorial de programación en C 3-3 (temporizador 2)Timer 2:Timer2 es un temporizador de 8-bits con un pre-escalador y un postscaler. Se puede utilizar como la base de tiempo PWM para el modo PWM del módulo CCP (s). El registro TMR2 es lectura y escritura y se borra en cualquier reinicio del dispositivo.

La entrada de reloj (FOSC / 4) tiene una opción preescala de 1:1, 1:4 o 1:16, seleccionada por T2CKPS1 bits de control: T2CKPS0 (T2CON <01:00>). 

El módulo Timer2 tiene un registro período de 8-bits, PR2. Timer2 incrementos de 00h hasta que coincida con PR2 y luego se restablece a 00h en el ciclo siguiente incremento. PR2 es un registro de lectura y escritura. El registro PR2 se inicializa a FFh en Restablecer. 

La salida partido de TMR2 pasa a través de un postscaler 4-bits (que da una escala inclusiva 01:01-un y dieciséis minutos) para generar una interrupción TMR2 (enclavada en bit de bandera, TMR2IF (PIR1 <1>)). 

P á g i n a | 13

Timer2 puede ser cerrado -off por el bit de control claro, TMR2ON (T2CON <2>), para reducir al mínimo el consumo de energía.

Prescaler y Postscaler - Timer2 es un temporizador de 8 bits con un prescaler y un postscaler. Cada permite realizar la división adicional de la fuente de reloj de frecuencia. prescaler divide la fuente de reloj de frecuencia antes de la cuenta tendrá lugar en el TMR2 registro, por lo tanto el conteo en el interior del registro TMR2 se lleva a cabo sobre la base de la fuente de frecuencia de reloj dividida por el pre-escalador.Postscaler divide la frecuencia que sale del comparador.T2CON Registro:

¿Cómo calcular los valores necesarios de la Timer2: 

Fout -. La frecuencia de salida después de la división Tout - El tiempo de ciclo después de la división. 4 - La división del reloj original por 4, cuando se utiliza como reloj interno de cristal (y no oscilador externo). Conde - Un valor numérico que se coloca para obtener la frecuencia de salida deseada - FOUT. 

P á g i n a | 14

(PR2 - TMR2) - El número de veces que el contador contará. 

Código :  Le permite escribir el código para cambiar los bits de PORTC después de 2 segundos;

void main() {     // using 4MHz ext xtal     int count=0;     trisc=0;     portc=255;/////////////////// comment this block if you are using 877///////////     ansel=0;     anselh=0;     c1on_bit=0;     c2on_bit=0;////////////////////////////////////////////          t2con=124;         //prescaler is 16     pr2=255;            //final value to count     tmr2=0;              //initial value

     while(1){        while(!tmr2if_bit);        //tmr2 flag bit        tmr2if_bit=0;        cnt++;

     if(cnt==488){                //for 2 sec(16*256u*488=2sec)         portc=~portc;         cnt=0;         }

  }    }

P á g i n a | 15

Esquema:Timer 0 esquemática se puede utilizar (tutorial 3 parte 1). 

PIC16F887/877 de programación en C Tutorial 4 (contador)Contador:Temporizador 0 y 1 del temporizador puede ser utilizado como contador, también. La única diferencia es Timer0 puede contar hasta 256, donde, como Timer1 hasta 65.536, como Timer0 es de 8 bits y Timer1 es de 16 bits.

Para usar el temporizador 1 en la lucha contra acaba de establecer la TMRCS (Timer1 fuente del reloj Seleccione) bits, de T1CON reg. Contará cuando la señal se aplica a T1CK1 pin, RC0. Cuando, como, si desea utilizar el Timer0, a continuación, establecer los T0CS (TMR0 Clock Source Select) bits de registro opción. Se cuentan cuando la señal se aplica a T0CK1 pasador, RA4. También puede seleccionar el borde, ascendente o descendente, para activar el contador de a poco T0SE.

Código: Ahora vamos a escribir un código que contará hasta el 65536 y mostrar su número de LEDs conectados al PORTD y PORTB;

void main() {     //using 4MHz ext xtal     trisd=0;     portd=0;     trisb=0;     portb=0;

//////////////////////comment for 877 //////////////////////////     ansel=0;     anselh=0;     c1on_bit=0;     c2on_bit=0;/////////////////////////////////////////////////////////////

P á g i n a | 16

     tmr1l=0;     tmr1h=0;     t1con=3;     while(1){          if(!tmr1if_bit) {                           portd=tmr1l;              portb=tmr1h;          }          tmr1if_bit=0;

     }  }

Esquema:

P á g i n a | 17

PIC16F887/877 de programación en C Tutorial 5 (LCD Interfaz)LCD Interfaz:En este tutorial te mostraré cómo interfaz de 16x2 LCD con micro-controlador. 16x2 significa que hay dos filas y cada fila contienen un máximo de 16 caracteres. 

Para más detalles consulte la hoja de cristal líquido, el que está utilizando.Conexión básica:Se aplica 5v al pin 2 y GND a los pines 1 y 5. Utilice resistencia variable en el pin 3 para ajustar el contraste. Los pines 7 y 14 años son los pines de datos, se utilizan para enviar datos / rec. Pin 6 es de permitir que, cada vez que se escribe en pantalla LCD usted debe tener para dar de alta a baja, a este pin. el pin 4 es registrarse seleccione el uso del PIN para dar órdenes, como clara, etc, en casa  

En este tutorial voy a interfaz LCD de 4-bits en lugar de 8-bit, por lo que sólo requería cuatro pines de datos.

Código:Le permite escribir un código que mostrará el estado del motor y su dirección, sino que va a ser divertido!!

Requisitos:Diseñar un circuito de control del motor con L298 y mostrar su estado en la pantalla LCD. LCD está conectado al puerto B y el controlador de motor en el circuito es PORTD.Se requiere dos interruptores para cambiar la dirección del motor, y si ambos

P á g i n a | 18

son de apertura / cierre, el motor debe permanecer apagado. También los interruptores están conectados a PORTD.

// LCD module connectionssbit LCD_RS at RB4_bit;sbit LCD_EN at RB5_bit;sbit LCD_D4 at RB0_bit;sbit LCD_D5 at RB1_bit;sbit LCD_D6 at RB2_bit;sbit LCD_D7 at RB3_bit;

sbit LCD_RS_Direction at TRISB4_bit;sbit LCD_EN_Direction at TRISB5_bit;sbit LCD_D4_Direction at TRISB0_bit;sbit LCD_D5_Direction at TRISB1_bit;sbit LCD_D6_Direction at TRISB2_bit;sbit LCD_D7_Direction at TRISB3_bit;

// End LCD module connectionschar txt3[] = "Motor Direction";char txt2[] = "Clock Wise ";char txt1[] = "Counter C.W";char txt[]  = "Motor Off  ";

void main() {/////// comment for 877//////////////////     ansel=0;     anselh=0;          c1on_bit=0;     c2on_bit=0; ///////////////////////////////////////     trisd0_bit=0;     trisd1_bit=0;     trisd2_bit=0;     

P á g i n a | 19

     trisd3_bit=1;                 // CW dir     trisd4_bit=1;                  //CCW dir

     Lcd_Init();                    // lcd ini     Lcd_Cmd(_LCD_CLEAR);           //lcd clear     Lcd_Cmd(_LCD_CURSOR_OFF);     while(1){

      Lcd_Out(1,1,txt3);             //1row 1col      delay_ms(500);      if(rd3_bit){        Lcd_Out(2,1,txt2);        rd1_bit=0;        rd0_bit=1;      }              if(rd4_bit){        Lcd_Out(2,1,txt1);        rd0_bit=0;        rd1_bit=1;      }              if(rd3_bit & rd4_bit){             //invalid selction        lcd_out(2,1,txt);        rd0_bit=0;                       //to stop motor        rd1_bit=0;      }              if(!rd3_bit & !rd4_bit){           //inv sec        lcd_out(2,1,txt);        rd0_bit=0;        rd1_bit=0;      }      }

}

P á g i n a | 20

Este es el código simple de acuerdo a los requisitos a cabo. Para interconectar la pantalla LCD que debe tener para especificar el puerto (puerto de E / S), así como la SFR de ese puerto, está utilizando "LCD_RS sbit en RB4_bit 'y' LCD_RS_Direction sbit en TRISB4_bit 'haciendo este trabajo. Como estamos utilizando la pantalla LCD en cuatro bits es así, basta con especificar los cuatro pines de datos (pines 11 a 14 de la LCD), los pines de E y RS. txt1 de txt3 son la matriz de caracteres que contiene el mensaje que desea mostrar. Los pines 0, 1 y 2 del PORTD se configuran como O / P, mientras que los pines 3 y 4, i / p. L298 está conectado a la pins0-2 y los interruptores están en los pines 3 y 4. Después de fijar los pasadores para LCD que utiliza lcd_init (); un mikroC LCD función de biblioteca, para inicializar el LCD. Lcd_Cmd (char) se utiliza para enviar comandos al LCD como pantalla clara, fuera de curs0r etc Lcd_Out (fila char, columna char, char * text); Imprime el texto en la pantalla LCD a partir de la posición especificada, 1, fila 1 significa primero y la primera columna . Luego de una simple lógica de interruptores y sus funciones. L298 Conexiones: Una cosa importante es la conexión de la L298, ya que estamos usando OUT1 y OUT2 lo que tenemos que utilizar in1 in2 y, también hay que habilitar el PIN de la ENA para estas selecciones. Use una resistencia de 10 ohm para conectar entre el pin sensaciones y la tierra. Aplicar 9/12v a VCC, 9 pines, dependiendo de la tensión del motor y 5V en el pin 4, VC. Para cambiar a dirección sólo cambia el valor del bit de IN1 e IN2, o en otras palabras intercambiar estos valores. Si ambos tienen el mismo valor, 0 o 1, el motor no gira; como potencial es la misma, la corriente no puede fluir!. Esquema:

P á g i n a | 21

controlador de motor

PIC16F887/877 la programación en C Tutorial 6 (Interfaz del teclado)Teclado Interfaz:Este tutorial es sobre la interconexión de 4x3 (4 filas y 3 columnas) con el teclado micro-controlador con rutina de la biblioteca de mikroC. El uso de estas funciones es mucho más fácil de programa. La técnica básica es, hacer que los coloums como I / P y conducir las filas haciéndolos o / p, todo este procedimiento de leer el teclado se llama digitalización.

Con el fin de detectar que se pulsa la tecla de la matriz, hacemos líneas de fila bajo una por una y leer los coloums. Digamos que lo primero que hacen baja row1, a continuación, lea las columnas. Si alguno de la llave en row1 se presiona hará la columna corrosponding como por ejemplo baja si la clave se presiona en el segundo row1, entonces columna2 dará de baja. Así llegamos a saber que la llave 2 de row1 se presiona. Esta es la forma de exploración se lleva a cabo. Así que para escanear el teclado completo, tenemos que hacer filas bajo uno por uno y leer las columnas. Si alguno de pulsar el botón en una fila, que se llevará a la columna corrosponding a un estado bajo, lo que nos dice que se pulsa una tecla en la fila. Si el botón 1 de la fila que se pulsa a continuación la columna 1 se convertirá en baja, si el botón 2 y luego columna2 y así sucesivamente ...

P á g i n a | 22

El algoritmo anterior es en toda Keypad_Key_Click (), la vamos a utilizar, los que tienen clave sólo se compara el valor ASCII para obtener la clave correcta.  

Código:Le permite escribir un programa que muestra la tecla pulsada y la cantidad (número de veces que se pulsa la tecla), en la pantalla LCD utilizando rutinas mickroc.  

Código:unsigned short kp, cnt, oldstate = 0;char txt[4];

// Keypad module connectionschar  keypadPort at PORTD;// End Keypad module connections

// LCD module connectionssbit LCD_RS at RB4_bit;sbit LCD_EN at RB5_bit;sbit LCD_D4 at RB0_bit;sbit LCD_D5 at RB1_bit;sbit LCD_D6 at RB2_bit;sbit LCD_D7 at RB3_bit;

sbit LCD_RS_Direction at TRISB4_bit;sbit LCD_EN_Direction at TRISB5_bit;sbit LCD_D4_Direction at TRISB0_bit;sbit LCD_D5_Direction at TRISB1_bit;sbit LCD_D6_Direction at TRISB2_bit;sbit LCD_D7_Direction at TRISB3_bit;// End LCD module connections

void main() {  cnt = 0;                                 // Reset counter  Keypad_Init();                           // Initialize Keypad ///////////// comment for 877/////////////////////////////////////

P á g i n a | 23

  ANSEL  = 0;                              // Configure AN pins as digital I/O  ANSELH = 0;  c1on_bit=0;  c2on_bit=0;/////////////////////////////////////////////////////////////////  Lcd_Init();                              // Initialize LCD  Lcd_Cmd(_LCD_CLEAR);                     // Clear display  Lcd_Cmd(_LCD_CURSOR_OFF);                // Cursor off

  Lcd_Out(1, 1, "Key Pressed :");                 // Write message text on LCD  Lcd_Out(2, 1, "Times: ");

  do {    kp = 0;                                // Reset key code variable

    // Wait for key to be pressed and released    do            kp = Keypad_Key_Click();             // Store key code in kp variable    while (!kp);   // Prepare value for output, transform key to it's ASCII value    switch (kp) {

      case  1: kp = 49; break; // 1      case  2: kp = 50; break; // 2      case  3: kp = 51; break; // 3      case  4:                              //  kp = 65; break; // A for 4x4 pad      case  5: kp = 52; break; // 4      case  6: kp = 53; break; // 5      case  7: kp = 54; break; // 6      case  8:                              //kp = 66; break; // B for 4x4 pad      case  9: kp = 55; break; // 7      case 10: kp = 56; break; // 8      case 11: kp = 57; break; // 9      case 12:                             //kp = 67; break; // C for 4x4 pad      case 13: kp = 42; break; // *      case 14: kp = 48; break; // 0

P á g i n a | 24

      case 15: kp = 35; break; // #      //case 16: kp = 67; break; // D for 4x4 pad    }

    if (kp != oldstate) {                  // Pressed key differs from previous      cnt = 1;      oldstate = kp;      }    else {                                 // Pressed key is same as previous      cnt++;      }

    Lcd_Chr(1, 15, kp);                    // Print key ASCII value on LCD

    byteToStr(cnt, txt);                   // Transform counter value to string    Lcd_Out(2, 12, txt);                   // Display counter value on LCD  } while (1);}

En primer lugar especificar las conexiones del teclado, lo mismo que hicimos en el tutorial anterior, y las conexiones de LCD. A continuación, iniciar la rutina de teclado mediante la función Keypad_Init (), inicializa la pantalla LCD y mostrar los mensajes apropiados. Ahora, una vez se pulsa la tecla y el valor es la tienda en el Protocolo de Kioto, mediante el uso de Keypad_Key_Click () función, tenemos que comparar el número clave de su código ASCII para obtener la clave correcta. El interruptor (KP) se utiliza para este propósito.

Una vez que tengamos la llave correcta se la compara con oldstate, si difiere de la tecla pulsada anterior, asignar la CNT con una y actualizar el oldstate. Y si la tecla presionada es igual que el anterior, la CNT se incrementa (para contar el número de veces que se presiona esta tecla).

Después de esto queremos mostrar la tecla pulsada y el número de veces en la pantalla LCD. Para mostrar el valor ASCII, kp, se utiliza la función "Lcd_Chr '. Por

P á g i n a | 25

otro lado la CNT es un corto para que se muestre que tenemos que convertir en una cadena, la función 'byteToStr' es hacer el trabajo. Se convierte byte de entrada a una cadena. La cadena de salida se ha fijado la anchura de 4 caracteres, incluidos los de carácter nulo al final. txt [4] se declara para este propósito. Para la clave de los próximos pasos enteros se repiten. 

Esquema:

diagrama de conexión del teclado

PIC16F887/877 de programación en C Tutorial 7 (LCD de pantalla en movimiento n caracteres personalizados)LCD, de pantalla en movimiento y carácter personalizado :Puede mostrar los caracteres personalizados utilizando la herramienta mikroC carácter personalizado. Ir al carácter de las herramientas de cliente >> luego hacer el personaje que desea mostrar. Después de esto haga clic en "Generar Código". Se generará una función customchar sólo tienes que copiar y pegar encima de la función principal.customchar tiene dos parámetros, la fila y la posición en la fila. Sólo tiene que pasar estos parámetros en el que desea ver a tu personaje personalizado en la pantalla LCD.También puede mover el texto, a la izquierda y la derecha, en la pantalla LCD, mediante el uso de los comandos de LCD. _LCD_SHIFT_LEFT Y _LCD_SHIFT_RIGHT son los comandos. Hay varios otros comandos en mikroC, me olvide de decirte en el tutorial de LCD, estos son:

P á g i n a | 26

LCD de comandos

Ahora vamos a escribir un código para mostrar y mover el personaje a medida, de ida y vuelta, (de su elección) en la pantalla LCD.

Código:

// LCD module connectionssbit LCD_RS at RB4_bit;sbit LCD_EN at RB5_bit;sbit LCD_D4 at RB0_bit;sbit LCD_D5 at RB1_bit;sbit LCD_D6 at RB2_bit;sbit LCD_D7 at RB3_bit;

sbit LCD_RS_Direction at TRISB4_bit;sbit LCD_EN_Direction at TRISB5_bit;sbit LCD_D4_Direction at TRISB0_bit;sbit LCD_D5_Direction at TRISB1_bit;sbit LCD_D6_Direction at TRISB2_bit;sbit LCD_D7_Direction at TRISB3_bit;// End LCD module connections

P á g i n a | 27

char txt[] = "MOVING TEXT";char txt1[] = "EEW";char i;                              // Loop variableconst char character[] = {0,31,4,10,17,17,14,0};

void CustomChar(char pos_row, char pos_char) {  char i;    Lcd_Cmd(64);    for (i = 0; i<=7; i++) Lcd_Chr_CP(character[i]);    Lcd_Cmd(_LCD_RETURN_HOME);    Lcd_Chr(pos_row, pos_char, 0);}

void main(){///////// comment for 877////////////////////////////////////////  ANSEL  = 0;                        // Configure AN pins as digital I/O  ANSELH = 0;  C1ON_bit = 0;                      // Disable comparators  C2ON_bit = 0;////////////////////////////////////////////////////////////////  Lcd_Init();                        // Initialize LCD

  Lcd_Cmd(_LCD_CLEAR);               // Clear display  Lcd_Cmd(_LCD_CURSOR_OFF);          // Cursor off  Lcd_Out(1,8,txt);                 // Write text in first row  Lcd_Out(2,11,txt1);                 // Write text in second row  CustomChar(2,14);  CustomChar(2,10);

  // Moving text  for(i=0; i<8; i++) {               // Move text to the right 4 times    Lcd_Cmd(_LCD_SHIFT_RIGHT);    Delay_ms(200);  }

P á g i n a | 28

  while(1) {                         // Endless loop    for(i=0; i<8; i++) {             // Move text to the left 7 times      Lcd_Cmd(_LCD_SHIFT_LEFT);      Delay_ms(200);    }

    for(i=0; i<8; i++) {             // Move text to the right 7 times      Lcd_Cmd(_LCD_SHIFT_RIGHT);      Delay_ms(200);    }  }}

Después de especificar las conexiones de LCD pegue el código de tu personaje a medida que quieras pantalla. A continuación, inicializar el LCD, el texto de la pantalla (si quieres), y mostrar su costumbre caracteres pasando el parámetro posiciones.  

Ahora, para mover el texto sólo tiene que utilizar para el comando de bucle y LCD IZQUIERDA / DERECHA, en la que desea mover. Número de iteraciones depende de usted. Una vez hecho esto, utilice un bucle sin fin y aplicar el bucle para mover el texto en la parte trasera hacia atrás. Eso es todo!!.

Esquema:

P á g i n a | 29

PIC16F887/877 de programación en C Tutorial 8 (PWM)PWM:El modo PWM genera una señal PWM en el terminal CCPx. El ciclo de trabajo, el período y la resolución se determina por los siguientes registros: • PR2 • T2CON CCPRxL • • CCPxCON En la modulación de ancho de pulso (PWM) el modo, el módulo CCP produce hasta una resolución de 10-bit PWM de salida en el terminal CCPx. Desde la terminal CCPx se multiplexa con el seguro puerto de datos, el TRIS para que el pin debe ser limpiado para que el conductor pin de salida CCPx.

PWM Periodo:El período de PWM se especifica mediante el registro PR2 de Timer2. El período de PWM se puede calcular usando la fórmula                             Período PWM = [(PR2) + 1] • 4 • • TOSC (TMR2 valor de pre-escala)                             Nota: TOSC = 1/FOSC

Cuando TMR2 es igual a PR2, los siguientes tres eventos se producen en el ciclo siguiente incremento: • TMR2 se borra • El terminal CCPx se establece. (Excepción: Si el ciclo de trabajo PWM = 0%, el pasador no se fijan) • El ciclo de trabajo PWM se precintaron CCPRxL en CCPRxH.

PWM Ciclo de trabajo:El ciclo de trabajo PWM se especifica escribiendo un valor de 10-bits a varios registros: CCPRxL registro y DCxB <01:00> bits del registro CCPxCON. El CCPRxL contiene las ocho de la MSB y DCxB <01:00> bits del registro de CCPxCON contienen los dos bits menos significativos. CCPRxL y DCxB <01:00> bits del registro CCPxCON se puede escribir en cualquier momento. El ciclo de trabajo de valor no se bloquea en CCPRxH hasta después del período se completa (es decir, un partido entre PR2 y TMR2 registros se produce). Mientras se utiliza el PWM, el registro CCPRxH es de sólo lectura.

P á g i n a | 30

         De ancho de pulso = (CCPRxL: CCPxCON <5:4>) • TOSC • (TMR2 valor de pre-escala)

                  Deber relación de ciclo (CCPRxL: CCPxCON <5:4>) / 4 (PR2 + 1)

PWM Resolución:La resolución determina el número de ciclos de trabajo disponibles para un período determinado. Por ejemplo, una resolución de 10-bits se traducirá en 1024 ciclos de trabajo discretos, mientras que un 8-bits de resolución se traducirá en 256 ciclos de trabajo discretos. La resolución máxima es de 10 bits de PWM cuando PR2 es de 255.                                     Resolución = log [4 (PR2 + 1)] / log (2) bits

Configuración para el funcionamiento PWM:Los siguientes pasos se deben tomar cuando se configura el módulo CCP para la operación PWM: 1. Desactivar el PWM pin (CCPx) Los controladores de salida como de entrada mediante el establecimiento de la correspondiente bit de TRIS. 2. Establecer el período de PWM mediante la carga del registro PR2. 3. Configurar el módulo CCP para el modo PWM cargando el registro CCPxCON con los valores apropiados. 4. Ajuste el ciclo de trabajo PWM cargando el registro y la CCPRxL DCxB <01:00> bits de la CCPxCON registrarse. 5. Configurar e iniciar Timer2: . • Borrar la interrupción TMR2IF bit de bandera del registro PIR1 . • Establecer el valor de preescala Timer2 por la carga de los bits del registro T2CKPS T2CON . • Habilitar Timer2 al establecer el bit TMR2ON del registro T2CON 6. Activa la salida PWM después de un nuevo ciclo de PWM se ha iniciado: • Espere hasta que se desborda Timer2 (poco TMR2IF del registro PIR1 está

P á g i n a | 31

establecido). • Habilitar la terminal CCPx controlador de salida en la limpieza de la broca asociado TRIS.

Nota: Esto es sólo para 887. Para Mayor modo PWM consulte PIC16F887 hoja de datos.

Vamos a hacer todas estas cosas en forma sencilla mediante el uso de-construir la biblioteca mikroC para el PWM.Código:Le permite escribir el código para generar PWM en los pines RC1 y RC2. Y los interruptores RA0-RA3 para aumentar / disminuir el ciclo de trabajo PWM.

//using 887 and 8MHz xtal//////////////  ANSEL  = 0;                         // Configure AN pins as digital  ANSELH = 0;  C1ON_bit = 0;                       // Disable comparators  C2ON_bit = 0;

  PORTA = 255;  TRISA = 255;                        // configure PORTA pins as input  PORTC = 0;                          // set PORTC to 0  TRISC = 0;                          // designate PORTC pins as output  PWM1_Init(1000);                    // Initialize PWM1 module at 1KHz  PWM2_Init(2000);                    // Initialize PWM2 module at 2KHz}

void main() {  InitMain();  current_duty  = 16;                 // initial value for current_duty  current_duty1 = 16;                 // initial value for current_duty1

  PWM1_Start();                       // start PWM1  PWM2_Start();                       // start PWM2  PWM1_Set_Duty(current_duty);        // Set current duty for PWM1  PWM2_Set_Duty(current_duty1);       // Set current duty for PWM2

P á g i n a | 32

  while (1) {                         // endless loop    if (RA0_bit) {                    // button on RA0 pressed      Delay_ms(40);      current_duty++;                 // increment current_duty      PWM1_Set_Duty(current_duty);     }

    if (RA1_bit) {                    // button on RA1 pressed      Delay_ms(40);      current_duty--;                 // decrement current_duty      PWM1_Set_Duty(current_duty);     }

    if (RA2_bit) {                    // button on RA2 pressed      Delay_ms(40);      current_duty1++;                // increment current_duty1      PWM2_Set_Duty(current_duty1);     }

    if (RA3_bit) {                    // button on RA3 pressed      Delay_ms(40);      current_duty1--;                // decrement current_duty1      PWM2_Set_Duty(current_duty1);     }

    Delay_ms(5);                      // slow down change pace a little  }}

PWM1_Init (); Inicializa el PWM módulo con relación de trabajo 0. Parámetrofrecuencia deseada es un PWM de frecuencia en Hz.PWM1_Set_Duty (); Juegos PWM relación de trabajo. Parámetro deber de toma valores de 0 a 255, donde 0 es 0%, 127 es del 50%, y 255 es 100% de relación de trabajo. Otros valores específicos para relación de trabajo se puede calcular como / (Porcentaje * 255) 100 .

P á g i n a | 33

PWM1_Start (); Inicia PWM. Esquema: 

PIC16F887/877 la programación en C Tutorial 9 (Interrumpe temporizadores)Interrupción de los temporizadores:Ahora vamos a ver la interrupción de los temporizadores. Como sabemos Timer0 generará una interrupción cuando el TMR0 registrarse desbordamientos de FFh a 00h.La interrupción T0IF bit de bandera del registro INTCON se pone cada vez que el TMR0 se desborda de registro, independientemente de si o no la interrupción del Timer0 está habilitado. El bit T0IF debe ser limpiado en el software. La habilitación de interrupción Timer0 es el bit T0IE del registro INTCON. Sin embargo vamos a utilizar poco TMR0IF para la programación de interrupción.

El par Timer1 registro (TMR1H: TMR1L) incrementos a FFFFh y da la vuelta a 0000h.Cuando Timer1 se da la vuelta, el bit de interrupción del Timer1 bandera del registro PIR1 está establecido. Para habilitar la interrupción en la renovación, se debe establecer estos bits: • Timer1 interrumpir el bit de habilitación del registro PIE1 • PEIE bits del registro INTCON • bit GIE del registro INTCON La interrupción se borra en la limpieza de la broca TMR1IF en la rutina de interrupción .

P á g i n a | 34

Para la programación de interrupciones tenemos que crear ISR (rutina de interrupción), de modo que cuando una interrupción se producirá ISR se hará cargo de ella. Por lo tanto, para usar los temporizadores de interrupción, primero tenemos que habilitar la interrupción global estableciendo el bit GIE del registro INTCON, a continuación, las interrupciones del temporizador correspondiente.

Código:  unsigned cnt, cnt1, cnt2;

void interrupt() {  if (TMR2IF_bit) {    cnt2++;                    // increment counter    TMR2IF_bit = 0;           // clear TMR2IF    TMR2 = 0;    if (cnt2 >= 122) {      PORTc = ~PORTc;         // Toggle PORTc LEDs      cnt2 = 0;                // Reset cnt    }      }  if (TMR0IF_bit) {    cnt++;                 // increment counter    TMR0IF_bit = 0;        // clear TMR0IF    TMR0   = 0;    if (cnt >= 122) {         //1 sec delay      PORTd = ~PORTd;      // Toggle PORTd LEDs      cnt = 0;             // Reset cnt    }      }  if(tmr1if_bit){      tmr1if_bit=0;      cnt1++;      tmr1h=128;      tmr1l=0;

P á g i n a | 35

      if(cnt1>=36){           porta=!porta;           cnt1=0;        }    }    }

void main() {  OPTION_REG = 0x84;       // Assign prescaler to TMR0 32 ////////////// commect for 877///////////////  ansel=0;  anselh=0;  c1on_bit=0;  c2on_bit=0;///////////////////////////////////////  TRISc = 0;               // PORTc is output  PORTc = 0xFF;            // Initialize PORTc  TRISd = 0;               // PORTd is output  PORTd = 0xFF;            // Initialize PORTd  TRISa = 0;               // PORTa is output  PORTa = 1;            // Initialize PORTa  TMR0  = 0;              // Timer0 initial value  INTCON = 0xA0;           // Enable TMRO interrupt  cnt = 0;                 // Initialize cnt

  t1con=1;  tmr1if_bit=0;  tmr1h=128;  tmr1l=0;  tmr1ie_bit=1;  cnt1=0;  intcon=192;  

P á g i n a | 36

  cnt2 = 0;                    // initialize cnt  PORTc = 0xFF;               // Initialize PORTc  TRISc =   0;                // PORTc is output  T2CON = 7;               // Timer2 settings  TMR2  =   0;                // Initialize Timer2 register  TMR2IE_bit = 1;             // enable interupt  INTCON = 0xC0;              // Set GIE, PEIE

}

Este código de alternar los bits de un puerto, B y D, cuando las interrupciones de temporizador 1, 0, y 2, respectivamente. El tiempo de duración es de aproximadamente 0,5 segundos, sección 1, y 2 seg.

interrupción de vacío () es el ISR el cuidado de las interrupciones, el manejo de las interrupciones y tomar decisiones de acuerdo con ellos.

Esquema:

P á g i n a | 37

PIC16F887/877 de programación en C Tutorial 10 (ADC)

Analógico a digital (ADC):En este tutorial te mostraré cómo convertir los valores analógicos en digitales, mediante el uso de 887 (poco difieren con 877) , a continuación, mostrar estos valores digitales en la pantalla LCD.

El convertidor de analógico a digital (ADC) permite la conversión de una señal de entrada analógica a una representación binaria de 10-bits de esa señal. Este dispositivo utiliza entradas analógicas, que son multiplexadas en una sola muestra y mantenga circuito. La salida de la muestra y retención está conectada a la entrada del convertidor. El convertidor genera un resultado binario de 10 bits a través de aproximaciones sucesivas y almacena el resultado de la conversión en los registros de resultados de ADC (ADRESL y ADRESH).

La tensión de referencia ADC es software seleccionable para ser generado internamente o externamente suministrada.

ADC de configuración:Al configurar y usar el ADC de las siguientes funciones deben ser considerados: • Configuración del puerto • La selección de canales • Selección de la referencia de tensión ADC • ADC fuente de reloj de conversión • Control de Interrupción • Resultados de formato

Configuración del puerto:El producto puede ser usado para convertir señales analógicas y digitales. Al convertir las señales analógicas, el pin de E / S debe estar configurado para analógica estableciendo el TRIS correspondiente y los bits de Ansel.

Selección de canales:Los bits de la CHS ADCON0 registrar determinar qué canal está conectado a la de muestreo y retención del circuito. Al cambiar canales, un retraso se requiere antes de comenzar la conversión siguiente .

P á g i n a | 38

ADC de voltaje de referencia de selección:Los bits de la VCFG ADCON0 registrar proporcionar un control independiente de las referencias de tensión positiva y negativa. La tensión de referencia positiva puede ser VDD o una fuente de tensión externa. Asimismo, la tensión de referencia negativa puede ser VSS o una fuente de tensión externa. 

ADC de conversión de la fuente de reloj: La fuente del reloj de conversión es un software seleccionables a través de los bits ADCS del registro ADCON0. Hay cuatro opciones posibles de reloj: • FOSC / 2 • FOSC / 8 • FOSC/32 • FRC (oscilador interno dedicado) El tiempo para completar una conversión de bits se define como TAD. Un total de 10-bits de conversión requiere 11 períodos TAD, como se muestra en la figura.

Interrumpir el control:El módulo ADC permite la capacidad de generar una interrupción al término de una conversión analógica a digital. La bandera de interrupción ADC es el bit ADIF en el registro PIR1. La interrupción del ADC de habilitación es el bit ADIE en el registro PIE1.El bit ADIF debe ser limpiada en el software. 

Resultados de formato: El 10-bit A / D resultado de la conversión se puede suministrar en dos formatos, justificado a la izquierda o justificado a la derecha. El bit ADFM del registro ADCON0 controla el formato de salida. 

P á g i n a | 39

ADC Operación:De iniciar una conversión: Para habilitar el módulo ADC, el bit ADON del registro ADCON0 se debe establecer un '1 '. Al establecer el bit GO / DONE del registro ADCON0 a un '1 'se iniciará la conversión de analógico a digital. 

EJECUCIÓN DE UNA CONVERSIÓN: Cuando la conversión haya terminado, el módulo ADC hará lo siguiente: • Limpie el GO / DONE bits • Ajuste el bit de bandera ADIF • Actualizar los registros ADRESH: ADRESL con resultado de la conversión nueva

UN PROCEDIMIENTO DE CONVERSIÓN A / D:Este es un ejemplo de procedimiento para el uso de la ADC para llevar a cabo una conversión de analógico a digital: 1. Configurar puerto: • Desactivar controlador pin de salida (Ver registro TRIS) • Configurar pin como analógico 2. Configure el módulo ADC: • Seleccione reloj de conversión ADC • Configurar la tensión de referencia ADC • Seleccione el canal de entrada de formato • Seleccionar resultado • Encienda el módulo ADC 

P á g i n a | 40

3. Configurar la interrupción ADC (opcional): • Borrar marca de interrupción ADC • Habilitar ADC interrumpir • Habilitar interrupción periférica • Habilitar interrupción global (1) 4. Espere el tiempo de adquisición requerido (2). 5. Iniciar la conversión mediante el establecimiento de la GO / bit de efectuado. 6. Espere a que la conversión ADC para completar uno de los siguientes: • Sondeo de la GO / DONE bits • Tiempo de espera para la interrupción del ADC (interrumpe habilitado) 7. Leer el resultado de ADC 8. Desactive la bandera de interrupción ADC (se requiere si la interrupción está habilitada).

ADC DEFINICIONES REGISTRO:Los registros siguientes se utilizan para controlar el funcionamiento del ADC.

P á g i n a | 41

P á g i n a | 42

Código:Vamos a hacer más fácil mediante el uso de ADC biblioteca de mikroC. El siguiente código convirtiendo la entrada analógica, en el pin RA2, en digital y lo mostrará en la pantalla LCD. A medida que la conversión es de 10 bits, por lo que el rango es de 0 a 1023.

unsigned int temp_res;

// LCD module connectionssbit LCD_RS at RB4_bit;sbit LCD_EN at RB5_bit;sbit LCD_D4 at RB0_bit;sbit LCD_D5 at RB1_bit;sbit LCD_D6 at RB2_bit;sbit LCD_D7 at RB3_bit;

sbit LCD_RS_Direction at TRISB4_bit;sbit LCD_EN_Direction at TRISB5_bit;sbit LCD_D4_Direction at TRISB0_bit;sbit LCD_D5_Direction at TRISB1_bit;sbit LCD_D6_Direction at TRISB2_bit;sbit LCD_D7_Direction at TRISB3_bit;// End LCD module connections

char txt1[] = "ADC Example";char txt[7];void main() {/////////// comment for 877/////////////////////////////////////  ansel=4;                     // Configure AN2 pin as analog  anselh=0;  c1on_bit=0;  c2on_bit=0; ////////////////////////////////////////////////////////////////  TRISA  = 0xFF;              // PORTA is input  Lcd_Init();  Lcd_Cmd(_LCD_CLEAR);               // Clear display

P á g i n a | 43

  Lcd_Cmd(_LCD_CURSOR_OFF);          // Cursor off  Lcd_Out(1,1,txt1);  adc_init();  do {

    temp_res = ADC_read(2);   // Get 10-bit results of AD conversion    IntToStr(temp_res, txt);    //int to string conversion    Lcd_Out(2,1,txt);  } while(1);}

adc_init (); Esta rutina inicializa el módulo interno del PIC ADC para trabajar con el reloj RC. Reloj determina el período de tiempo necesario para realizar la conversión AD.

ADC_read (2);. 10 o 12-bits sin signo valor leído del canal especificado (MCU dependiente) Parámetro canal representa el canal desde el cual el valor analógico se va a acquired.In este caso es 2.

IntToStr (temp_res, txt), de entrada convierte firmado número entero en una cadena.La cadena de salida se ha fijado la anchura de 7 caracteres, incluidos los de carácter nulo al final (terminación de cadena). La cadena de salida se justifica a la derecha y las posiciones restantes a la izquierda (si existe) se rellenan con espacios en blanco.

Esquema: