Mostrando entradas con la etiqueta tutorial CCS compiler y proteus. Mostrar todas las entradas
Mostrando entradas con la etiqueta tutorial CCS compiler y proteus. Mostrar todas las entradas
miércoles, 26 de febrero de 2014
FOR
Se utiliza para repetir alguna sentencia
For (inicialización; condición de finalización; incremento)
{
sentencias;
}
En las expresiones del FOR la inicialización es una variable a la cual se le asigna un valor inicial con el que controlar en bucle. Por ejemplo si se utiliza la variable a se puede indicar como inicialización a=0 (se le asigno un valor inicial de 0).
La condición de finalización sirve para evaluar ANTES de ejecutar las sentencias si es cierta o no, en caso de ser cierta se ejecutan las sentencias ( como prender o apagar un led, un motor, etc.). y en caso contrario se sale del FOR. Por ejemplo cuando a es igual a 9 (a=9) entonces se sale de la sentencia FOR.
Por ultimo, la expresión de incremento o decremento modifica la variable de control DESPUÉS de ejecutar el bucle. Por ejemplo si la variable a decrementa (a++), y la inicialización es a=0 y la finalización es a=9 entonces la variable a incrementa de 1,2,.....,8 en este intervalo se repite el bucle hasta que la variable a es igual a 9 (a=9) se sale del bucle.
Se pueden anidar bucles FOR utilizando distintas variables de control.
Si se ejecuta la siguiente expresión se consigue un BUCLE SIN FIN:
For( ; ;)
{
sentencias;
}
For (A=0; A=9; A++)
{
PORTB=0x01;
}
Ejemplo 1: temporizador de 9 a 0 segundos con PIC 16f84a.
MATERIAL:1- PIC16f84a.
1- Crystal 4Mhz.
2- Capacitores cerámicos 22pf.
1- Pushbutton.
1- Resistor 10k.
1- Display 7 segmentos cátodo común.
7-Resistores de 220.
CÓDIGO:
#include <16f84a.h>
#use delay(clock=4000000)
#fuses xt,nowdt,noprotect,noput
#byte trisa=0x85
#byte trisb=0x86
#byte porta=0x05
#byte portb=0x06
byte display[10]={0xDB,0xFB,0x0B,0xF9,0xD9,0xCA,0x9B,0xB3,0x0A,0x7B};
int8 a;
void main(){
trisa=0xff;
trisb=0x00;
while(true){
if(bit_test(porta,0)==1){
for(a=1;a<10;a++){
portb=display[a];
delay_ms(1000);
}
}
else{
portb=display[0];
}
}
}
// Cada vez que se aprieta el porta,0 se inicializa el temporizador hasta que llega a 0.
SIMULACION:
SWITCH
Switch es un caso particular de una decisión múltipleSwich (expresión) // expresión puede ser a, b o por ejemplo el porta
{
case constante 1: // constante 1 puede ser 1, 2, o 0x01, 0x02 o 0b00001,000010
sentencias; //podemos activar un puerto
break;
case constante 2:
sentencias;
break;
...........................
[default:
sentencias;]
}
Evalúa la expresión y en orden a la constante adecuada realiza las sentencias asociadas. Si ninguno de los case corresponde a la constante se ejecuta default (este comando es opcional).
El comando break provoca la salida de swich, de lo contrario se ejecuta el siguiente case.
No puede existir dos case con la misma constante.
el
switch tiene una ventaja en comparación con el if cuando se refiere a
decisiones múltiples ya que con el if necesitamos anidar demasiados if.
El switch se puede utilizar cuando se tiene un gran numero de combinaciones por ejemplo en un seguilineas al haber un gran numero de sensores y cada combinacion binaria de estos sensores realiza una acción en los motores, es conveniente utilizar un switch en lugar de anidar if.
El switch se puede utilizar cuando se tiene un gran numero de combinaciones por ejemplo en un seguilineas al haber un gran numero de sensores y cada combinacion binaria de estos sensores realiza una acción en los motores, es conveniente utilizar un switch en lugar de anidar if.
Switch(A){
case 0:
bit_set(portb,0);
break;
case 1:
bit_set(portb,1);
break;
case 2:
bit_set(portb,2);
break;
}
Ejemplo 2: convertidor de binario a hexadecimal .
MATERIAL:
1- PIC16f887.
1- Cristal 8 Mhz.
2- Capacitores cerámicos.
2- Display 7 segmentos cátodo común.
14- Resistores de 220.
5- Resistores 10k.
1- Dipswitch 5 posiciones.
1- Fuente de 5v.
CÓDIGO:
#include <16f887.h>
#fuses hs,wdt
#use delay(clock=8000000)
#byte trisb=0x86
#byte trisa=0x85
#byte trisd=0x88
#byte portb=0x06
#byte porta=0x05
#byte portd=0x08
byte display[16]={0x7B,0x0A,0xB3,0x9B,0xCA,0xD9,0xF9,0x0B,0xFB,0xDB,0xEB,0xF8,0x71,0xBA,0xF1,0xE1};
byte display_2[4]={0x7B,0x0A,0xB3,0x9B};
int8 a;
void main(){
trisa=0xff;
trisb=0x00;
trisd=0x00;
portb=0x00;
portd=0x00;
while(true){
a=porta;
Switch (a){
case 0:
portd=display[0];
portb=display_2[0];
break;
case 1:
portd=display[1];
portb=display_2[0];
break;
case 2:
portd=display[2];
portb=display_2[0];
break;
case 3:
portd=display[3];
portb=display_2[0];
break;
case 4:
portd=display[4];
portb=display_2[0];
break;
case 5:
portd=display[5];
portb=display_2[0];
break;
case 6:
portd=display[6];
portb=display_2[0];
break;
case 7:
portd=display[7];
portb=display_2[0];
break;
case 8:
portd=display[8];
portb=display_2[0];
break;
case 9:
portd=display[9];
portb=display_2[0];
break;
case 10:
portd=display[10];
portb=display_2[0];
break;
case 11:
portd=display[11];
portb=display_2[0];
break;
case 12:
portd=display[12];
portb=display_2[0];
break;
case 13:
portd=display[13];
portb=display_2[0];
break;
case 14:
portd=display[14];
portb=display_2[0];
break;
case 15:
portd=display[15];
portb=display_2[0];
break;
case 16:
portd=display[0];
portb=display_2[1];
break;
case 17:
portd=display[1];
portb=display_2[1];
break;
case 18:
portd=display[2];
portb=display_2[1];
break;
case 19:
portd=display[3];
portb=display_2[1];
break;
case 20:
portd=display[4];
portb=display_2[1];
break;
case 21:
portd=display[5];
portb=display_2[1];
break;
case 22:
portd=display[6];
portb=display_2[1];
break;
case 23:
portd=display[7];
portb=display_2[1];
break;
case 24:
portd=display[8];
portb=display_2[1];
break;
case 25:
portd=display[9];
portb=display_2[1];
break;
case 26:
portd=display[10];
portb=display_2[1];
break;
case 27:
portd=display[11];
portb=display_2[1];
break;
case 28:
portd=display[12];
portb=display_2[1];
break;
case 29:
portd=display[13];
portb=display_2[1];
break;
case 30:
portd=display[14];
portb=display_2[1];
break;
case 31:
portd=display[15];
portb=display_2[1];
break;
case 32:
portd=display[0];
portb=display_2[2];
break;
case 33:
portd=display[1];
portb=display_2[2];
break;
case 34:
portd=display[2];
portb=display_2[2];
break;
case 35:
portd=display[3];
portb=display_2[2];
break;
case 36:
portd=display[4];
portb=display_2[2];
break;
case 37:
portd=display[5];
portb=display_2[2];
break;
case 38:
portd=display[6];
portb=display_2[2];
break;
case 39:
portd=display[7];
portb=display_2[2];
break;
case 40:
portd=display[8];
portb=display_2[2];
break;
case 41:
portd=display[9];
portb=display_2[2];
break;
case 42:
portd=display[10];
portb=display_2[2];
break;
case 43:
portd=display[11];
portb=display_2[2];
break;
case 44:
portd=display[12];
portb=display_2[2];
break;
case 45:
portd=display[13];
portb=display_2[2];
break;
case 46:
portd=display[14];
portb=display_2[2];
break;
case 47:
portd=display[15];
portb=display_2[2];
break;
case 48:
portd=display[0];
portb=display_2[3];
break;
case 49:
portd=display[1];
portb=display_2[3];
break;
case 50:
portd=display[2];
portb=display_2[3];
break;
case 51:
portd=display[3];
portb=display_2[3];
break;
case 52:
portd=display[4];
portb=display_2[3];
break;
case 53:
portd=display[5];
portb=display_2[3];
break;
case 54:
portd=display[6];
portb=display_2[3];
break;
case 55:
portd=display[7];
portb=display_2[3];
break;
case 56:
portd=display[8];
portb=display_2[3];
break;
case 57:
portd=display[9];
portb=display_2[3];
break;
case 58:
portd=display[10];
portb=display_2[3];
break;
case 59:
portd=display[11];
portb=display_2[3];
break;
case 60:
portd=display[12];
portb=display_2[3];
break;
case 61:
portd=display[13];
portb=display_2[3];
break;
case 62:
portd=display[14];
portb=display_2[3];
break;
case 63:
portd=display[15];
portb=display_2[3];
break;
}
}
}
SIMULACION:
REFERENCIA:
- —COMPILADOR C CCS Y SIMULADOR PROTEUS PARA MICROCONTROLADORES PIC.
sábado, 30 de noviembre de 2013
Las declaraciones son usadas para controlar el proceso de ejecución del programa.
WHILE
WHILE se utiliza para repetir sentencias.
while(expresión)
{
sentencia;
}
La expresión se evalúa y la sentencia se ejecuta mientras la expresión es verdadera, cuando es falsa se sale del WHILE.
si se ejecutan la siguiente expresiones se consigue un BUNCLE SIN FIN:
while(1)
{
sentencias;
}
if(bit_test(porta,0)= =1){ // se evalúa si esta activado (en 1 lógico) el primer bit del puerto a.
bit_set(portb,0); //si esta activado se pone en 1 el portb,0.
}
else{ //si no esta activado se pone en 0 el portb,0.
bit_clear(portb,0);
}
#use delay (clock=4000000)//reloj de 4Mhz
#byte trisa=0x85 //dirección del trisa en la memoria
#byte trisb=0x86
#byte porta=0x05
#byte portb=0x06
void main(){ //función principal
trisa=0xff;//se configura el puerto a como entrada
trisb=0x00;//se configura el puerto b como salida
portb=0x00;//se pone en cero el puerto b
while(true){ //se crea un buncle infinito
if(bit_test(porta,0)= =1){ // se evalúa si esta activado (en 1 lógico) el primer bit del puerto a.
bit_set(portb,0); //si esta activado se pone en 1 el portb,0.
}
else{ //si no esta activado se pone en 0 el portb,0.
bit_clear(portb,0);
}
}
}
Se puede anidar los IF-ELSE dando lugar a los ELSE-IF; con esto se pueden tomar decisiones múltiples. Un ejemplo es cuando se tienen varios sensores y cada sensor tiene que activar cierto actuador. Con la instrucción IF se puede ocupar otra herramienta importante para la toma de decisiones como lo son los operadores; los operadores mas utilizados son:
Lógicos
&& = AND
|| = OR
De bits
&=AND
| =OR
Nota: con estos operadores se puede realizar lógica operacional.
Ejemplo: cada salida activara el giro y activación de dos motores de D.C. RB7=1 motor 2 izquierda, RB6=1 motor 2 derecha, RB5=1 motor 1 izquierda y RB4=1 motor 1 derecha.
Código:
#include <16f84a.h> //llamado del fichero donde se especifican las características del PIC
#fuses xt,nowdt //tipo de cristal a utilizar
#use delay (clock=4000000)//reloj de 4Mhz
#byte trisa=0x85 //dirección del trisa en la memoria
#byte trisb=0x86
#byte porta=0x05
#byte portb=0x06
void main(){ //función principal
trisa=0xff;//se configura el puerto a como entrada
trisb=0x00;//se configura el puerto b como salida
portb=0b00000001;//se pone en cero el puerto b
while(true){ //se crea un buncle infinito
if((bit_test(porta,0)==1||bit_test(porta,1)==1)&&(bit_test(portb,0)==0)){ //RA0=1 o RA1=1 y RB0=0
bit_clear(portb,4)&bit_clear(portb,5)&bit_clear(portb,6)&bit_set(portb,7);// entonces RB4=0 y RB5=0 y
} // RB6=0 y RB7=1
else{
if((bit_test(portb,0)==1)&&(bit_test(porta,0)==0)&&(bit_test(porta,1)==0)){
bit_clear(portb,4)&bit_clear(portb,5)&bit_clear(portb,7)&bit_set(portb,6);
}
else{
if((bit_test(portb,0)==1)&&(bit_test(porta,0)==1)&&(bit_test(porta,1)==0)){
bit_clear(portb,5)&bit_clear(portb,6)&bit_clear(portb,7)&bit_set(portb,4);
}
else{
if((bit_test(porta,1)==1)&&(bit_test(portb,0)==1)&&(bit_test(porta,0)==0)){
bit_clear(portb,4)&bit_clear(portb,6)&bit_set(portb,5)&bit_set(portb,7);
}
else{
if((bit_test(porta,0)==1)&&(bit_test(porta,1)==1)&&(bit_test(portb,0)==1)){
bit_clear(portb,5)&bit_clear(portb,6)&bit_set(portb,7)&bit_set(portb,4);
}
else{
portb=0x00; //si no se cumple ningun if se pone en 0 el portb
}
}
}
}
}
}
}
Lo que hace el ELSE- IF es tomar decisiones múltiples es decir si un el primer IF no se cumple se pasa al siguiente IF hasta que uno de estos se cumpla si no se cumple ninguno se ejecuta el ultimo ELSE.
1- Crystal 4Mhz.
2- Capacitores ceramicos 22pf.
1- Led (practica 1).
1- Resistor de 220 (practica 1).
3- Pushbutoon (van en lugar de los logicstate y conectados como en la practica 1).
3- Resistores de 10k (van conectados entre el pushbutton y la tierra como en la practica 1).
1- L293D (practica 2).
2- Motores de DC de 12v (practica 2).
IF - ELSE
Estas declaraciones de control nos ayuda a tomar decisiones. Por ejemplo prender o apagar un led cuando se este pulsando un push button.if(bit_test(porta,0)= =1){ // se evalúa si esta activado (en 1 lógico) el primer bit del puerto a.
bit_set(portb,0); //si esta activado se pone en 1 el portb,0.
}
else{ //si no esta activado se pone en 0 el portb,0.
bit_clear(portb,0);
}
Ejemplo 1 encender y apagar un led con un push button.
#include <16f84a.h> //llamado del fichero donde se especifican las características del PIC
#fuses xt,nowdt //tipo de cristal a utilizar #use delay (clock=4000000)//reloj de 4Mhz
#byte trisa=0x85 //dirección del trisa en la memoria
#byte trisb=0x86
#byte porta=0x05
#byte portb=0x06
void main(){ //función principal
trisa=0xff;//se configura el puerto a como entrada
trisb=0x00;//se configura el puerto b como salida
portb=0x00;//se pone en cero el puerto b
while(true){ //se crea un buncle infinito
if(bit_test(porta,0)= =1){ // se evalúa si esta activado (en 1 lógico) el primer bit del puerto a.
bit_set(portb,0); //si esta activado se pone en 1 el portb,0.
}
else{ //si no esta activado se pone en 0 el portb,0.
bit_clear(portb,0);
}
}
}
Se puede anidar los IF-ELSE dando lugar a los ELSE-IF; con esto se pueden tomar decisiones múltiples. Un ejemplo es cuando se tienen varios sensores y cada sensor tiene que activar cierto actuador. Con la instrucción IF se puede ocupar otra herramienta importante para la toma de decisiones como lo son los operadores; los operadores mas utilizados son:
Lógicos
&& = AND
|| = OR
De bits
&=AND
| =OR
Nota: con estos operadores se puede realizar lógica operacional.
—Ejemplo: se tienen tres sensores y cada combinación activa los puertos RB4, RB5,
RB6 y RB7 la secuencia
se observa
en la siguiente tabla
de verdad.
Ejemplo: cada salida activara el giro y activación de dos motores de D.C. RB7=1 motor 2 izquierda, RB6=1 motor 2 derecha, RB5=1 motor 1 izquierda y RB4=1 motor 1 derecha.
Código:
#include <16f84a.h> //llamado del fichero donde se especifican las características del PIC
#fuses xt,nowdt //tipo de cristal a utilizar
#use delay (clock=4000000)//reloj de 4Mhz
#byte trisa=0x85 //dirección del trisa en la memoria
#byte trisb=0x86
#byte porta=0x05
#byte portb=0x06
void main(){ //función principal
trisa=0xff;//se configura el puerto a como entrada
trisb=0x00;//se configura el puerto b como salida
portb=0b00000001;//se pone en cero el puerto b
while(true){ //se crea un buncle infinito
if((bit_test(porta,0)==1||bit_test(porta,1)==1)&&(bit_test(portb,0)==0)){ //RA0=1 o RA1=1 y RB0=0
bit_clear(portb,4)&bit_clear(portb,5)&bit_clear(portb,6)&bit_set(portb,7);// entonces RB4=0 y RB5=0 y
} // RB6=0 y RB7=1
else{
if((bit_test(portb,0)==1)&&(bit_test(porta,0)==0)&&(bit_test(porta,1)==0)){
bit_clear(portb,4)&bit_clear(portb,5)&bit_clear(portb,7)&bit_set(portb,6);
}
else{
if((bit_test(portb,0)==1)&&(bit_test(porta,0)==1)&&(bit_test(porta,1)==0)){
bit_clear(portb,5)&bit_clear(portb,6)&bit_clear(portb,7)&bit_set(portb,4);
}
else{
if((bit_test(porta,1)==1)&&(bit_test(portb,0)==1)&&(bit_test(porta,0)==0)){
bit_clear(portb,4)&bit_clear(portb,6)&bit_set(portb,5)&bit_set(portb,7);
}
else{
if((bit_test(porta,0)==1)&&(bit_test(porta,1)==1)&&(bit_test(portb,0)==1)){
bit_clear(portb,5)&bit_clear(portb,6)&bit_set(portb,7)&bit_set(portb,4);
}
else{
portb=0x00; //si no se cumple ningun if se pone en 0 el portb
}
}
}
}
}
}
}
Lo que hace el ELSE- IF es tomar decisiones múltiples es decir si un el primer IF no se cumple se pasa al siguiente IF hasta que uno de estos se cumpla si no se cumple ninguno se ejecuta el ultimo ELSE.
En la linea if((bit_test(porta,0)==1||bit_test(porta,1)==1)&&(bit_test(portb,0)==0)) significa que si RA0=1 o RA1=1 o ambos son uno y además RB0=0 se ejecuta la sentencia. Si el RB0=1 o si RA0=0 y RA1=0 no se cumple esta condición.
Simulación:
MATERIAL:
1- PIC 16f84a.1- Crystal 4Mhz.
2- Capacitores ceramicos 22pf.
1- Led (practica 1).
1- Resistor de 220 (practica 1).
3- Pushbutoon (van en lugar de los logicstate y conectados como en la practica 1).
3- Resistores de 10k (van conectados entre el pushbutton y la tierra como en la practica 1).
1- L293D (practica 2).
2- Motores de DC de 12v (practica 2).
DESCARGAR ARCHIVOS Y SIMULACIÓN:
TUTORIAL 1 CCS:
http://microcontroladores-ing-elec-rh.blogspot.mx/2013/10/programando-pics-en-lenguaje-c-en-ccs.html
VIDEO DE LAS SIMULACIONES:
- —COMPILADOR C CCS Y SIMULADOR PROTEUS PARA MICROCONTROLADORES PIC.
viernes, 11 de octubre de 2013
Un PIC tiene terminales de entrada/salida divididos en puertos, cada puerto se puede comportar como entrada/salida por ejemplo el PIC 16f628a cuenta con 2 puertos el A y B, en la figura se muestra que el puerto A consta de 8 terminales (RA0,.......,RA7) y el puerto B también consta de 8 terminales (RB0,.........,RB7). Por lo regular en el puerto A solo se utilizan 5 pines ya que en el RA6 y RA7 se coloca el cristal externo (aunque este PIC cuenta con un cristal interno), además en el puerto RA5 es utilizado para resetear el PIC.
Existen PICs con mayor numero de puertos como el 18f4550 que cuenta con los puertos A, B, C, D y E.
¿Como habilitar los puertos como entrada o salida?
La habilitación como entrada o salida se realiza a través del registro TRISx. Para saber en que dirección se sitúan el TRIS y PORT en la memoria solo hay que checar el datasheet de cada PIC ya que en algunos casos la dirección tiende a cambiar según el PIC.
En la figura se muestra el datasheet del PIC 16f628a y se observa las direcciones de los puertos A y B.
Cuales son:
PORTA=05h,
PORTB=06h.
NOTA: la h indica que se encuentra en hexadecimal.
En CCS se puede manipular los puertos a través de la RAM, para esto se
deben definir los registros PORTx y TRISx como bytes y se sitúan en la
posición correspondiente a la memoria RAM. La directiva utilizada de C
es #BYTE.
#BYTE porta=0x05 // variable porta en 05h
#BYTE portb=0x06 // variable portb en 06h
#BYTE trisa= 0x85 // variable trisa en 85h
#BYTE trisb= 0x86 // variable trisb en 86h
NOTA: en CCS se utilizan las // para escribir comentarios.
Una vez definidas las direcciones de los PORTx y los TRISx se pueden configurar los puertos a través de los TRISx.
TRISA=0b11111 //indica que el RA0, RA1, RA2, RA3 y RA4 se ocupan como entradas.
TRISB=0b00001111// indica que RB0 al RB3 se ocupan como entradas y del RB4 al RB7 como salidas.
NOTA: Para asignar a un puerto como entrada se debe de adjudicarle un 1 y para una salida un cero. Para ocupar código binario en CCS se utiliza el código 0b antes de los bits.
PORTB=0b00011010// saca por el RB1, RB3 y RB4 un uno y por el RB0, RB2, RB5, RB6 y RB7 saca un cero.
PORTD=0x00// pon en cero el puerto d.
Ejemplo:
#include <16f628a.h> //llamado del fichero donde se especifican las características del PIC
#fuses xt,nowdt //tipo de cristal a utilizar #use delay (clock=4000000)//reloj de 4Mhz
#byte trisa=0x85 //dirección del trisa en la memoria
#byte trisb=0x86
#byte porta=0x05
#byte portb=0x06
void main(){ //función principal
trisa=0b10100; //RA0,RA1 y RA3 como salida, el RA2 y RA4 como entrada
trisb=0b00000000;//todo el puerto B como salida
portb=0x00; //se pone el puerto B en cero
while(true){ //buncle infinito
portb=0b01010101; //RB0,RB2,RB4 y RB6 se ponen en uno, RB1,RB3,RB5 y RB7 se ponen en 0
porta=0b01011; //RA0,RA1 y RA3 se ponen a 1, RA2 y RA4 se ponen a 0
}
}
Existen unas funciones de C que permiten trabajar bit a bit con los registros o variables definidas previamente. Estas funciones son las siguientes:
bit_clear(var,bit);//pone a 0 el bit especifico (0 a 7) de la variable.
bit_set(var,bit); //pone a 1 el bit especifico (0 a 7) de la variable.
bit_test(var,bit); //muestra el bit especifico (0 a 7) de la variable.
ejemplo:
bit_clear (portb,0);// saca un 0 en la terminal RB0.
bit_set (portb,2);// saca un 1 en la terminal RB2.
NOTA:el bit_test se utilizara mas adelante cuando esplique sobre el if.
Para poder sacar un retardo en CCS solo se utiliza el comando:
delay_ms(100);// saca un retardo de 100 milisegundos.
delay_us(100); //saca un retardo de 100 microsegundos.
con toda esta información podemos realizar nuestro primer proyecto.
PROYECTO 1 SEMÁFORO
#include <16f84a.h> //llamado del fichero donde se especifican las características del PIC
#fuses xt,nowdt //tipo de cristal a utilizar#use delay (clock=4000000)//reloj de 4Mhz
#byte trisa=0x85 //dirección del trisa en la memoria
#byte trisb=0x86
#byte porta=0x05
#byte portb=0x06
void main(){ //función principal
bit_clear(trisa,3);//el RA3 como salida
trisb=0x00;//todo el puerto B como salida
portb=0x00;//puerto B puesto en 0
while(true){ //buncle infinito
bit_set(porta,3);//pone en 1 el RA3
delay_ms(5000); //retardo de 5 segundos
bit_clear(porta,3);//pone en 0 el RA3
bit_set(portb,0); //pone en 1 el RB0
delay_ms(5000);
bit_clear(portb,0);//pone en 0 el RB0
bit_set(portb,1); //pone en 1 el RB1
delay_ms(5000);
bit_clear(portb,1);//pone en 0 el RB1 y empieza de nuevo el programa desde el while
}
}
NOTA: en la simulación no se requiere poner el cristal ya que se programa cuando le damos doble click al pic, tampoco se requiere poner en 1 el MCLR, en el ejemplo 1 no le puso resistencia a los leds. Si desea realizar la practica en protoboard requiere poner lo señalado anteriormente.
PCB:
listo para imprimir:
NOTA: en la carpeta de archivos se encuentra un archivo word con las imagenes listo para imprimir y realizar el pcb, si no dentro de la carpeta semaforo esta el archivo para abrir con pcbwizard.
MATERIAL:
1 PIC 16f84a.
1 cristal de 4Mhz.
2 capacitores cerámicos de 22pf.
1 porta circuito integrado de 18 pines.
1 borne(kulca) doble.
3 resistencias de 220 ohms
1 led rojo de 5mm.
1 led verde de 5mm.
1 led amarillo de 5mm.
DESCARGAR ARCHIVO HEX, SIMULACIÓN y PCB:
TUTORIAL 2:
http://microcontroladores-ing-elec-rh.blogspot.mx/2013/11/programando-pics-en-lenguaje-c-en-ccs.html
VIDEO SIMULACION Y PRUEBAS:
DOCUMENTO:
Suscribirse a:
Entradas (Atom)
.png)
