////////////////////////////////////////////////////////////////////////////////

///
Practica 1 :
Parpadeo de LEDS con PIC16F84A
///
///
para el foro.elhacker.net
by Marco
///
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

///////////////////////////// DIRECTIVAS DE PREPROCESADO //////////////////////

/// libreria para el manejo del pic16f84a
#include <16F84A.h>
/// declara la frecuencia del cristal
#use delay(clock=8000000)
///configura los fusibles
/// HS es la configuraricion del oscilador la cual indica High speed es decir
/// frecuencias altas esto es a partir de 8 Mhz.
/// NOWDT deshabilita el Watch Dog Timer
/// NOPUT deshabilita le reseteo de power up timer
/// NOPROTECT deshabilita la proteccion del codigo del pic.
#fuses HS,NOWDT,NOPUT,NOPROTECT
/// asignamos a variable port_b el espacio memoria 0x06 que es la dir de port_b
#byte port_b=0x06
//////////////////////////GLOBALES//////////////////////////////////////////////
///
Estos parmetros son visibles desde todo el cdigo
///
///
por eso se les llama globales
///
///
Al ser constantes,lo ms prctico es declararlas aqu.
///
////////////////////////////////////////////////////////////////////////////////////
int contador;
////////////////////////// Principal //////////////////////////////////////////
void main()
{
/// declaramos el puerto B como salidas
set_tris_b(0);
/// lo igualamos con cero para que tengamos un valor inicial de lo contrario
/// no sabriamos con que valor iniciaria al comienzo de nuestro programa
port_b=0;
/// bucle infinito para que las instrucciones que tiene siempre se ejecuten
while (true)
{
/// activa todos los pins del puerto B
/// otra instruccion que podemos poner es contador=255 las dos son lo mismo
contador=0xff;
port_b=contador;
/// Retardo de 1000 milisegundos es decir 1 segundo
delay_ms(1000);
//// apaga todos los pins del puerto B}
contador=0x00;

port_b=contador;
/// Retardo de 1000 milisegundos es decir 1 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_programacion_de_pics_en_lenguaje_c_ccst174021.0.html;msg824964#ixzz1XiDoFnfW

/////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////
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)
#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;
}
}

/// con esta instruccion evitamos que

/// se este configurando cada vez que usamos
/// alguna instruccion de entrada o salida
//

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;msg833331#ixzz1XiEMU0Xl

Aqui esta otro programa en este caso es la visualizacion de dos display por el portb
////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////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
#use
#use
#use
#use

fast_io(A)
fast_io(B)
fast_io(C)
fast_io(D)
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#ixzz1XiEwQoA5

////////////////////////////////////////////////////////////////////////////////
//////////////
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 <lcd.c> // Librera 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

para poder meter un valor de una variable hay que escribir lo siguiente
printf(lcd_putc," %d volts ",variable_adc);
y con esto escribes el valor de tu variable tenemos que tener cuidado en el tipo de
variable pues este ejemplo es para un tipo entero s ifuera para un tipo float tendria que ser %f y para
varios mas

http://foro.elhacker.net/electronica/introduccion_a_la_programacion_de_pics_en_lenguaje_c_ccst174021.0.html;msg857910#msg857910#ixzz1XiFTpc9m

me gusto la practica de lcd y aprendi bocha y hice un agregado al programa original para q entre
todos entendamos un poco mas, creo q haciendo una buena rutina en c se puede manejar por
espacios el display...
////////////////////////////////////////////////////////////////////////////////
//////////////
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 <lcd.c> // Librera 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#ixzz1XiFjOqsk

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 DISPLAYS 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 <ds1307.c>
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
byte
byte
byte
byte
byte
byte

sec;
min;
hrs;
day;
month;
yr;
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;msg861704#msg861704#ixzz1XiG3RWko

//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 analgico
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.0.html;msg934861#ixzz1XiGHtgjh

 Respuesta #65 en: 18 Marzo 2008, 08:30

despues de mil aos 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
#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

#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);
}
}

http://foro.elhacker.net/electronica/introduccion_a_la_programacion_de_pics_en_lenguaje_c_ccst174021.0.html;msg972288#ixzz1XiH4OyqI