Codigo:
////////////////////////////////////////////////////////////////////////////////
// Escribe en la LCD el caracter pasado
////////////////////////////////////////////////////////////////////////////////
void nokia_printchar(byte caracter)
}
nokia_write_data(0x00); delay_ms(500); // Mandamos 1 espacio Blanco
}
Codigo:
////////////////////////////////////////////////////////////////////////////////
// Inicialización de la pantalla
////////////////////////////////////////////////////////////////////////////////
void Lcd_init(void) {
TRISB = 0; //CNF_TRISB1;
delay_us(200); // Pequeño delay de seguridad
nok_dc=1; // Destino de Bytes -> RAM
Codigo:
byte CONST System_3_6_0 [195]={ /* font System 3x6 (char #32 to #96) */
0x00,0x00,0x00, /* Espace 0x20 */
0x00,0x5C,0x00, /* ! */
0x0C,0x00,0x0C, /* " */
0x7C,0x28,0x7C, /* # */
0x7C,0x44,0x7C, /* 0x */
0x24,0x10,0x48, /* % */
0x28,0x54,0x08, /* & */
0x00,0x0C,0x00, /* " */
0x38,0x44,0x00, /* ( */
0x44,0x38,0x00, /* ) */
0x20,0x10,0x08, /* // */
0x10,0x38,0x10, /* + */
0x80,0x40,0x00, /* , */
0x10,0x10,0x10, /* - */
0x00,0x40,0x00, /* . */
0x20,0x10,0x08, /* / */
0x38,0x44,0x38, /* 0 0x30 */
0x00,0x7C,0x00, /* 1 */
0x64,0x54,0x48, /* 2 */
0x44,0x54,0x28, /* 3 */
0x1C,0x10,0x7C, /* 4 */
0x4C,0x54,0x24, /* 5 */
0x38,0x54,0x20, /* 6 */
0x04,0x74,0x0C, /* 7 */
0x28,0x54,0x28, /* 8 */
0x08,0x54,0x38, /* 9 */
0x00,0x50,0x00, /* : */
0x80,0x50,0x00, /* ; */
0x10,0x28,0x44, /* < */
0x28,0x28,0x28, /* = */
0x44,0x28,0x10, /* > */
0x04,0x54,0x08, /* ? */
0x38,0x4C,0x5C, /* @ 0x40 */
0x78,0x14,0x78, /* A */
0x7C,0x54,0x28, /* B */
0x38,0x44,0x44, /* C */
0x7C,0x44,0x38, /* D */
0x7C,0x54,0x44, /* E */
0x7C,0x14,0x04, /* F */
0x38,0x44,0x34, /* G */
0x7C,0x10,0x7C, /* H */
0x00,0x7C,0x00, /* I */
0x20,0x40,0x3C, /* J */
0x7C,0x10,0x6C, /* K */
0x7C,0x40,0x40, /* L */
0x7C,0x08,0x7C, /* M */
0x7C,0x04,0x7C, /* N */
0x7C,0x44,0x7C, /* O */
0x7C,0x14,0x08, /* P 0x50 */
0x38,0x44,0x78, /* Q */
0x7C,0x14,0x68, /* R */
0x48,0x54,0x24, /* S */
0x04,0x7C,0x04, /* T */
0x7C,0x40,0x7C, /* U */
0x3C,0x40,0x3C, /* V */
0x7C,0x20,0x7C, /* W */
0x6C,0x10,0x6C, /* X */
0x1C,0x60,0x1C, /* Y */
0x64,0x54,0x4C, /* Z */
0x7C,0x44,0x00, /* [ */
0x08,0x10,0x20, /* */
0x44,0x7C,0x00, /* ] */
0x08,0x04,0x08, /* ^ */
0x80,0x80,0x80, /* _ */
0x04,0x08,0x00 /* ` 0x60 */
};
/// *****************************************************************************
byte CONST System_7_8_0 [255]={ /* System 7x8 (char #32 to #67) */
0, 0, 0, 0, 0, 0, 0, //" "
0, 6, 95, 95, 6, 0, 0, //"!"
0, 7, 7, 0, 7, 7, 0, //"""
20, 127, 127, 20, 127, 127, 20, //"#"
36, 46, 107, 107, 58, 18, 0, //"$"
70, 102, 48, 24, 12, 102, 98, //"%"
48, 122, 79, 93, 55, 122, 72, //"&"
4, 7, 3, 0, 0, 0, 0, //"""
0, 28, 62, 99, 65, 0, 0, //"("
0, 65, 99, 62, 28, 0, 0, //")"
8, 42, 62, 28, 28, 62, 42, //"*"
8, 8, 62, 62, 8, 8, 0, //"+"
0, 128, 224, 96, 0, 0, 0, //","
8, 8, 8, 8, 8, 8, 0, //"-"
0, 0, 96, 96, 0, 0, 0, //"."
96, 48, 24, 12, 6, 3, 1, //"/"
62, 127, 113, 89, 77, 127, 62, //"0"
64, 66, 127, 127, 64, 64, 0, //"1"
98, 115, 89, 73, 111, 102, 0, //"2"
34, 99, 73, 73, 127, 54, 0, //"3"
24, 28, 22, 83, 127, 127, 80, //"4"
39, 103, 69, 69, 125, 57, 0, //"5"
60, 126, 75, 73, 121, 48, 0, //"6"
3, 3, 113, 121, 15, 7, 0, //"7"
54, 127, 73, 73, 127, 54, 0, //"8"
6, 79, 73, 105, 63, 30, 0, //"9"
0, 0, 102, 102, 0, 0, 0, //":"
0, 128, 230, 102, 0, 0, 0, //";"
8, 28, 54, 99, 65, 0, 0, //"<"
36, 36, 36, 36, 36, 36, 0, //"="
0, 65, 99, 54, 28, 8, 0, //">"
2, 3, 81, 89, 15, 6, 0, //"?"
62, 127, 65, 93, 93, 31, 30, //"@"
124, 126, 19, 19, 126, 124, 0, //"A"
65, 127, 127, 73, 73, 127, 54, //"B"
28, 62, 99, 65, 65, 99, 34 //"C"
};
byte CONST System_7_8_1 [255]={ /* System 7x8 (char #68 to #103) */
65, 127, 127, 65, 99, 62, 28, //"D"
65, 127, 127, 73, 93, 65, 99, //"E"
65, 127, 127, 73, 29, 1, 3, //"F"
28, 62, 99, 65, 81, 115, 114, //"G"
127, 127, 8, 8, 127, 127, 0, //"H"
0, 65, 127, 127, 65, 0, 0, //"I"
48, 112, 64, 65, 127, 63, 1, //"J"
65, 127, 127, 8, 28, 119, 99, //"K"
65, 127, 127, 65, 64, 96, 112, //"L"
127, 127, 14, 28, 14, 127,127, //"M"
127, 127, 6, 12, 24, 127,127, //"N"
28, 62, 99, 65, 99, 62, 28, //"O"
65, 127, 127, 73, 9, 15, 6, //"P"
30, 63, 33, 113, 127, 94, 0, //"Q"
65, 127, 127, 9, 25, 127, 102, //"R"
38, 111, 77, 89, 115, 50, 0, //"S"
3, 65, 127, 127, 65, 3, 0, //"T"
127, 127, 64, 64, 127, 127, 0, //"U"
31, 63, 96, 96, 63, 31, 0, //"V"
127, 127, 48, 24, 48, 127, 127, //"W"
67, 103, 60, 24, 60, 103, 67, //"X"
7, 79, 120, 120, 79, 7, 0, //"Y"
71, 99, 113, 89, 77, 103, 115, //"Z"
0, 127, 127, 65, 65, 0, 0, //"["
1, 3, 6, 12, 24, 48, 96, //""
0, 65, 65, 127, 127, 0, 0, //"]"
8, 12, 6, 3, 6, 12, 8, //"^"
128, 128, 128, 128, 128,128, 128, //"_"
0, 0, 3, 7, 4, 0, 0, //"`"
32, 116, 84, 84, 60, 120, 64, //"a"
65, 127, 63, 72, 72, 120, 48, //"b"
56, 124, 68, 68, 108, 40, 0, //"c"
48, 120, 72, 73, 63, 127, 64, //"d"
56, 124, 84, 84, 92, 24, 0, //"e"
72, 126, 127, 73, 3, 2, 0, //"f"
56, 188, 164, 164, 252, 120, 0 //"g"
};
byte CONST System_7_8_2 [175]={ /* System 7x8 (char #104 to #128) */
65, 127, 127, 8, 4, 124, 120, //"h"
0, 68, 125, 125, 64, 0, 0, //"i"
96, 224, 128, 128, 253, 125, 0, //"j"
65, 127, 127, 16, 56, 108, 68, //"k"
0, 65, 127, 127, 64, 0, 0, //"l"
120, 124, 28, 56, 28, 124, 120, //"m"
124, 124, 4, 4, 124, 120, 0, //"n"
56, 124, 68, 68, 124, 56, 0, //"o"
0, 252, 252, 164, 36, 60, 24, //"p"
24, 60, 36, 164, 248, 252, 132, //"q"
68, 124, 120, 76, 4, 28, 24, //"r"
72, 92, 84, 84, 116, 36, 0, //"s"
0, 4, 62, 127, 68, 36, 0, //"t"
60, 124, 64, 64, 60, 124, 64, //"u"
28, 60, 96, 96, 60, 28, 0, //"v"
60, 124, 112, 56, 112, 124, 60, //"w"
68, 108, 56, 16, 56, 108, 68, //"x"
60, 188, 160, 160, 252, 124, 0, //"y"
76, 100, 116, 92, 76, 100, 0, //"z"
8, 8, 62, 119, 65, 65, 0, //"{"
0, 0, 0, 119, 119, 0, 0, //"|"
65, 65, 119, 62, 8, 8, 0, //"}"
2, 3, 1, 3, 2, 3, 1, //"~"
255, 29, 129,129, 129, 129, 255, //""
14, 159, 145, 177, 251, 74, 0 //"ç"
};
//*******************************************
////////////////////////////////////////////////////////////////////////////////
// Escribe en la LCD font System 3x6
////////////////////////////////////////////////////////////////////////////////
void nokia_print_3_6(byte caracter )
{
byte char_row,charpos;
charpos=(((caracter&0xff)-0x20)*3);
for (char_row=0;char_row<3;char_row++) { // Son 3 Bytes por caracter
nokia_write_data(System_3_6_0[charpos+char_row]); // Manda el caracter
}
nokia_write_data(0x00); // Mandamos 1 espacio Blanco
}
////////////////////////////////////////////////////////////////////////////////
// Escribe en la LCD font System 7x8
////////////////////////////////////////////////////////////////////////////////
void nokia_print_7_8(byte caracter )
{
byte char_row,charpos,chardata,f;
if (caracter < 0x44 ) { // D
charpos=(((caracter&0xff)-0x20)*7);
f=0;
} else
if ((caracter > 0x43 ) & (caracter < 0x68 )) { // h
charpos=(((caracter&0xff)-0x44)*7);
f=1;
} else
{
charpos=(((caracter&0xff)-0x68)*7);
f=2;
}
for (char_row=0;char_row<7;char_row++) { // Son 7 Bytes por caracter
switch (f) {
case 0:
chardata=System_7_8_0[(charpos+char_row)];
break;
case 1:
chardata=System_7_8_1[(charpos+char_row)];
break;
case 2:
chardata=System_7_8_2[(charpos+char_row)];
break;
}
nokia_write_data(chardata); // Manda el caracter
}
nokia_write_data(0x00); // Mandamos 1 espacio Blanco
}
Codigo:
void adquisicion(void){
int lectura[84];
ad_rd=0;
while(ad_int);
lectura[0]=PORTC;
ad_rd=1;
printf(nokia_printchar,"%u ",lectura[0]); // Escribimos
}
Codigo:
#int_global
isr() {
#asm
MOVWF W_TEMP ; Guarda W
MOVFF STATUS, STATUS_TEMP ; Guarda STATUS
clrf INTCON
btfss PIR1,0 ; TMR1 desbordado ,
goto sige
incf (&freq+2),f ; la feq se encuentra en TMR1L,TMR1H,freq+2 en este momento
bcf PIR1,0
sige:
decfsz counter1,F
goto sal1
; Ajuste fino ************ chapuzilla ********************
MOVLW Counter_1
MOVWF counter1
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
;*********************************************
decfsz counter,F
goto sal1
ya: ; ya pasó un segundo
bcf T1CON,0 ; para el timer1 que cuenta los pulsos y sale sin activar la interrupcion
goto sal0
sal1:
MOVLW 250 ;254
MOVWF TMR0L
bsf INTCON,5
bsf INTCON,7
sal0:
MOVF W_TEMP, W ; Restaura W
MOVFF STATUS_TEMP,STATUS ; Restaura STATUS
retfie
#endasm
}
Codigo:
////////////////////////////////////////////////////////////////////////////////
// Resetea Los Timers para la frecuencia
////////////////////////////////////////////////////////////////////////////////
void ResetTimers(){
/* Timer1 cuenta los pulsos por RC0 */
ADCON0=0b10000000;
ADCON1=0b01000000;
TMR1H=0;
TMR1L=0;
INTCON=0;
/* Timer0 Reloj 1 segundo */
counter = Counter_; ?????????
counter1= Counter_1; ?????????
T0CON= 0b11000111; ????????
TMR0L=254 ; ???????
TMR0h=255;
INTCON=0b10100000; // activa interrupcion para el tiempo
T1CON=0b00000011; // a contar los pulsos de RC0
}
Codigo:
if ( counter == 0){ // A pasado 1 segundo calcula freq e imprime
freq=freq+((tmr1h*256)+tmr1l); // calcula la freq y la imprime
{ nokia_gotoxy(0,5); printf(nokia_printchar, " "}
{ nokia_gotoxy(0,5); printf(nokia_printchar, "%LU Hz
",freq);}
freq=0;
ResetTimers();
}
Codigo:
while (1)
{
ENB_CLOCK=1; // deja pasar los pulsos del oscilador al contador
CLOCK_ADDR_RAM=1; // deja pasar los pulsos de clock al contador
WR_RAM=0; // RAM en write
OE_ADC=1; // selecciona el AD
CS_RAM=0; // selecciona la RAM
RST_ADDR_RAM=0; // resetea el contador de direcciones para que empieze la cuenta
while ( ADDR_FIN==0){} // espera que termine la cuenta
ENB_CLOCK=0; // no deja pasar los pulsos al contador del oscilador
CS_RAM=1; // inive la RAM
OE_ADC=0; // inive el AD
WR_RAM=1; // RAM en read
CS_RAM=0; // selecciona la RAM
RST_ADDR_RAM=1; // resetea el contador
RST_ADDR_RAM=0;
for(i=0 ; i<84 ; i++) {
CLOCK_ADDR_RAM=1; // impulso de clock al contador
CLOCK_ADDR_RAM=0;
Buffer_AD=DATOS_BUS ; // lee RAM
}
RST_ADDR_RAM=1; // resetea el contador
CS_RAM=1; // inive la RAM
clear_scope();
DrawBuffer();
}
Escrito originalmente por cucaracha
Otra idea sería, ir tomando muestras de la señal mediante un disparo, de distintos ciclos de la onda... y luego reconstruir la onda con el micro. Esto estaría bien... pero no damos como hacerlo. Por ejemplo, hacer que con un AD de 1MHZ se pueda adquirir una señal de 1MHz consiguiendo tantos puntos como se quiera, mediante esa idea.

















con tanto exito y al final pasa lo que pasa... que pos han
en la copa jajajajaja


Codigo:
/* Programilla para calcular la transformada de fourier iterando a "NFou" puntos,
entre las frecuencias f1 y f2, con una muestra formada por N puntos.
Aquí habría que poner los includes, etc, para las librerías de funciones matemáticas
y esas cosas mariposas.
*/
/*
función principal y tal (normalmente en C esto se pone al final, pero yo soy muy
chula y lo pongo aquí, hala.)
******************************************************************/
int main (char *arg[] )
{
// Variables
int N; /* número de muestras leídas por el ADC, N>1 claro.... avispao*/
double f1, f2; /* rango de frecuencias, inicial f1 y final f2 (en Hz) */
int Nfou; /* número de puntos de iteraciones de Fourier. Vamos a calcular la
transformada en cada uno de esos puntos.*/
double deltaf; /* incremento de frecuencia*/
double mps; /* muestras por segundo */
int i, n; /* índices para los contadores */
double Omega; /* Omega = 2*Pi*f*T estos son cosas del fourier este...*/
double deltaOmega; /* incremento de Omega */
double *q; /* un punterillo para ir guardando los resultados de los cálculos.*/
double Qreal, Qimag; /* coordenada X y coordenada Y que van a configurar la
curva transformada, .... Sisco, Cuca, esto habría que plotearlo, no?*/
/*supongo que el argumento de entrada es un vector de caracteres, que serán los
parámetros para configurar los cálculos de adquisición de datos, osea:*/
/*(ah! hay que pasar los caracteres a números enteros y reales, según convenga)*/
f1 = atof( arg[1] ); //frecuencia inicial
f2 = atof( arg[2] ); //frecuencia final
Nfou = atoi( arg[3] ); //puntos de iteración
N = atoi( arg[4] ); //número de muestras
mps = atof( arg[5] ); //velocidad de muestreo
if( N < 2 )
{
//NOOOOO ¡¡N debe ser mayor!!, hombre porfavóooo....
exit( -1 );
}
/* ahora ya podemos leer dato a dato. Podemos tomar los datos de un fichero
externo, o de donde sea... yo voy a suponer que entra directamente en una
posición del array, vale? por ejemplo arg[6], entra como por arte de magia*/
for( n = 0; n < N; ++n )
{
// pues eso... hay que tomar cada dato del arg[6] con este bucle y cargarlo en
un puntero o un buffer o como se quiera
}
/* preparar en memoria un array bidimensional de tamaño N */
q = (double *)malloc( N * sizeof(double) );
//calcular el incremento de frecuencia
deltaf = (f2-f1)/((double)(Nfou-1));
//calcular omega (fourier y sus cositas...)
Omega = 2.0 * M_PI * f1 / mps;
deltaOmega = 2.0 * M_PI * deltaf / mps;
// ahora ya podemos calcular la transformada para cada iteración
for( i = 0; i < Nfou; ++i )
{
funcionFT( N, q, Omega, &Qreal, &Qimag );
Omega += deltaOmega; //se va incrementando omega
}
free( q ); //liberar la memoria, antes de hacer esto habría que dibujar los datos en
la LCD
return( 0 );
}
/*****************************************************************
**
esta función calcula la transformada para cada iteración
para calcular los cosenos y los senos, he utilizado aproximación de suma de
polinomios. Esto lo he medio copiado de un libro (qué morro).
*/
void funcionFT( int N, double *q, double Omega, double *Qr, double *Qi )
{
int n;
double C0, S0; /* cos(Omega) & sin(Omega) */
double T0, T1, T2; /* polinomios tipo I */
double U0, U1, U2; /* polinomios tipo II*/
double Cn, Sn; /* cos(n*Omega) & sin(n*Omega) */
C0 = cos(Omega);
S0 = sin(Omega);
T0 = 1.0;
T1 = C0;
U0 = 1.0;
U1 = 2.0*C0;
/* para los dos primeros órdenes*/
*Qr = q[0] + q[1]*T1;
*Qi = q[1]*S0*U0;
C0 *= 2.0;
for( n = 2; n < N; ++n )
{
T2 = C0*T1 - T0;
T0 = T1;
T1 = T2;
U2 = C0*U1 - U0;
U0 = U1;
U1 = U2;
Cn = T2;
Sn = S0*U0;
*Qr += q[n]*Cn;
*Qi += q[n]*Sn;
} /* el resto de los órdenes hasta llegar a N */
} /* se acabó la funcionFT*/


















(de risa eeee!)



está trabajando duramente.
Escrito originalmente por Gokuden
de donde sacastes la info para ese osciloscopio? y como haces para mandar esa imagen a la tv o el protocolo para ello!!!
esoy haciendo un osciloscopio y uso una lcd de 8cmx7cm y ya muestro perfectamente señales hasta 1mhz. use un microcontrolador 16f877 que lo toy cambiando por un 18f458 y un atmel 89s52. pero me interesa eso de la tv.




...muy buen proyecto.......

, pero estoy utilizando un ATMEGA16, y un display grafico de 128*64 T6963C, bueno le puese un menu grafico basando me un proyecto similar que vi con un PIC, pero a mi vercion le puese un analizador de diagramas de tiempo, puedo seleccionar por hardware la amplitud en la que puedo trabajar.
sobre este proyecto por favor madenme un email a: gpereira_munoz@hotmail.com o al germanpereira@gmail.com donde tengo mas espacio para poder intercambiar informacion ok.
Hola a todos, perdon por lo de las fotos pero he tenido problemas para madar las venditas fotos, haber ya voy por mi tercer intento
.
, los que quieran que les mande las fotos, denme su correo electronico.
es por la camara que tengo pero, se nota no.
, pero ni modo tengo que probar que me da. Otro problemita que veo es que al usar un ADC esterno, perderia la entrada digital para el analizador de diagramas de tiempo como lo mostre en las fotos. Haver voy a ver como arreglo la cuestion.
QUE PASO CON ESTE PROYECTO YA NADIE ESCRIBE ALGO NUEVO
, a lo mejor te las envían.
. Hasta pronto
, como habras oido en los noticieros internacionales mi pais esta pasando por un caos social, bloqueos de caminos, marchas por la ciudad todos los dias disturbios y cosas asi, y te habras enterado del show que hubo en el senado de mi pais cuando nos visito el presidente FOX no, ya veras que el asinto es complicado, pero echale ganas no mas, tu sabes que el que persebera alcanza.
o ver si existe alguna libreria que ya proponga algo como esto en el C30 asi que tengo que quemarme las pestañas y el cerebro para ver si es posible. Luego comento logros. Hasta pronto.



.

Escrito originalmente por radon
Me han respondido esto:
Estimado Daniel,
Los precios de los equipos que nos indica son los siguientes (IVA no
incluido):
OSC20-PCI = 250 EUR
PenScopeDAQ = 240 EUR
M522 = 425 EUR
DS1002 = 525 EUR
DS1102 = 650 EUR
ScopeDAQ = 350 EUR
USBScope50 = 325 EUR










Escrito originalmente por radon
Al que hizo la foto, que calibre la sonda del scope jejejeje

pues si te fijas bien tiene como un tornillito que te explico, como ves en la imagen, la onda cuadrada que hace tu pic, no es cuadrada verdad? si no que se abomba, pues eso es por la capacitancia de entrada de tu scope no esta calibrada con la de la sonda. Para ello los scope tienen un punto donde pinchar con la sonda, el cual genera una onda de 1khz aprox, esta es para eso, equilibrarla, ve girando el tornillo hasta que sea lo mas cuadrada posible 
Suerte con el scope
la verdad no necesito un osciloscopio de 100Mhz o mas. yo con uno de 10Msps me basta y sobra para los circuitos normalmente utilizados.me podrian ayudar con este codigo solo compila en isis y en el pic18 no, no se porque.
https://www.dropbox.com/s/i0f7lmic7wystm5/proyecto.rar?dl=0
me podrian ayudar con este codigo solo compila en isis y en el pic18 no, no se porque.
https://www.dropbox.com/s/i0f7lmic7wystm5/proyecto.rar?dl=0