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
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.
meinte zwischen [ c ] und [ /c ] (ohne die leerzeichen ;-) )
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 | }
|
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.
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
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.