La opcion #INCLUDE "Esto"

[oriolba0007]

Hola a tod@s otra vez :

He hecho varios programas en PIC-C, con sus rutinas, sus variables globales, constantes ..etc cada uno.

Ahora quiero hacer un MEGAprograma que usará todos estos subprogramas que he diseñado ( estan compilados y funcionan bien por separado ).

Se que lo puedo hacer usando la instruccion #Include XXXX pero no tengo ni idea de como!

De momento tengo todos los Subprogramas con esta estructura ;

//Variables Globales//
//Constantes//
//Rutinas//

//Programa//

Void main () {
el programa hace cosas
}

Ilustrarme Ohhhhh todopoderosos Programadores de PICS en C !!!!!

[nordestenica]

yo creo que es lo mas simples de entender en ccs e es facil

por exemplo si quieres usar un 16f84 tendras que poner esto
#include <16F84A.H>
si quieres usar un 16f877 esto tendrias que poner
#include <16F877A.H>
si usas LCD esto tendrias que estar
#include <MI LCD .H>( la controladora de lcd  que uses )

este es un exemplo que me esta dando dolores de cabeca no esta completo ya que mal consigo acer funcionar la lcd pero sirve para lo que queremos la idea es acer que en una lcd nos diga la fecha ,  la hora ,que me despierte si es tarde e todas essas cosas que se puede acer com el DS1307

#include <16F628.H>//el processador
#include <DS1307.H>//libreria del relo ds1307

#use standard_io ( A )
#use standard_io ( B )
#use delay ( clock = 6000000 )




/* LCD STUFF */
#define LCD_D0  PIN_B4
#define LCD_D1  PIN_B5
#define LCD_D2  PIN_B6
#define LCD_D3  PIN_B7
#define LCD_EN  PIN_B1
#define LCD_RS  PIN_B2
#define FIRST_LINE  0x00
#define SECOND_LINE 0x40
#define CLEAR_DISP  0x01



#use standard_io ( A )
#use standard_io ( B )
//#use standard_io ( C )


void LCD_Init ( void );
void LCD_SetPosition ( unsigned int cX );
void LCD_PutChar ( unsigned int cX );
void LCD_PutCmd ( unsigned int cX );
void LCD_PulseEnable ( void );
void LCD_SetData ( unsigned int cX );

/******************************************************************************/

void main ( void )
    {
    char cX;


    // initilize screen
    LCD_Init();
   // delay_us(45);
    LCD_PutCmd ( CLEAR_DISP );
    //delay_us(45);
   LCD_SetPosition ( FIRST_LINE );
    printf ( LCD_PutChar, "" );
     LCD_SetPosition ( SECOND_LINE );
    printf ( LCD_PutChar, "      v1.1      " );
    delay_ms ( 100 );
    LCD_SetPosition ( FIRST_LINE );
    printf ( LCD_PutChar, "" );
    LCD_SetPosition ( SECOND_LINE );
    printf ( LCD_PutChar, "" );



}

void LCD_Init ( void )
    {
    LCD_SetData ( 0x00 );
    delay_ms ( 400 );       /* wait enough time after Vdd rise */
    output_low ( LCD_RS );
    LCD_SetData ( 0x03 );   /* init with specific nibbles to start 4-bit mode */
    LCD_PulseEnable();
    LCD_PulseEnable();
    LCD_PulseEnable();
    LCD_SetData ( 0x02 );   /* set 4-bit interface */
    LCD_PulseEnable();      /* send dual nibbles hereafter, MSN first */
    LCD_PutCmd ( 0x2C );    /* function set (all lines, 5x7 characters) */
    LCD_PutCmd ( 0x0C );    /* display ON, cursor off, no blink */
    LCD_PutCmd ( 0x01 );    /* clear display */
    LCD_PutCmd ( 0x06 );    /* entry mode set, increment */
    }

void LCD_SetPosition ( unsigned int cX )
    {
    /* this subroutine works specifically for 4-bit Port A */
    LCD_SetData ( swap ( cX ) | 0x08 );
    LCD_PulseEnable();
    LCD_SetData ( swap ( cX ) );
    LCD_PulseEnable();
    }

void LCD_PutChar ( unsigned int cX )
    {
    /* this subroutine works specifically for 4-bit Port A */
    output_high ( LCD_RS );
    LCD_SetData ( swap ( cX ) );     /* send high nibble */
    LCD_PulseEnable();
    LCD_SetData ( swap ( cX ) );     /* send low nibble */
    LCD_PulseEnable();
    output_low ( LCD_RS );
    }

void LCD_PutCmd ( unsigned int cX )
    {
    /* this subroutine works specifically for 4-bit Port A */
    LCD_SetData ( swap ( cX ) );     /* send high nibble */
    LCD_PulseEnable();
    LCD_SetData ( swap ( cX ) );     /* send low nibble */
    LCD_PulseEnable();
    }

void LCD_PulseEnable ( void )
    {
    output_high ( LCD_EN );
    delay_us(10);
    output_low ( LCD_EN );
    delay_ms(5);
    }

void LCD_SetData ( unsigned int cX )
    {
    output_bit ( LCD_D0, cX & 0x01 );
    output_bit ( LCD_D1, cX & 0x02 );
    output_bit ( LCD_D2, cX & 0x04 );
    output_bit ( LCD_D3, cX & 0x08 );
    }


 

[oriolba0007]

Gracias por la contestacion nordestenica pero no me referia a esto

Me explico mejor :

Yo tengo hechos varios programas, el estilo de estos programas és

#include "16f877.h"              
#Fuses NO SE AUN BIEN KOMO IRAN  

//Declaracion de variables globales

//otras variables
//Declaracion de Constantes
     int Tabla1[4];
     int Tabla2[4];
     int Tabla3[4];
     int E;

//Rutinas

//Programa: el programa ma o menos es asi :

void main () {
         "Aki el programa opera"
         "Al final se termina, me interessa el contenido de estas variables ( ahora
           estan llenas :
                  int Tabla1[4];
                  int Tabla2[4];
                  int Tabla3[4];
                  int E; )"              }


Como este programa tengo varios ( un total de 5 ).
Por separado funcionan correctamente ( en ellos he usado timers i interrupciones ).

Lo ke kiero hacer es un programa grande que use estos programas como rutinas.
MAs o menos se que se haria asi :
       en lugar de "Void Main ()" pondria algo asi como :

                                       "INT Programito1 (por aki tienen ke ir las variables ke
                                         kiero, pero no se como meterlas ) {

El programa Principal seria mas o menos asi :

#include programita1
/variables globales

void main () {
       programita1 (aki pondria las variables ke me interesan del programita1, no se
                           komo );
       Ahora seguiria el programa operando con las variables Tabla1,2,3 i E
}

Hasta pronto =
                             

[manex_1987]

Veamos, si las variables van a ser usadas por todas las subrutinas, no puedes declararlas en cada una de ellas.

#include <16f84.h>
#FUSES ..............

//variables globales

int tabla1[4]
int tabla2[4]
int tabla3[4]

//incluimos programas que contienen SUBRUTINAS
 
#include <progra1.h> // contiene subrutina void main2();
#include <progra2.h> // contiene subrutina void main3();

//luego iria el principal

void main()
{
main2;
main3;
}

------------

Luego, mencionas un INT, pero no le encuentro sentido. Las subrutinas saltarán mediante instrucciones del programa, o mediante interrupciones?

salu2

[oriolba0007]

Saltaran mediante programa, pero algunas de ellas activaran interrupciones del PIC.

Tengo un programa que usa la interrupcion RB0, lo tengo configurado como tal para que lo haga. Lo quiero convertir en una gran Rutina que me devuelva como resultado una Structure. Luego guardaria el programa como programa1.h ( supongo )

Crearia ahora un programa principal, en la cabecera d este programa és cuando meteria el #include programa1.h,

Lo que no se hacer :

Que tengo que guardar en programa1.h, que tengo que guardar en programa1.c

Como tengo que hacer la cabecera de la funcion, como la tengo que llamar.

Las variables que me interessan del programa1, una vez ejecutado son :

Tabla1[4] ( 4 posiciones )
Tabla2[4] ( 4 pos. )
Tabla3[4] ( 4 pos. )
E

Todas las variables son tipo "INT".

Otra manera que tambien me vale és que el programa me devuelva la Estructura1, que seria :

Struct Estructura {
Tabla1[4] ( 4 posiciones )
Tabla2[4] ( 4 pos. )
Tabla3[4] ( 4 pos. )
E
} Estructura1 ;

Espero contestacion

[manex_1987]

Si quieres llamar las rutinas mediante interrupciones, es muy simple. Que cuando salte la interrupcion, active un flag (nada, un INT o un BOOLEAN basta), y que luego en el programa principal, se compruebe este flag , y si esta activado, que salte el subprograma.

No dejas muy claro, si tus "subprogramas" seran subrutinas O funciones... si lo que quieres es, que las variables usadas por el programa principal esten tambien usadas por los subs... no tienes mas que declarar las variables al principio.

RECUERDA que debes de declararlas ANTES de cualquier "uso" de ellas, de lo contrario el compilador te llorará diciendo que la variable no existe.

Porque en realidad, cuando tu realizas un #INCLUDE, lo que estas haciendo es INCLUIR el archivo es decir, añadirlo al programa (aunque luego el compilador solo se queda con las funciones que realmente son usadas).

espero haberte aclarado algo.