Deklaration von Zahlen und Wo im C Programm

Daniel X. OP #1551985
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
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Jimmy Gast #1552238
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Daniel X. OP #1552546
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

1
/** I N C L U D E S **********************************************************/ 

2
#include <p18f4580.h> 

3
#include <delays.h>                        // für die Warteschleife 

4
#include <usart.h> 

5
#include <adc.h> 

6
#include <stdio.h> 

7
#include <timers.h> 

8


9


10
#pragma config OSC = HS        //HS Oscillator

11
#pragma config FCMENB = OFF      //Fail-safe clock monitor disabled

12
#pragma config IESOB = OFF      //Internal OSC switch over bit

13
#pragma config PWRT = ON      //Power up timer ON

14
#pragma config BOR = BOACTIVE    //enabled whenever part is active, SBOREN disabled

15
#pragma config BORV = 42      // Reset if Vcc smaller 4,2V

16
#pragma config WDT = ON        //Watchdog ON

17
#pragma config WDTPS = 4096      //after 16,384 s reset

18
#pragma config PBADEN = ON      //Pins are configured as analog input channels on Reset

19
#pragma config LPT1OSC = OFF    //bei 0; Timer1 configured for higher power operation

20
#pragma config MCLRE = ON      //Reset at MCLR ON

21
#pragma config LVP = OFF      //LVP OFF  

22
    

23
//-------------------------------------------------------------------------------------------------------------------- 

24
#define UMSCHALTUNG_RL     LATDbits.RD0           // output K01 

25
#define BRENNERSPERRE     LATDbits.RD1           // output K02 

26
#define LADEPUMPE        LATDbits.RD2           // output K03 

27
#define Brenner          PORTBbits.RB6           // input 

28


29
//-------------------------------------------------------------------------------------------------------------------- 

30


31
void InterruptHandlerHigh (void);

32
void InterruptHandlerLow (void);

33


34
volatile unsigned int AN0;                   //0...65565   VL_HEIZUNG          1,04 mA    1,062 

35
volatile unsigned int AN1;                   //0...65565   RL_HEIZUNG                1,03 mA    1,014 

36
volatile unsigned int AN4;                   //0...65565   PUFFER1000_OBEN           1,13 mA    1,125 

37
volatile unsigned int AN5;                   //0...65565   PUFFER1000_UNTEN        1,13 mA    1,123 

38
volatile unsigned int AN6;                   //0...65565   HOLZGASER               1,01 mA    0,96 

39
volatile unsigned int AN7;                   //0...65565   PUFFER1000_MITTE          1,12 mA    1,088 

40
volatile unsigned int AN8;                   //0...65565   ABGAS             2,80 mA    2,884 

41
volatile unsigned int AN9;                   //0...65565   AUSSENTEMP.             1,10 

42
volatile unsigned int AN10;                   //0...65565   TV ÖLOFEN 

43
volatile unsigned char Zahl = 1;              //0 bis 255                        

44
volatile unsigned char Runde = 0;

45


46


47
volatile unsigned char sec = 0;

48
volatile unsigned char minute = 0;

49
volatile int stunde = 0;

50
volatile unsigned int tag = 0;

51


52


53
volatile float VL_HEIZUNG;                   //Fließkomma  

54
volatile float RL_HEIZUNG;                   //Fließkomma 

55
volatile float PUFFER1000_OBEN;                //Fließkomma 

56
volatile float PUFFER1000_UNTEN;                //Fließkomma 

57
volatile float HOLZGASER;                   //Fließkomma 

58
volatile float PUFFER1000_MITTE;                //Fließkomma 

59
volatile float ABGAS;                      //Fließkomma 

60
volatile float AUSSENTEMP;                   //Fließkomma 

61
volatile float TV_OELPUFFER;                   //Fließkomma 

62


63
volatile float HYST_OBEN_EIN;                  //Fließkomma 

64
volatile float HYST_MITTE_EIN;                //Fließkomma 

65
volatile float HYST_UNTEN_EIN;                //Fließkomma 

66
volatile float RL_AUS;                      //Fließkomma 

67


68
volatile unsigned int VL_HEIZUNG_1;             //0...65565 

69
volatile unsigned int RL_HEIZUNG_1;             //0...65565 

70
volatile unsigned int PUFFER1000_OBEN_1;          //0...65565 

71
volatile unsigned int PUFFER1000_UNTEN_1;         //0...65565 

72
volatile unsigned int HOLZGASER_1;               //0...65565 

73
volatile unsigned int PUFFER1000_MITTE_1;         //0...65565 

74
volatile unsigned int ABGAS_1;                //0...65565 

75
volatile unsigned int AUSSENTEMP_1;              //0...65565 

76
volatile unsigned int TV_OELPUFFER_1;             //0...65565 

77
volatile unsigned char KommaFaktor = 1;            //0 bis 255          

78
volatile unsigned char delayADC = 25;            //0 bis 255 DELAY ADC Messung 

79
volatile unsigned char LCD = 10;               //0 bis 255 DELAY LCD (war 110/ 25 =0,25s)

80


81
void main(void) 

82
{ 

83


84
//-----------------------------------------------------------------------------------------------------------------//

85


86
T0CONbits.T0PS0 = 1;                //Teiler 1:256

87
T0CONbits.T0PS1 = 1;                //Teiler 1:256

88
T0CONbits.T0PS2 = 1;                //Teiler 1:256

89
T0CONbits.T0PS3 = 0;                //laut Datenblatt (PSA=0)  Vorteiler wird verwendet

90
T0CONbits.T0SE = 1;                  //H-L wird gezählt

91
T0CONbits.T0CS = 0;                  //der Takt ist 1/4 des PIC-Taktes

92
T0CONbits.T08BIT = 0;                //16bit Timer

93
T0CONbits.TMR0ON = 1;                //enable Timer  0

94


95
//-----------------------------------------------------------------------------------------------------------------//

96


97
T1CONbits.RD16 = 1;                  //1 = Enables register read/write of TImer1 in one 16-bit operation

98
T1CONbits.T1RUN = 1;                //1 = Device clock is derived from Timer1 oscillator

99
T1CONbits.T1CKPS1 = 1;                //Prescale = 8

100
T1CONbits.T1CKPS0 = 1;                //Prescale = 8

101
T1CONbits.T1OSCEN = 1;                //1 = Timer1 oscillator is enabled

102
T1CONbits.TMR1CS = 0;                //0 = Internal clock (FOSC/4)        

103
T1CONbits.TMR1ON = 1;                //1 = Enables Timer1

104


105
PIE1bits.TMR1IE = 1;                 //TMR1 Overflow Interrupt Enable bit

106
                          //1 = Enables the TMR1 overflow interrupt

107
IPR1bits.TMR1IP = 0;                //TMR1 Overflow Interrupt Priority bit

108
                          //1 = High priority

109
                          //0 = Low priority

110


111
//-----------------------------------------------------------------------------------------------------------------//

112


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

114


115
//-----------------------------------------------------------------------------------------------------------------//

116
                          //1 = Enable priority levels on interrupts

117
INTCONbits.GIEH = 1;                       //Global Interrupt Enable bit

118
                          //When IPEN = 1:

119
                          //1 = Enables all high priority interrupts

120
INTCONbits.GIEL = 1;                //When IPEN = 1:

121
                          //1 = Enables all low priority peripheral interrupts

122
INTCONbits.TMR0IE = 1;                //TMR0 Overflow Interrupt Enable bit

123
                          //1 = Enables the TMR0 overflow interrupt

124


125
//-----------------------------------------------------------------------------------------------------------------//

126


127
INTCON2bits.TMR0IP =1;                   //TMR0 Overflow Interrupt Priority bit for RTC

128
                          //1 = High priority

129
                          //0 = Low priority

130


131
INTCON2bits.RBPU = 1;                //PORTB Pull-up Enable bit

132
                          //1 = All PORTB pull-ups are disabled

133
                          //0 = PORTB pull-ups are enabled by individual port latch values

134


135
//-----------------------------------------------------------------------------------------------------------------//

136


137


138
OpenUSART( USART_TX_INT_OFF &              // Transmit interrupt off 

139
USART_RX_INT_OFF &                     // Receive interrupt off 

140
USART_ASYNCH_MODE &                    // Asynchronous mode 

141
USART_EIGHT_BIT &                     // 8-bit data 

142
USART_CONT_RX &                     // Continuous reception 

143
USART_BRGH_HIGH,                     // High baud rate 

144
25 );                            // 12 für 19200, 25 für 9600 

145


146
ADCON0bits.ADON = 1;                   //1 = A/D converter module is enabled 

147
ADCON0bits.GO = 1;                    //1 = A/D conversion in progress 

148
ADCON0bits.CHS0 = 0;                   //1010 = Channel 10 (AN9) 

149
ADCON0bits.CHS1 = 1;                   //1010 = Channel 10 (AN9) 

150
ADCON0bits.CHS2 = 0;                   //1010 = Channel 10 (AN9) 

151
ADCON0bits.CHS3 = 1;                   //1010 = Channel 9 (AN9) 

152
ADCON1bits.PCFG0 = 1;                   //1111  (AN10) A A A A A A A A A A A A A (AN0) 

153
ADCON1bits.PCFG1 = 1;                   //1111  (AN10) A A A A A A A A A A A A A (AN0) 

154
ADCON1bits.PCFG2 = 1;                   //1111  (AN10) A A A A A A A A A A A A A (AN0) 

155
ADCON1bits.PCFG3 = 1;                   //1111  (AN10) A A A A A A A A A A A A A (AN0) 

156
ADCON1bits.VCFG0 = 1;                   //1 = VREF+ (AN3) 

157
ADCON1bits.VCFG1 = 0;                   //1 = VREF- (AN2)  Masse =0 

158
ADCON2bits.ADCS0 = 0;                   //110 = FOSC/64 

159
ADCON2bits.ADCS1 = 1;                   //110 = FOSC/64 

160
ADCON2bits.ADCS2 = 1;                   //110 = FOSC/64 

161
ADCON2bits.ACQT0 = 1;                   //111 = 20 TAD 

162
ADCON2bits.ACQT1 = 1;                   //111 = 20 TAD 

163
ADCON2bits.ACQT2 = 1;                   //111 = 20 TAD 

164
ADCON2bits.ADFM = 1;                   //1 = Right justified 

165


166
TRISAbits.TRISA0 = 1;                   // VL_HEIZUNG 

167
TRISAbits.TRISA1 = 1;                   // RL_HEIZUNG 

168
TRISAbits.TRISA5 = 1;                   // PUFFER1000_OBEN 

169
TRISEbits.TRISE0 = 1;                   // PUFFER1000_MITTE 

170
TRISEbits.TRISE1 = 1;                   // PUFFER1000_UNTEN 

171
TRISEbits.TRISE2 = 1;                   // PUFFER_OEL 

172
TRISBbits.TRISB1 = 1;                   // ABGAS 

173
TRISBbits.TRISB4 = 1;                   // HOLZOFEN 

174
TRISBbits.TRISB0 = 1;                    // AUSSENTEMP 

175
TRISDbits.TRISD0 = 0;                   // output K01 UMSCHALTUNG_RL 

176
TRISDbits.TRISD1 = 0;                   // output K02 

177
TRISDbits.TRISD2 = 0;                   // output K03 

178
TRISDbits.TRISD3 = 0;                   // output K04 

179
TRISCbits.TRISC4 = 0;                   // output K05 

180
TRISCbits.TRISC5 = 0;                  // output K06 

181
TRISDbits.TRISD4 = 0;                   // DTR 

182
TRISBbits.TRISB5 = 0;                   // output LED 

183
TRISBbits.TRISB6 = 1;                   // input Brennerückmeldung 

184


185
TRISCbits.TRISC7 = 1;                   // RX RS232 i.O. getestet 

186
TRISCbits.TRISC6 = 0;                   // TX RS232 i.O. getestet 

187


188


189
LATDbits.LATD0 = 0;                    // output K01 UMSCHALTUNG_RL 

190
LATDbits.LATD1 = 0;                 // output K02 Brennersperre

191
LATDbits.LATD2 = 0;                 // output K03 Ladepumpe

192


193


194
while (1) 

195
  { 

196


197
   

198
  ClrWdt()                    // clear Watchdog

199
//--------------------------------------------------------------------------------------------------------// 

200
     // Messung und Berchnung aller Temperaturen 

201
      

202
     Delay10TCYx(delayADC);                 // Vorlauf Heizung messen 

203
     SetChanADC( ADC_CH0); 

204
     Delay10TCYx(delayADC); 

205
     ConvertADC(); 

206
     Delay10TCYx(delayADC); 

207
     while( BusyADC() ){}       

208
     AN0 = ReadADC(); 

209
     VL_HEIZUNG = (float) AN0 * 0.25667  - 82.95907; 

210
     VL_HEIZUNG_1 = (float) VL_HEIZUNG * KommaFaktor; 

211


212
     Delay10TCYx(delayADC);                  // Rücklauf Heizung messen          

213
     SetChanADC( ADC_CH1); 

214
     Delay10TCYx(delayADC); 

215
     ConvertADC(); 

216
     Delay10TCYx(delayADC); 

217
     while( BusyADC() ){}     

218
     AN1 = ReadADC(); 

219
     RL_HEIZUNG = (float) AN1 *  0.25916 - 82.95907; 

220
     RL_HEIZUNG_1 = (float) RL_HEIZUNG * KommaFaktor; 

221


222
     Delay10TCYx(delayADC);                  // 1000l Puffer oben messen          

223
     SetChanADC( ADC_CH4); 

224
     Delay10TCYx(delayADC); 

225
     ConvertADC();           

226
     Delay10TCYx(delayADC); 

227
     while( BusyADC() ){} 

228
     AN4 = ReadADC(); 

229
     PUFFER1000_OBEN = (float) AN4 * 0.23623 - 82.95907; // 26,xxx 

230
     PUFFER1000_OBEN_1 = (float) PUFFER1000_OBEN * KommaFaktor; 

231


232
     Delay10TCYx(delayADC);                  // 1000l Puffer unten messen         

233
     SetChanADC( ADC_CH5); 

234
     Delay10TCYx(delayADC); 

235
     ConvertADC(); 

236
     Delay10TCYx(delayADC); 

237
     while( BusyADC() ){} 

238
     AN5 = ReadADC(); 

239
     PUFFER1000_UNTEN = (float) AN5 * 0.23623 - 82.95907;   

240
     PUFFER1000_UNTEN_1 = (float) PUFFER1000_UNTEN * KommaFaktor; 

241


242
     Delay10TCYx(delayADC);                  // HOLZGASER messen       

243
     SetChanADC( ADC_CH6); 

244
     Delay10TCYx(delayADC); 

245
     ConvertADC(); 

246
     Delay10TCYx(delayADC);     

247
     while( BusyADC() ){} 

248
     AN6 = ReadADC(); 

249
     HOLZGASER = (float) AN6 * 0.26430 - 82.95907;  // 87.749070 war am 02.04.09 

250
     HOLZGASER_1 = (float) HOLZGASER * KommaFaktor; 

251


252
     Delay10TCYx(delayADC);                  //          

253
     SetChanADC( ADC_CH7); 

254
     Delay10TCYx(delayADC); 

255
     ConvertADC(); 

256
     Delay10TCYx(delayADC);   

257
     while( BusyADC() ){} 

258
     AN7 = ReadADC(); 

259
     PUFFER1000_MITTE = (float) AN7 * 0.23834 - 82.95907; 

260
     PUFFER1000_MITTE_1 = (float) PUFFER1000_MITTE * KommaFaktor; 

261


262
     Delay10TCYx(delayADC);                  // Abgastemperatur messen          

263
     SetChanADC( ADC_CH8); 

264
     Delay10TCYx(delayADC); 

265
     ConvertADC(); 

266
     Delay10TCYx(delayADC); 

267
     while( BusyADC() ){}     

268
     AN8 = ReadADC(); 

269
     ABGAS = (float) AN8 * 1.1772 - 272.82; 

270
     ABGAS_1 = (float) ABGAS * KommaFaktor; 

271


272


273
     Delay10TCYx(delayADC);                      // Aussentemp.messen         

274
     SetChanADC( ADC_CH9); 

275
     Delay10TCYx(delayADC); 

276
     ConvertADC(); 

277
     Delay10TCYx(delayADC); 

278
     while( BusyADC() ){} 

279
     AN9 = ReadADC(); 

280
     AUSSENTEMP = (float) AN9 * 0.3082 - 113.3766;       // 

281
     AUSSENTEMP_1 = (float) AUSSENTEMP * KommaFaktor; 

282


283
     Delay10TCYx(delayADC);                      // TV Oelpuffer messen         

284
     SetChanADC( ADC_CH10); 

285
     Delay10TCYx(delayADC); 

286
     ConvertADC(); 

287
     Delay10TCYx(delayADC); 

288
     while( BusyADC() ){} 

289
     AN10 = ReadADC(); 

290
     TV_OELPUFFER = (float) AN10 * 0.299033 - 101.664316;  //war 98 

291
     TV_OELPUFFER_1 = (float) TV_OELPUFFER * KommaFaktor; 

292


293
//--------------------------------------------------------------------------------------------------------// 

294
     

295
     HYST_OBEN_EIN = (float) PUFFER1000_OBEN  - 7; 

296
     HYST_UNTEN_EIN = (float) PUFFER1000_UNTEN  - 7; 

297
     RL_AUS = (float) RL_HEIZUNG  + 3; 

298
  } 

299
} 

300


301


302


303
//--------------------------------------------------------------------------------------------------------// 

304
// High priority interrupt vector 

305
#pragma code InterruptVectorHigh = 0x08 

306
void 

307
InterruptVectorHigh (void) 

308
{ 

309
_asm 

310
   goto InterruptHandlerHigh                                   //jump to interrupt routine 

311
_endasm 

312
} 

313
//--------------------------------------------------------------------------------------------------------// 

314
// High priority interrupt routine 

315
#pragma code 

316
#pragma interrupt InterruptHandlerHigh 

317


318


319
void 

320
InterruptHandlerHigh () 

321
{ 

322


323
    if (INTCONbits.TMR0IF) 

324
         {   

325
      INTCONbits.TMR0IF = 0;                       //clear interrupt flag 

326
      WriteTimer0(61630);   

327
      INTCONbits.GIEH = 0;                                   //disable interrupts

328
 

329
              if ( sec<59 )

330
            {

331
              sec++;

332
            }

333
            else

334
              {

335
                sec=0;

336
                if ( minute<59 )

337
                  {

338
                    minute++;

339
                  }

340
            else

341
                  {

342
                    minute= 0;

343
                    if (stunde<23 )

344
                      {

345
                        stunde++;

346
                       }

347
                    else

348
                          {

349
                            stunde = 0;

350
                 tag++;

351
                }

352


353
            }

354
          }

355
      

356
      INTCONbits.TMR0IE = 1;                       //Enables the TMR0 overflow interrupt

357
      INTCONbits.GIEH = 1;                               //enable interrupts

358


359


360
      }    

361


362
}

363


364


365


366


367
 

368
//--------------------------------------------------------------------------------------------------------// 

369
// Low priority interrupt vector 

370
#pragma code InterruptVectorLow = 0x18 

371
void 

372
InterruptVectorLow (void) 

373
{ 

374
_asm 

375
   goto InterruptHandlerLow                                   //jump to interrupt routine 

376
_endasm 

377
} 

378
//--------------------------------------------------------------------------------------------------------// 

379
// Low priority interrupt routine 

380
#pragma code 

381
#pragma interrupt InterruptHandlerLow 

382


383
char buffer[20]; 

384
int i = 0xA12; 

385


386


387


388


389


390
void free_buffer(char* array)

391
{

392
  int i;                  //Laufvariable deklarieren

393
  int len;                //Variable für die Länge deklarieren

394


395
  len = sizeof(array) / sizeof(char);    //Länge ermitteln

396
  for(i=0;i<len;i++)            //In einer for-Schleife alle

397
    array[i]='\0';            //Felder mit terminierter Null

398
                      //belegen

399
}

400


401


402
void 

403
InterruptHandlerLow () 

404
{ 

405


406


407
    if (PIR1bits.TMR1IF) 

408
      {

409
      PIE1bits.TMR1IE = 1;                                         //0 = Disables the TMR1 overflow interrupt

410
      PIR1bits.TMR1IF = 0;                                        //clear interrupt flag 

411
      Runde++;

412
             free_buffer(buffer); 

413


414
      if  (Runde==8)

415
        {

416
        Runde = 0;

417
        

418


419
          if (Zahl==1) 

420
           { 

421
           putrsUSART ("\x1b\x66\xd\xa");                                     // Clear Display 

422
           Delay10KTCYx(LCD); 

423
          putrsUSART ("VL HEIZUNG    \r\n");  

424
           free_buffer(buffer);     

425
          sprintf(buffer,"%d \r\n",VL_HEIZUNG_1);                                // integer Dezimalzahl 

426
          putsUSART(buffer);  

427
           Delay10KTCYx(LCD);                                       

428
           putrsUSART ("\x1b\x6F\x40\xd\xa");                                   // 2 Zeile 1 Spalte   

429
           Delay10KTCYx(LCD); 

430
           putrsUSART ("RL HEIZUNG    \r\n"); 

431
           free_buffer(buffer); 

432
           sprintf(buffer,"%d \r\n",RL_HEIZUNG_1);                                // integer Dezimalzahl 

433
           putsUSART(buffer); 

434
            } 

435
  

436
              if (Zahl ==2) 

437
              { 

438
              putrsUSART ("\x1b\x66\xd\xa");                                    // Clear Display 

439
              Delay10KTCYx(LCD); 

440
              putrsUSART ("PUFFER O. M. U.   \r\n"); 

441
              Delay10KTCYx(LCD); 

442
              putrsUSART ("\x1b\x6F\x40\xd\xa");                                // 2 Zeile 1 Spalte   

443
              Delay10KTCYx(LCD); 

444
              free_buffer(buffer); 

445
              sprintf(buffer,"%d \r\n",PUFFER1000_OBEN_1);                           // integer Dezimalzahl 

446
              putsUSART(buffer); 

447
              Delay10KTCYx(LCD);     

448
              putrsUSART ("\x1b\x6F\x47\xd\xa");                                // 2 Zeile 8 Spalte   

449
              Delay10KTCYx(LCD); 

450
              free_buffer(buffer); 

451
              sprintf(buffer,"%d \r\n",PUFFER1000_MITTE_1);                         // integer Dezimalzahl 

452
              putsUSART(buffer); 

453
              Delay10KTCYx(LCD); 

454
              putrsUSART ("\x1b\x6F\x4E\xd\xa");                                // 2 Zeile 15 Spalte   

455
              Delay10KTCYx(LCD); 

456
              free_buffer(buffer); 

457
              sprintf(buffer,"%d \r\n",PUFFER1000_UNTEN_1);                         // integer Dezimalzahl 

458
              putsUSART(buffer); 

459
            }

460
 

461
                 if (Zahl ==3) 

462
                { 

463
                 putrsUSART ("\x1b\x66\xd\xa");                                 // Clear Display 

464
                 Delay10KTCYx(LCD); 

465
                putrsUSART ("OELBRENNER    \r\n"); 

466
                 free_buffer(buffer); 

467
                 sprintf(buffer,"%d \r\n",TV_OELPUFFER_1);                         // integer Dezimalzahl 

468
                 putsUSART(buffer); 

469
                 Delay10KTCYx(LCD);  

470
                          free_buffer(buffer); 

471


472
                 if(AUSSENTEMP_1>=10) 

473
                  { 

474
                  putrsUSART ("\x1b\x6F\x40\xd\xa");                            // 2 Zeile 1 Spalte   

475
                  Delay10KTCYx(LCD); 

476
                  putrsUSART ("AUSSENTEMP.   \r\n"); 

477
                  Delay10KTCYx(LCD); 

478
                  free_buffer(buffer); 

479
                  sprintf(buffer,"%d \r\n",AUSSENTEMP_1);                         // integer Dezimalzahl 

480
                  putsUSART(buffer); 

481
                  } 

482
                   if(AUSSENTEMP_1<10 && AUSSENTEMP_1>=0) 

483
                   { 

484
                  putrsUSART ("\x1b\x6F\x40\xd\xa");                            // 2 Zeile 1 Spalte   

485
                  Delay10KTCYx(LCD);

486
                  putrsUSART ("AUSSENTEMP.    \r\n"); 

487
                  Delay10KTCYx(LCD); 

488
                  free_buffer(buffer); 

489
                  sprintf(buffer,"%d \r\n",AUSSENTEMP_1);                         // integer Dezimalzahl 

490
                  putsUSART(buffer); 

491
                  } 

492
                   if(AUSSENTEMP_1<0 && AUSSENTEMP_1>=-9) 

493
                   { 

494
                  putrsUSART ("\x1b\x6F\x40\xd\xa");                            // 2 Zeile 1 Spalte   

495
                  Delay10KTCYx(LCD); 

496
                  putrsUSART ("AUSSENTEMP.   \r\n"); 

497
                  Delay10KTCYx(LCD); 

498
                  free_buffer(buffer); 

499
                  sprintf(buffer,"%d \r\n",AUSSENTEMP_1);                         // integer Dezimalzahl 

500
                  putsUSART(buffer); 

501
                  } 

502
                   if(AUSSENTEMP_1<=-10 ) 

503
                  { 

504
                  putrsUSART ("\x1b\x6F\x40\xd\xa");                            // 2 Zeile 1 Spalte   

505
                  Delay10KTCYx(LCD); 

506
                  putrsUSART ("AUSSENTEMP.  \r\n"); 

507
                  Delay10KTCYx(LCD); 

508
                  free_buffer(buffer); 

509
                  sprintf(buffer,"%d \r\n",AUSSENTEMP_1);                         // integer Dezimalzahl 

510
                  putsUSART(buffer); 

511
                  } 

512
              } 

513
    

514
                 if (Zahl ==4) 

515
                   {  

516
                    free_buffer(buffer); 

517
                    putrsUSART ("\x1b\x66\xd\xa");                                 // Clear Display 

518
                    Delay10KTCYx(LCD); 

519
                 

520
                  if (LATDbits.LATD0 == 1) 

521
                      { 

522
                      putrsUSART ("RL ANHEBUNG   AN \r\n"); 

523
                      } 

524
  

525
                     if (LATDbits.LATD0 == 0) 

526
                      { 

527
                      putrsUSART ("RL ANHEBUNG  AUS \r\n"); 

528
                      } 

529
                      Delay10KTCYx(LCD);  

530
                      putrsUSART ("\x1b\x6F\x40\xd\xa");                              // 2 Zeile 1 Spalte 

531
                      Delay10KTCYx(LCD);       

532
                 

533
                  if (LATDbits.LATD2 == 1) 

534
                      { 

535
                      putrsUSART ("PUMPE PUFFER  AN \r\n"); 

536
                      } 

537
                 

538
                  if (LATDbits.LATD2 == 0) 

539
                      { 

540
                      putrsUSART ("PUMPE PUFFER AUS \r\n"); 

541
                      } 

542
                   } 

543
    

544
                       if (Zahl ==5) 

545
                       {  

546
                      putrsUSART ("\x1b\x66\xd\xa");                               // Clear Display 

547
                      Delay10KTCYx(LCD); 

548
      

549
                        if (LATDbits.LATD1 == 1) 

550
                        { 

551
                        putrsUSART ("BRENNER GESPERRT\r\n"); 

552
                        } 

553
                        if (LATDbits.LATD1 == 0) 

554
                        { 

555
                        putrsUSART ("BRENNER     FREI\r\n"); 

556
                        } 

557
                        Delay10KTCYx(LCD); 

558
                        if( ABGAS_1<100 ) 

559
                        { 

560
                        putrsUSART ("\x1b\x6F\x40\xd\xa");                          // 2 Zeile 1 Spalte   

561
                        Delay10KTCYx(LCD); 

562
                        putrsUSART ("ABGASTEMP.    \r\n"); 

563
                        Delay10KTCYx(LCD); 

564
                        free_buffer(buffer); 

565
                        sprintf(buffer,"%d \r\n",ABGAS_1);                         // integer Dezimalzahl 

566
                        putsUSART(buffer); 

567
                        } 

568
                        if( ABGAS_1>=100 ) 

569
                        { 

570
                        putrsUSART ("\x1b\x6F\x40\xd\xa");                          // 2 Zeile 1 Spalte   

571
                        Delay10KTCYx(LCD); 

572
                        putrsUSART ("ABGASTEMP.   \r\n"); 

573
                        Delay10KTCYx(LCD); 

574
                        free_buffer(buffer); 

575
                        sprintf(buffer,"%d \r\n",ABGAS_1);                         // integer Dezimalzahl 

576
                        putsUSART(buffer); 

577
                        } 

578
                   } 

579


580
                          if (Zahl ==6) 

581
                        {  

582
                           { 

583
                           free_buffer(buffer); 

584
                           putrsUSART ("\x1b\x66\xd\xa");                           // Clear Display 

585
                           Delay10KTCYx(LCD); 

586
                           putrsUSART ("HOLZGASER     \r\n"); 

587
                           free_buffer(buffer); 

588
                           sprintf(buffer,"%d \r\n",HOLZGASER_1);                     // integer Dezimalzahl 

589
                           putsUSART(buffer); 

590
                           Delay10KTCYx(LCD); 

591
                           } 

592
          

593
                           if (PUFFER1000_OBEN < 68 && TV_OELPUFFER < 68 ) 

594
                           { 

595
                           Delay10KTCYx(LCD); 

596
                           putrsUSART ("\x1b\x6F\x40\xd\xa");                        // 2 Zeile 1 Spalte 

597
                           Delay10KTCYx(LCD); 

598
                           putrsUSART ("JETZT FEUERN !!!\r\n"); 

599
                           Delay10KTCYx(LCD); 

600
                           } 

601
                        }    

602


603
                      if (Zahl ==7) 

604
                          {  

605
                           putrsUSART ("\x1b\x66\xd\xa");                           // Clear Display 

606
                           Delay10KTCYx(LCD);

607
                      free_buffer(buffer);  

608
                      sprintf(buffer,"%d \r\n",tag); 

609
                      putsUSART(buffer); 

610
                      Delay10KTCYx(LCD);

611
                      //putrsUSART ("T\r\n");

612
                    

613
                      Delay10KTCYx(LCD);

614
                      free_buffer(buffer); 

615
                      sprintf(buffer,"%d \r\n",stunde); 

616
                      putsUSART(buffer); 

617
                      Delay10KTCYx(LCD);

618
                      //putrsUSART ("h\r\n");

619


620
                      Delay10KTCYx(LCD); 

621
                      free_buffer(buffer);

622
                      sprintf(buffer,"%d \r\n",minute);

623
                      putsUSART(buffer);  

624
                      Delay10KTCYx(LCD);

625
                      //putrsUSART ("min\r\n");

626


627
                      Delay10KTCYx(LCD); 

628
                      free_buffer(buffer);

629
                      sprintf(buffer,"%d \r\n",sec); 

630
                      putsUSART(buffer); 

631
                      Delay10KTCYx(LCD);

632
                      //putrsUSART ("s\r\n");

633
                      }

634


635
                        if (Zahl ==8) 

636
                          { 

637
                          

638
//--------------------------------------------------------------------------------------------------------// 

639
     

640
                             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 ) 

641
                              {  

642
                              LATDbits.LATD0 = 1;                                       // RL AN 

643
                              } 

644
                            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 

645
                            { 

646
                              LATDbits.LATD0 = 0;                                       // RL AUS 

647
                              } 

648


649
                          //--------------------------------------------------------------------------------------------------------// 

650


651
                          if ((HOLZGASER > 60 && ABGAS_1 > 200) || HOLZGASER > 86  ) 

652
                          {

653
                          LATDbits.LATD2 = 1;                                     // Pumpe AN 

654
                          }

655


656
                          if (HOLZGASER > 63 && ABGAS_1 < 130 && HOLZGASER < 84)  

657
                          {

658
                          LATDbits.LATD2 = 0;                                     // Pumpe AUS 

659
                          }

660


661
                          //--------------------------------------------------------------------------------------------------------// 

662


663
                             if (TV_OELPUFFER > 55 && PUFFER1000_OBEN > 50)                         // Brennersteuerung 

664
                              { 

665
                              LATDbits.LATD1 = 1;                                         // Brenner gesperrt 

666
                              } 

667
                             if (TV_OELPUFFER < 50 && PUFFER1000_OBEN < 45)                         // ODER draus machen !!!!!!

668
                              { 

669
                              LATDbits.LATD1 = 0;                                         // Brenner frei 

670
                              } 

671
                        

672
                        Zahl = 0; 

673
                          } 

674
//--------------------------------------------------------------------------------------------------------// 

675


676
        Zahl++; 

677
        }

678
        

679
      PIE1bits.TMR1IE = 1;       //1 = Enables the TMR1 overflow interrupt

680
         } 

681
}
Angehängte Dateien:
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #1552568
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.

1
int i;     // dieses i ist in keinem Block, und daher überall sichtbar

2


3
void foo()

4
{

5
  int k;     // dieses k ist nur in der Funktion foo sichtbar, weil

6
             // die Funktion selbst mit ihrem { }-Block die Sichtbarkeit

7
             // beschränkt  ....

8
}

9


10
void bar()

11
{

12
  int k;     // ... daher ist dieses k ein völlig anderes k, als das

13
             // in foo

14
}

15


16
void foobar()

17
{

18
   int j;

19


20
   if( ... )

21
   {            // hier beginnt wieder ein Block im Block

22
      int m;    // dieses m ist nur im inneren Block sichtbar ...

23
      ....

24
   }

25
 

26
                // ... und existiert in dieser Blockebene nicht mehr

27
                // wohl aber das j, welches ja im äusseren Block

28
                // definiert wurde

29
}


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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren