Simulación de portadora para infrarrojos (38khz) con PWM envio por rs232

En el grafico puede verse :
PWM: Es la señal emitida por el PIN C2 que es el PWM del pic configurado a 38khz
PICTX: Es el pin C6, utilizado como TX de RS232 a 1200 baudios.
SEND: Es el resultado de '(PICTX & PWM), en otras palabras, la negación de la multiplicación de las señales PICTX y PWM. Ésta es la señal que sera enviada al led infrarrojo.

Descargar simulacion y archivos CCs

Array multidimensional en c

ATMEGA AVR studio:

int seq[4][8] = {
  {{0x04}, {0x0c}, {0x08} , {0x0a},{0x0b}, {0x03}, {0x07} ,{0x05}},
  {{0x07}, {0x03} , {0x0b},{0x0a}, {0x08}, {0x0c} ,{0x04},{0x05}},
{{0x0c}, {0x0a}, {0x03} , {0x05},{0x0c}, {0x0a}, {0x03} ,{0x05}},
{{0x03}, {0x0a} , {0x0c},{0x05}, {0x03}, {0x0a} ,{0x0c},{0x05}} };

PIC PCWCCS:

int seq[4][8] = {
  // 0x04,0x0c,0x08,0x0a,0x0b,0x03,0x07,0x05,
  // 0x07,0x03,0x0b,0x0a,0x08,0x0c,0x04,0x05,
   0x0c,0x0a,0x03,0x05,0x0c,0x0a,0x03,0x05,
   0x03,0x0a,0x0c,0x05,0x03,0x0a,0x0c,0x05}   ;

Comunicacion RS-232 entre dos pic

Este proyecto puede resultar util, alguno de mis profesores, y muchos de mis compañeros  me dijeron  que no serviria para nada pero NO tenian razon jajaja, lo utilize en la practicas.

Bueno normalmente todo el mundo me dice que todo lo que hago no vale para nada, pero si nos ponemos asi... con esa forma de pensar:

nada vale para nada pues en menos de 60 años todos estaremos muertos y de que servira cualquier cosa que hagamos... 
asi que caso omiso y yo  a lo mio

y si a alguien le sirve he lo aqui!

tambien tengo que decir que mas que hacerlo lo he modificado a mi antojo, esto lo hizo otro chaval , pero bueno ... no me importa, la pirateria es vida

Descargar proteus y ccs

Grabar y leer dos bytes en EEprom

Funciones read_eeprom(address) y write_eeprom(address, byte)  




void write_eeprom_16bits(int address, long* val){
  int pLow, pHigh;
  pLow = val;
  pHigh = val>>8;
  write_eeprom(address,pHigh);
  delay_ms(12);
  ++address;
  write_eeprom(address,plow);
  delay_ms(12);
}

long read_eeprom_16bits(int address){
  int pLow, pHigh;
  long result;
  pHigh = read_eeprom(address);
  ++address;
  pLow = read_eeprom(address);
  result=(pHigh<<8);
  result+=pLow;
  return result;
}


Esto no es mio, lo he  sacado de aquí http://picmania.garcia-cuervo.net, porque me ha sido muy util

Funcion para reloj digital HH:MM:SS basada en la interrupcion TMR0

 //Hay que declarar esto en la funcion Main para que sea un segundo:
//setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256); //timer0 konfiguratu
//-------------------------------------------------
#int_TIMER0
void TIMER0_isr(void)
{

if (ms<15){ // 15 veces para lograr un segundo, (no son milisegundos)
      ms++;
}else{
ms=0;
      if (s<59){
      a0=1;
      s++;
      a0=0;
      if(s%2==0){a4=1;}
       if(s%2==1){a4=0;}
      }else{
      s=0;
                if (m<59){
                m++;
                }else{
                m=0;
                        if (h<23){
                        h++;
                        }else{
                        h=0;
                        }
                }
      }
}

AP-876: Interfaz logica programable basada en PIC16F876

La interaz logica AP-876, se trata de un dispositivo basado en el microcontrolador pic16F876 que permite al usuario interactuar con cualquier sistema digital que funcione a velocidades de hasta 4 GHz.

Muestra los datos al usuario por el puert B, a traves de una pantalla lcd de 16x2 y recibe datos por parte del mismo mediante un teclado matricial de 4x3.

Quedando libres los puertos A y C para el resto de funciones, comunicacion con otros microcontroladores, conversiones AD, pwm, secuencias y un largo etc.

Pese a haber experimentado varios errores de diseño, estos han podido ser solventados y el hardware es funcional.

El lo referente al software, han sido creados varios, de entre ellos el principal sistema

operativo, llamado SE (de Sistema Eragilea, en
euskera), del cual cabe mencionar que pese a sus
amplias posibilidades aun esta en desarrollo.

La placa ha sido fresada en el instituto lo que ha ayudado mucho en el avance del proyecto.Pero tambien se podria haber hecho mediante acidos.

Este video explica rapidamente el proyecto.
En este enlace pueden descargar todos los recursos Descargar documentacion.






Conclusion: Tenía que haberlo hecho para un pic 18, la memoria que ofrece la serie 16 es un escupitajo en el mar de Aral. 

CCS PIC: Funcion para convertir cadena de caracteres en numero float

 Usado para extraer caracteres pasar de char a float de un LCD lm16l  y operar con ellos.

float get_complex_num(){
int s;
 float result=0;
int xtract=0;
float mult;
float raw;

for (s=x-1;s>=1;s--){
xtract++;
if (xtract==1){mult=1;}
if (xtract==2){mult=10;}
if (xtract==3){mult=100;}
if (xtract==4){mult=1000;}
if (xtract==5){mult=10000;}
if (xtract==6){mult=100000;}
if (xtract==7){mult=1000000;}
if (xtract==8){mult=10000000;}
if (xtract==9){mult=100000000;}
if (xtract==10){mult=1000000000;}
if (xtract==11){mult=10000000000;}
raw=lcd_getc(s,2)-48;
result=(raw*mult)+result;
/*// zelan itten daben ikusteko!
printf(lcd_putc, "r-%f x->%i",result,x);
delay_ms(1500);*/
x--;

}
return result;

}

Libreria LCDC.c para utilizar LCD lm16l a traves del PORTC

Libreria LCDC.c para utilizar LCD a traves del PORTC, modificada con objetivo de utilizar interrupciones en PORTB, en el pic 16F877.
Library to use LCD LCDC.c through the PORTC, modified in order to use PORTB interruptions using the pic 16F877.

Es una modificacion de la libreria LCD.c que viene de serie
Descargar lcdc.c

Libreria para teclado matricial 4×4 a traves de Puerto B haciendo uso de interrupcion RB

Usando PORTB para teclado matricial con interrupciones, no hay mas que copiar este archivo en la carpeta PICC/drivers y
despues utilizarlo mediante include

Descarga aqui el archivo jkbd.c

///////////////////////////////////////////////////////////////////////////
//// jkbd.C ////
//// Driver for common 4×4 keypad modules ////
//// ////
//// kbd_init() Activa el rastreo EN PUERTO B RB0:RB3 ////
//// ////
//// getkey() Captura tecla pulsada a partir de la interrupcion por ////
//// cambio de estado en RB4:RB8 ////
//// ////
//// jkbd_getint(from,to,line) leer desde lcd numero decimal ////
//// de hasta 9 cifras y trasformar a int32 ////
//// para operar con el. ////
//// ////
//// ////
///////////////////////////////////////////////////////////////////////////////////////
//// El valor de trisB ha de ser 0xf0 ////
//// Un set_tris_b(0xf0); seria necesario en la funcion main ////
//// Libreria para uso de teclado matricial 4×4  2012 Made in Basque country
///////////////////////////////////////////////////////////////////////////////////////
#byte portb= 0×06
#byte porta= 0×05
#bit ra0=0×05.0
#bit ra1=0×05.1
#bit ra2=0×05.2
#bit ra3=0×05.3
#bit ra4=0×05.4
#bit ra5=0×05.5
#bit ra6=0×05.6
#bit ra7=0×05.7
#bit rb0=0×06.0
#bit rb1=0×06.1
#bit rb2=0×06.2
#bit rb3=0×06.3
#bit rb4=0×06.4
#bit rb5=0×06.5
#bit rb6=0×06.6
#bit rb7=0×06.7
int ink=0, inkc=0;
int s, n,num;
int ch=0;
int32 inkn=0;
void kbd_init(){// ciclo de rastreo de teclado a traves de nibble bajo de portb
while(1){
portb=0×01;
delay_ms(5);
portb=0×02;
delay_ms(5);
portb=0×04;
delay_ms(5);
portb=0×08;
delay_ms(5);
}
}
int getkey(){ // capturar caracter pulsado ¡formato char!
ink = (portb & 0xf0); // maskaratu
#asm
swapf ink,1; //nibbleak trukatu
#endasm
if (ink==0){
}else{
if (rb0==1){
if (ink==1){inkc=7;}
if (ink==2){inkc=8;}
if (ink==4){inkc=9;}
if (ink==8){inkc=15;}
}
if (rb1==1){
if (ink==1){inkc=4;}
if (ink==2){inkc=5;}
if (ink==4){inkc=6;}
if (ink==8){inkc=14;}
}
if (rb2==1){
if (ink==1){inkc=1;}
if (ink==2){inkc=2;}
if (ink==4){inkc=3;}
if (ink==8){inkc=13;}
}
if (rb3==1){
if (ink==1){inkc=10;}
if (ink==2){inkc=0;}
if (ink==4){inkc=11;}
if (ink==8){inkc=12;}
}
return inkc;
}
}
int32 jkbd_getint(from,to,line){// leer desde lcd numero decimal de hasta 9 cifras y trasformar a int32 para operar
int32 multx, mult=1;
inkn=0;
for (s=from-1;s>=to;s–){
ch= (lcd_getc(s,line)-48);
if (mult==1){multx=1;}
if (mult==2){multx=10;}
if (mult==3){multx=100;}
if (mult==4){multx=1000;}
if (mult==5){multx=10000;}
if (mult==6){multx=100000;}
if (mult==7){multx=1000000;}
if (mult==8){multx=10000000;}
if (mult==9){multx=100000000;}
inkn=inkn+(ch*multx);
mult++;
}
return inkn;
mult=1;

}