Comienzo en C

[jukinch]

Solo code model modificá.

Por el otro warning cambiaste en los dos archivos el tipo de dato de unsigned char a char? Es decir, en el archivo *.c y e el *.h?

Subí el proyecto zipeado y lo vemos.

[macedo]

Hola Jukinch, este cod. es parte de un modulo marca Olimex,
 

Código: C

1. extern char ext_test_state[20];       // usado en la seccion TEST Extesion Port y en test.c por sprintf
2.   extern char ext_test_state2[20];      // usado en la seccion TEST Extesion Port y en test.c por sprintf

están declarados en main.c y test.c,los cambie y sigue igual, pero no es gran molestia para que te lo tomes ya que solo estoy aprendiendo y como programo en ASM no dejo que me ponga el compilador ningún mensaje de advertencia trato de resolverlo hasta que salga, si queres decirme u orientarme te lo agradeceré.
Saludos

[Suky]

Son advertencias, no errores.


Saludos!

[jukinch]

Macedo:   
Para eliminar el warning [2073] null-terminated initializer string too long

reemplacé en main.c unsigned char Menu[MENU_NUMB][15]  por unsigned char Menu[MENU_NUMB][16] porque le faltaba agrandarlo para que pueda entrar una de las cadenas.



Para eliminar el warning [2058] call of function without prototype


en test.c luego de

#include "test.h"

agregué:

extern void Delay(unsigned long a) ;
extern void Delayc(unsigned char a) ;


en user.c luego de

#include "lcd.h"

agregué:

extern void LCDStr(unsigned char row, const unsigned char *dataPtr, unsigned char inv );
extern unsigned char GetJoystickPosition (void);


en lcd.c luego de
#define RES_LOW         PORTDbits.RD3=0

agregué:
void LCDStr(unsigned char row, const unsigned char *dataPtr, unsigned char inv );


en main.c luego de

#pragma config CCP2MX   = DEFAULT

agregué:
extern void LCDStr(unsigned char row, const unsigned char *dataPtr, unsigned char inv );


para eliminar el Warning [2054] suspicious pointer conversion

en main.c reemplacé en todos los sprintf
sprintf(buf,"X=0x");
así:
sprintf((char *)buf,(rom far char*)"X=0x");

casi todos los arrays han sido declarados como unsigned char y el primer parámetro del prototipo de sprintf te pide un puntero a char con signo.

para evitar el warning hay que castearlo con (char*)
así:
sprintf((char *)buf,"X=0x");

el segundo parámetro de sprintf te pide un rom far char* y si no tenés el large memory model seleccionado
hay que castear con (const rom char *)

asi:
sprintf((char *)buf,(rom far char*)"X=0x");



The compiler libraries are built with the large memory model (far rom pointers) while the compiler uses the near memory model (near rom pointers) by default, unless you compile with -ml. The compiler is complaining that you're passing a 16-bit pointer to a string constant to a function that expects a 24-bit pointer. The compiler knows how to perform that conversion, so the code will work correctly even with the warning. Most any random char* cast applied to the string literal will suppress the warning while still generating correct code. The correct cast is (const rom far char *), but incorrect casts like (char *) will work, and even meaningless casts like (near far rom rom rom char *) will work.

fuente: http://www.microchip.com/forums/tm.aspx?m=53856

sino podés elegir el large memory model desde build option project y listo.
Pero a buf si o si lo tenés que castear porque sprintf espera char* y no unsigned char*

Adjunto proyecto con cero warnings y build success! 
      Saludos
          Jukinch

[macedo]

Hola jukinch, sos un genio!, gracias, yo había visto lo del menú y lo agrande,  puedo preguntarte por que usas extern para declarar los protortipos,
yo declare en lcd.h:

Código: C

1. void LCDStr(unsigned char row, const unsigned char *dataPtr, unsigned char inv );

y dejo de decirme warning [2058] call of function without prototype.
Tambien estan declarados en el mismo archivo

Código: [Seleccionar]

[code=c]extern void Delay(unsigned long a) ;
extern void Delayc(unsigned char a) ;pero los sigue tirando, te hablo del archivo original[/code] que te envie. por que?
Lo de sprintf me supera pero dejame ver si lo entendí: esta expresion (char *)buf, castearlo, hace que buf cambie de unsigne char a char pero solamente en esta función para poder utilizarlo en este momento sin que afecte o que cambie el valor en otra parte del programa?
Como se selecciono large memory la funcion deberia quedar asi:

Código: C

1. sprintf((char *)buf,"X=0x");

y no asi:

Código: C

1. sprintf((char *)buf,(rom far char*)"X=0x");

te pregunto es lo mismo far rom char * que rom far char*? y segun el ejemplo no es (const rom far char *)?

Gracias por tomarte el tiempo.
Saludos

[jukinch]

macedo:
       el warning "call of function without prototype." te dice que estás llamando a una función que todavía no se ha declarado su prototipo. Por eso declarando los prototipos desaparecen los warnings. Lo de extern lo puse porque me lo daba en un archivo diferente a donde estaba definida la función. Por eso lo de extern.
     
El tema de los warnings en sprintf está relacionado con los tipos de datos y los parámetros que recibe una función.
Siempre que tengas un warning de ese estilo en el uso de una función tenés que ver como es el prototipo de la misma.

en el caso del sprintf podés ver el manual "C18 Compiler Libraries"

sprintf
Function: Formatted string output to a data memory buffer.
Include: stdio.h
Prototype: int sprintf (char *buf, const rom char *fmt, ...);

Los 2 parámetros que te pide son:
 
un puntero a char   

y

un puntero a const rom char

      En tu programa para dar cumplimiento al primer parámetro, debés hacer casting así: (char *)buf     
para poder convertir el tipo que le estás pasando: unsigned char* al tipo correcto que espera la función, es decir: char* .
      El casting hace la conversión sólo en esa sentencia. Y no cambia el tipo de dato de buf, el cual va a seguir siendo unsigned char*.
      Con respecto a si es lo mismo far rom char* que rom far char* no lo se.
Pero en el manual  mplab_c18_users_guide_51288j.pdf en la página (DS51288J-page 14) está como rom far char* y siempre lo pongo así.
              Saludos.
                      Julkinch

[macedo]

Gracias por aclarármelo, voy a ver que saco de todo esto y te comento.
Saludos

[macedo]

una pregunta, este codigo esta antes y fuera del  void main (void), no es llamado por nadie y configura puertos y parte del USB, no debería estar dentro del main y si  puedo yo hacer una funcion con todas las configuraciones de los pines del micro y llamarla desde el main o antes de este para configurarlo.
Les paso el cod.:

Código: C

1. ////////////////////////////////////////////////////////////////////////////////////////
2. static void InitializeSystem(void)
3. {
4.         //On the PIC18F87J50 Family of USB microcontrollers, the PLL will not power up and be enabled
5.         //by default, even if a PLL enabled oscillator configuration is selected (such as HS+PLL).
6.         //This allows the device to power up at a lower initial operating frequency, which can be
7.         //advantageous when powered from a source which is not gauranteed to be adequate for 48MHz
8.         //operation.  On these devices, user firmware needs to manually set the OSCTUNE<PLLEN> bit to
9.         //power up the PLL.
10.  
11.         #if defined(__18F87J50)||defined(__18F86J55)|| \
12.         defined(__18F86J50)||defined(__18F85J50)|| \
13.         defined(__18F67J50)||defined(__18F66J55)|| \
14.         defined(__18F66J50)||defined(__18F65J50)
15.  
16.     unsigned int pll_startup_counter = 600;
17.  
18. //I comment next line to enable debugging somehow///////////////////////////////////////////////////
19.     OSCTUNEbits.PLLEN = 1;  //Enable the PLL and wait 2+ms until the PLL locks before enabling USB module
20.  
21.     while(pll_startup_counter--);
22.     //Device switches over automatically to PLL output after PLL is locked and ready.
23.  
24.         //Configure all I/O pins to use digital input buffers.  The PIC18F87J50 Family devices
25.         //use the ANCONx registers to control this, which is different from other devices which
26.         //use the ADCON1 register for this purpose.
27.     WDTCONbits.ADSHR = 1;                       // Select alternate SFR location to access ANCONx registers
28.     ANCON0 = 0xFF;                  // Default all pins to digital
29.     ANCON1 = 0xFF;                  // Default all pins to digital
30.     WDTCONbits.ADSHR = 0;                       // Select normal SFR locations
31. //      ADCON1 |= 0x0F;   //I put that here
32.  
33.     #elif defined(PIC18F4550_PICDEM_FS_USB)
34.     ADCON1 |= 0x0F;                 // Default all pins to digital
35.  
36.     #else
37.         #error Double Click this message.  Please make sure the InitializeSystem() function correctly configures your hardware platform.
38.                 //Also make sure the correct board is selected in usbcfg.h.  If
39.                 //everything is correct, comment out the above "#error ..." line
40.                 //to suppress the error message.
41.     #endif
42.  
43.  
44.     #if defined(USE_USB_BUS_SENSE_IO)
45.     tris_usb_bus_sense = INPUT_PIN; // See io_cfg.h
46.     #endif
47.  
48.     #if defined(USE_SELF_POWER_SENSE_IO)
49.     tris_self_power = INPUT_PIN;
50.     #endif
51.    
52. //    mInitializeUSBDriver();         // See usbdrv.h
53.     UserInit();                       // See user.c & .h
54.  
55. }//end InitializeSystem

Userinit es otra configuración de puertos.
Todo esto es para C18
Saludos

[jukinch]

Macedo:
            Podés escribir código fuera de main. Por ejemplo podés definir variables globales. podés definir funciones, etc. y luego llamarlas desde dentro de main. Lo que no podés hacer es escribir sentencias, selectivas, if, while, for, switch, etc. Todas esas si o si deben ir dentro de una función, no pueden estar sueltas fuera de main. recordá que main es una función más.  

         Por tu inquietud sobre el tema de las configuraciones de los pines del micro podrías hacer una función con toda la configuración y llamarla desde main para configurarlos y hacer un código más estructurado. Hasta podrías incluir dicha función en un archivo separado para que quede prolijo el código y luego llamarla desde main.

Código: C

1. /***** funcion de configuracion de puertos ******/
2. void inicializarpuertos(void)
3. {       //inicializar puertoA como digital
4.         //todos los pines
5.         //seran digitales. Para ello debemos desactivar el ADC y los comparadores
6.  
7.                 ADCON0 = 0X00;  //ADC desactivado
8.                         ADCON1=0x0F;    /* Todos entradas/salidas digitales - equivalente en binario ADCON1= 0b00001111*/
9.                         CMCON = 0X07;   //Comparadores desactivados
10.  
11. /*****configuracion de los bits de entradas / salidas del puerto A ******/
12.                         TRISAbits.TRISA0=1; // rA0  como entrada  - para teclaUp y TeclaDebugger
13.                         TRISAbits.TRISA1=1; // rA1  como entrada  - para teclaDown
14.                         TRISAbits.TRISA2=1; // rA2  como entrada  - para teclaSelect
15.                         TRISAbits.TRISA3=1; // rA3  como entrada  - para teclaBack
16.  
17. /*****configuracion de los bits de entradas / salidas del puerto C ******/
18.                         TRISCbits.TRISC2=1; // rC2 como entrada
19.                         TRISCbits.TRISC1=1; // rC1 como entrada
20.                         TRISCbits.TRISC0=1; // rC0 como entrada
21.                                        
22. /*****configuracion de los bits de entradas / salidas del puerto B ******/
23.                         TRISBbits.TRISB7=0; // rB7 como salida
24.                         TRISBbits.TRISB6=0; // rB6 como salida
25.                         TRISBbits.TRISB5=0; // rB5 como salida
26.                         TRISBbits.TRISB4=0; // rB4 como salida
27.                         TRISBbits.TRISB3=0; // rB3 como salida
28.                         TRISBbits.TRISB2=0; // rB2 como salida
29.                         TRISBbits.TRISB1=0; // rB1 como salida
30.                         TRISBbits.TRISB0=0; // rB0 como salida
31.  
32.  
33.        
34. /*****configuración de los bits de entradas / salidas del puerto D ******/
35.                         TRISDbits.TRISD7=0; // rD7  como salida
36.                         TRISDbits.TRISD6=0; // rD6  como salida
37.                         TRISDbits.TRISD5=0; // rD5  como salida
38.                         TRISDbits.TRISD4=0; // rD4  como salida
39.                         TRISDbits.TRISD3=0; // rD3  como salida
40.                         TRISDbits.TRISD2=0; // rD2  como salida
41.                         TRISDbits.TRISD1=0; // rD1  como salida
42.                         TRISDbits.TRISD0=0; // rD0  como salida
43. }

y luego llamarla desde main.

Código: C

1. void main(void)
2. {
3.  inicializarpuertos();
4.  
5. // codigo
6. // codigo
7. // codigo
8.  
9. }

           Con respecto a tu duda sobre la función InitializeSystem verás que si es llamada desde dentro de main.  Y si observas el contenido de la función InitializeSystem encontrarás que llama a la función Userinit();

 Hacé control + f para buscarla dentro de main y vas a encontrar el llamado de la misma aquí:            

Código: C

1. //////////////////TEST USB///////////////////////////////////////////////
2.                         if(MenuPos==4)
3.                                 {       LCDClear();
4.                                     LCDUpdate();//check this
5.                                          
6.                                         if(PORTEbits.RE5==1)
7.                                                 {      
8.                                                 LCDStr(0,USB_C,0);
9.                                                 Delay(300000); 
10.                                                 LCDUpdate();    //clear screen
11.                                                 InitializeSystem();

                Saludos.
                         Jukinch

[macedo]

Hola jukinch, gracias por la explicación, lo que me llama la atención es que en este proyecto cuando testeas una parte configuras los pines en ese momento, yo estoy acostumbrado a configurar todo al principio y por lo general dejarlo así .
Te pregunto, asi yo empeze a configurar los puertos:

Código: C

1. void main(void)
2. {
3.             OSCTUNEbits.PLLEN = 0;  //Disable the PLL
4.             //Configure all I/O pins to use digital input buffers.  The PIC18F87J50 Family devices
5.             //use the ANCONx registers to control this, which is different from other devices which
6.             //use the ADCON1 register for this purpose.
7.             WDTCONbits.ADSHR = 1;   // Select alternate SFR location to access ANCONx registers
8.             ANCON0 = 0xFF;          // Default all pins to digital
9.             ANCON1 = 0xFF;          // Default all pins to digital
10.             WDTCONbits.ADSHR = 0;   // Select normal SFR locations
11.  
12.             TRISA  = 0XFF;          // Config del Puerto A [ RA5 RA4 RA3 RA2 RA1 RA0]
13.                                     //                     [  E   E   E   E   E   E ]  
14.  
15.             TRISB  = 0X00           // Config del Puerto B [ RB7 RB6 RB5 RB4 RB3 RB2 RB1 RB0]
16.                                     //                     [  E   E   E   E   E   E   E   E ]
17.  
18.             TRISC  = 0X83           // Config del Puerto C [ RC7 RC6 RC5 RC4 RC3 RC2 RC1 RC0]
19.                                         //                     [  E   S   S   S   S   S   E   E ]
20.  
21.             TRISD  = 0X20           // Config del Puerto D [ RD7 RD6 RD5 RD4 RD3 RD2 RD1 RD0]
22.                                     //                     [  S   S   E   S   S   S   S   S ]
23.  
24.             TRISE  = 0X23           // Config del Puerto E [ RE7 RE6 RE5 RE4 RE3 RE2 RE1 RE0]
25.                                     //                     [  S   S   E   S   S   S   E   E ]
26.  
27.             TRISF  = 0X08           // Config del Puerto F [ RF7 RF6 RF5 RF4 RF3 RF2 RF1 RF0]
28.                                     //                     [  S   S   S   S   E   S   X   X ]
29.  
30.  
31.             TRISG  = 0X03          // Config del Puerto G [ RG7 RG6 RG5 RG4 RG3 RG2 RG1 RG0]
32.                                        //                     [  X   X   X   S   S   S   E   E ]
33.  
34.             LATA   = 0X00;         // Apagamos todo el puerto A
35.             LATB   = 0X00;         // Apagamos todo el puerto B
36.             LATC   = 0X00;         // Apagamos todo el puerto C
37.             LATD   = 0X00;         // Apagamos todo el puerto D
38.             LATE   = 0X00;         // Apagamos todo el puerto E
39.             LATF   = 0X00;         // Apagamos todo el puerto F
40.             LATG   = 0X00;         // Apagamos todo el puerto G

Pero también esta esta otra posibilidad de configuración de cada puerto:

Código: C

1. //Port B initialization
2.         PORTB=PORTB &  0x00;//0b11111111;
3.         TRISB=TRISB | 0b11111111;

Quiero entender esto:

PORTB=PORTB &  0x00;          // esto es una operacion AND Y borra el puerto o que significa?
TRISB=TRISB | 0b11111111;   // Aca digo como si van a ser entradas o salidas pero con una OR?

Cual de las dos posibilidades es mejor para programar.
Gracias por lo de control + f, funciona!
Saludos

[jukinch]

Macedo: antes de usar los puertos debés configurarlos de acuerdo a tu hard mediante el registro tris.
Pero si luego tu programa requiere cambiar de sentido el pin de un puerto podés cambiar la configuración del tris en cualquier momento.

fuente:
http://www.microchip.com/forums/m569575.aspx
http://ww1.microchip.com/downloads/en/devicedoc/70058d.pdf
http://ww1.microchip.com/downloads/en/appnotes/00234a.pdf
http://informatica.uv.es/iiguia/SBM/manual.pdf pág 21/22

Con respecto a la forma de configurar los puertos podés usar la forma que más te convenga, a mi me gusta la sintaxis que te detallo más abajo porque me permite visualizar mejor cada pin y lo puedo comentar a la derecha.

así:
TRISAbits.TRISA0=1; // rA0  como entrada  - para teclaUp y TeclaDebugger
TRISAbits.TRISA1=1; // rA1  como entrada  - para teclaDown
TRISAbits.TRISA2=1; // rA2  como entrada  - para teclaSelect
TRISAbits.TRISA3=1; // rA3  como entrada  - para teclaBack


PORTB=PORTB &  0x00; // acá se hace una operación and entre PORTB y el valor 0x00 y luego se asigna a PORTB. es una operación a nivel de bit. El and funciona como una máscara o colador que deja pasar los bits que estén en 1. pero como la máscara está en cero (el valor 0x00) no deja pasar nada y pone a todo el puertob en cero.

Te paso ejemplos de  Operadores a nivel de bit (bitwise operators)
--------------------------------------------------------------------------------------------------------------

El operador AND "&" compara dos bits; si los dos son 1 el resultado es 1, en otro caso el resultado será 0.
Ejemplo:

        c1 = 0x45         --> 01000101
        c2 = 0x71         --> 01110001  // fijate que hace de colador
        ---------------------------
        c1 & c2 = 0x41 -->  01000001

--------------------------------------------------------------------------------------------------------------
El operador OR  "|" compara dos bits; si cualquiera de los dos bits es 1, entonces el resultado es 1;
en otro caso será 0. Ejemplo:

        i1 = 0x47      --> 01000111
        i2 = 0x53      --> 01010011
        ---------------------------
        i1 | i2 = 0x57 --> 01010111


--------------------------------------------------------------------------------------------------------------
El operador exclusivo (XOR) "^", da por resultado 1 cuando los dos operandos tienen distinto valor.

Cuando los dos operandos son distintos da 1.-
ej: 1 y 0    =1
    0 y 1    =1

Cuando los dos operandos son iguales da 0.-
    0 y 0    =0
    1 y 1    =0

 Ejemplo:

        i1 = 0x47      --> 01000111
        i2 = 0x53      --> 01010011
        ---------------------------
        i1 ^ i2 = 0x14 --> 00010100

--------------------------------------------------------------------------------------------------------------
El operador de complemento a 1 "~" cambia cada dígito del operando por su opuesto:

si el bit es 1 se cambia por 0 y viceversa


        c = 0x45  --> 01000101
        ----------------------
        ~c = 0xBA --> 10111010

--------------------------------------------------------------------------------------------------------------
Los operadores de desplazamiento a nivel de bit "<<" y ">>" Desplazan a la izquierda o a la derecha un número
especificado de bits.
En un desplazamiento a la izquierda los bits que sobran por el lado izquierdo se descartan y se rellenan los nuevos
espacios con ceros. De manera análoga pasa con los desplazamientos a la derecha.
Veamos un ejemplo:

        c = 0x1C    00011100
c << 1    c = 0x38    00111000
c >> 2    c = 0x07    00000111

Como en binario se trabaja en base dos cada posición de desplazamiento implica dividir o multiplicar por 2
>> divide por 2.
<< multiplica por 2

        c = 0x1C    00011100

c << 1    c = 0x38    00111000 multiplica por 2
c >> 2    c = 0x07    00000111 divide 2 veces por 2 (divide por 4)

[macedo]

    Impresionante gracias!

[macedo]

Hola que es este start:

Código: C

1. start:          UpdateMenu(MenuPos);

En la función main que no puedo encontrar referencias.
Saludos

[macedo]

Ha lo vi, es como una etiqueta (Label) en ASM, el programa hace un "goto start" para volver a empezar:

Código: C

1. //while (!(joystick_left()&& joystick_select() && joystick_down()) );
2.         if(MenuPos == 2) {             
3.                 if(TestUEXT())  test_state=1;
4.                         else    test_state=0;
5.                                         if(test_state)                                 
6.                                         {
7.                                       LCDInit();
8.                                       LCDContrast(0x45);
9.                                           LCDClear();
10.  
11.                                       LCDStr ( 2, uext_test_state, 0 );
12.                                       Delay(500000);
13.                                       //LCDUpdate();
14.                                         //  while(1);
15.                                     }
16.                                     else {
17.                                
18.                                       LCDInit();
19.                                       LCDContrast(0x45);
20.                                                                
21.                                       LCDClear();
22.                                       LCDStr ( 2, uext_test_state, 0 );
23.                                       Delay(500000);
24.                                       LCDUpdate();
25.                                          // while(1);
26.                                     }
27.                                         goto start;    
28.                                 }
29. /

Se puede poner varias etiquetas y volver a ellas con goto?
Saludos

[jukinch]

Es un label. Es una etiqueta para un "mala palabra en C" goto  

buscá en el código y encontrarás esta línea.
 goto start; // esto hace ir al label start al programa.