ayuda con fixed_io

[Cryn]

saludos, tengo entendido, segun loque lei aca y en el manual de ccs, que el fixed io te genera el tris correspondiente cada vez qeu generes un in o un out a ciertos pines que definas, lo he definido en mi program asi:

#use fixed_io(a_outputs=PIN_A3,PIN_A4)

y cuando hago output_high(PIN_A3); el led no se me enciende (en proteus uso resistencia de 150 ohm)
y lo mismo del PIN_A4 , con un transistor con pullup; estoy usando la libreria del lcd2 para manejar teclado y lcd, por eso la necesidad de usar el fixed, ahh tb uso un 16f84a y el ccs 4.032

alguna sugerencia, un saludo gracias

[Nocturno]

Pon set_tris_a(0) antes del output_high y prueba de nuevo, a ver si sale.

[Menta]

En teoría, con el método fixed no debe usarse el set_tris, justamente, por programa es que quedan prefijados los tris y el registro de memoria ram que se usaba para el tris del puerto queda disponible para uso genérico.

Primero, no sé bien por qué no te funciona, podrías colgar tu código?
La función set_tris_x() debe usarse con fast_io() y cuando se accede a los puertos de I/O como si fueran memoria (#BYTE)
Se me ocurre que quizas sea por eso, pero habría que ver el código.

Segundo, por qué debes usar este método?
En la mayoría de los casos puedes usar Fast_IO, pones el set_tris como quieras y no lo tocas más. El fixed_io presenta la única ventaja de ahorrar ram, pero no código (respecto de fast_io)

[Cryn]

la solucion que me diste nocturno no me ha funcionado.

Menta, intento usar este metodo porque estoy usando una lcd y un teclado para un 16f84a, y como vos sabeis este micro solo tiene un puerto b de 8 bits, y el a son de 5, el teclado y el lcd puedo compartirlo en el puerto b con la librteria lcd2.c que uso, y pues el lcd tb usa algunos pines (3 en realidad, de control) del puerto a, y me quedan 2 que quiero usarlo con leds, el codigo lo resumire aca:

Código: [Seleccionar]

#include <16F84A.h>
#byte port_b=0x06
#use delay(clock=4000000)
#include <teclado.c>    // mi libreria qeu devuelve el codigo ascii del numero presionado
#include <lcd2.c>
#fuses XT,NOWDT,PUT,NOPROTECT
#use fixed_io(a_outputs=PIN_A3,PIN_A4)
//#use fast_io(a)
#use fast_io(b)

char c,c2;
int i,error=0;

void main()                      // programa principal
{
   set_tris_b(0xf0);
   port_b=0;                     // inicializa puerto B
   set_tris_a(0x00);           // define puerto A como todas salidas excepto RA4
   output_a(0);                     // inicializa puerto A
   lcd_init();     
   output_high(PIN_A4);
   delay_ms(1000);
   output_low(PIN_A4);
   while(true)                   // bucle de trabajo
   {
      lcd_gotoxy(2,1);        //cursor para escribir mensaje     
      lcd_putc("\f ingresar clave:");
      c=kbd_getc();       // capturo tecla presionada
      if(c=='*')   // pregunto por los dígitos y codigo ingresado ok?
      {
         output_high(PIN_A3);
         lcd_gotoxy(1,2);
         lcd_putc("\f clave correcta");
         delay_ms(2000);
         lcd_putc("\fcandado abierto");
         delay_ms(2000);
         lcd_putc("\f ingresar clave:");
         while(1)                  // candado activado, hasta ingresar el codigo
         {
            c=kbd_getc();          // pregunta por presion de tecla para cambiar modo
            if(c!=0)               // con codigo de activacion correcto
            {
               if(c=='*')   // pregunto por digitos y codigo ingresado ok?
               {
                  lcd_putc("\f clave correcta");
                  delay_ms(2000);
                  lcd_gotoxy(2,1);
                  lcd_putc("candado cerrado");
                  delay_ms(2000);
                  output_low(PIN_A3);
                  break;           // salgo del modo, y pasa a modo apagado
               }
            }
         }
      }
   } //end while(true)
} // end main()

prove con todas las combinaciones posibles de fast_io, para a pra b, para los dos para ninguno, y nada, el #byet portb lo uso en la libreria del teclado, weno espero puedan ayudarme, aca dejo el esquema:



un saludo gracais adios.

[micro_cadaver]

sera un bug?

[Cryn]

nose, no lo creo, porque tb lo he complidao con la version viejita que tengo la 3.242 y esta igual, umm nose, qeu raro, debreia dar, verdad???

un saludo

[Menta]

si podés Cryn, pasame la librería del teclado y el archivo de proteus para la version 6.7 SP2 (si es otra versión no hay drama lo hago yo)
Asi buscamos la falla, si es que existe.
4 ojos ven más que 2, 2 cabezas piensan más que 1,  y 2 pcs compilan más que 1 

PD y lcd2 tb, pues la tenía, pero no la encuentro...

[Cryn]

jeje, haber si el proteus y el ccs se dejan con dos cabezas, jajjaa

yo use proteus 7.1 sp1, aca te dejo el link donde lo adjunte:

http://www.4shared.com/file/19864891/4c6ffdc5/lcd_y_teclado.html

gracias

[Menta]

Hola amigo...   Te diré lo que creo que ocurre:

Primero: la librería lcd2 que usas se maneja con los tris, así que te sugiero que trabajes con fast_io()
Esta librería no usa para nada los pines que tu quieres manejar RA3 y RA4, no sé si ha sido modificada, pero en ella en las funciones

lcd_init() y lcd_leer() te pone set_tris_a(0x18);
y en la función lcd_enviar(int dir, int valor) te pone set_tris_a(0x00);

como ves, cuando pone tris:0x18
11000b te pone justamente RA3 y RA4 en alta impedancia (todo lo contrario a lo que pretendes)

Lo que debes hacer es reemplazar los 0x18 por 0x00 (son sólo 2 sentencias) Las señales de control E, RS y RW conectadas a RA0, RA1 y RA2 son siempre salidas al igual que RA3 y RA4, por eso el tris debe ser siempre 0

Prueba con eso, me parece que hay algo que no funciona bien en la multiplexación teclado-lcd debes asegurarte que no hay teclas presionadas cuando escribas en el lcd, pero eso te lo dejo a ti. cualquier cosa ya sabes que aquí estoy como siempre pa' ayudar... yo y todo el foro

Saludos para Bolivia

[Cryn]

pues si efectivamente ese era el problema, muchas gracias, no vi a detalle la libreria porque la vi en un ejemplo y ahi si andaba bien, y pues pensaba que igual deberia darme, jejeje, ahora pasa un problema, el PIN_A4 con el pullup y el transistor no se me enciende, si es que pongo una resistencia de cualquier valor, pero si pongo un de PULLUP del propio proteus ahi si, da, porque??

weno muchas gracais por la ayuda un saludo para Argentina, y mucha suerte hoy en la final de la copa america, adios!!

[Menta]

Son cosas de proteus! simple y llanamente, 

Si con la R pullup funciona, te va a funcionar.
Ese es un tema que tuvo a más de uno en desvelo, incluyendome. Usando memorias I2C hace cualquier cosa, con las Pullup se solucionan algunas 
Me agarraron los exámenes y no llegué a probar las memorias en "la vida real" (más allá del mundo proteus)

PD.  Vamos Argentina!!! Espero que se de la lógica y la copa la gane el equipo que fue a ganarla.

[Cryn]

saludos, qeu mala pata con la final, cosas del futbol...

me qeudo la duda de el fixed, ya que no esta haciendo el trabajo que deberia, porque no deberia interesar que tris estazr y manejar como salida cada vez qeu yo lo necesite, esta muy raro, o tenog el concepto equivocado??

[LABmouse]

Bueno, pues me han dejado confundido. Yo generalmente uso standard_io, tengo entendido, esta opcion es para que CCS te configure automáticamente el tris, según se quiere output o input.

fast_io es para configurar manualmente el tris usando set_tris_x

El fixed nunca lo he usado, porque no entendí como es que funciona cuando estaba aprendiendo a trabajar en CCS y pues con las otras 2 opciones cumplía totalmente las necesidades.

Pero como es que funciona FIXED???   

[Menta]

Mirá, lo mio es sólo de opinólogo...  no lo encontré detallado en ninguna parte...

#use standard_io(x) --> cada vez que escribas un input o un output el compilador te agrega el set_tris_x antes de manera que el codigo generado crece, esto es útil para el caso en que los pines formen parte de un bus bidireccional o alguna aplicación en la que estemos usando los pines en forma alternada como entrada y salida La ventaja es que no tenemos que escribir el set_tris, nada más.

#use fast_io(x) --> el compilador no hace nada, cada vez que escribas un input o un output el responsable de que el tris esté correctamente definido eres tú mediante el programa. Esa es la desventaja, lo bueno es que puedes evitar la redundancia de sentencias set_tris_x. Imagina tener que sacar por un puerto 20 valores consecutivos, con este método "rápido" se ejecutan sólo las operaciones de output, mientras que con el método standard tienes ademas 20 sentencias set_tris_x que no son necesarias.

#use fixed_io(x...) --> Acá esta el tema complicado! Segun la ayuda de CCS se usa al igual que el método standard, el compilador genera código para cada sentencia de I/O y la única diferencia es el byte de ram que te ahorrás.

Aunque dice que para poner el tris previo a la sentencia de I/O recurre a lo que se ponga en esta directiva [#use fixed_io(XXX)] agrega que No son las operaciones realmente implementadas

Al margen: Qué pasa con los estados despues de las sentencias de I/O. Imaginate que mando a escribri un "0" ( con standard_io) y despues al rato voy a leer pero el hard que me tenía que contestar me mandó un "1" antes que lo leyera (cortocircuito) sería interesante que algún método tipo #use buses_io() que me lo tenga siempre en alta impedancia y cuando le doy escribir setea el tris, escribe y vuelve a setear. Y si leo no setea nada antes ni nada después, es mucho pedir? 



*Cuando dice que el standard_io() USA UN BYTE DE RAM, se refiere al registro del tris, o es otro adicional?

*Hay alguna forma de modificar el tris sin usar el registro ese. Por el código OP o algo así?