Pgina |1

PIC16F887/877 de programacin en C Tutorial 1 (Introduccin) En este tutorial te mostrar cmo programar en C. PIC16F887/877 As que en primer lugar , descarga mikroC PRO for PIC compilador tambin descargar el manual del usuario. Despus de esto crear un nuevo proyecto elige P16F887 o 877 lo que tengas, y 4MHz cristal, etc Si usted no sabe cmo crear un nuevo proyecto de referirse a su manual o descargar el documento "cmo crear el primer proyecto" de su sitio. Nota: Voy a utilizar PIC16F887 y 4MHz cristal externo (aunque tambin 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 (vase la figura a continuacin). 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 mltiplexados I / O, en el PIC16F887, de PortA a Port E. Para nuestro primer programa, que slo 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 pnico va a ver ms de un nombre de pines, te dir las funciones de las patillas cuando las usemos.

Pgina |2

Despus de crear el proyecto, escribir el cdigo de abajo en mikroC IDE y compilarlo, si desea cambiar la configuracin del proyecto, los bits de fusibles, etc reloj, ir a proyecto >> Proyecto >> edicin. Cdigo: 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 cdigo; primero seleccione el puerto que desea utilizar, en este caso es PORTC. A continuacin, limpie el ponindolo 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

Pgina |3

nico en lugar de todos, a continuacin, utilizar trisxy_bit = 1, donde y podra 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. Adems de utilizar pines de E / S digita,l asignar a Ansel y anselh=0, no tengas pnico cuando hablamos del ADC, luego te dir acerca de esto. Ntese 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 aadir 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 slo 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.

Pgina |4

Circuito de reset:

Pgina |5

PIC16F887/877 de programacin en el Tutorial C 3-1 (Timer 0) Temporizadores

Tanto PIC16F887 y 877 tienen tres temporizadores; timer0, timer1 y el timer2. Timer0 es de 8-bits y tambin se puede utilizar como contador, timer1 es de 16-bit de temporizacin, as como un contador, el timer2 es de 8-bit de temporizacin y puede utilizarse como la base de tiempo PWM para el modo PWM de el mdulo CCP (s). Timer0: El temporizador Timer0 mdulo / contador tiene las siguientes caractersticas:

8-bit del temporizador / contador De lectura y escritura 8-bit software programable prescaler Reloj interno o externo, seleccione Interrupcin por desbordamiento de FFh a 00h Borde de seleccin (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 mdulo Timer0 se incrementa cada ciclo de instruccin (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 tamao. Se puede escribir el valor deseado en el registro que ser incremento como el programa avanza. La frecuencia vara dependiendo del preescalador. El valor mximo que se puede asignar a este registro es 255. TMR0IF -. TMR0 interrupcin de desbordamiento del bit de la bandera de la interrupcin de TMR0 se genera cuando los desbordamientos de TMR0 registro de FFh a 00h. Este desbordamiento establece el bit TMR0IF (INTCON <2>).

Pgina |6

Prescaler - Divisor de frecuencia. Podemos utilizar prescaler para dividir an ms la frecuencia de reloj, el ERE opciones: PS2: PS0 000 001 010 011 100 0 1:64 101 110 1:128 111 1 : 256 TMR0 tasa de 1:02 1:04 1:08 1:16 1:32

Registro Opcin: Opcin de registro es un registro de 8 bits utilizado para inicializar el timer0.

Clculo de Contador, Frecuency out, y los valores de TMR0:

Pgina |7

Si se utiliza cristal interno como el reloj, la divisin se realiza de la siguiente manera:

Fout -. La frecuencia de salida despus de la divisin Tout - El tiempo de ciclo despus de la divisin. 4 - La divisin del reloj original por 4, cuando se utiliza como reloj interno de cristal (y no oscilador externo). Conde - Un valor numrico que se coloca para obtener la frecuencia de salida deseada - Fout. (256 - TMR0) - El nmero de veces en el temporizador contar a partir del registro TMR0. Si se usa reloj externo fuente (oscilador), la divisin se realiza de la siguiente manera:

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

Cdigo: Ahora vamos a escribir el cdigo de 0,5 segundos de retardo;

Pgina |8

void main() { // 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; t0cs_bit=0; psa_bit=0; ps0_bit=1; ps1_bit=1; ps2_bit=1; while(1){

// low to high edge trigger // using internal clk //using prescaler //prescaler 256

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

if(cunt==8){ portc=~portc; cunt=0; } } }

//delay 0.5 sec(256*256u*8)

Pgina |9

Esquema:

PIC16F887/877 Tutorial de programacin en C 3-2 (Temporizador 1) Timer 1: El mdulo 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 creacin / 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 interrupcin TMR1, si est habilitado, se genera en caso de desbordamiento, que se enclava en el bit indicador de interrupcin, TMR1IF (PIR1 <0>). Esta interrupcin puede ser activado / desactivado mediante la creacin / borrado de habilitacin de interrupcin TMR1 poco, TMR1IE (PIE1 <0>). TMR1IF -. TMR1 desbordamiento de bits bandera de interrupcin Este 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 numrico 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 tamao del registro es de 8 bits. Vamos a explorar las partes ms importantes:

Cuando, como T1CON de 887 bits tambin 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 funcin de puerta Timer1 0 = Timer1 siempre est contando

P g i n a | 11

Clculo de Contador, Fout, y los valores Timer1 Si se utiliza cristal interno como el reloj, la divisin se realiza de la siguiente manera:

Fout -. La frecuencia de salida despus de la divisin Tout - El tiempo de ciclo despus de la divisin. 4 - La divisin del reloj original por 4, cuando se utiliza como reloj interno de cristal (y no oscilador externo). Conde - Un valor numrico que se coloca . para obtener la frecuencia de salida deseada - Fout (65536 - TMR1) . - El nmero de veces en el temporizador contar a partir del registro TMR1 Cdigo: Ahora vamos a escribir el cdigo para cambiar los bits de PORTC despus 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; tmr1h=0; tmr1l=0; //tmr1 on bit is set //begin with 0

while(1){ while(!tmr1if_bit);

//tmr1 flag bit

P g i n a | 12

tmr1if_bit=0; count++;

if(count==16){ portc=~portc; count=0; } } }

//for 1 sec delay //16*65535us=1sec

Esquema: Timer 0 esquemtica se puede utilizar (tutorial 3 parte 1).

PIC16F887/877 Tutorial de programacin 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 mdulo 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 opcin preescala de 1:1, 1:4 o 1:16, seleccionada por T2CKPS1 bits de control: T2CKPS0 (T2CON <01:00>). El mdulo Timer2 tiene un registro perodo 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 travs de un postscaler 4-bits (que da una escala inclusiva 01:01-un y diecisis minutos) para generar una interrupcin 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 mnimo el consumo de energa. Prescaler y Postscaler - Timer2 es un temporizador de 8 bits con un prescaler y un postscaler. Cada permite realizar la divisin 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 preescalador. Postscaler divide la frecuencia que sale del comparador. T2CON Registro:

Cmo calcular los valores necesarios de la Timer2:

Fout -. La frecuencia de salida despus de la divisin Tout - El tiempo de ciclo despus de la divisin. 4 - La divisin del reloj original por 4, cuando se utiliza como reloj interno de cristal (y no oscilador externo). Conde - Un valor numrico que se coloca para obtener la frecuencia de salida deseada - FOUT.

P g i n a | 14

(PR2 - TMR2) - El nmero de veces que el contador contar.

Cdigo : Le permite escribir el cdigo para cambiar los bits de PORTC despus 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; pr2=255; tmr2=0; //prescaler is 16 //final value to count //initial value

while(1){ while(!tmr2if_bit); tmr2if_bit=0; cnt++;

//tmr2 flag bit

if(cnt==488){ portc=~portc; cnt=0; } } }

//for 2 sec(16*256u*488=2sec)

P g i n a | 15

Esquema: Timer 0 esquemtica se puede utilizar (tutorial 3 parte 1). PIC16F887/877 de programacin en C Tutorial 4 (contador) Contador: Temporizador 0 y 1 del temporizador puede ser utilizado como contador, tambin. 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 seal se aplica a T1CK1 pin, RC0. Cuando, como, si desea utilizar el Timer0, a continuacin, establecer los T0CS (TMR0 Clock Source Select) bits de registro opcin. Se cuentan cuando la seal se aplica a T0CK1 pasador, RA4. Tambin puede seleccionar el borde, ascendente o descendente, para activar el contador de a poco T0SE. Cdigo: Ahora vamos a escribir un cdigo que contar hasta el 65536 y mostrar su nmero 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 programacin en C Tutorial 5 (LCD Interfaz) LCD Interfaz: En este tutorial te mostrar cmo interfaz de 16x2 LCD con micro-controlador. 16x2 significa que hay dos filas y cada fila contienen un mximo de 16 caracteres.

Para ms detalles consulte la hoja de cristal lquido, el que est utilizando. Conexin bsica: 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 aos 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 slo requera cuatro pines de datos. Cdigo: Le permite escribir un cdigo que mostrar el estado del motor y su direccin, sino que va a ser divertido!! Requisitos: Disear 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 direccin del motor, y si ambos

P g i n a | 18

son de apertura / cierre, el motor debe permanecer apagado. Tambin los interruptores estn conectados a PORTD. // LCD module connections sbit 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 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; trisd4_bit=1;

// CW dir //CCW dir

Lcd_Init(); // lcd ini Lcd_Cmd(_LCD_CLEAR); //lcd clear Lcd_Cmd(_LCD_CURSOR_OFF); while(1){ Lcd_Out(1,1,txt3); 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){ lcd_out(2,1,txt); rd0_bit=0; rd1_bit=0; } if(!rd3_bit & !rd4_bit){ lcd_out(2,1,txt); rd0_bit=0; rd1_bit=0; } } } //invalid selction //to stop motor //1row 1col

//inv sec

P g i n a | 20

Este es el cdigo 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 estn en los pines 3 y 4. Despus de fijar los pasadores para LCD que utiliza lcd_init (); un mikroC LCD funcin 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 posicin especificada, 1, fila 1 significa primero y la primera columna . Luego de una simple lgica de interruptores y sus funciones. L298 Conexiones: Una cosa importante es la conexin de la L298, ya que estamos usando OUT1 y OUT2 lo que tenemos que utilizar in1 in2 y, tambin 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 tensin del motor y 5V en el pin 4, VC. Para cambiar a direccin slo 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 programacin en C Tutorial 6 (Interfaz del teclado) Teclado Interfaz: Este tutorial es sobre la interconexin 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 ms fcil de programa. La tcnica bsica es, hacer que los coloums como I / P y conducir las filas hacindolos o / p, todo este procedimiento de leer el teclado se llama digitalizacin. Con el fin de detectar que se pulsa la tecla de la matriz, hacemos lneas de fila bajo una por una y leer los coloums. Digamos que lo primero que hacen baja row1, a continuacin, 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 exploracin 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 botn 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 botn 1 de la fila que se pulsa a continuacin la columna 1 se convertir en baja, si el botn 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 slo se compara el valor ASCII para obtener la clave correcta. Cdigo: Le permite escribir un programa que muestra la tecla pulsada y la cantidad (nmero de veces que se pulsa la tecla), en la pantalla LCD utilizando rutinas mickroc. Cdigo: unsigned short kp, cnt, oldstate = 0; char txt[4]; // Keypad module connections char keypadPort at PORTD; // End Keypad module connections // LCD module connections sbit 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 :"); Lcd_Out(2, 1, "Times: "); do { kp = 0; // Write message text on LCD

// 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) { cnt = 1; oldstate = kp; } else { cnt++; } Lcd_Chr(1, 15, kp); // Pressed key differs from previous

// Pressed key is same as previous

// Print key ASCII value on LCD

byteToStr(cnt, txt); Lcd_Out(2, 12, txt); } while (1); }

// Transform counter value to string // Display counter value on LCD

En primer lugar especificar las conexiones del teclado, lo mismo que hicimos en el tutorial anterior, y las conexiones de LCD. A continuacin, iniciar la rutina de teclado mediante la funcin 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 () funcin, tenemos que comparar el nmero clave de su cdigo ASCII para obtener la clave correcta. El interruptor (KP) se utiliza para este propsito. 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 nmero de veces que se presiona esta tecla). Despus de esto queremos mostrar la tecla pulsada y el nmero de veces en la pantalla LCD. Para mostrar el valor ASCII, kp, se utiliza la funcin "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 funcin '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 carcter nulo al final. txt [4] se declara para este propsito. Para la clave de los prximos pasos enteros se repiten. Esquema:

diagrama de conexin del teclado

PIC16F887/877 de programacin en C Tutorial 7 (LCD de pantalla en movimiento n caracteres personalizados) LCD, de pantalla en movimiento y carcter personalizado : Puede mostrar los caracteres personalizados utilizando la herramienta mikroC carcter personalizado. Ir al carcter de las herramientas de cliente >> luego hacer el personaje que desea mostrar. Despus de esto haga clic en "Generar Cdigo". Se generar una funcin customchar slo tienes que copiar y pegar encima de la funcin principal.customchar tiene dos parmetros, la fila y la posicin en la fila. Slo tiene que pasar estos parmetros en el que desea ver a tu personaje personalizado en la pantalla LCD. Tambin 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 cdigo para mostrar y mover el personaje a medida, de ida y vuelta, (de su eleccin) en la pantalla LCD. Cdigo: // LCD module connections sbit 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 variable const 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); } } } Despus de especificar las conexiones de LCD pegue el cdigo de tu personaje a medida que quieras pantalla. A continuacin, inicializar el LCD, el texto de la pantalla (si quieres), y mostrar su costumbre caracteres pasando el parmetro posiciones. Ahora, para mover el texto slo tiene que utilizar para el comando de bucle y LCD IZQUIERDA / DERECHA, en la que desea mover. Nmero 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 atrs. Eso es todo!!. Esquema:

P g i n a | 29

PIC16F887/877 de programacin en C Tutorial 8 (PWM) PWM: El modo PWM genera una seal PWM en el terminal CCPx. El ciclo de trabajo, el perodo y la resolucin se determina por los siguientes registros: PR2 T2CON CCPRxL CCPxCON En la modulacin de ancho de pulso (PWM) el modo, el mdulo CCP produce hasta una resolucin 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 perodo de PWM se especifica mediante el registro PR2 de Timer2. El perodo de PWM se puede calcular usando la frmula Perodo PWM = [(PR2) + 1] 4 TOSC (TMR2 valor de preescala) 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. (Excepcin: 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 despus del perodo se completa (es decir, un partido entre PR2 y TMR2 registros se produce). Mientras se utiliza el PWM, el registro CCPRxH es de slo lectura.

P g i n a | 30

De ancho de pulso = (CCPRxL: CCPxCON <5:4>) TOSC (TMR2 valor de pre-escala) Deber relacin de ciclo (CCPRxL: CCPxCON <5:4>) / 4 (PR2 + 1) PWM Resolucin: La resolucin determina el nmero de ciclos de trabajo disponibles para un perodo determinado. Por ejemplo, una resolucin de 10-bits se traducir en 1024 ciclos de trabajo discretos, mientras que un 8-bits de resolucin se traducir en 256 ciclos de trabajo discretos. La resolucin mxima es de 10 bits de PWM cuando PR2 es de 255. Resolucin = log [4 (PR2 + 1)] / log (2) bits

Configuracin para el funcionamiento PWM: Los siguientes pasos se deben tomar cuando se configura el mdulo CCP para la operacin 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 perodo de PWM mediante la carga del registro PR2. 3. Configurar el mdulo 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 interrupcin 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 despus 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 slo 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. Cdigo: Le permite escribir el cdigo 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; PORTC = 0; TRISC = 0; PWM1_Init(1000); PWM2_Init(2000); } void main() { InitMain(); current_duty = 16; current_duty1 = 16;

// configure PORTA pins as input // set PORTC to 0 // designate PORTC pins as output // Initialize PWM1 module at 1KHz // Initialize PWM2 module at 2KHz

// initial value for current_duty // 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); } } PWM1_Init (); Inicializa el PWM mdulo con relacin de trabajo 0. Parmetrofrecuencia deseada es un PWM de frecuencia en Hz. PWM1_Set_Duty (); Juegos PWM relacin de trabajo. Parmetro deber de toma valores de 0 a 255, donde 0 es 0%, 127 es del 50%, y 255 es 100% de relacin de trabajo. Otros valores especficos para relacin de trabajo se puede calcular como / (Porcentaje * 255) 100 . // slow down change pace a little

P g i n a | 33

PWM1_Start (); Inicia PWM. Esquema:

PIC16F887/877 la programacin en C Tutorial 9 (Interrumpe temporizadores) Interrupcin de los temporizadores: Ahora vamos a ver la interrupcin de los temporizadores. Como sabemos Timer0 generar una interrupcin cuando el TMR0 registrarse desbordamientos de FFh a 00h.La interrupcin T0IF bit de bandera del registro INTCON se pone cada vez que el TMR0 se desborda de registro, independientemente de si o no la interrupcin del Timer0 est habilitado. El bit T0IF debe ser limpiado en el software. La habilitacin de interrupcin Timer0 es el bit T0IE del registro INTCON. Sin embargo vamos a utilizar poco TMR0IF para la programacin de interrupcin. El par Timer1 registro (TMR1H: TMR1L) incrementos a FFFFh y da la vuelta a 0000h.Cuando Timer1 se da la vuelta, el bit de interrupcin del Timer1 bandera del registro PIR1 est establecido. Para habilitar la interrupcin en la renovacin, se debe establecer estos bits: Timer1 interrumpir el bit de habilitacin del registro PIE1 PEIE bits del registro INTCON bit GIE del registro INTCON La interrupcin se borra en la limpieza de la broca TMR1IF en la rutina de interrupcin .

P g i n a | 34

Para la programacin de interrupciones tenemos que crear ISR (rutina de interrupcin), de modo que cuando una interrupcin se producir ISR se har cargo de ella. Por lo tanto, para usar los temporizadores de interrupcin, primero tenemos que habilitar la interrupcin global estableciendo el bit GIE del registro INTCON, a continuacin, las interrupciones del temporizador correspondiente. Cdigo: 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; PORTc = 0xFF; TRISc = 0; T2CON = 7; TMR2 = 0; TMR2IE_bit = 1; INTCON = 0xC0; }

// initialize cnt // Initialize PORTc // PORTc is output // Timer2 settings // Initialize Timer2 register // enable interupt // Set GIE, PEIE

Este cdigo de alternar los bits de un puerto, B y D, cuando las interrupciones de temporizador 1, 0, y 2, respectivamente. El tiempo de duracin es de aproximadamente 0,5 segundos, seccin 1, y 2 seg. interrupcin de vaco () 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 programacin en C Tutorial 10 (ADC) Analgico a digital (ADC): En este tutorial te mostrar cmo convertir los valores analgicos en digitales, mediante el uso de 887 (poco difieren con 877) , a continuacin, mostrar estos valores digitales en la pantalla LCD. El convertidor de analgico a digital (ADC) permite la conversin de una seal de entrada analgica a una representacin binaria de 10-bits de esa seal. Este dispositivo utiliza entradas analgicas, que son multiplexadas en una sola muestra y mantenga circuito. La salida de la muestra y retencin est conectada a la entrada del convertidor. El convertidor genera un resultado binario de 10 bits a travs de aproximaciones sucesivas y almacena el resultado de la conversin en los registros de resultados de ADC (ADRESL y ADRESH). La tensin de referencia ADC es software seleccionable para ser generado internamente o externamente suministrada. ADC de configuracin: Al configurar y usar el ADC de las siguientes funciones deben ser considerados: Configuracin del puerto La seleccin de canales Seleccin de la referencia de tensin ADC ADC fuente de reloj de conversin Control de Interrupcin Resultados de formato Configuracin del puerto: El producto puede ser usado para convertir seales analgicas y digitales. Al convertir las seales analgicas, el pin de E / S debe estar configurado para analgica estableciendo el TRIS correspondiente y los bits de Ansel. Seleccin de canales: Los bits de la CHS ADCON0 registrar determinar qu canal est conectado a la de muestreo y retencin del circuito. Al cambiar canales, un retraso se requiere antes de comenzar la conversin siguiente .

P g i n a | 38

ADC de voltaje de referencia de seleccin: Los bits de la VCFG ADCON0 registrar proporcionar un control independiente de las referencias de tensin positiva y negativa. La tensin de referencia positiva puede ser VDD o una fuente de tensin externa. Asimismo, la tensin de referencia negativa puede ser VSS o una fuente de tensin externa. ADC de conversin de la fuente de reloj: La fuente del reloj de conversin es un software seleccionables a travs 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 conversin de bits se define como TAD. Un total de 10bits de conversin requiere 11 perodos TAD, como se muestra en la figura.

Interrumpir el control: El mdulo ADC permite la capacidad de generar una interrupcin al trmino de una conversin analgica a digital. La bandera de interrupcin ADC es el bit ADIF en el registro PIR1. La interrupcin del ADC de habilitacin 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 conversin 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 Operacin: De iniciar una conversin: Para habilitar el mdulo 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 conversin de analgico a digital.

EJECUCIN DE UNA CONVERSIN: Cuando la conversin haya terminado, el mdulo ADC har lo siguiente: Limpie el GO / DONE bits Ajuste el bit de bandera ADIF Actualizar los registros ADRESH: ADRESL con resultado de la conversin nueva

UN PROCEDIMIENTO DE CONVERSIN A / D: Este es un ejemplo de procedimiento para el uso de la ADC para llevar a cabo una conversin de analgico a digital: 1. Configurar puerto: Desactivar controlador pin de salida (Ver registro TRIS) Configurar pin como analgico 2. Configure el mdulo ADC: Seleccione reloj de conversin ADC Configurar la tensin de referencia ADC Seleccione el canal de entrada de formato Seleccionar resultado Encienda el mdulo ADC

P g i n a | 40

3. Configurar la interrupcin ADC (opcional): Borrar marca de interrupcin ADC Habilitar ADC interrumpir Habilitar interrupcin perifrica Habilitar interrupcin global (1) 4. Espere el tiempo de adquisicin requerido (2). 5. Iniciar la conversin mediante el establecimiento de la GO / bit de efectuado. 6. Espere a que la conversin ADC para completar uno de los siguientes: Sondeo de la GO / DONE bits Tiempo de espera para la interrupcin del ADC (interrumpe habilitado) 7. Leer el resultado de ADC 8. Desactive la bandera de interrupcin ADC (se requiere si la interrupcin 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

Cdigo: Vamos a hacer ms fcil mediante el uso de ADC biblioteca de mikroC. El siguiente cdigo convirtiendo la entrada analgica, en el pin RA2, en digital y lo mostrar en la pantalla LCD. A medida que la conversin es de 10 bits, por lo que el rango es de 0 a 1023. unsigned int temp_res; // LCD module connections sbit 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); Lcd_Out(1,1,txt1); adc_init(); do {

// Cursor off

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 mdulo interno del PIC ADC para trabajar con el reloj RC. Reloj determina el perodo de tiempo necesario para realizar la conversin AD. ADC_read (2);. 10 o 12-bits sin signo valor ledo del canal especificado (MCU dependiente) Parmetro canal representa el canal desde el cual el valor analgico se va a acquired.In este caso es 2. IntToStr (temp_res, txt), de entrada convierte firmado nmero entero en una cadena.La cadena de salida se ha fijado la anchura de 7 caracteres, incluidos los de carcter nulo al final (terminacin 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: