Busco consejo sobre que lenguaje conviene aprender

[Picuino]

Código: [Seleccionar]

if ( var & 0x08 ) {
 Si el resultado de la operacion "var & 0x08" es 0 no va a entrar aca
 Si esta en un 1 ese bit va a entrar aca
}
Aclaracion, si eso no funciona, podria ser ((var & 0x08) == 0) o != 0, pero creo que deberia funcionar sin el condicional.
Que esto se reemplaze en un simple BTFSS/BTFSC ahi lo veo complejo.

Todos los códigos que has puesto funcionan perfectamente y el compilador (si es bueno como el XC8) lo traduce directamente a un BTFSS/BTFSC

Saludos.

[Chaly29]

Hola gente, así da gusto aprender. Picuino, por supuesto que no andaba buscando el reemplazo exacto de esas funciones del .asm, pero si tu dices que llegan a ese nivel, pues mejor todavía.

elgarbe, muy bueno ese link, ya lo e agendado para tenerlo a mano. Gracias

if ( condición ) { true    ;
} else { false               ;
}                                ;

A ver si entendí correctamente la función "if", si condición es 1 o superior realiza la operación en TRUE, y si es cero realiza lo ubicado en FALSE. ¿Esto es así?

Por lo tanto si lo anterior es correcto, dentro de "condición" no es obligatorio usar una función matemática, con que tenga una variable es suficiente. ¿Es esto correcto o me equivoco?

Muchas gracias a todos por la enseñanza y sobre todo por la paciencia. Un saludo.

Atte. CARLOS.

[Picuino]

Condición puede ser cualquier cosa que devuelva un valor de cualquier tipo.

Si el valor es cero, la condición es falsa. En cualquier otro caso, es verdadera.

   if (0)                Falso
   if (23)              Verdadero
   if ('m')             Verdadero
   if (4>3)            Verdadero
   if (0b1100 & 0b0011)     Falso porque el and binario vale 0b0000
   if (0b1100 && 0b0011)   Verdadero porque 0b1100 es verdadero y 0b0011 es verdadero. El and lógico es por lo tanto verdadero.
   a = 3;
   if (a == 4)    Falso porque a no es igual a 4
   if (a = 4)      Verdadero, porque el resultado de la asignación es cuatro.
                      Mucho cuidado con esta última instrucción. Es muy común equivocarse y ponerla por error al no escribir más que un igual.


La instrucción if sería igual a hacer una operación y comprobar el bit Zero del registro de estado.
Si el bit Zero está activado, salta al else.

Picuino, por supuesto que no andaba buscando el reemplazo exacto de esas funciones del .asm, pero si tu dices que llegan a ese nivel, pues mejor todavía.

En realidad cuando conozcas bien el XC8 y si utilizas la versión Full, puedes escribir en C todos los programas que antes escribías en asm, con la misma eficiencia.
Tendrás la opción de programar en C computed gotos (con switch case), tablas de datos con retlw y todo lo demás.
Lo bueno del C es que es muy cercano a la máquina, casi ensamblador.


Saludos.

[elgarbe]

Hola gente, así da gusto aprender. Picuino, por supuesto que no andaba buscando el reemplazo exacto de esas funciones del .asm, pero si tu dices que llegan a ese nivel, pues mejor todavía.

elgarbe, muy bueno ese link, ya lo e agendado para tenerlo a mano. Gracias

if ( condición ) { true    ;
} else { false               ;
}                                ;

A ver si entendí correctamente la función "if", si condición es 1 o superior realiza la operación en TRUE, y si es cero realiza lo ubicado en FALSE. ¿Esto es así?

Por lo tanto si lo anterior es correcto, dentro de "condición" no es obligatorio usar una función matemática, con que tenga una variable es suficiente. ¿Es esto correcto o me equivoco?

Muchas gracias a todos por la enseñanza y sobre todo por la paciencia. Un saludo.

Atte. CARLOS.

Así es, y como eso de que con algo mayor a 1 tambien es conciderado TRUE es un arma de doble ya que con algún error o descuido podemos entrar como condicion verdadera algo que no lo es, se suele hacer:

#DEFINE TRUE 1
#DEFINE FALSE 0
#DEFINE PIN_LED (1<<5)

if ( (PORTB & PIN_LED) == TRUE) { }


Si bien son más "caracteres" escritos, se evitan algun posible error. No sé si es buena práctica lo que pongo acá, simplemente comentar que lo he visto en muchos programas "grandes"

Saludos!

[KILLERJC]

Así es, y como eso de que con algo mayor a 1 tambien es conciderado TRUE es un arma de doble ya que con algún error o descuido podemos entrar como condicion verdadera algo que no lo es, se suele hacer:

#DEFINE TRUE 1
#DEFINE FALSE 0
#DEFINE PIN_LED (1<<5)

if ( (PORTB & PIN_LED) == TRUE) { }


Si bien son más "caracteres" escritos, se evitan algun posible error. No sé si es buena práctica lo que pongo acá, simplemente comentar que lo he visto en muchos programas "grandes"

Saludos!

Yo creo que no tendria sentido realizarlo, si me parece mas intuitivo para alguien que no sabe C el poner la condicion, pero sabiendo como funciona el if(), con los ejemplos que dio Picuino no deberia haber ningun problema. Algunos lenguajes True y False son palabras reservadas, asi que lo considero como una practica muy comun, ademas de poder designar a TRUE con cualquier valor que va a funcionar igual no importa que sea 1. Me explico el por que no se me ocurre que sea necesario.

EDIT: Me di cuenta de mi error en la explicacion que esta en el quote siguiente, pido perdon y espero que no cause confusiones (de todas formas dejo la explicacion que di para que se de cuenta del error), tome el operador == como si fuera un AND logico ( && ) lo cual fue mi error. Pero abajo del quote respondo por cual es el error realmente.

En la condicion del if, lo que realmente vale la pena mirar es PORTB & PIN_LED, Si vos te equivocas en eso o metes un error en eso el "== TRUE" no te va a salvar para nada. Miremos las 2 posibilidades

True == True -> True
False == True -> False

si la condicion que dije es True, el resultado es True. Si la condicion es False, el resultado tambien es False. No evitaria ningun error o un descuido por que pusiste mal el valor PIN o el PORT.

Ahora si pongo el error, en el caso que se presento if ( (PORTB & PIN_LED) == TRUE) { } , la condicion (PORTB & PIN_LED) puede que no de 1,
si suponemos que queremos saber el bit4 entonces PIN_LED seria 0x10 y de estar activo el PIN, devolviera 0x10 lo cual se compararia con un 0x01.
A no ser que hagas if ( (PORTB & PIN_LED) == PIN_LED) { } , veo complejo que funcione como se quiere. Y termina siendo mas engorroso.

No se me ocurre algo que implique una arma de doble filo a no ser que uses operadores de pre-incremento/decremento y multiples condiciones:

i=0,j=0;
if ( ++i<10 || ++j<10 )
{
 Mostra los valores de i y de j
}

Pero hacer algo asi deberias tener un poco mas de conocimientos de C.
O tratar de resumirlo a ASM donde se ejecuta la primer condicion y si se cumple entonces no hay necesidad de hacer la otra. lo cual j no incrementaria hasta que i sea igual o mayor a 10.

[Picuino]

Yo siempre uso en .asm una pequeña rutina para manejar los LCD's, la e realizado en XC8 y si bien es más fácil y rápida de comprender, incluso de programar, la contra es que en .asm me ocupaba solo 180 posiciones de memoria de programa y en XC8 me ocupa 290, una diferencia importante.
Pero bueno, es un precio bajo a pagar (si logro llegar a manejar bien el C) por la comodidad y velocidad de programación.

¿Se puede ver la rutina en c?
Probablemente se puede mejorar y así vas aprendiendo trucos.

Un saludo.

[Chaly29]

Hola Picuino, en este momento que te estoy respondiendo estoy complicado con el tiempo. Mas luego la subiré y me comentas. En una de esas asta le sirve a alguien.

Un saludo.

Atte. CARLOS.

[Chaly29]

Hola a todos, acá posteo el pequeño programa en C que e creado para el manejo de LCD's:

Código: C

1. /*
2.  * File:   main.c
3.  * Author: Carlos
4.  *
5.  * Created on 4 de enero de 2015, 01:48
6.  */
7.  
8. #include <stdio.h>
9. #include <stdlib.h>
10. #include <xc.h>
11.  
12. #pragma config BOREN = ON       // Brown-out Reset Enable bit (BOR enabled)
13. #pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)
14. #pragma config CPD = OFF        // Data EE Memory Code Protection bit (Code protection off)
15. #pragma config PWRTE = ON       // Power-up Timer Enable bit (PWRT enabled)
16. #pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
17. #pragma config LVP = OFF        // Low-Voltage Programming Enable bit (RB3/PGM pin has PGM function, Low-Voltage Programming enabled)
18. #pragma config MCLRE = OFF      // RA5/MCLR/VPP Pin Function Select bit (RA5/MCLR/VPP pin function is MCLR)
19. //#pragma config FOSC = XT_OSC // Oscillator Selection bits (INTRC oscillator; CLKO function on RA6/OSC2/CLKO pin and port I/O function on RA7/OSC1/CLKI pin)
20.  
21. #define     _XTAL_FREQ      4000000
22. #define     LCD_RS          PORTBbits.RB0
23. #define     LCD_E           PORTBbits.RB1
24. #define     LCD_D4          PORTBbits.RB2
25. #define     LCD_D5          PORTBbits.RB3
26. #define     LCD_D6          PORTBbits.RB4
27. #define     LCD_D7          PORTBbits.RB5
28.  
29. extern void LCD_INICIALIZAR(void);
30. extern void LCD_IN(unsigned char);
31. extern void LCD_INST(unsigned char);
32. extern void SACAR(unsigned char);
33. extern void LCD_DATO(unsigned char);
34.  
35. void LCD_INICIALIZAR(void) {
36.     LCD_E = 0;
37.     LCD_RS = 0;
38.     __delay_ms(15);
39.     LCD_IN(0b00110010); //Setea 4 BITS
40.     LCD_IN(0b00101000); //Setea 2 lineas, matris de 5x7
41.     LCD_INST(0b00000110); //Activa el display, desactiva el cursor y desactiva el destello del cursor
42.     LCD_INST(0b00001100);
43.     LCD_INST(0b00000001); //BORRA DISPLAY
44.     return;
45. }
46.  
47. void LCD_IN(unsigned char DATO) {
48.     SACAR(DATO);
49.     LCD_E = 1;
50.     __delay_ms(4);
51.     LCD_E = 0;
52.     DATO = DATO << 4;
53.     SACAR(DATO);
54.     LCD_E = 1;
55.     __delay_ms(4);
56.     LCD_E = 0;
57.     return;
58. }
59.  
60. void LCD_INST(unsigned char DATO) {
61.     SACAR(DATO);
62.     LCD_E = 1;
63.     __delay_ms(2);
64.     LCD_E = 0;
65.     DATO = DATO << 4;
66.     SACAR(DATO);
67.     LCD_E = 1;
68.     __delay_ms(2);
69.     LCD_E = 0;
70.     return;
71. }
72.  
73. void LCD_DATO(unsigned char DATO) {
74.     SACAR(DATO);
75.     LCD_RS = 1;
76.     LCD_E = 1;
77.     __delay_us(20);
78.     LCD_E = 0;
79.     LCD_RS = 0;
80.     DATO = DATO << 4;
81.     SACAR(DATO);
82.     LCD_RS = 1;
83.     LCD_E = 1;
84.     __delay_us(20);
85.     LCD_E = 0;
86.     LCD_RS = 0;
87.     return;
88. }
89.  
90. void SACAR(unsigned char DATO) {
91.     DATO = DATO << 1;
92.     LCD_D7 = 0;
93.     if (STATUSbits.CARRY == 0x01) (LCD_D7 = 1);
94.     DATO = DATO << 1;
95.     LCD_D6 = 0;
96.     if (STATUSbits.CARRY == 0x01) (LCD_D6 = 1);
97.     DATO = DATO << 1;
98.     LCD_D5 = 0;
99.     if (STATUSbits.CARRY == 0x01) (LCD_D5 = 1);
100.     DATO = DATO << 1;
101.     LCD_D4 = 0;
102.     if (STATUSbits.CARRY == 0x01) (LCD_D4 = 1);
103.     return;
104. }
105.  
106. void main(void) {
107.     TRISB = 0b11000000;    // Configuro el puerto
108.     PORTB = 0;
109.     LCD_INICIALIZAR();     // Inicializo el display
110.  
111.     LCD_INST(0X80);        // Indico escribir en la primera posición de la primera linea
112.     LCD_DATO(32);
113.     LCD_DATO(32);
114.     LCD_DATO(32);
115.     LCD_DATO(72);
116.     LCD_DATO(111);
117.     LCD_DATO(108);
118.     LCD_DATO(97);
119.     LCD_DATO(32);
120.     LCD_DATO(77);
121.     LCD_DATO(117);
122.     LCD_DATO(110);
123.     LCD_DATO(100);
124.     LCD_DATO(111);
125.     LCD_DATO(32);
126.     LCD_DATO(32);
127.     LCD_DATO(32);
128.  
129.     LCD_INST(0XC0);        // Indico escribir en la primera posición de la segunda linea
130.     LCD_DATO(32);
131.     LCD_DATO(32);
132.     LCD_DATO(32);
133.     LCD_DATO(32);
134.     LCD_DATO(67);
135.     LCD_DATO(104);
136.     LCD_DATO(97);
137.     LCD_DATO(108);
138.     LCD_DATO(121);
139.     LCD_DATO(50);
140.     LCD_DATO(57);
141.     LCD_DATO(32);
142.     LCD_DATO(32);
143.     LCD_DATO(32);
144.     LCD_DATO(32);
145.     LCD_DATO(32);
146.  
147.     asm("nop");            // Esto hace que el micro quede en un bucle cerrado solo para simular el programa
148.     asm("goto $-1");
149.     return;
150. }

Tal y como ya e comentado anteriormente, este programa lo realice en .asm y lo e usado mucho. No es la gran cosa, estoy seguro que habrá mejores, pero este tiene la facilidad de poder asignar cualquier pin del micro para el manejo del LCD, por lo tanto no es necesario tener un puerto entero esclavo al display.

Con lo anterior es posible una flexibilidad extra en el diseño del PCB (muchas veces una gran ventaja) sin por ello aumentar la complejidad del programa.

Si bien el programa en .asm estaba bastante optimizado, creo que en C le falta mucho para estarlo, funciona, pero de seguro hay muchas cosas para mejorarle.

En .asm no lo usaba como librería, por una cuestión de capricho propio de que me gusta tener todo en el mismo programa. Pero en C y algún día (un poco lejano me temo) lo convertiré en librería ya que creo que el C es para simplificar la mente y no poner en el programa cosas ya vistas y sabidas, pero bueno, en un futuro....

Me gustaría comenten los errores que vean y en que se podría mejorar. Y al que le sea de utilidad, pues, provecho.

Un saludo.

Atte. CARLOS.

[Joseph90]

Muy bueno Chaly , sería bueno que comentaras un poco las funciones pues no me quedan muy claras. Por cierto para que IDE está escrito el código...
Saludos

[Chaly29]

Hola Joseph90, está escrito para el XC8 de microchip. Y en realidad es bastante sencillo de usar, te explico:

Código: C

1. #define     LCD_RS          PORTBbits.RB0
2. #define     LCD_E           PORTBbits.RB1
3. #define     LCD_D4          PORTBbits.RB2
4. #define     LCD_D5          PORTBbits.RB3
5. #define     LCD_D6          PORTBbits.RB4
6. #define     LCD_D7          PORTBbits.RB5

En este punto defines los pines que usarás para manejar el LCD. Cambiando las sentencias PORTBbits.RBx puedes usar cualquier pin de cualquier puerto, por supuesto si dicho pin es apto para salida.

Código: C

1. TRISB = 0b11000000;    // Configuro el puerto

Luego debes configurar los "TRIS" involucrados de manera correcta ya sean estos los TRISA, TRISB, TRISC, etc.

Código: C

1. void main(void) {
2.     TRISB = 0b11000000;    // Configuro el puerto
3.     PORTB = 0;
4.     LCD_INICIALIZAR();     // Inicializo el display

En el programa principal y luego de configurar puertos y demás funciones debes usar por única ves el comando "LCD_INICIALIZAR()". Esto es para inicializar el LCD y se hace solo una ves y al principio del funcionamiento del micro.

Código: C

1. LCD_INST(0X80);        // Indico escribir en la primera posición de la primera linea
2. LCD_INST(0XC0);        // Indico escribir en la primera posición de la segunda linea

Estas dos instrucciones le indican al LCD donde vas a escribir el carácter que viene a continuación. Con 0x80 indico la primera posición de la primera linea, si colocara, por ejemplo 0x85 sería la quita posición de la primera linea.

Código: C

1. LCD_INST(0X80);        // Indico escribir en la primera posición de la primera linea
2.     LCD_DATO(32);          // = " "
3.     LCD_DATO(32);          // = " "
4.     LCD_DATO(32);          // = " "
5.     LCD_DATO(72);          // = "H"
6.     LCD_DATO(111);         // = "o"
7.     LCD_DATO(108);         // = "l"
8.     LCD_DATO(97);          // = "a"
9.     LCD_DATO(32);          // = " "
10.     LCD_DATO(77);          // = "M"
11.     LCD_DATO(117);         // = "u"
12.     LCD_DATO(110);         // = "n"
13.     LCD_DATO(100);         // = "d"
14.     LCD_DATO(111);         // = "o"
15.     LCD_DATO(32);          // = " "
16.     LCD_DATO(32);          // = " "
17.     LCD_DATO(32);          // = " "

Por lo tanto, con la instrucción anterior estoy escribiendo "Hola Mundo" en el centro de la primera linea del display. Entre los () "paréntesis" esta el valor de cada carácter Ascii2.

Tal como expliqué, no es el programa más óptimo (tener en cuenta que es mi primer programa en C), pero puede ser de utilidad. Cada cual es libre de mejorarlo a su gusto y por supuesto sería interesante que posteara sus resultados para que nos sea de utilidad a todos.

Un saludo.

Atte. CARLOS.

[Picuino]

Hola Carlos. Te adjunto una pequeña modificación que es más estandar.
En C no se suelen utilizar los registros de estado porque dependen de la máquina.

Código: C

1. void SACAR(unsigned char DATO) {
2.     LCD_D7 = 0;
3.     if (DATO & 0x80) LCD_D7 = 1;
4.     DATO <<= 1;
5.     LCD_D6 = 0;
6.     if (DATO & 0x80) LCD_D6 = 1;
7.     DATO <<= 1;
8.     LCD_D5 = 0;
9.     if (DATO & 0x80) LCD_D5 = 1;
10.     DATO <<= 1;
11.     LCD_D4 = 0;
12.     if (DATO & 0x80) LCD_D4 = 1;
13. }

Un saludo.

[Picuino]

Otra modificación para escribir un string:

Código: [Seleccionar]


void lcd_puts(char *string) {
   while(*string != 0) {
      LCD_DATO(*string);
      string++;
}

void main(void) {

   char mensaje[] = "Hola Mundo";
   lcd_puts(mensaje);
}



Otro comentario sobre el estilo de escritura en C:

   Los nombres de funciones y variables siempre se escriben en minúsculas o como mucho con tipo título: rutinaEscrituraPantalla()

   Las definiciones del preprocesador siempre se escriben en mayúsculas:  #define     LCD_RS          PORTBbits.RB0


Saludos.

[Picuino]

Por último.
Las definiciones de las funciones se escriben en un archivo separado con extensión *.h (header)
De esta forma, se puede acceder a las definiciones de las funciones en el caso de utilizar una librería y que el código c no sea accesible

Archivo lcd.h:

Código: [Seleccionar]

#ifndef __LCD_H
#define __LCD_H

#define     LCD_RS          PORTBbits.RB0
#define     LCD_E           PORTBbits.RB1
#define     LCD_D4          PORTBbits.RB2
#define     LCD_D5          PORTBbits.RB3
#define     LCD_D6          PORTBbits.RB4
#define     LCD_D7          PORTBbits.RB5

void LCD_INICIALIZAR(void);
void LCD_IN(unsigned char);
void LCD_INST(unsigned char);
void SACAR(unsigned char);
void LCD_DATO(unsigned char);

#endif


En otro archivo colocamos las funciones de tratamiento de LCD
Archivo lcd.c:

Código: [Seleccionar]

#include "lcd.h"

   // Resto del programa con las funciones de tratamiento del lcd ...
   // En este archivo no se coloca la rutina main



Por último se puede hacer un programa en un archivo separado que utilice las rutinas del LCD:
Archivo main.c:

Código: [Seleccionar]

#include "lcd.h"

   // Programa que va a utilizar el LCD (rutina main)
void main(void) {
    //...
}

El archivo "lcd.h" lo puedes incluir en cualquier programa que vaya a utilizar el lcd.

Creo que esto es lo que querías hacer cuando comentaste lo de la "Librería"

Saludos.

[MGLSOFT]

Las definiciones de las funciones se escriben en un archivo separado con extensión *.h (header)
De esta forma, se puede acceder a las definiciones de las funciones en el caso de utilizar una librería y que el código c no sea accesible

Como es eso de que no puedes acceder al código de las funciones??
Como lo implementas??

[Picuino]

No lo se bien porque nunca lo he hecho para un PIC, pero no es difícil.

Sólo hay que compilar los *.c para producir los ficheros objeto. *.o

Luego puedes utilizar sólo los ficheros objeto *.o con los header *.h sin el código c original.

Si juntas varios ficheros objeto *.o, puedes hacer una librería *.lib.


Seguro que alguien puede explicarlo mejor.

Saludos.


PD. En el caso del código de Charly esto no valdría porque el código c depende de las definiciones de los pines de salida. Habría que implementar el código de otra forma.