El proyecto C para PIC no se creará cuando llamo a las funciones definidas por el usuario

-2

Así que estoy intentando configurar una conexión serie UART, y tengo una función llamada UART_INIT para inicializar mi UART, sin embargo, cuando trato de llamarlo, mi proyecto no se compila y no puedo ver por qué. Si solo copio el código de la función a la principal, funciona bien, así que no es lo que estoy haciendo dentro de la función, ese es el problema, es el acto real que llama a la función. Se compila bien cuando defino la función, pero no cuando intento usarla.

También tengo funciones para transmitir datos y cuando los llamo, tengo el mismo problema. Estoy usando un código de un tutorial de UART como plantilla pero un PIC diferente y ajustado (solo usando el bit de transmisión del código por el momento). El ejemplo compila bien, así que es casi seguro que estoy haciendo algo, pero honestamente no tengo idea de qué.

El error que me está dando es

ERROR EN LA CONSTRUCCIÓN (valor de salida 2, tiempo total: 304 ms)

Estoy creando un proyecto para un PIC12F1822 y uso MPLAB v3.35 con el compilador XC8.

Aquí está mi código a continuación:

// PIC12F1822 Configuration Bit Settings

// 'C' source line config statements

// CONFIG1
#pragma config FOSC = INTOSC // Oscillator Selection (INTOSC oscillator: I/O function on CLKIN pin)
#pragma config WDTE = OFF // Watchdog Timer Enable (WDT disabled)
#pragma config PWRTE = OFF // Power-up Timer Enable (PWRT disabled)
#pragma config MCLRE = OFF // MCLR Pin Function Select (MCLR/VPP pin function is digital input)
#pragma config CP = OFF // Flash Program Memory Code Protection (Program memory code protection is disabled)
#pragma config CPD = OFF // Data Memory Code Protection (Data memory code protection is disabled)
#pragma config BOREN = ON // Brown-out Reset Enable (Brown-out Reset enabled)
#pragma config CLKOUTEN = OFF // Clock Out Enable (CLKOUT function is disabled. I/O or oscillator function on the CLKOUT pin)
#pragma config IESO = ON // Internal/External Switchover (Internal/External Switchover mode is enabled)
#pragma config FCMEN = ON // Fail-Safe Clock Monitor Enable (Fail-Safe Clock Monitor is enabled)

// CONFIG2
#pragma config WRT = OFF // Flash Memory Self-Write Protection (Write protection off)
#pragma config PLLEN = ON // PLL Enable (4x PLL enabled)
#pragma config STVREN = ON // Stack Overflow/Underflow Reset Enable (Stack Overflow or Underflow will cause a Reset)
#pragma config BORV = LO // Brown-out Reset Voltage Selection (Brown-out Reset Voltage (Vbor), low trip point selected.)
#pragma config LVP = ON // Low-Voltage Programming Enable (Low-voltage programming enabled)

// #pragma config statements should precede project file includes.
// Use project enums instead of #define for ON and OFF.

#include <xc.h>

#include <stdio.h>
#include <stdlib.h>


/*
 * 
 */
int main(int argc, char** argv) {

    //set oscillator speed
    OSCCONbits.SCS=0b00;
    OSCCONbits.IRCF = 0b1110;
    OSCCONbits.SPLLEN=1;

    //if replace this line with the code from the function, it works fine
    USART_init();

    //doesn't build with the line below either
    //USART_puts("Init complete!\n");

    return (EXIT_SUCCESS);
}

void USART_init(void)
{
    //Enabling transmitter

    TXSTAbits.TXEN = 1; // enable transmitter
    TXSTAbits.SYNC = 0; // Asynchronous mode
    RCSTAbits.SPEN = 1; //Enables USART
    TRISAbits.TRISA0 = 1; // TX pin is input (automatically configured)

    //set up baud rate
    TXSTAbits.BRGH = 1; // high baud rate mode
    SPBRGL = 207; //speed register 


    RCSTAbits.SPEN = 1; // enable USART

}

void USART_putc(unsigned char c)
{
    while (!TXSTAbits.TRMT); // wait until transmit shift register is empty
    TXREG = c; // write character to TXREG and start transmission
}

void USART_puts(unsigned char *s)
{
    while (*s)
    {
        USART_putc(*s); // send character pointed to by s
        s++; // increase pointer location to the next character
    }
}

Este es el código de ejemplo que funciona.

enlace

    

1 respuesta

7

La diferencia entre el código de trabajo y su código es que las funciones en el código de trabajo están declaradas y definidas antes que se usan.

El compilador de C debe ver la función prototipo antes de saber cómo generar el código correcto. Si no, adivinará, y en este caso, la suposición es incorrecta.

Puedes resolver eso moviendo las funciones, o mejor aún, agrega prototipos de funciones antes de tu main :

void USART_init(void);

int main( void )
{
    ...
    USART_init();
    ...
}

void USART_init(void)
{
    //Enabling transmitter
    ....
}

La solución estándar que ayuda tanto a la legibilidad como al desarrollo es poner todas las funciones de USART en un archivo, usart.c , y luego crear el correspondiente archivo header , usart.h . El archivo de encabezado se vería así:

#ifndef USART_H
#define USART_H

void USART_init(void);
void USART_putc(unsigned char c);
void USART_puts(unsigned char *s);

#endif /* USART_H */

Ahora solo tienes que poner #include "usart.h" en la parte superior de tu archivo principal, y todos los demás archivos en los que quieras usarlo. Los #ifndef/#define/#endif son incluyen guardias e inútiles en este caso, pero a menudo se colocan allí para protegerlos contra problemas que podrían provienen de incluir el mismo archivo varias veces.

    
respondido por el pipe

Lea otras preguntas en las etiquetas