/////////////////// ////////////////////////////// ///////////////////// //////////////////// ///////////////////// ////////////////////// /////////////////// //////// /////////////////// ////////////////////////////// ///////////////////// //////////////////// ///////////////////// ////////////////////// /////////////////// //////// /// Practica 1 : Parpadeo de LED´S LED´S con PIC16F84A /// /// para el foro.elhacker.net by Marco /// /////////////////// ////////////////////////////// ///////////////////// //////////////////// ///////////////////// ////////////////////// /////////////////// //////// /////////////////// ////////////////////////////// ///////////////////// //////////////////// ///////////////////// ////////////////////// /////////////////// ////////
/////////////////// ///////////////////////////// ////////// DIRECTIVAS DIRECTIVAS DE PREPROCESADO PREPROCESADO /////////////// ////////////////////// /////// /// libreria para el manejo manejo del pic16f84a #include <16F84A.h> /// declara la frecuencia del cristal cristal #use delay(clock=8000000 delay(clock=8000000)) ///configura los fusibles fusibles /// HS es la configuraricion configuraricion del oscilador oscilador la cual indica High speed speed es decir /// frecuencias frecuencias altas esto es a partir de de 8 Mhz. /// NOWDT deshabilita deshabilita el Watch Dog Timer /// NOPUT deshabilita deshabilita le reseteo de power power up timer /// NOPROTECT deshabilita deshabilita la proteccion del del codigo del pic. #fuses HS,NOWDT,NOPUT,NOPROTECT HS,NOWDT,NOPUT,NOPROTECT /// asignamos a variable port_b port_b el espacio memoria memoria 0x06 que es la dir de de port_b #byte port_b=0x06 /////////////////// //////////////////////////GLOBALES// ///////GLOBALES////////// ////////////////// ///////////////////// ////////////////////// /////////////// //// /// Estos parámetros son son visibles desde todo todo el código /// /// por eso se les llama llama globales /// /// Al ser constantes,lo más más práctico es declararlas declararlas aquí. /// /////////////////// ////////////////////////////// ///////////////////// //////////////////// //////////////////////// /////////////////////// //////////////////// /////////// int contador; /////////////////// ////////////////////////// /////// Principal ///////////////////// /////////////////////////////// ///////////////////// /////////// void main() { /// declaramos declaramos el puerto B como salidas set_tris_b(0); /// lo igualamos con cero para que tengamos tengamos un valor inicial de lo contrario contrario /// no sabriamos con que que valor iniciaria al comienzo comienzo de nuestro programa programa port_b=0; /// bucle infinito para que que las instrucciones que que tiene siempre se se ejecuten while (true) { /// activa todos los pins del del puerto B /// otra instruccion que que podemos poner poner es contador=255 las dos dos son lo mismo contador=0xff; port_b=contador; /// Retardo Retardo de 1000 milisegundos milisegundos es decir 1 segundo segundo delay_ms(1000); //// apaga todos los los pins del puerto B}
contador=0x00; port_b=contador; /// Retardo Retardo de 1000 milisegundos milisegundos es decir 1 segundo segundo delay_ms(1000); } /// fin de bucle while } /// fin de funcion principal main aqui los archivos para PICC y Proteus
http://foro.elhacker.net/electronica/introduccion_a_la_progr http://foro.elhacker.net/electronica/ introduccion_a_la_programacion_de_pics_e amacion_de_pics_en_lenguaje_c_ccsn_lenguaje_c_ccst174021.0.html;msg824964#ixzz1XwqeObLW
///////////////////////////////////////////////////////////////////////////////////////// /////////////////////////// Practica 2 ///////////////////////////////// // Esta practica pasa la informacion que hay en el puerto B y la pasa // // al puerto A // ///////////////////////// By Marco_recargado /////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////// #include <16F877A.h> #use delay(clock=8000000)
/// libreria para el manejo del pic16f877a /// declara la frecuencia del cristal
#fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT,NOPROTECT
#use fast_io(B) #use fast_io(C)
/// con esta instruccion evitamos que /// se este configurando cada vez que usamos /// alguna instruccion de entrada o salida
#byte portb = 6 #byte portc = 7
void main(void) { while(true) { set_tris_b(0xff); set_tris_c(0x00); port_b_pullups(true); portc=portb; } }
//
se definen las direcciones de memoria
// Bucle infinito // se configura el puerto A como entrada // se configura el puerto B como salida // activa las resistencias de pull-up
// fin de programa
http://foro.elhacker.net/electronica/introduccion_a_la_programacion_de_pics_en_lenguaje_c_ccst174021.0.html;msg824964#ixzz1Xwr126MY
//////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////Practica 3 /////////////////////////////////////////// ////////Visualiza un conteo por el PORTB a travez de dos display de 8 seg//////// ////////////////////////// By MARCO_RECARGADO/////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// #include <16F877A.h> /// libreria para el manejo del pic16f877a #use delay(clock=8000000) /// declara la frecuencia del cristal #fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT,NOPROTECT int conteo=0; #use fast_io(A) #use fast_io(B) #use fast_io(C) #use fast_io(D) #use fast_io(E) #byte #byte #byte #byte #byte
porta = 5 portb = 6 portc = 7 portd = 8 porte = 9
/// con esta instruccion evitamos que /// se este configurando cada vez que usamos /// alguna instruccion de entrada o salida
/// se definen direcciones de memoria
//////////////////////////////////////////////////////////////////////////////////// //////////////////////inicio del programa principal///////////////////////////// /////////////////////////////////////////////////////////////////////////////////// void main(void) { set_tris_b(0x00); while(true) { conteo++; if((conteo&0x0f)>9)
//bucle infinito
// aqui observamos si el primer display llego a 10 // para solo comparar los primeros 4 bit hacemos una // operacion and con 0x0f
{ conteo=conteo+10; // hacemos que los 4 bits mas significativos incrementen conteo=conteo&0xf0; } if(conteo>99) {conteo=0;} // verificamos que la cuenta se haga de 0 a 99 else{ portb=conteo; delay_ms(400);} } //fin de ciclo while } //fin de programa
http://foro.elhacker.net/electronica/introduccion_a_la_programacion_de_pics_en_lenguaje_c_ccst174021.0.html;msg844004#ixzz1XwroZ91m
//////////////////////////////////////////////////////////////////////////////// ////////////// Practica 2 ////////////////////// ////////////// practica que escribe en una LCD ////////////////////// //////////////////////////////////////////////////////////////////////////////// ////////////// By MARCO RECARGADO ////////////////////// //////////////////////////////////////////////////////////////////////////////// #include <16F877A.h> /// libreria para el manejo del pic16f877a #use delay(clock=8000000) /// declara la frecuencia del cristal #fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT,NOPROTECT #include // Librería para el manejo del lcd para ver las conexiones // abran el archivo C:\Archivos de programa\PICC\Drivers\lcd.c // y ahi les muestra. //////////////////////////////////////////////////////////////////////////////// // D0 enable // D1 rs // D2 rw // D4 D4 // D5 D5 // D6 D6 // D7 D7 ////////////////////////////////////////////////////////////////////////////////
void main(void) { lcd_init(); // Antes de usar el lcd,hay que inicializarlo lcd_putc("HOLA MUNDO"); // Escribes en la lcd } // fin de programa http://foro.elhacker.net/electronica/introduccion_a_la_programacion_de_pics_en_lenguaje_c_ccst174021.0.html;msg857910#msg857910#ixzz1Xws9GKPj
//////////////////////////////////////////////////////////////////////////////// ////////////// Practica 2 ////////////////////// ////////////// practica que escribe en una LCD ////////////////////// //////////////////////////////////////////////////////////////////////////////// ////////////// By MARCO RECARGADO ////////////////////// //////////////////////////////////////////////////////////////////////////////// #include <16F877A.h> /// libreria para el manejo del pic16f877a #use delay(clock=8000000) /// declara la frecuencia del cristal #fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT,NOPROTECT #include // Librería para el manejo del lcd para ver las conexiones // abran el archivo C:\Archivos de programa\PICC\Drivers\lcd.c // y ahi les muestra. //////////////////////////////////////////////////////////////////////////////// // D0 enable // D1 rs // D2 rw // D4 D4 // D5 D5 // D6 D6 // D7 D7 //////////////////////////////////////////////////////////////////////////////// int i; void main(void) { lcd_init(); // Antes de usar el lcd,hay que inicializarlo while (1){ lcd_gotoxy(5,1); lcd_putc("Martin"); // Escribes en la lcd delay_ms(50); for(i=0;i<8;++i){
lcd_putc("\fM\n"); delay_ms(30); lcd_putc("\f a\n"); delay_ms(30); lcd_putc("\f t\n"); delay_ms(30); lcd_putc("\f i\n"); delay_ms(30); lcd_putc("\f n\n"); delay_ms(30); }} } // fin de programa http://foro.elhacker.net/electronica/introduccion_a_la_programacion_de_pics_en_lenguaje_c_ccst174021.0.html;msg857910#msg857910#ixzz1XwsLTRQ0
Hola pues en esta ocasion la practica consiste en leer un reloj de tiempo real. con ayuda de una libreria //////////////////////////////////////////////////////////////////////////////// ////////////ESTE PROGRAMA UTILZA EL CIRCUITO DS1307 PARA MOSTRAR LA //////////// //////////HORA EN TIEMPO REAL A TRAVEZ DE UNOS DISPLAY´S DE 7 SEGMENTOS///////// //////////EL PROGRAMA PARA SIMULARLO EN PROTEUS SE LLAMA RELOJ TIEMPO REAL////// ////////////////////////BY MARCO RECARGADO////////////////////////////////////// #include <16F877A.h> /// libreria para el manejo del pic16f877a #use delay(clock=8000000) /// declara la frecuencia del cristal #fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT,NOPROTECT #use i2c(Master, SDA=PIN_C4, SCL=PIN_C3) #include int32 tiempo_real=0; long dato_1=0; long dato_2=0; long dato_3=0; long dato_4=0; long dato_5=0; long dato_6=0; #use fast_io(A) #use fast_io(B) //#use fast_io(C) #use fast_io(D) #use fast_io(E) #byte portc = 7 #byte portd = 8 #bit #bit #bit #bit #bit #bit #bit #bit
portd0 portd1 portd2 portd3 portd4 portd5 portd6 portd7
= = = = = = = =
0x08.0 0x08.1 0x08.2 0x08.3 0x08.4 0x08.5 0x08.6 0x08.7
#bit #bit #bit #bit #bit #bit #bit #bit
portc0 portc1 portc2 portc3 portc4 portc5 portc6 portc7
= = = = = = = =
0x07.0 0x07.1 0x07.2 0x07.3 0x07.4 0x07.5 0x07.6 0x07.7
#bit #bit #bit #bit
dato_6a = dato_6.0 dato_6b = dato_6.1 dato_6c = dato_6.2 dato_6d = dato_6.3
#bit #bit #bit #bit
dato_5a = dato_5.0 dato_5b = dato_5.1 dato_5c = dato_5.2 dato_5d = dato_5.3
/// con esta instruccion evitamos que /// se este configurando cada vez que usamos /// alguna instruccion de entrada o salida /// se definen direcciones de memoria
#bit #bit #bit #bit
dato_4a = dato_4.0 dato_4b = dato_4.1 dato_4c = dato_4.2 dato_4d = dato_4.3
#bit #bit #bit #bit
dato_3a = dato_3.0 dato_3b = dato_3.1 dato_3c = dato_3.2 dato_3d = dato_3.3
#bit #bit #bit #bit
dato_2a = dato_2.0 dato_2b = dato_2.1 dato_2c = dato_2.2 dato_2d = dato_2.3
#bit #bit #bit #bit
dato_1a = dato_1.0 dato_1b = dato_1.1 dato_1c = dato_1.2 dato_1d = dato_1.3
byte sec; byte min; byte hrs; byte day; byte month; byte yr; byte dow; //////////////////////////////////////////////////////////////////////////////// ////////funcion que manda el a desplagar informacion en los displays//////////// /////Tomese en cuenta que las conexiones de los puertos son las siguientes////// // pc0=a // // pc1=b // // pc6=d // // pc7=c // // pd1=digito 6 // // pd4=digito 5 // // pd0=digito 4 // // pd7=digito 3 // // pd5=digito 2 // // pd6=digito 1 // //////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// void desplegar() { portd1=0; portd4=0; portd0=0; portd7=0; portd5=0; portd6=0;
portc0=dato_6a; portc7=dato_6b; portc1=dato_6c;
/// se inihiben los displays
portc6=dato_6d;
portd1=1; portd1=0; portc0=dato_5a; portc7=dato_5b; portc1=dato_5c; portc6=dato_5d; portd4=1; portd4=0; portc0=dato_4a; portc7=dato_4b; portc1=dato_4c; portc6=dato_4d; portd0=1; portd0=0; portc0=dato_3a; portc7=dato_3b; portc1=dato_3c; portc6=dato_3d; portd7=1; portd7=0; portc0=dato_2a; portc7=dato_2b; portc1=dato_2c; portc6=dato_2d; portd5=1; portd5=0;
portc0=dato_1a; portc7=dato_1b; portc1=dato_1c; portc6=dato_1d; portd6=1; portd6=0; } //////////////////////////////////////////////////////////////////////////////// //////////////////////Comienzo de la funcion principal////////////////////////// //////////////////////////////////////////////////////////////////////////////// void main() { ds1307_init(); set_tris_a(0xff); set_tris_d(0x00); set_tris_b(0x00); set_tris_c(0x04); set_tris_e(0x01); port_b_pullups(true);
///se inicializa el ds1307
dato_1=8; dato_2=8; dato_3=8; dato_4=8; dato_5=8; dato_6=8; desplegar(); // Set date for -> 15 June 2005 Tuesday // Set time for -> 15:20:55 (9:49:00 am) ds1307_set_date_time(24,4,7,2,9,49,00);
/// se escribe ne le displositivo
while(1) { delay_ms(1000); ds1307_get_date(day,month,yr,dow); ds1307_get_time(hrs,min,sec);
/// se obtiene la fecha /// se obtiene la hora
////////////////////bin2bcd(sec) funcion para pasar de binario(hasta 99) a bcd ////////////////////bcd2bin(sec) funcion para pasar de bcd(hasta 99) a binario sec=bin2bcd(sec); min=bin2bcd(min); hrs=bin2bcd(hrs); dato_1=0x0f&sec; dato_2=swap(0xf0&sec); dato_3=0x0f&min; dato_4=swap(0xf0&min); dato_5=0x0f&hrs; dato_6=swap(0xf0&hrs); desplegar(); } } ///////////////////////////// fin de programa /////////////////////////////////////////////
http://foro.elhacker.net/electronica/introduccion_a_la_programacion_de_pics_en_lenguaje_c_ccst174021.0.html;msg857910#msg857910#ixzz1Xwsc1lTN
Perdon por este enorme receso pero no habia podido entrar al foro, porque mi computadora se me habia quemado y por tanto no podia grabar mis pics y bla bla bla. Citar 1-asignas la dccion del puerto B a tu gusto? o es la dccion qeu la datasheet del pic establece para este modelo?
La direccion del puertoB ya esta dada por la misma arquitectura del micro puedes abrir la el archivo donde se encuentra la libreria del 16f877.h la ruta generalmente es esta C:\Archivos de programa\PICC\Devices ahi veras que el mismo programa ya tiene definidos el nombre de los parametros del pic. y la instruccion Citar #byte PORTB = 6
//declaramos a la variable PORTB
solo que asocio la variable PORTB a la direccion 0x06 Citar 2-el 6 está en decimal o en hexa? (en este caso, si el nro es 6 en decimal, en hexa es lo mismo, pero quiero ver si la sintaxis obliga a poner 0x06 por ejemplo)
el programa lo asocia por default como decimal sin embargo te da la direccion pero si tu pusieras 54 la direccion a la que te referirias no seria la 0x54 sino a 0x36 Citar 3-eso ya no està definido cuando pones #include<16F84> ?
En efecto tienes razon cuando se pone la libreria ahi ya tienes definido varios parametros, pero no con el mismo nombre que yo les asigno en este caso por ejemplo tiene definido #define #define #define #define #define #define
PIN_A0 PIN_A1 PIN_A2 PIN_A3 PIN_A4 PIN_A5
40 41 42 43 44 45
sin embargo para comodidad mia le pongo variables con los que yo lo relaciono mas inmediatamente Citar 4-para acceder al bit 3 del puertoB deberia acceder a la dccion de memoria 6*8+3=51? o hay alguna manera ya optimizada en el CSS (soy nuevo enel CSS )
bueno con lo anterior puedes ver que se tiene acceso a un solo bit en especifico y no tienes que declararlo te recomiendo nuevamente leer la libreria y si te gusta de esa forma pues usarlos asi. por ejemplo para encender el bit 5 del puerto a tendiras que hacer lo sigueinte PIN_A5=1; espero haber resuelto tus dudas. y perdonen nuevamente la demora de mis respuestas las estare contestando en el t ranscurso de la sigueinte semana En línea
"Desde muy chico tuve que interrumpir mis estudios para ir a la escuela" Gabriel García Márquez MARCO_RECARGADO
Desconectado
Re: Introduccion a la programacion de PICS en lenguaje C (CCS) « Respuesta #32 en: 16 Noviembre 2007, 20:39 »
Mensajes: 75 Citar Hola Marcos Recargado, estoy estudiando tus post, pero en el ejemplo de 2 displays de 7 segmentos, no entiendo como es la lògica. No puedo ver el Proteus pero ¿como se hace el multiplexado de los displays. Sino, como se haria con CSS? ¿estas usando un conversor de binario a bcd no? no puedo seguir el pedazo de codigo donde suma 10 a count
Mas recargado que nunca
mira los displays van a un decodificador bcd las terminales portb0portb3 estan a un decodificador y las terminales portb4-portb7 al otro decodificador vamos viendo paso a paso que se esta haciendo Citar conteo=conteo+1;
en este segmento obviamente estoy incrementando en uno a la variable contador Citar if((conteo&0x0f)>9)
en este estoy haciendo una operacion logica AND de la variable conteo con el numero 0x0f ¿y que diablos obtengo de esto? facil que yo seleccione mi parte baja de lo que contiene esta variable es decir si mi variable conteo=0b1111 0101 que es igual a conteo=0xf5 al hacer esta operacion yo tengo como resultado conteo=0x05 es decir anule la parte alta ya una vez hecho esto la compara con si es mayor a 9 si es mayor a 9 significa que estoy en el 10 pero en hexadecimal seria 0x0A y ese no es el valor que quiero sino quiero este 0x10 Citar { conteo=conteo+10; conteo=conteo&0xf0; }
por eso a la hora de que es mayor a nuevo yo le sumo 10 para que me de el numero hexadecimal que deseo if(conteo>99) {conteo=0;} por ultimo si ya llego a 99 lo reseteo porque recuerda que esta varialbe como fue declarada de tipo int es una variable que puede llegar hasta 255. Espero haberte ayudado
gracias meta.... pude hacer el programa para el conversor analogo digital del pic 16f877
//programa que usa el conversor analogo digital del pic 16f877// ///// // //// /// //// by EPALE /// /////////////////////////////////////////////////////////////////// •
#include <16F877a.h> #fuses HS,NOWDT,NOPROTECT,NOLVP #use delay(clock=20000000) #use fast_io(B) /// con esta instruccion evitamos que /// se este configurando cada vez que usamos #use fast_io(a) /// alguna instruccion de entrada o salida #use fast_io(c) #byte portb = 6 // se definen las direcciones de memoria #byte porta = 5 #byte portc = 7 #DEFINE LED DELAY_MS(100) // se define el tiempo de retardo para ahorrar memoria
void main() { uno: set_tris_a(0xff); set_tris_c(0x00); set_tris_b(0x00);
// se configura el puerto A como entrada // se configura el puerto B como salida // activa las resistencias de pull-up
SETUP_ADC(ADC_CLOCK_INTERNAL); // configuras esto para que el a/d funcione con un reloj interno del micro SETUP_ADC_PORTS(AN0); // aca determianr que el puerto RA0 será analógico SET_ADC_CHANNEL(0); // con esto fijas el canal con el qeu trabajas, en este caso 0 por el RA0
output_b(READ_ADC()); uestra el en puerto b LED; goto uno;}
// lee el canal analogico seleccionado anteriormente, y lo
http://foro.elhacker.net/electronica/introduccion_a_la_programacion_de_pics_en_lenguaje_c_ccst174021.45.html#ixzz1XwwL3hyB
Cita de: montero2210 en 5 Mayo 2008, 23:32 Hola a todos!!! Tengo un problemilla y no se resolverlo a ver si ustedes que veo que teneis bastante experiencia me podeis ayudar. Estoy intentando hacer que con el pic16f84, se encienda como el coche fantastico una serie de leds. Hasta hay todo correcto y funcionando. Mi problema viene que le he añadido un pulsador para que cuando yo lo pulse el led que este encendido parpadee durante un tiempo, y no se como leer la pulsacion del pulsador. Gracias de antemano!!!!
primero debes de saber que pin quieres yo te recomendaria el portb por tener resistencias de pull up primero tienes que configurar el porb como entrada set_tris_b(0xff); ahora testeas el puerto si es cero o uno dependiendo de lo que desees if(pin_b0==0) { y aqui metes todo lo que desees hacer cuando se pulse el boton } dato
//////////////////////////////////////////////////////////////////////////////// ////////////ESTE PROGRAMA UTILZA EL CIRCUITO DS1307 PARA MOSTRAR LA //////////// //////////HORA EN TIEMPO REAL A TRAVEZ DE UN UNA LCD DE 2 POR 16 CARACTERES///// //////////////////////////PARA FORO ELHACKER.NET//////////////////////////////// #include <16F877A.h> /// libreria para el manejo del pic16f877a #use delay(clock=8000000) /// declara la frecuencia del cristal #fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT,NOPROTECT #include #include #use fast_io(A) #use fast_io(B) #use fast_io(C) #use fast_io(D) #use fast_io(E)
#byte portc = 7 #byte portd = 8 int int int int int int int
/// con esta instruccion evitamos que /// se este configurando cada vez que usamos /// alguna instruccion de entrada o salida
/// se definen direcciones de memoria
sec; min; hrs; day; month; yr; dow;
//////////////////////////////////////////////////////////////////////////////// //////////////////////Comienzo de la funcion principal////////////////////////// //////////////////////////////////////////////////////////////////////////////// void main() { ds1307_init(0);
///se inicializa el ds1307
set_tris_a(0xff); set_tris_d(0x00); set_tris_b(0x00); set_tris_c(0x04); set_tris_e(0x01); port_b_pullups(true); lcd_init();
/// inicializamos lcd
// Set date for -> 15 June 2005 Tuesday // Set time for -> 15:20:55 (9:49:00 am) ds1307_set_date_time(8,11,7,2,9,49,00); /// se escribe en el displositivo /// el tiempo deseado while(1) { delay_ms(100); ds1307_get_date(day,month,yr,dow);
/// se obtiene la fecha
ds1307_get_time(hrs,min,sec); lcd_gotoxy(1,2); printf(lcd_putc,"%02d:%02d:%02d
/// se obtiene la hora ",hrs,min,sec);
///se despliegan los datos
lcd_gotoxy(1,1); lcd_putc("WWW.ELHACKER.NET"); } }
Re: Introduccion a la programacion de PICS en lenguaje C (CCS) « Respuesta #108 en: 19 Noviembre 2008, 05:48 » ha llegado el momento de agregarle una practica mas a nuestro pequeño tutorial esta practica lo que hace es que pasa los datos recibidos por puerto serie a la lcd utilizo la terminal virtual para simular la comunicacion con el pic ///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////comunicacion RS232 con pic/////////////////////////////// ///////////////by marco_recargado para foro.elhacker.net/////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////// #include <16F877A.h> #fuses HS, NOWDT, NOPROTECT #use delay(clock=8000000) #use rs232(baud=9600,xmit=pin_c6,rcv=pin_c7) /// libreria para el manejo del /// puerto serie se establece /// velocidad de 9600 baudios #include /// libreria para el manejo de la lcd char dato_recibido[16]; /// aqui va a ir los datos recibidos por rs232 #byte porte=0x09 #int_rda void rda_isr() { gets(dato_recibido);
//// interrupcion por escritura en buffer del puerto //// esta instruccion almacena en la variable los //// datos que se esten enviando hasta que llega //// la tecla enter
}
void main() { enable_interrupts(int_rda); enable_interrupts(global);
//// se habilita la interrupcion por //// escritura del puerto serial
set_tris_d(0b00000000); lcd_init(); lcd_gotoxy(1,1); lcd_putc(" com RS232
");
while(true) { lcd_gotoxy(1,2); printf(lcd_putc,"%s",dato_recibido); } }
nuestra gloriosa imagen
/// se manda a lcd lo que se recibio
Re: Introduccion a la programacion de PICS en lenguaje C (CCS) « Respuesta #117 en: 6 Enero 2009, 16:32 » pues bien para los niños que se han portado bien los reyes magos nos han dejado un regalito. la practica de un contador por interrupcion bueno un regalo es un regalo la cuenta es ascendiente aprox cada segundo (.98304 seg) //////////////////////////////////////////////////////////////////////////////// /////////// practica 10 : contador por interrupcion ////////////////// ////////// By Marco_recargado para foro.elhacker.net ////////////////// //////////////////////////////////////////////////////////////////////////////// #include <16F877.h> /// libreria para el manejo del pic16f877a #use delay(clock=8000000) /// declara la frecuencia del cristal #fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT,NOPROTECT,NODEBUG ///configura los fusibles int contador=0; int delay=30;
/// Variable que llevara la cuenta total
#byte portb = 6 #int_TIMER0 void timer0() {
delay--; if(delay==0){contador++; delay=30;} set_timer0(0); } //////////////////////////////////////////////////////////////////////////////// //////////////////////inicio del programa principal///////////////////////////// ////////////////////////////////////////////////////////////////////////////////
void main(void) { set_tris_b(0x00); ///la formula para saber cada cuando se ejecutara nuestra interrupcion con el timer0 /// es T=N*M*(4/FOSC) donde /// T= tiempo /// N= preescalador del timer o divisor /// M= numero de iteracciones /// asi por ejemplo con un preescalador de 256 un numero de iteraciones de 256 y un cristal de 8mhz /// nos da un resultado de 32.7 milisegundos por interrupcion setup_timer_0 ( RTCC_INTERNAL | RTCC_DIV_256 ); /// configura a timer0 con reloj /// interno y un divisor de 256 enable_interrupts(GLOBAL); enable_interrupts(INT_timer0); set_timer0(0);
/// permitir interrupciones ///activar interrupcion en timer0
while(true) { portb=contador; } } // fin de programa principal y nuestra imagen
Saludos y feliz año nuevo
http://foro.elhacker.net/electronica/introduccion_a_la_programacion_de_pics_en_lenguaje_c_ccst174021.105.html#ixzz1Xx2zKz8h
Re: Introduccion a la programacion de PICS en lenguaje C (CCS) « Respuesta #118 en: 12 Marzo 2009, 04:30 » hola a todos por fortuna e encontrado lo que queria.. un foro para programar en ccs y ojala poder daer mis aportes y que ojala me puedan solucionar muchas dudas que tengo en algunas areas de programacion de este tema a continuacion adjunto un programa para un enlace de radiofrecuencia este codigo repsonde muy bien ya lo probe y lo presente en un proyecto de la universidad este es el codigo del emisor #include<16f877a.h> #fuses XT,NOWDT,NOPROTECT,PUT,NOBROWNOUT,NOLVP #use delay(clock=4000000) #use rs232(baud=2400, parity=N, xmit=PIN_C6, rcv=PIN_C7, bits=8) #byte PORTD = 0x08 #byte PORTB = 0x06 void main() { set_tris_D(0b11111111); PORTD=0; PORTB=0; while(1) { if(PORTD==0){printf("%d",0);} if(PORTD==1){printf("%d",1);} if(PORTD==2){printf("%d",2);} if(PORTD==4){printf("%d",3);} if(PORTD==8){printf("%d",4);} if(PORTD==64){printf("%d",5);} if(PORTD==128){printf("%d",6);} } }
y este es el codigo del receptor
#include<16f877a.h> #fuses XT,NOWDT,NOPROTECT,PUT,NOBROWNOUT,NOLVP #use delay(clock=4000000) #use rs232(baud=2400, parity=N, xmit=PIN_C6, rcv=PIN_C7) #byte PORTD = 0x08 #byte PORTB = 0x06 enable_interrupts(int_rda); enable_interrupts(global); char orden;
#int_rda void serial_isr() { orden=getc()-48; if(orden==0){PORTD=0b00000000;} if(orden==3){PORTD=0b00000101;} if(orden==2){PORTB=0b00000110;}
// adelante // giro
} void main() { set_tris_D(0b00000000); set_tris_B(0b00000000); PORTd=0; PORTB=0;
while(1) {
} }
los modulos de transmision de señal son tlp 434a y rlp434a y son de transmision serial
En línea
http://foro.elhacker.net/electronica/introduccion_a_la_programacion_de_pics_en_lenguaje_c_ccst174021.105.html#ixzz1Xx3TXkK2
Re: Introduccion a la programacion de PICS en lenguaje C (CCS) « Respuesta #134 en: 5 Mayo 2009, 17:45 » buenas amigos del foro navegando por la red encontre este tema esta muy bueno yo tambien estoy iniciandome en Cy estoy usando el ccs compiler el proteus ...mi pregunta es la siguiente.estoy usando el pic 16f84A usando como entradas el puerto A y el puerto b como salidas;en ra0,ra1 y ra2 e colocado un pulsador a cada pin,pulsando cada uno de estos me sale una secuencia por el puerto B...solo me trabaja con la primera secuencia y al apretar el segundo pulsador no funca hasta q termine la secuencia del primero me han dicho que coloque interrupciones alos pulsdores pero no entiendo bien eso aqui va el ejemplo de lo que estoy haciendo. #include <16f84a.h> #use delay(clock=4000000) void main() { set_tris_b(0b11110000); set_tris_a(0xff); output_b(0); while(true) { if(input(pin_a0)) { output_high(pin_b0); output_low(pin_b1); output_low(pin_b2); delay_ms(3000); output_low(pin_b0); } if(input(pin_a1)) { output_low(pin_b0); output_high(pin_b1); output_low(pin_b2); } if(input(pin_a2)) { output_low(pin_b0); output_low(pin_b1); output_high(pin_b2); output_high(pin_b3); } } output_low(pin_b0); output_low(pin_b1); output_high(pin_b2); output_high(pin_b3); } }
http://foro.elhacker.net/electronica/introduccion_a_la_programacion_de_pics_en_lenguaje_c_ccst174021.120.html#ixzz1Xx40a78Y
hola,aqui te dejo el codigo corregido,chau y suerte. Código: #include <16f84a.h> #fuses XT,NOWDT,NOPROTECT, #use delay(clock=4000000) void main() { set_tris_b(0b11110000); set_tris_a(0xff); output_b(0); while(true) { if(!input(pin_a0)) //en esta linea le agregue el signo de admiracion { output_high(pin_b0); output_low(pin_b1); output_low(pin_b2); output_low(pin_b3); //le agregue esta linea delay_ms(500); //aqui le puse medio segundo para visualizarlo output_low(pin_b0); } if(!input(pin_a1)) //en esta linea le agregue el signo de admiracion { output_low(pin_b0); output_high(pin_b1); output_low(pin_b2); output_low(pin_b3);//le agregue esta linea } if(!input(pin_a2)) //en esta linea le agregue el signo de admiracion { output_low(pin_b0); output_low(pin_b1); output_high(pin_b2); output_high(pin_b3); } } }
" ! "
mejor
" ! "
" ! "
http://foro.elhacker.net/electronica/introduccion_a_la_programacion_de_pics_en_lenguaje_c_ccst174021.135.html#ixzz1Xx47HSOg
//programa que usa el conversor analogo digital del pic 16f877// ///// // //// /// //// by EPALE /// /////////////////////////////////////////////////////////////////// •
#include <16F877a.h> #fuses HS,NOWDT,NOPROTECT,NOLVP #use delay(clock=20000000) #use fast_io(B) /// con esta instruccion evitamos que /// se este configurando cada vez que usamos #use fast_io(a) /// alguna instruccion de entrada o salida #use fast_io(c) #byte portb = 6 // se definen las direcciones de memoria #byte porta = 5 #byte portc = 7 #DEFINE LED DELAY_MS(100) // se define el tiempo de retardo para ahorrar memoria
void main() { uno: set_tris_a(0xff); set_tris_c(0x00); set_tris_b(0x00);
// se configura el puerto A como entrada // se configura el puerto B como salida // activa las resistencias de pull-up
SETUP_ADC(ADC_CLOCK_INTERNAL); // configuras esto para que el a/d funcione con un reloj interno del micro SETUP_ADC_PORTS(AN0); // aca determianr que el puerto RA0 será analógico SET_ADC_CHANNEL(0); // con esto fijas el canal con el qeu trabajas, en este caso 0 por el RA0
output_b(READ_ADC()); puerto b LED; goto uno;}
// lee el canal analogico seleccionado anteriormente, y lo uestra el en
http://foro.elhacker.net/electronica/introduccion_a_la_programacion_de_pics_en_lenguaje_c_ccst174021.0.html;msg934861#ixzz1Xx73DvWF
Practica 5 DAC a displays de 7 segmentos « Respuesta #65 en: 18 Marzo 2008, 08:30 » despues de mil años la tierra prometida. #include <16F877A.h> #use delay(clock=8000000) #fuses NOWDT,NOPUT,NOPROTECT,NOBROWNOUT,NOLVP,NOPROTECT,HS,NOWRT,NODEBUG
#use #use #use #use #use
fast_io(A) fast_io(B) fast_io(C) fast_io(D) fast_io(E)
#byte porta = 5 #byte portb = 6 #byte portc = 7 #byte portd = 8 #byte porte = 9
/// con esta instruccion evitamos que /// se este configurando cada vez que usamos /// alguna instruccion de entrada o salida
/// se definen direcciones de memoria
#bit porte0 = 0x09.0 int int int int
canal0=0; unidades=0; decenas=0; centenas=0;
void main () { set_tris_b(0b00000000); set_tris_c(0b00000000); set_tris_d(0b00000000); set_tris_e(0b11111111); SETUP_ADC(ADC_CLOCK_INTERNAL);
// declaramos que el reloj del adc sera interno
setup_adc_ports(all_analog); SET_ADC_CHANNEL(0);
// todos los canales analogicos habilitados // seleccionamos canal 0
DISABLE_INTERRUPTS(global); while(1) { canal0= READ_ADC();
// retardo para esperar que el adc termine // conversion fabricante menciona que al // menos 50 microsegundos
delay_ms(1); centenas=canal0/100; decenas=(canal0 - (centenas*100))/10; unidades=(canal0 - (centenas*100) - (decenas*10)); portb=centenas; portc=decenas; portd=unidades; delay_ms(100); } }
proteus
Instrucciones: Para activar el programa: 1. Ejecutar setup76.exe. 1.1. Cuando pida el origen de la licencia (local o por servidor), clic en la opción de local. 1.2. Seguir los pasos de instalación que indique el wizard. 2. Dirigirse a la carpeta de accesos directos del programa recién instalado y abrir el programa Licence Manager, normalmente sería: Inicio > Todos los programas > Proteus 7 Professional > Licence Manager. 2.1. Clic en Browse for a key, encontrar la ruta donde se descomprimió el paquete y seleccionar el archivo Grassington North Yorkshire.lxk. 2.2. En Licence Manager, clic en Install y todas las llaves irán de izquierda al cuadro derecho. 2.3. Salir del programa. 3. Ejecutar el LXK Proteus 7.6 SP0 v2.0.1.exe que viene en el paquete. 3.1. Clic en browse, para encontrar la carpeta de instalación del programa. 3.2. Clic en Update, la barra de progreso se comenzará a llenar. 3.3. El software ya está listo para usarse.
