Que levanten la mano los que tienen osciloscopio

[cucaracha]

Esa es la cosa y por más vueltas que le he dado, y han sido muuchas, no consigo encontrar donde está el error.
Oye, tu sabes por qué usa dos configuraciones distintas para el puerto B?? Si le quitas eso no funciona... ???? y no lo entiendo, aunque eso es lo de menos, lo importante es el problema del texto.

Saludos!!

[Sispic]

Pues síí es este el problema :

He borrado todo lo referente al  // TRISB =  y dejando en solo en el procedimiento de configuración el trisB como salidas

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

ya funciona Ok.
Aunque si dominas ccs veras que estas rutinas consumen muchos recursos y se pueden arreglar , aunque no es mi caso pero intentaré entretenerme .

Tambien me encargo si quieres de diseñar un juego de caracteres mas grandes .

Ya estoy biendo todo esto funcionando ,,, Heyyy ¿ que le incluiras frecuencimetro tambien ???.

abrazos.

[Elena2000]

upps.. a lo mejor he dicho una burrada, pero me refería a ver el código en ensamblador en lugar de C... era por si lo tenías por ahí para echar un ojo a las instrucciones, porque yo piloto mejor en asm ( asi  gana el madrid..), y ver si te podía ayudar, Tombita..

[cucaracha]

Como que ya funciona todo bien??? Tengo que probarlo!! Esta tarde lo hago, que ahora me tengo que largar....

En cuanto a lo del frecuencímetro, pues creo que si... es una posibilidad. Quizás a traves del trigger se pueda sacar también la frecuencia. Yo habia pensado colocar debajo del gráfico una única línea donde vaya mostrando la tensión por división, la base de tiempo, la frecuencia, Vpp... Ya se irán viendo las posibilidades.
Ahora estoy tomando notas en un cuaderno de como pasar los datos del conversor (0 a 255) a puntos del display (0 a 84), en vertical todo. Como simplificaría que el LCD tuviera 128 en lugar de 84, ya que es múltiplo de 256. Pero habrá que comerse la cabeza un poco...
Hacerlo con tablas será más rápido creo, pero quizás ocupe más memoria. Hacerlo con alguna función matemática a lo mejor es más lento pero ahorra memoria... no se...
Luego habrá que ir añadiendo al byte resultante más puntos negros para unir dos muestras consecutivos...  En fin... que cuesta mucho explicarlo... espero que al menos tomen una idea.

Esta tarde pruebo...

[cucaracha]

Gracias Elena. El único asm que tengo de esto es el que se puede sacar desde el CCS. Pero como el amigo Sisco es un fiera, está todo solucionado.
Lo que no esntiendo es porqué no me funcionó antes a mí. Si yo hice eso!! No sé... quizás dejé por ahí alguno sin quitar o los quité todos... no se, la cosa es que ya funciona. Ahora a otra cosa...

Bueno Elena, ahora a otra cosa no, ahora a hacer funcionar el tuyo o creías que me había olvidado!! Monta el display de una vez en una protoboard y a tu orden empiezo a bombardearte con  librerías para que vayas probando, eso sí, en C (si, si, transfuga que es uno)

Gracias Sisco. Ahora cuelgo la librería definitiva. Si te fijas, las ñ no salían. Había un error de nada. Solucionado.
Y voy a dejarlo también en el foro de Conket, que aunque ni siquiera me han contestado para decir que no tienen ni idea, fueron ellos los que hicieron las rutinas iniciales desde las que partimos.

Estoy contento!!

Saludos!!

[Sispic]

Estoy disfrutando como un bebé con su chupete nuebo .

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
}

Pero hay un problema gordo :
El display es de solo escritura y para imprimir pixels sueltos es necesario hacer el AND correspondiente para no borrar el byte entero existente .

Seria necesario un buffer ram con la imagen de la pantalla
Habia pensado con algun 18F que tienen mucha y cabe mas programa .

Boy haber mientras si hago alguna rutinilla para circulitos y mariconadas de estas .

Pero no se que pasa que la serie 18 no lo compila la version que tengo 3.34

Helena esto lo haria en asm sin despeinarse seguro , almenos en las partes de medición etc seria importante (sobre la marcha ya lo veras)

adu

[MGLSOFT]

Je..Je..
El lento para agarrar los lenguajes le dicen a Cisco!!

Void Felicitaciones_!! (Void)

Y muy bueno el manejo de tablas...
Lo de los bytes me parece conocido...

[Sispic]

Andaaa Marcos  estoy yo para aprender C en 30 minutos encontré en mi ratón el boton (derecho - copiar - pergar ) y poco mas .

Tengo alguna  fuente mas grande pero como ocupan mas de 8 bits por columna , se imprimen pero borra todos los pixels que le sobra al no poder leer .

[Elena2000]

Si si si si!! ¡¡¡¿qué tengo que hacer?? una rutina en ensamblador que escriba pixels aislados en la pantalla, no? y que pueda imprimir círculos, o curvas en general, si? VALE! pero en asm, please, que el C me marea un poco (.... void, void... ).

Ahh! qué bien, Cuca y Sispic, sois un par de tíos, eh. Felicidades!
Vale, a las órdenes, si, destripo el zapatófono este fin de semana seguro. Qué bien!

MUUUUchos besotes!

[Sispic]

destripo el zapatófono este fin de semana seguro.

Uhi , Uhi  , esto de destripar suena muy mal ¿ que es ?

Yo estoy haciendo de las mias con un 18F252/452 con un buffer ram con la imagen de pantalla ya se pueden ir haciendo virgerias .

He encontrado unas rutinas para el  HD61202 y las he modificado un poco . pero para hacer una linea no lo trae , y los circulos salen un poco ovalados



Tambien intentaré modicar las funciones para poder imprimir caracteres en pixel x,y ya que ahora no se puede .

Cuca , como andas con el scope ?  si quieres cuelgo lo que tengo para ver si te sirve algo .

[cucaracha]

Ok, sí, cuélgalo y lo voy ojeando. Sobre todo ese ejemplo del de los círculos del HD61202, para ir viendo como lo hacen.
Elena, a ver si te paso el código en asm que genera el CCS y lo pones bonito, y ya lo tenemos en ASM.
Voy a intentar medir una frecuencia a través de un comparador, usado como disparo, a ver que sale. A ver si tengo un poquito de tiempo, que ahora en las fechas que estamos a todo el mundo le dá por hacer barbacoas y esas cosas. Pero entre chuleta y chuleta yo en la cabeza tendré siempre los mismos pensamientos..... conseguir otra chuleta. Qué creían??

Seguimos...

Saludos!!

[marmatar]

A ver Cuca si queda algo como ésto...

http://www.lanzo.se/WTT/

Por aquí se consigue a USD200 + IVA...

Por lo que veo va bien el proyecto, los felicito...

a ver si consigo algún zapatófono por ahí o un display gráfico para hacer  alguna prueba de las que pusieron aquí y sorprenderme yo también...jejeje

Un abrazo...
marmatar

[Sispic]

Pues ya tienes casi todas las herramientas necesarias , ahora es cuando realmente empieza la "fiesta" con tu proyecto y estoy seguro de que lo conseguiras .

Por cierto , ya te has decidido por el Ad a usar ?.

saludos.

PD. No estoy 100x100 seguro pero los pixels no son cuadrados (son ligeramente mas largos que anchos) por esto salen los circulos ovalados . ,  por si tienes que tenerlo en cuenta .

[Elena2000]

Jooo.. pero si ya está todo hecho!!!!!!!! ya he visto las curvas, Cuca, y
están genial!!! y las líneas, y todo todo!.. y ahora qué hago yo??!!
Bueno, chicos, pasadme al menos el código el asm, andaaaaaaa... y lo
a ver si coincide con lo que he estado preparando este finde, pliiiiiiis.

[cucaracha]

Elenita, ya te he enviado eso. Como va esa carnicería. Destripastes ya el LCD?? jejeje
Sispic, creo que llevas razón en lo de que los pixels son más altos que anchos.
En cuanto a lo del AD a usar, aún no me he decidido. He mirado en maxim algunos, pero todavía no me decido por cual.
En cuanto a lo que preguntas del disparo... es lo que más me está costando entender.
Con un comparador veloz puedo saber cuando la señal pasa por cero (o por la tensión que quiera comparar). La cosa es que eso está perfecto si la señal es senidal y pasa por cero. Pero que pasa si es una señal continua de 5v por ejemplo... como lo averiguo... y si no es periódica...
He estado buscando información sobre eso, sobre el trigger, pero no encuentro nasa que me saque de dudas... A ver si alguien no guía un poco.
Voy a hacer algunas pruebas ya más serias
Veremos que sale...
Os tengo informados..

Saludos!!