www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Deklaration von Zahlen und Wo im C Programm


Autor: Daniel Xxx (daniel_78)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Neuer Versuch, irgendwie ist meine Frage irgendwo gelandet. :-(

Hallo User,

ich hoffe mir kann jemand helfen.
Ich habe Fragen zum Programmaufbau bzw. der Deklaration von Zahlen:

#include <p18cxxx.h>
#pragma config OSC = HS
#pragma config WDT = OFF
#pragma config LVP = OFF


void main (void)
{

    while (1)
  {
Hier messe ich mit dem ADC Temperaturen (ADC Wert und Multiplikation und 
+ oder -). Das Ergebnis ist float und ich mache im nächsten Schritt eine 
ganze Zahl draus.
  }
}


// High priority interrupt vector
#pragma code InterruptVectorHigh = 0x08
void
InterruptVectorHigh (void)
{
  _asm
    goto InterruptHandlerHigh //jump to interrupt routine
  _endasm
}

//---------------------------------------------------------------------- 
------
// High priority interrupt routine
#pragma code
#pragma interrupt InterruptHandlerHigh

void
InterruptHandlerHigh ()
{
  if (INTCONbits.TMR0IF)
    {
Ich habe ein High Interrupt Programm für einen Betriebsstundenzählen. 
Nach Reset werden Tage, Stunden, Minuten und Sekunden mit 0 geladen und 
neu los gezählt.
    }
}

// Low priority interrupt vector
#pragma code InterruptVectorLow = 0x18
void
InterruptVectorLow (void)
{
  _asm
    goto InterruptHandlerLow //jump to interrupt routine
  _endasm
}

//---------------------------------------------------------------------- 
------
// Low priority interrupt routine
#pragma code
#pragma interrupt InterruptHandlerLow

void
InterruptHandlerLow ()
{
  if (INTCONbits.TMR1IF)
    {
Hier sollen die Zahlen/Temperaturen aus dem Hauptprogramm sowie die 
Tage, Stunden, Minuten und Sekunden des Betriebstundenzählers der High 
ISR mit der RS 232 ausgegeben werden.

    }
}


Frage 1: Wie (unsigned char =0 , volatile unsigned char =0, ???) und Wo 
(in der ISR, Hauptprogramm??) deklariere ich die Tage, Stunden, Minuten 
und Sekunden ?? Am Besten in meiner Vorlage zeigen.

Frage 2: Wie (unsigned char =0 , volatile unsigned char =0, ???) und Wo 
deklariere ich die ganzen Zahlen des Hauptprogrammes, welche auch in der 
LOW ISR ausgegeben werden sollen? Am Besten in meiner Vorlage zeigen.

Vielen tausend Dank im Voraus.

Daniel

Autor: Jimmy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Da du ja eine menge Code ausgelassen hast, die erschweren zu ermitteln 
ob du die Variabel Regional oder Global brauchst, würde ich sie Global 
deklarien.

Also direkt unter deine #pragma zeilen.

Ach ja... das Progamm wird nur

""Hier messe ich mit dem ADC Temperaturen (ADC Wert und Multiplikation 
und
+ oder -). Das Ergebnis ist float und ich mache im nächsten Schritt eine
ganze Zahl draus.
""

diesen teil ausführen, oder wird dort auf die anderen Funktionen 
verwiesen?
Und wenn du die Funktionen nach main() schreibst, muss du vor main() für 
jede Funktion ein Prototyp schreiben.

Wenn ich was falsch verstehe, dann poste doch mal dein Code ganz und 
bitte zwischen
 
 damit man es besser lesen kann.

Autor: Jimmy (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
meinte zwischen [ c ] und [ /c ]
(ohne die leerzeichen ;-) )

Autor: Daniel Xxx (daniel_78)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Jimmy,

anbei der Code. Im wesentlichen handelt es sich um Wiederholungen. Wenn 
Du mal einen Blick über den Code werfen könntest wäre ich Dir dankbar. 
Ich bin mir unsicher wie und wo die die Zahlen richtig deklariert werden 
müssen.

Vielen Dank im Voraus.

Daniel
/** I N C L U D E S **********************************************************/ 
#include <p18f4580.h> 
#include <delays.h>                        // für die Warteschleife 
#include <usart.h> 
#include <adc.h> 
#include <stdio.h> 
#include <timers.h> 


#pragma config OSC = HS        //HS Oscillator
#pragma config FCMENB = OFF      //Fail-safe clock monitor disabled
#pragma config IESOB = OFF      //Internal OSC switch over bit
#pragma config PWRT = ON      //Power up timer ON
#pragma config BOR = BOACTIVE    //enabled whenever part is active, SBOREN disabled
#pragma config BORV = 42      // Reset if Vcc smaller 4,2V
#pragma config WDT = ON        //Watchdog ON
#pragma config WDTPS = 4096      //after 16,384 s reset
#pragma config PBADEN = ON      //Pins are configured as analog input channels on Reset
#pragma config LPT1OSC = OFF    //bei 0; Timer1 configured for higher power operation
#pragma config MCLRE = ON      //Reset at MCLR ON
#pragma config LVP = OFF      //LVP OFF  
    
//-------------------------------------------------------------------------------------------------------------------- 
#define UMSCHALTUNG_RL     LATDbits.RD0           // output K01 
#define BRENNERSPERRE     LATDbits.RD1           // output K02 
#define LADEPUMPE        LATDbits.RD2           // output K03 
#define Brenner          PORTBbits.RB6           // input 

//-------------------------------------------------------------------------------------------------------------------- 

void InterruptHandlerHigh (void);
void InterruptHandlerLow (void);

volatile unsigned int AN0;                   //0...65565   VL_HEIZUNG          1,04 mA    1,062 
volatile unsigned int AN1;                   //0...65565   RL_HEIZUNG                1,03 mA    1,014 
volatile unsigned int AN4;                   //0...65565   PUFFER1000_OBEN           1,13 mA    1,125 
volatile unsigned int AN5;                   //0...65565   PUFFER1000_UNTEN        1,13 mA    1,123 
volatile unsigned int AN6;                   //0...65565   HOLZGASER               1,01 mA    0,96 
volatile unsigned int AN7;                   //0...65565   PUFFER1000_MITTE          1,12 mA    1,088 
volatile unsigned int AN8;                   //0...65565   ABGAS             2,80 mA    2,884 
volatile unsigned int AN9;                   //0...65565   AUSSENTEMP.             1,10 
volatile unsigned int AN10;                   //0...65565   TV ÖLOFEN 
volatile unsigned char Zahl = 1;              //0 bis 255                        
volatile unsigned char Runde = 0;


volatile unsigned char sec = 0;
volatile unsigned char minute = 0;
volatile int stunde = 0;
volatile unsigned int tag = 0;


volatile float VL_HEIZUNG;                   //Fließkomma  
volatile float RL_HEIZUNG;                   //Fließkomma 
volatile float PUFFER1000_OBEN;                //Fließkomma 
volatile float PUFFER1000_UNTEN;                //Fließkomma 
volatile float HOLZGASER;                   //Fließkomma 
volatile float PUFFER1000_MITTE;                //Fließkomma 
volatile float ABGAS;                      //Fließkomma 
volatile float AUSSENTEMP;                   //Fließkomma 
volatile float TV_OELPUFFER;                   //Fließkomma 

volatile float HYST_OBEN_EIN;                  //Fließkomma 
volatile float HYST_MITTE_EIN;                //Fließkomma 
volatile float HYST_UNTEN_EIN;                //Fließkomma 
volatile float RL_AUS;                      //Fließkomma 

volatile unsigned int VL_HEIZUNG_1;             //0...65565 
volatile unsigned int RL_HEIZUNG_1;             //0...65565 
volatile unsigned int PUFFER1000_OBEN_1;          //0...65565 
volatile unsigned int PUFFER1000_UNTEN_1;         //0...65565 
volatile unsigned int HOLZGASER_1;               //0...65565 
volatile unsigned int PUFFER1000_MITTE_1;         //0...65565 
volatile unsigned int ABGAS_1;                //0...65565 
volatile unsigned int AUSSENTEMP_1;              //0...65565 
volatile unsigned int TV_OELPUFFER_1;             //0...65565 
volatile unsigned char KommaFaktor = 1;            //0 bis 255          
volatile unsigned char delayADC = 25;            //0 bis 255 DELAY ADC Messung 
volatile unsigned char LCD = 10;               //0 bis 255 DELAY LCD (war 110/ 25 =0,25s)

void main(void) 
{ 

//-----------------------------------------------------------------------------------------------------------------//

T0CONbits.T0PS0 = 1;                //Teiler 1:256
T0CONbits.T0PS1 = 1;                //Teiler 1:256
T0CONbits.T0PS2 = 1;                //Teiler 1:256
T0CONbits.T0PS3 = 0;                //laut Datenblatt (PSA=0)  Vorteiler wird verwendet
T0CONbits.T0SE = 1;                  //H-L wird gezählt
T0CONbits.T0CS = 0;                  //der Takt ist 1/4 des PIC-Taktes
T0CONbits.T08BIT = 0;                //16bit Timer
T0CONbits.TMR0ON = 1;                //enable Timer  0

//-----------------------------------------------------------------------------------------------------------------//

T1CONbits.RD16 = 1;                  //1 = Enables register read/write of TImer1 in one 16-bit operation
T1CONbits.T1RUN = 1;                //1 = Device clock is derived from Timer1 oscillator
T1CONbits.T1CKPS1 = 1;                //Prescale = 8
T1CONbits.T1CKPS0 = 1;                //Prescale = 8
T1CONbits.T1OSCEN = 1;                //1 = Timer1 oscillator is enabled
T1CONbits.TMR1CS = 0;                //0 = Internal clock (FOSC/4)        
T1CONbits.TMR1ON = 1;                //1 = Enables Timer1

PIE1bits.TMR1IE = 1;                 //TMR1 Overflow Interrupt Enable bit
                          //1 = Enables the TMR1 overflow interrupt
IPR1bits.TMR1IP = 0;                //TMR1 Overflow Interrupt Priority bit
                          //1 = High priority
                          //0 = Low priority

//-----------------------------------------------------------------------------------------------------------------//

RCONbits.IPEN = 1;                         //Interrupt Priority Enable bit

//-----------------------------------------------------------------------------------------------------------------//
                          //1 = Enable priority levels on interrupts
INTCONbits.GIEH = 1;                       //Global Interrupt Enable bit
                          //When IPEN = 1:
                          //1 = Enables all high priority interrupts
INTCONbits.GIEL = 1;                //When IPEN = 1:
                          //1 = Enables all low priority peripheral interrupts
INTCONbits.TMR0IE = 1;                //TMR0 Overflow Interrupt Enable bit
                          //1 = Enables the TMR0 overflow interrupt

//-----------------------------------------------------------------------------------------------------------------//

INTCON2bits.TMR0IP =1;                   //TMR0 Overflow Interrupt Priority bit for RTC
                          //1 = High priority
                          //0 = Low priority

INTCON2bits.RBPU = 1;                //PORTB Pull-up Enable bit
                          //1 = All PORTB pull-ups are disabled
                          //0 = PORTB pull-ups are enabled by individual port latch values

//-----------------------------------------------------------------------------------------------------------------//


OpenUSART( USART_TX_INT_OFF &              // Transmit interrupt off 
USART_RX_INT_OFF &                     // Receive interrupt off 
USART_ASYNCH_MODE &                    // Asynchronous mode 
USART_EIGHT_BIT &                     // 8-bit data 
USART_CONT_RX &                     // Continuous reception 
USART_BRGH_HIGH,                     // High baud rate 
25 );                            // 12 für 19200, 25 für 9600 

ADCON0bits.ADON = 1;                   //1 = A/D converter module is enabled 
ADCON0bits.GO = 1;                    //1 = A/D conversion in progress 
ADCON0bits.CHS0 = 0;                   //1010 = Channel 10 (AN9) 
ADCON0bits.CHS1 = 1;                   //1010 = Channel 10 (AN9) 
ADCON0bits.CHS2 = 0;                   //1010 = Channel 10 (AN9) 
ADCON0bits.CHS3 = 1;                   //1010 = Channel 9 (AN9) 
ADCON1bits.PCFG0 = 1;                   //1111  (AN10) A A A A A A A A A A A A A (AN0) 
ADCON1bits.PCFG1 = 1;                   //1111  (AN10) A A A A A A A A A A A A A (AN0) 
ADCON1bits.PCFG2 = 1;                   //1111  (AN10) A A A A A A A A A A A A A (AN0) 
ADCON1bits.PCFG3 = 1;                   //1111  (AN10) A A A A A A A A A A A A A (AN0) 
ADCON1bits.VCFG0 = 1;                   //1 = VREF+ (AN3) 
ADCON1bits.VCFG1 = 0;                   //1 = VREF- (AN2)  Masse =0 
ADCON2bits.ADCS0 = 0;                   //110 = FOSC/64 
ADCON2bits.ADCS1 = 1;                   //110 = FOSC/64 
ADCON2bits.ADCS2 = 1;                   //110 = FOSC/64 
ADCON2bits.ACQT0 = 1;                   //111 = 20 TAD 
ADCON2bits.ACQT1 = 1;                   //111 = 20 TAD 
ADCON2bits.ACQT2 = 1;                   //111 = 20 TAD 
ADCON2bits.ADFM = 1;                   //1 = Right justified 

TRISAbits.TRISA0 = 1;                   // VL_HEIZUNG 
TRISAbits.TRISA1 = 1;                   // RL_HEIZUNG 
TRISAbits.TRISA5 = 1;                   // PUFFER1000_OBEN 
TRISEbits.TRISE0 = 1;                   // PUFFER1000_MITTE 
TRISEbits.TRISE1 = 1;                   // PUFFER1000_UNTEN 
TRISEbits.TRISE2 = 1;                   // PUFFER_OEL 
TRISBbits.TRISB1 = 1;                   // ABGAS 
TRISBbits.TRISB4 = 1;                   // HOLZOFEN 
TRISBbits.TRISB0 = 1;                    // AUSSENTEMP 
TRISDbits.TRISD0 = 0;                   // output K01 UMSCHALTUNG_RL 
TRISDbits.TRISD1 = 0;                   // output K02 
TRISDbits.TRISD2 = 0;                   // output K03 
TRISDbits.TRISD3 = 0;                   // output K04 
TRISCbits.TRISC4 = 0;                   // output K05 
TRISCbits.TRISC5 = 0;                  // output K06 
TRISDbits.TRISD4 = 0;                   // DTR 
TRISBbits.TRISB5 = 0;                   // output LED 
TRISBbits.TRISB6 = 1;                   // input Brennerückmeldung 

TRISCbits.TRISC7 = 1;                   // RX RS232 i.O. getestet 
TRISCbits.TRISC6 = 0;                   // TX RS232 i.O. getestet 


LATDbits.LATD0 = 0;                    // output K01 UMSCHALTUNG_RL 
LATDbits.LATD1 = 0;                 // output K02 Brennersperre
LATDbits.LATD2 = 0;                 // output K03 Ladepumpe


while (1) 
  { 

   
  ClrWdt()                    // clear Watchdog
//--------------------------------------------------------------------------------------------------------// 
     // Messung und Berchnung aller Temperaturen 
      
     Delay10TCYx(delayADC);                 // Vorlauf Heizung messen 
     SetChanADC( ADC_CH0); 
     Delay10TCYx(delayADC); 
     ConvertADC(); 
     Delay10TCYx(delayADC); 
     while( BusyADC() ){}       
     AN0 = ReadADC(); 
     VL_HEIZUNG = (float) AN0 * 0.25667  - 82.95907; 
     VL_HEIZUNG_1 = (float) VL_HEIZUNG * KommaFaktor; 

     Delay10TCYx(delayADC);                  // Rücklauf Heizung messen          
     SetChanADC( ADC_CH1); 
     Delay10TCYx(delayADC); 
     ConvertADC(); 
     Delay10TCYx(delayADC); 
     while( BusyADC() ){}     
     AN1 = ReadADC(); 
     RL_HEIZUNG = (float) AN1 *  0.25916 - 82.95907; 
     RL_HEIZUNG_1 = (float) RL_HEIZUNG * KommaFaktor; 

     Delay10TCYx(delayADC);                  // 1000l Puffer oben messen          
     SetChanADC( ADC_CH4); 
     Delay10TCYx(delayADC); 
     ConvertADC();           
     Delay10TCYx(delayADC); 
     while( BusyADC() ){} 
     AN4 = ReadADC(); 
     PUFFER1000_OBEN = (float) AN4 * 0.23623 - 82.95907; // 26,xxx 
     PUFFER1000_OBEN_1 = (float) PUFFER1000_OBEN * KommaFaktor; 

     Delay10TCYx(delayADC);                  // 1000l Puffer unten messen         
     SetChanADC( ADC_CH5); 
     Delay10TCYx(delayADC); 
     ConvertADC(); 
     Delay10TCYx(delayADC); 
     while( BusyADC() ){} 
     AN5 = ReadADC(); 
     PUFFER1000_UNTEN = (float) AN5 * 0.23623 - 82.95907;   
     PUFFER1000_UNTEN_1 = (float) PUFFER1000_UNTEN * KommaFaktor; 

     Delay10TCYx(delayADC);                  // HOLZGASER messen       
     SetChanADC( ADC_CH6); 
     Delay10TCYx(delayADC); 
     ConvertADC(); 
     Delay10TCYx(delayADC);     
     while( BusyADC() ){} 
     AN6 = ReadADC(); 
     HOLZGASER = (float) AN6 * 0.26430 - 82.95907;  // 87.749070 war am 02.04.09 
     HOLZGASER_1 = (float) HOLZGASER * KommaFaktor; 

     Delay10TCYx(delayADC);                  //          
     SetChanADC( ADC_CH7); 
     Delay10TCYx(delayADC); 
     ConvertADC(); 
     Delay10TCYx(delayADC);   
     while( BusyADC() ){} 
     AN7 = ReadADC(); 
     PUFFER1000_MITTE = (float) AN7 * 0.23834 - 82.95907; 
     PUFFER1000_MITTE_1 = (float) PUFFER1000_MITTE * KommaFaktor; 

     Delay10TCYx(delayADC);                  // Abgastemperatur messen          
     SetChanADC( ADC_CH8); 
     Delay10TCYx(delayADC); 
     ConvertADC(); 
     Delay10TCYx(delayADC); 
     while( BusyADC() ){}     
     AN8 = ReadADC(); 
     ABGAS = (float) AN8 * 1.1772 - 272.82; 
     ABGAS_1 = (float) ABGAS * KommaFaktor; 


     Delay10TCYx(delayADC);                      // Aussentemp.messen         
     SetChanADC( ADC_CH9); 
     Delay10TCYx(delayADC); 
     ConvertADC(); 
     Delay10TCYx(delayADC); 
     while( BusyADC() ){} 
     AN9 = ReadADC(); 
     AUSSENTEMP = (float) AN9 * 0.3082 - 113.3766;       // 
     AUSSENTEMP_1 = (float) AUSSENTEMP * KommaFaktor; 

     Delay10TCYx(delayADC);                      // TV Oelpuffer messen         
     SetChanADC( ADC_CH10); 
     Delay10TCYx(delayADC); 
     ConvertADC(); 
     Delay10TCYx(delayADC); 
     while( BusyADC() ){} 
     AN10 = ReadADC(); 
     TV_OELPUFFER = (float) AN10 * 0.299033 - 101.664316;  //war 98 
     TV_OELPUFFER_1 = (float) TV_OELPUFFER * KommaFaktor; 

//--------------------------------------------------------------------------------------------------------// 
     
     HYST_OBEN_EIN = (float) PUFFER1000_OBEN  - 7; 
     HYST_UNTEN_EIN = (float) PUFFER1000_UNTEN  - 7; 
     RL_AUS = (float) RL_HEIZUNG  + 3; 
  } 
} 



//--------------------------------------------------------------------------------------------------------// 
// High priority interrupt vector 
#pragma code InterruptVectorHigh = 0x08 
void 
InterruptVectorHigh (void) 
{ 
_asm 
   goto InterruptHandlerHigh                                   //jump to interrupt routine 
_endasm 
} 
//--------------------------------------------------------------------------------------------------------// 
// High priority interrupt routine 
#pragma code 
#pragma interrupt InterruptHandlerHigh 


void 
InterruptHandlerHigh () 
{ 

    if (INTCONbits.TMR0IF) 
         {   
      INTCONbits.TMR0IF = 0;                       //clear interrupt flag 
      WriteTimer0(61630);   
      INTCONbits.GIEH = 0;                                   //disable interrupts
 
              if ( sec<59 )
            {
              sec++;
            }
            else
              {
                sec=0;
                if ( minute<59 )
                  {
                    minute++;
                  }
            else
                  {
                    minute= 0;
                    if (stunde<23 )
                      {
                        stunde++;
                       }
                    else
                          {
                            stunde = 0;
                 tag++;
                }

            }
          }
      
      INTCONbits.TMR0IE = 1;                       //Enables the TMR0 overflow interrupt
      INTCONbits.GIEH = 1;                               //enable interrupts


      }    

}




 
//--------------------------------------------------------------------------------------------------------// 
// Low priority interrupt vector 
#pragma code InterruptVectorLow = 0x18 
void 
InterruptVectorLow (void) 
{ 
_asm 
   goto InterruptHandlerLow                                   //jump to interrupt routine 
_endasm 
} 
//--------------------------------------------------------------------------------------------------------// 
// Low priority interrupt routine 
#pragma code 
#pragma interrupt InterruptHandlerLow 

char buffer[20]; 
int i = 0xA12; 





void free_buffer(char* array)
{
  int i;                  //Laufvariable deklarieren
  int len;                //Variable für die Länge deklarieren

  len = sizeof(array) / sizeof(char);    //Länge ermitteln
  for(i=0;i<len;i++)            //In einer for-Schleife alle
    array[i]='\0';            //Felder mit terminierter Null
                      //belegen
}


void 
InterruptHandlerLow () 
{ 


    if (PIR1bits.TMR1IF) 
      {
      PIE1bits.TMR1IE = 1;                                         //0 = Disables the TMR1 overflow interrupt
      PIR1bits.TMR1IF = 0;                                        //clear interrupt flag 
      Runde++;
             free_buffer(buffer); 

      if  (Runde==8)
        {
        Runde = 0;
        

          if (Zahl==1) 
           { 
           putrsUSART ("\x1b\x66\xd\xa");                                     // Clear Display 
           Delay10KTCYx(LCD); 
          putrsUSART ("VL HEIZUNG    \r\n");  
           free_buffer(buffer);     
          sprintf(buffer,"%d \r\n",VL_HEIZUNG_1);                                // integer Dezimalzahl 
          putsUSART(buffer);  
           Delay10KTCYx(LCD);                                       
           putrsUSART ("\x1b\x6F\x40\xd\xa");                                   // 2 Zeile 1 Spalte   
           Delay10KTCYx(LCD); 
           putrsUSART ("RL HEIZUNG    \r\n"); 
           free_buffer(buffer); 
           sprintf(buffer,"%d \r\n",RL_HEIZUNG_1);                                // integer Dezimalzahl 
           putsUSART(buffer); 
            } 
  
              if (Zahl ==2) 
              { 
              putrsUSART ("\x1b\x66\xd\xa");                                    // Clear Display 
              Delay10KTCYx(LCD); 
              putrsUSART ("PUFFER O. M. U.   \r\n"); 
              Delay10KTCYx(LCD); 
              putrsUSART ("\x1b\x6F\x40\xd\xa");                                // 2 Zeile 1 Spalte   
              Delay10KTCYx(LCD); 
              free_buffer(buffer); 
              sprintf(buffer,"%d \r\n",PUFFER1000_OBEN_1);                           // integer Dezimalzahl 
              putsUSART(buffer); 
              Delay10KTCYx(LCD);     
              putrsUSART ("\x1b\x6F\x47\xd\xa");                                // 2 Zeile 8 Spalte   
              Delay10KTCYx(LCD); 
              free_buffer(buffer); 
              sprintf(buffer,"%d \r\n",PUFFER1000_MITTE_1);                         // integer Dezimalzahl 
              putsUSART(buffer); 
              Delay10KTCYx(LCD); 
              putrsUSART ("\x1b\x6F\x4E\xd\xa");                                // 2 Zeile 15 Spalte   
              Delay10KTCYx(LCD); 
              free_buffer(buffer); 
              sprintf(buffer,"%d \r\n",PUFFER1000_UNTEN_1);                         // integer Dezimalzahl 
              putsUSART(buffer); 
            }
 
                 if (Zahl ==3) 
                { 
                 putrsUSART ("\x1b\x66\xd\xa");                                 // Clear Display 
                 Delay10KTCYx(LCD); 
                putrsUSART ("OELBRENNER    \r\n"); 
                 free_buffer(buffer); 
                 sprintf(buffer,"%d \r\n",TV_OELPUFFER_1);                         // integer Dezimalzahl 
                 putsUSART(buffer); 
                 Delay10KTCYx(LCD);  
                          free_buffer(buffer); 

                 if(AUSSENTEMP_1>=10) 
                  { 
                  putrsUSART ("\x1b\x6F\x40\xd\xa");                            // 2 Zeile 1 Spalte   
                  Delay10KTCYx(LCD); 
                  putrsUSART ("AUSSENTEMP.   \r\n"); 
                  Delay10KTCYx(LCD); 
                  free_buffer(buffer); 
                  sprintf(buffer,"%d \r\n",AUSSENTEMP_1);                         // integer Dezimalzahl 
                  putsUSART(buffer); 
                  } 
                   if(AUSSENTEMP_1<10 && AUSSENTEMP_1>=0) 
                   { 
                  putrsUSART ("\x1b\x6F\x40\xd\xa");                            // 2 Zeile 1 Spalte   
                  Delay10KTCYx(LCD);
                  putrsUSART ("AUSSENTEMP.    \r\n"); 
                  Delay10KTCYx(LCD); 
                  free_buffer(buffer); 
                  sprintf(buffer,"%d \r\n",AUSSENTEMP_1);                         // integer Dezimalzahl 
                  putsUSART(buffer); 
                  } 
                   if(AUSSENTEMP_1<0 && AUSSENTEMP_1>=-9) 
                   { 
                  putrsUSART ("\x1b\x6F\x40\xd\xa");                            // 2 Zeile 1 Spalte   
                  Delay10KTCYx(LCD); 
                  putrsUSART ("AUSSENTEMP.   \r\n"); 
                  Delay10KTCYx(LCD); 
                  free_buffer(buffer); 
                  sprintf(buffer,"%d \r\n",AUSSENTEMP_1);                         // integer Dezimalzahl 
                  putsUSART(buffer); 
                  } 
                   if(AUSSENTEMP_1<=-10 ) 
                  { 
                  putrsUSART ("\x1b\x6F\x40\xd\xa");                            // 2 Zeile 1 Spalte   
                  Delay10KTCYx(LCD); 
                  putrsUSART ("AUSSENTEMP.  \r\n"); 
                  Delay10KTCYx(LCD); 
                  free_buffer(buffer); 
                  sprintf(buffer,"%d \r\n",AUSSENTEMP_1);                         // integer Dezimalzahl 
                  putsUSART(buffer); 
                  } 
              } 
    
                 if (Zahl ==4) 
                   {  
                    free_buffer(buffer); 
                    putrsUSART ("\x1b\x66\xd\xa");                                 // Clear Display 
                    Delay10KTCYx(LCD); 
                 
                  if (LATDbits.LATD0 == 1) 
                      { 
                      putrsUSART ("RL ANHEBUNG   AN \r\n"); 
                      } 
  
                     if (LATDbits.LATD0 == 0) 
                      { 
                      putrsUSART ("RL ANHEBUNG  AUS \r\n"); 
                      } 
                      Delay10KTCYx(LCD);  
                      putrsUSART ("\x1b\x6F\x40\xd\xa");                              // 2 Zeile 1 Spalte 
                      Delay10KTCYx(LCD);       
                 
                  if (LATDbits.LATD2 == 1) 
                      { 
                      putrsUSART ("PUMPE PUFFER  AN \r\n"); 
                      } 
                 
                  if (LATDbits.LATD2 == 0) 
                      { 
                      putrsUSART ("PUMPE PUFFER AUS \r\n"); 
                      } 
                   } 
    
                       if (Zahl ==5) 
                       {  
                      putrsUSART ("\x1b\x66\xd\xa");                               // Clear Display 
                      Delay10KTCYx(LCD); 
      
                        if (LATDbits.LATD1 == 1) 
                        { 
                        putrsUSART ("BRENNER GESPERRT\r\n"); 
                        } 
                        if (LATDbits.LATD1 == 0) 
                        { 
                        putrsUSART ("BRENNER     FREI\r\n"); 
                        } 
                        Delay10KTCYx(LCD); 
                        if( ABGAS_1<100 ) 
                        { 
                        putrsUSART ("\x1b\x6F\x40\xd\xa");                          // 2 Zeile 1 Spalte   
                        Delay10KTCYx(LCD); 
                        putrsUSART ("ABGASTEMP.    \r\n"); 
                        Delay10KTCYx(LCD); 
                        free_buffer(buffer); 
                        sprintf(buffer,"%d \r\n",ABGAS_1);                         // integer Dezimalzahl 
                        putsUSART(buffer); 
                        } 
                        if( ABGAS_1>=100 ) 
                        { 
                        putrsUSART ("\x1b\x6F\x40\xd\xa");                          // 2 Zeile 1 Spalte   
                        Delay10KTCYx(LCD); 
                        putrsUSART ("ABGASTEMP.   \r\n"); 
                        Delay10KTCYx(LCD); 
                        free_buffer(buffer); 
                        sprintf(buffer,"%d \r\n",ABGAS_1);                         // integer Dezimalzahl 
                        putsUSART(buffer); 
                        } 
                   } 

                          if (Zahl ==6) 
                        {  
                           { 
                           free_buffer(buffer); 
                           putrsUSART ("\x1b\x66\xd\xa");                           // Clear Display 
                           Delay10KTCYx(LCD); 
                           putrsUSART ("HOLZGASER     \r\n"); 
                           free_buffer(buffer); 
                           sprintf(buffer,"%d \r\n",HOLZGASER_1);                     // integer Dezimalzahl 
                           putsUSART(buffer); 
                           Delay10KTCYx(LCD); 
                           } 
          
                           if (PUFFER1000_OBEN < 68 && TV_OELPUFFER < 68 ) 
                           { 
                           Delay10KTCYx(LCD); 
                           putrsUSART ("\x1b\x6F\x40\xd\xa");                        // 2 Zeile 1 Spalte 
                           Delay10KTCYx(LCD); 
                           putrsUSART ("JETZT FEUERN !!!\r\n"); 
                           Delay10KTCYx(LCD); 
                           } 
                        }    

                      if (Zahl ==7) 
                          {  
                           putrsUSART ("\x1b\x66\xd\xa");                           // Clear Display 
                           Delay10KTCYx(LCD);
                      free_buffer(buffer);  
                      sprintf(buffer,"%d \r\n",tag); 
                      putsUSART(buffer); 
                      Delay10KTCYx(LCD);
                      //putrsUSART ("T\r\n");
                    
                      Delay10KTCYx(LCD);
                      free_buffer(buffer); 
                      sprintf(buffer,"%d \r\n",stunde); 
                      putsUSART(buffer); 
                      Delay10KTCYx(LCD);
                      //putrsUSART ("h\r\n");

                      Delay10KTCYx(LCD); 
                      free_buffer(buffer);
                      sprintf(buffer,"%d \r\n",minute);
                      putsUSART(buffer);  
                      Delay10KTCYx(LCD);
                      //putrsUSART ("min\r\n");

                      Delay10KTCYx(LCD); 
                      free_buffer(buffer);
                      sprintf(buffer,"%d \r\n",sec); 
                      putsUSART(buffer); 
                      Delay10KTCYx(LCD);
                      //putrsUSART ("s\r\n");
                      }

                        if (Zahl ==8) 
                          { 
                          
//--------------------------------------------------------------------------------------------------------// 
     
                             if( HYST_OBEN_EIN >= RL_HEIZUNG && LATDbits.LATD1 == 1  )                       // Puffer muss o./u. +7 Grad mehr/gleich haben als RL und Brenner gesperrt für Umschaltung ( && HYST_UNTEN_EIN >= RL_HEIZUNG ) 
                              {  
                              LATDbits.LATD0 = 1;                                       // RL AN 
                              } 
                            if( PUFFER1000_OBEN <= RL_AUS && PUFFER1000_UNTEN <= RL_AUS && LATDbits.LATD1 == 0  )     //wenn RL 3 Grad kälter/gleich als Puffer oder Brenner frei erfolgt Umschaltung  (&& PUFFER1000_UNTEN < RL_AUS) raus genommen 
                            { 
                              LATDbits.LATD0 = 0;                                       // RL AUS 
                              } 

                          //--------------------------------------------------------------------------------------------------------// 

                          if ((HOLZGASER > 60 && ABGAS_1 > 200) || HOLZGASER > 86  ) 
                          {
                          LATDbits.LATD2 = 1;                                     // Pumpe AN 
                          }

                          if (HOLZGASER > 63 && ABGAS_1 < 130 && HOLZGASER < 84)  
                          {
                          LATDbits.LATD2 = 0;                                     // Pumpe AUS 
                          }

                          //--------------------------------------------------------------------------------------------------------// 

                             if (TV_OELPUFFER > 55 && PUFFER1000_OBEN > 50)                         // Brennersteuerung 
                              { 
                              LATDbits.LATD1 = 1;                                         // Brenner gesperrt 
                              } 
                             if (TV_OELPUFFER < 50 && PUFFER1000_OBEN < 45)                         // ODER draus machen !!!!!!
                              { 
                              LATDbits.LATD1 = 0;                                         // Brenner frei 
                              } 
                        
                        Zahl = 0; 
                          } 
//--------------------------------------------------------------------------------------------------------// 

        Zahl++; 
        }
        
      PIE1bits.TMR1IE = 1;       //1 = Enables the TMR1 overflow interrupt
         } 
}

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Daniel Xxx schrieb:
> Hallo Jimmy,
>
> anbei der Code. Im wesentlichen handelt es sich um Wiederholungen. Wenn
> Du mal einen Blick über den Code werfen könntest wäre ich Dir dankbar.
> Ich bin mir unsicher wie und wo die die Zahlen richtig deklariert werden
> müssen.

Welche Zahlen?
Zahlen werden nicht deklariert.

Variablen werden deklariert bzw. definiert!

Und wo man sie genau definiert, hängt davon ab, wer aller auf diese 
Variablen zugreifen können soll.
Vereinfacht gesagt ist die Sichtbarkeit einer Variablen immer der 
einschliessende { } Block. Variablen, die in keinem Block sind, sind 
globale Variablen und in allen Blöcken sichtbar.
int i;     // dieses i ist in keinem Block, und daher überall sichtbar

void foo()
{
  int k;     // dieses k ist nur in der Funktion foo sichtbar, weil
             // die Funktion selbst mit ihrem { }-Block die Sichtbarkeit
             // beschränkt  ....
}

void bar()
{
  int k;     // ... daher ist dieses k ein völlig anderes k, als das
             // in foo
}

void foobar()
{
   int j;

   if( ... )
   {            // hier beginnt wieder ein Block im Block
      int m;    // dieses m ist nur im inneren Block sichtbar ...
      ....
   }
 
                // ... und existiert in dieser Blockebene nicht mehr
                // wohl aber das j, welches ja im äusseren Block
                // definiert wurde
}

Im Grunde reicht es vom Ort der Verwendung einer Variablen, alle Blöcke 
nach aussen zu durchsuchen, ob die gesuchte Variable in diesem Block 
gefunden werden kann.

Und anhand dieser Regeln entscheidest du, in welcher 
Block-Hierarchiestufe du Variablen anordnen möchtest. Man möchte 
Variablen normalerweise in den am tiefsten geschachtelten Block legen. 
Wird das m in foobar() nur in diesem if gebraucht, dann ist es dort gut 
aufgehoben auch wenn man es theoretisch in der Blockhierarchie auch 
weiter nach aussen schieben könnte. Aber: Je weiter nach aussen man eine 
Variable verlagert, desto größer wird auch der Kreis der potentiellen 
Code-Kandidaten, die diese Variable (unabsichtlich) verändern können. Es 
wird so immer schwieriger zu überblicken wann sich eine Variable warum 
verändert hat. Daher möchte man als Programmierer die Sichtbarkeit so 
weit als möglich einschränken.

Soweit zur generellen Software-Theorie.
In der µC-Programmierung gibt es noch andere Themenkreise zu 
berücksichtigen, aber als Grundregel sollte das reichen.

> void free_buffer(char* array)
> {
>   int i;                  //Laufvariable deklarieren
>   int len;                //Variable für die Länge deklarieren
>
>   len = sizeof(array) / sizeof(char);    //Länge ermitteln

Das geht so nicht.
In dieser Funktion ist array einfach nur ein Pointer. Aus dem Pointer 
ist nicht mehr ablesbar, wie gross das Array ist, auf das er 
möglicherweise zeigt.

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Bitte, bitte, kauf dir ein C-Buch, und versuche, daß Konzept und den 
Sinn von Funktionen bzw. Unterprogrammen zu verstehen. Dabei wird auch 
deine Ausgangsfrage nebenbei mit beantwortet.

Oliver

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.