Forum: Markt [S] Suche Dienstleistung für PIC18F45K22


Announcement: there is an English version of this forum on EmbDev.net. Posts you create there will be displayed on Mikrocontroller.net and EmbDev.net.
von Detlef M. (dau)


Bewertung
0 lesenswert
nicht lesenswert
Moin Zusammen,

ich möchte einen vorhandenen C-Quellcode auf einen PIC18F45K22IP 
bekommen.

Als Interessierter, aber leider noch nicht Wissender, erscheint mir eine 
Umsetzung in Eigenleistung gerade zuviele Unbekannte zu haben.

Der Code wurde für die Nutzung mit einem PIC18F45K22, in Verbindung mit 
dem CC18-Compiler, erstellt und aktuell ist wohl der XC18-Compiler. Dann 
las ich noch von einer Migration von C18 auf XC18, alles Dinge die sich 
dem Neuling nicht spontan erschließen.

Da es um ein privates Photovoltaik-Projekt geht (und die Saison geht 
bald wieder los) möchte ich eine zeitaufwendige Selbstschulung gerade 
gerne umgehen.

Daher suche ich jemand Kundigen, der mir den Code, unter 
Berücksichtigung etwaiger Migrationsanpassungen, compiliert oder noch 
besser einen funktionieren PIC liefert. Bezahlung nach Vereinbarung.

Ich würde mich freuen wenn sich hier jemand findet...

Bis dahin, alles Gute und bleibt gesund.

: Bearbeitet durch User
von Tobias C. (tobich)


Bewertung
0 lesenswert
nicht lesenswert
Poste doch mal deinen Quellcode, dann kann man das ganze besser 
abschätzen.

von Detlef M. (dau)


Bewertung
0 lesenswert
nicht lesenswert
Tobias C. schrieb:
> Poste doch mal deinen Quellcode, dann kann man das ganze besser
> abschätzen.


1
 /*********************************************************************************
2
*        File: 6_Panel.C
3
*        Controller: PIC18F45K22
4
*        Compiler: CC18
5
*        Date: 25.5.2020
6
*        Author: 
7
*        Description: Solarstation groß
8
************************************************************************************
9
         Header files
10
************************************************************************************/
11
#include <p18f45k22.h>               
12
#include <stdlib.h>
13
/***********************************************************************************
14
         Configuration Bits
15
************************************************************************************/
16
17
#pragma  config FOSC=INTIO67, PWRTEN=ON, BOREN=ON, PLLCFG = ON, MCLRE=INTMCLR, WDTEN=ON, WDTPS = 256, LVP=OFF, PBADEN=OFF //, P2BMX = PORTD2, T3CMX = PORTB5
18
/***********************************************************************************
19
         Konstanten
20
************************************************************************************/
21
#define  REL1     LATAbits.LATA4
22
#define  REL2     LATEbits.LATE1
23
#define  REL3     LATBbits.LATB4
24
#define  REL4     LATBbits.LATB1
25
#define  REL5     LATDbits.LATD6
26
#define  REL6     LATCbits.LATC5
27
#define  ENABLE   PORTBbits.RB5
28
#define  LCD_OFF  LATCbits.LATC4
29
#define  CREN     RC1STAbits.CREN
30
#define  RCIF     PIR1bits.RC1IF 
31
#define  OERR     RC1STAbits.OERR
32
#define  SPEN     RCSTA1bits.SPEN
33
#define  FERR     RCSTA1bits.FERR
34
#define  RELAIS2  LATEbits.LATE2
35
#define  NETZ     PORTCbits.RC0
36
#define  UP       PORTAbits.RA7
37
#define  DOWN     PORTAbits.RA6
38
39
/**********************************************************************************
40
         Variablen
41
***********************************************************************************/
42
unsigned char DATA, MWERT, TEMP1, INSEL, ANZ, INV_FLAG, TAST_FLAG;
43
unsigned int DATA1, TEMP2, U1, U2, U3, U4, U5, U6, I1, I2, I3, I4, I5, I6, P_IN, I_REIN, P_OUT, P_MAX;
44
unsigned int U_INV, U_BAT, I_INV, O_V, U_V, U_MAX, U_MIN, ANZ_FLAG;
45
long LCD_TIMER;
46
47
/**********************************************************************************
48
         Deklaration der Funktionen, Unterprograme
49
***********************************************************************************/
50
#pragma  code
51
void init (void);                     // ...eben Initialisierung :-)
52
void Delaykurz (void);                // ...war zu faul, um eine Delayroutine mit
53
void Delaylang (void);                
54
void Delay (void);
55
void LCDAD (void);
56
void LCDAD1 (void);
57
void LCDBefehl(const rom char *buffer); // Text aus Buffer auf LCD
58
void LCDWrite (char TEMP);
59
void FFF (void);                      //wird nach jedem Befehl gesendet
60
void ADWert (void);                   // Spannungsmessungen
61
void Menue (void);
62
void Steuerung (void);
63
void Anzeige (void);
64
void Panel_Anz (void);
65
void Panel_Anz2 (void);
66
void EELese (void);
67
void EESchreibe (void);
68
/**********************************************************************************
69
         Main
70
***********************************************************************************/
71
void main (void)
72
{ 
73
  init ();
74
  REL2 = 0;
75
  FFF();
76
  Delay();
77
  ClrWdt();  
78
  SPEN = 0;
79
  SPEN = 1;
80
  CREN = 0;
81
  CREN = 1;
82
  LCD_OFF = 0;
83
  LCDBefehl("page 1");
84
  Delay();
85
  FFF();
86
  ANZ_FLAG = 0;
87
  ANZ = 0;
88
  CCPR1L = 0;
89
  LCD_TIMER = 0;
90
  TAST_FLAG = 0;
91
  while (CCPR1L < 140)
92
  {
93
    CCPR1L++;
94
    Delay();
95
  }
96
  if (INSEL == 0)
97
  CCPR1L = 140;                  // PWM, 192 => 100 % / 41,5 kHz
98
  if (INSEL == 1)
99
  CCPR1L = 192;
100
  LCD_TIMER = 0;
101
  INV_FLAG = 1;                  // 1 = Inverter an
102
  while (1)  
103
  { 
104
    ClrWdt();
105
    if (LCD_TIMER < 700000)      // Nach ca. 2 Minuten ausschalten
106
    LCD_TIMER++;
107
    if (LCD_TIMER > 699999)
108
    LCD_OFF = 1;
109
    if (ENABLE == 0)
110
    {
111
      LCD_TIMER = 0;
112
      SPEN = 0;
113
      LCD_OFF = 0;  // an
114
      SPEN = 1;
115
    }
116
    ADWert();
117
    Steuerung();
118
    ANZ_FLAG++;
119
    if (ANZ_FLAG == 1500)
120
    Panel_Anz();
121
    if (ANZ_FLAG == 3000)
122
    Panel_Anz2();
123
    if (ANZ_FLAG > 8000)
124
    Anzeige();
125
    if (RCIF == 1)
126
    {
127
      TEMP1 = RCREG;
128
      if (TEMP1 == 101)
129
      {
130
        LCDBefehl("page 2");
131
        Delay();
132
        FFF();
133
        Delaykurz();
134
        Menue();
135
      }
136
      SPEN = 0;
137
      SPEN = 1;
138
      CREN = 0;
139
      CREN = 1;
140
    }
141
  }
142
}
143
144
/***********************************************************************************
145
 Unterprogramme, wie Delays, LCD, Texte, Initialisierung und der Rest...
146
***********************************************************************************/
147
148
void Steuerung (void)
149
{
150
151
  if (ANZ_FLAG == 1500)
152
  {
153
    if (U_BAT > U_MAX)
154
    {
155
      if (ANZ < 7)
156
      ANZ++;
157
      if ((REL1 == 1) && (ANZ > 6)) // Wenn Akku voll
158
      REL1 = 0;                     // dann aus
159
      if ((REL2 == 1) && (ANZ > 5))
160
      REL2 = 0;
161
      if ((REL3 == 1) && (ANZ > 4))
162
      REL3 = 0;
163
      if ((REL4 == 1) && (ANZ > 3))
164
      REL4 = 0;
165
      if ((REL5 == 1) && (ANZ > 2))
166
      REL5 = 0;
167
      if ((REL6 == 1) && (ANZ > 1))
168
      REL6 = 0;
169
    }
170
    if (U_BAT < U_MAX)
171
    {
172
      if (ANZ > 0)
173
      ANZ--;
174
      if ((U1 > U_BAT+10) & (ANZ < 6))    // Wenn Panelspannung > Akkuspannung
175
      REL1 = 1;
176
      if ((U2 > U_BAT+10) & (ANZ < 5))   
177
      REL2 = 1;
178
      if ((U3 > U_BAT+10) & (ANZ < 4))    
179
      REL3 = 1;
180
      if ((U4 > U_BAT+10) & (ANZ < 3))    
181
      REL4 = 1;
182
      if ((U5 > U_BAT+10) & (ANZ < 2))    
183
      REL5 = 1;
184
      if ((U6 > U_BAT+10) & (ANZ < 1))   
185
      REL6 = 1;
186
    }
187
  }
188
189
  if (ANZ_FLAG == 2500)
190
  {
191
    if (I1 < 13)    // Wenn Strom < 0,1 Ampere, dann aus
192
    REL1 = 0;
193
    if (I2 < 13)
194
    REL2 = 0;
195
    if (I3 < 13)
196
    REL3 = 0;
197
    if (I4 < 13)
198
    REL4 = 0;
199
    if (I5 < 13)
200
    REL5 = 0;
201
    if (I6 < 13)
202
    REL6 = 0;
203
  }
204
    
205
206
  if ((U_BAT > U_MAX)&&(ANZ_FLAG == 1000))
207
  RELAIS2 = 1;
208
209
  if ((U_BAT < (U_MAX - 40))&&(ANZ_FLAG == 1000))
210
  RELAIS2 = 0;
211
212
  if ((U_BAT < U_MIN)&&(CCPR1L > 0)&&(INSEL == 0)&&(ANZ_FLAG == 200)&&(INV_FLAG == 1))
213
  CCPR1L--;
214
215
  if ((U_BAT < U_MIN-5)&&(CCPR1L > 0)&&(INSEL == 1)&&(ANZ_FLAG == 200)&&(INV_FLAG == 1))
216
  CCPR1L = 0;
217
218
  if ((P_OUT > P_MAX)&&(INSEL == 0)&&(U_BAT > U_MIN)&&(ANZ_FLAG == 500)&&(CCPR1L > 0)&&(INV_FLAG == 1))
219
  CCPR1L--;
220
  
221
  if ((P_OUT < P_MAX)&&(INSEL == 0)&&(U_BAT > U_MIN)&&(ANZ_FLAG == 500)&&(CCPR1L < 192)&&(INV_FLAG == 1))
222
  CCPR1L++;
223
224
  if (INV_FLAG == 0)
225
  CCPR1L = 0;           // Inverter aus
226
227
  if ((U_BAT > U_MIN)&&(INSEL == 0)&&(INV_FLAG == 1)&&(CCPR1L < 192)&&(UP == 0)&&(TAST_FLAG == 0))
228
  {  
229
    P_MAX++;
230
    TAST_FLAG = 1;
231
  }
232
233
  if ((U_BAT > U_MIN)&&(INSEL == 0)&&(INV_FLAG == 1)&&(CCPR1L > 0)&&(DOWN == 0)&&(TAST_FLAG == 0))
234
  {  
235
    P_MAX--;
236
    TAST_FLAG = 1;
237
  }
238
239
  if ((UP == 1)&&(DOWN == 1)&&(ANZ_FLAG == 100))
240
  TAST_FLAG = 0;
241
  
242
243
}
244
245
246
void Panel_Anz (void)
247
{
248
  if (REL1 == 0)
249
  {
250
     LCDBefehl("t9.txt=");                 
251
     LCDWrite(34);
252
     LCDBefehl("1");
253
     LCDWrite(34);
254
  }
255
  if (REL1 == 1)
256
  {
257
     LCDBefehl("t15.txt=");                 
258
     LCDWrite(34);
259
     LCDBefehl("1");
260
     LCDWrite(34);
261
  }
262
  FFF();
263
  Delay();
264
265
  if (REL2 == 0)
266
  {
267
     LCDBefehl("t10.txt=");                 
268
     LCDWrite(34);
269
     LCDBefehl("2");
270
     LCDWrite(34);
271
  }
272
  if (REL2 == 1)
273
  {
274
     LCDBefehl("t16.txt=");                 
275
     LCDWrite(34);
276
     LCDBefehl("2");
277
     LCDWrite(34);
278
  }
279
  FFF();
280
  Delay();
281
282
  if (REL3 == 0)
283
  {
284
     LCDBefehl("t11.txt=");                 
285
     LCDWrite(34);
286
     LCDBefehl("3");
287
     LCDWrite(34);
288
  }
289
  if (REL3 == 1)
290
  {
291
     LCDBefehl("t17.txt=");                 
292
     LCDWrite(34);
293
     LCDBefehl("3");
294
     LCDWrite(34);
295
  }
296
  FFF();
297
  Delay();
298
}
299
300
301
void Panel_Anz2 (void)
302
{
303
  if (REL4 == 0)
304
  {
305
     LCDBefehl("t12.txt=");                 
306
     LCDWrite(34);
307
     LCDBefehl("4");
308
     LCDWrite(34);
309
  }
310
  if (REL4 == 1)
311
  {
312
     LCDBefehl("t18.txt=");                 
313
     LCDWrite(34);
314
     LCDBefehl("4");
315
     LCDWrite(34);
316
  }
317
  FFF();
318
  Delay();
319
320
  if (REL5 == 0)
321
  {
322
     LCDBefehl("t13.txt=");                 
323
     LCDWrite(34);
324
     LCDBefehl("5");
325
     LCDWrite(34);
326
  }
327
  if (REL5 == 1)
328
  {
329
     LCDBefehl("t19.txt=");                 
330
     LCDWrite(34);
331
     LCDBefehl("5");
332
     LCDWrite(34);
333
  }
334
  FFF();
335
  Delay();
336
337
  if (REL6 == 0)
338
  {
339
     LCDBefehl("t14.txt=");                 
340
     LCDWrite(34);
341
     LCDBefehl("6");
342
     LCDWrite(34);
343
  }
344
  if (REL6 == 1)
345
  {
346
     LCDBefehl("t20.txt=");                 
347
     LCDWrite(34);
348
     LCDBefehl("6");
349
     LCDWrite(34);
350
  }
351
  FFF();
352
  Delay();
353
}
354
355
356
void Anzeige (void)
357
{   
358
  LCDBefehl("upan.txt=");                 
359
  LCDWrite(34);
360
  if (U1 > 10)
361
  DATA1 = U1;
362
  if (U2 > 10)
363
  DATA1 = U2;
364
  if (U3 > 10)
365
  DATA1 = U3;
366
  if (U4 > 10)
367
  DATA1 = U4;
368
  if (U5 > 10)
369
  DATA1 = U5;
370
  if (U6 > 10)
371
  DATA1 = U6;
372
  if ((U1 < 11)&&(U2 < 11)&&(U3 < 11)&&(U4 < 11)&&(U5 < 11)&&(U6 < 11))
373
  DATA1 = 0;
374
  LCDAD1();
375
  LCDWrite(34);
376
  FFF();
377
  Delay();
378
  LCDBefehl("ubat.txt=");                 
379
  LCDWrite(34);
380
  DATA1 = U_BAT;
381
  LCDAD1();
382
  LCDWrite(34);
383
  FFF();
384
  LCDBefehl("pin.txt=");                 
385
  LCDWrite(34);
386
  I_REIN = I1 + I2 + I3 + I4 + I5 + I6;
387
  P_IN = (((U_BAT/5) * (I_REIN/5))/60);
388
  if (P_IN < 4)
389
  P_IN = 0;
390
  DATA1 = P_IN;
391
  LCDAD();
392
  LCDWrite(34);
393
  FFF();
394
  Delay();
395
  LCDBefehl("pout.txt=");                 
396
  LCDWrite(34);
397
  P_OUT = ((U_BAT/4) * (I_INV/4))/65;
398
  if (P_OUT < 4)
399
  P_OUT = 0;
400
  DATA1 = P_OUT;
401
  LCDAD();
402
  LCDWrite(34);
403
  FFF();
404
  Delay();
405
  ANZ_FLAG = 0;
406
}
407
408
409
void Menue (void)
410
{
411
  TEMP1 = RCREG;
412
  TEMP1 = 100;
413
  LCD_TIMER = 0; 
414
  LCDBefehl("umin.txt=");                 
415
  LCDWrite(34);
416
  DATA1 = U_MIN;
417
  LCDAD1();
418
  LCDWrite(34);
419
  FFF();
420
  Delay();
421
  CREN = 0;
422
  CREN = 1;
423
  LCDBefehl("umax.txt=");                 
424
  LCDWrite(34);
425
  DATA1 = U_MAX;
426
  LCDAD1();
427
  LCDWrite(34);
428
  FFF();
429
  Delay();
430
  CREN = 0;
431
  CREN = 1;
432
  LCDBefehl("pmax.txt=");                 
433
  LCDWrite(34);
434
  DATA1 = P_MAX;
435
  LCDAD();
436
  LCDWrite(34);
437
  FFF();
438
  Delay();
439
  CREN = 0;
440
  CREN = 1;
441
  LCDBefehl("b7.txt=");                 
442
  LCDWrite(34);
443
  if (INSEL == 1)
444
  LCDBefehl("Island");
445
  if (INSEL == 0)
446
  LCDBefehl("Grid");
447
  LCDWrite(34);
448
  FFF();
449
  Delay();
450
  LCDBefehl("b5.txt=");                 
451
  LCDWrite(34);
452
  if (CCPR1L == 0)
453
  LCDBefehl("Inv.Off");
454
  if (CCPR1L > 0)
455
  LCDBefehl("Inv.On");
456
  LCDWrite(34);
457
  FFF();
458
  Delay();
459
  TEMP1 = RCREG;
460
  CREN = 0;
461
  CREN = 1;
462
  SPEN = 0;
463
  SPEN = 1;
464
  TEMP1 = 100;
465
  while ((TEMP1 < 15)||(TEMP1 > 15))
466
  {
467
    if (ENABLE == 0)
468
    {
469
      LCD_OFF = 0;
470
      LCD_TIMER = 0;
471
      Reset();
472
    }
473
    if ((TEMP1 == 100)||((TEMP1 < 15)&&(TEMP1 > 2))||(TEMP1 == 255))
474
    ClrWdt();
475
    if (RCIF == 1)
476
    TEMP1 = RCREG;
477
 
478
    if (TEMP1 == 7)
479
    {
480
      if ((U_MIN < 1024)&&(U_MIN < U_MAX-50))
481
      U_MIN = (U_MIN + 2);
482
      LCDBefehl("umin.txt=");
483
      LCDWrite(34);
484
      DATA1 = U_MIN;
485
      LCDAD1();
486
      LCDWrite(34);
487
      FFF();
488
      DATA1 = U_MIN;
489
      CREN = 0;
490
      CREN = 1;
491
      EEDATA = DATA1 & 0b0000000011111111;
492
      EEADR = 2;
493
      EESchreibe();
494
      EEDATA = DATA1 >> 8 & 0b0000000011111111;
495
      EEADR = 1;
496
      EESchreibe();
497
      TEMP1 = 100;
498
    }
499
500
    if (TEMP1 == 8)
501
    {
502
      if (U_MIN > 0)
503
      U_MIN = (U_MIN - 2);
504
      LCDBefehl("umin.txt=");
505
      LCDWrite(34);
506
      DATA1 = U_MIN;
507
      LCDAD1();
508
      LCDWrite(34);
509
      FFF();
510
      DATA1 = U_MIN;
511
      CREN = 0;
512
      CREN = 1;
513
      EEDATA = DATA1 & 0b0000000011111111;
514
      EEADR = 2;
515
      EESchreibe();
516
      EEDATA = DATA1 >> 8 & 0b0000000011111111;
517
      EEADR = 1;
518
      EESchreibe();
519
      TEMP1 = 100;
520
    }
521
522
    if (TEMP1 == 9)
523
    {
524
      if (U_MAX < 1024)
525
      U_MAX = (U_MAX + 2);
526
      LCDBefehl("umax.txt=");
527
      LCDWrite(34);
528
      DATA1 = U_MAX;
529
      LCDAD1();
530
      LCDWrite(34);
531
      FFF();
532
      DATA1 = U_MAX;
533
      CREN = 0;
534
      CREN = 1;
535
      EEDATA = DATA1 & 0b0000000011111111;
536
      EEADR = 4;
537
      EESchreibe();
538
      EEDATA = DATA1 >> 8 & 0b0000000011111111;
539
      EEADR = 3;
540
      EESchreibe();
541
      TEMP1 = 100;
542
    }
543
544
    if (TEMP1 == 10)
545
    {
546
      if ((U_MAX > 100)&&(U_MAX > U_MIN+50))
547
      U_MAX = (U_MAX -2);;
548
      LCDBefehl("umax.txt=");
549
      LCDWrite(34);
550
      DATA1 = U_MAX;
551
      LCDAD1();
552
      LCDWrite(34);
553
      FFF();
554
      DATA1 = U_MAX;
555
      CREN = 0;
556
      CREN = 1;
557
      EEDATA = DATA1 & 0b0000000011111111;
558
      EEADR = 4;
559
      EESchreibe();
560
      EEDATA = DATA1 >> 8 & 0b0000000011111111;
561
      EEADR = 3;
562
      EESchreibe();
563
      TEMP1 = 100;
564
    }
565
566
    if (TEMP1 == 11)
567
    {
568
      if (P_MAX < 200)
569
      P_MAX++;
570
      LCDBefehl("pmax.txt=");
571
      LCDWrite(34);
572
      DATA1 = P_MAX;
573
      LCDAD();
574
      LCDWrite(34);
575
      FFF();
576
      DATA1 = P_MAX;
577
      CREN = 0;
578
      CREN = 1;
579
      EEDATA = DATA1 & 0b0000000011111111;
580
      EEADR = 6;
581
      EESchreibe();
582
      EEDATA = DATA1 >> 8 & 0b0000000011111111;
583
      EEADR = 5;
584
      EESchreibe();
585
      TEMP1 = 100;
586
    }
587
588
    if (TEMP1 == 12)
589
    {
590
      if (P_MAX > 10)
591
      P_MAX--;
592
      LCDBefehl("pmax.txt=");
593
      LCDWrite(34);
594
      DATA1 = P_MAX;
595
      LCDAD();
596
      LCDWrite(34);
597
      FFF();
598
      DATA1 = P_MAX;
599
      CREN = 0;
600
      CREN = 1;
601
      EEDATA = DATA1 & 0b0000000011111111;
602
      EEADR = 6;
603
      EESchreibe();
604
      EEDATA = DATA1 >> 8 & 0b0000000011111111;
605
      EEADR = 5;
606
      EESchreibe();
607
      TEMP1 = 100;
608
    }
609
610
    if (TEMP1 == 13)
611
    {
612
      LCDBefehl("b5.txt=");
613
      LCDWrite(34);
614
      if (CCPR1L > 0)
615
      {
616
        LCDBefehl("Inv.Off");
617
        INV_FLAG = 0;
618
        CCPR1L = 0;
619
      }
620
      else
621
      {
622
        LCDBefehl("Inv.On");
623
        INV_FLAG = 1;
624
        if (INSEL == 1)
625
        {
626
          while (CCPR1L < 192)
627
          {
628
            CCPR1L++;
629
            Delay();
630
          }
631
        }
632
        if (INSEL == 0)
633
        {
634
          while (CCPR1L < 140)
635
          {
636
            CCPR1L++;
637
            Delay();
638
          }
639
        }
640
      }
641
642
      LCDWrite(34);
643
      FFF();
644
      Delay();
645
      CREN = 0;
646
      CREN = 1;
647
      TEMP1 = 100;
648
    } 
649
650
    if (TEMP1 == 14)
651
    {
652
      LCDBefehl("b7.txt=");
653
      LCDWrite(34);
654
      if (INSEL == 0)
655
      {
656
        LCDBefehl("Island");
657
        INSEL = 1;
658
      }
659
      else
660
      {
661
        LCDBefehl("Grid");
662
        INSEL = 0;
663
      }
664
      LCDWrite(34);
665
      FFF();
666
      CREN = 0;
667
      CREN = 1;
668
      EEDATA = INSEL;
669
      EEADR = 7;
670
      EESchreibe();
671
      TEMP1 = 100;
672
    }
673
674
  }
675
  TEMP1 = RCREG;
676
  LCDBefehl("page 1");
677
  Delay();
678
  FFF();
679
  Delaykurz();
680
  CREN = 0;
681
  CREN = 1;
682
  SPEN = 0;
683
  SPEN = 1;
684
}
685
686
687
void ADWert (void)
688
{  
689
  ADCON0 = 0b00001011;               // AD2 an
690
  while (ADCON0bits.GO_DONE);
691
  U1 = ADRESH;
692
  U1 = (U1<<8);
693
  U1 = (U1|ADRESL);
694
695
  ADCON0 = 0b00001111;               // AD3 an
696
  while (ADCON0bits.GO_DONE);
697
  I1 = ADRESH;
698
  I1 = (I1<<8);
699
  I1 = (I1|ADRESL);
700
701
  ADCON0 = 0b00010011;               // AD4 an
702
  while (ADCON0bits.GO_DONE);
703
  U2 = ADRESH;
704
  U2 = (U2<<8);
705
  U2 = (U2|ADRESL);
706
707
  ADCON0 = 0b00010111;               // AD5 an
708
  while (ADCON0bits.GO_DONE);
709
  I2 = ADRESH;
710
  I2 = (I2<<8);
711
  I2 = (I2|ADRESL);
712
 
713
  ADCON0 = 0b01010011;               // AD20 an
714
  while (ADCON0bits.GO_DONE);
715
  U_BAT = ADRESH;
716
  U_BAT = (U_BAT<<8);
717
  U_BAT = (U_BAT|ADRESL);
718
  
719
  ADCON0 = 0b01010111;               // AD21 an
720
  while (ADCON0bits.GO_DONE);
721
  I_INV = ADRESH;
722
  I_INV = (I_INV<<8);
723
  I_INV = (I_INV|ADRESL);
724
725
  ADCON0 = 0b00100111;               // AD9 an
726
  while (ADCON0bits.GO_DONE);
727
  I3 = ADRESH;
728
  I3 = (I3<<8);
729
  I3 = (I3|ADRESL);
730
731
  ADCON0 = 0b00110011;               // AD12 an
732
  while (ADCON0bits.GO_DONE);
733
  I4 = ADRESH;
734
  I4 = (I4<<8);
735
  I4 = (I4|ADRESL);
736
737
  ADCON0 = 0b00100011;               // AD8 an
738
  while (ADCON0bits.GO_DONE);
739
  U3 = ADRESH;
740
  U3 = (U3<<8);
741
  U3 = (U3|ADRESL);
742
743
  ADCON0 = 0b01101111;               // AD27 an
744
  while (ADCON0bits.GO_DONE);
745
  U4 = ADRESH;
746
  U4 = (U4<<8);
747
  U4 = (U4|ADRESL);
748
749
  ADCON0 = 0b01100111;               // AD25 an
750
  while (ADCON0bits.GO_DONE);
751
  I5 = ADRESH;
752
  I5 = (I5<<8);
753
  I5 = (I5|ADRESL);
754
  
755
  ADCON0 = 0b01100011;               // AD24 an
756
  while (ADCON0bits.GO_DONE);
757
  U5 = ADRESH;
758
  U5 = (U5<<8);
759
  U5 = (U5|ADRESL);
760
761
  ADCON0 = 0b01011111;               // AD23 an
762
  while (ADCON0bits.GO_DONE);
763
  I6 = ADRESH;
764
  I6 = (I6<<8);
765
  I6 = (I6|ADRESL);
766
767
  ADCON0 = 0b01011011;               // AD22 an
768
  while (ADCON0bits.GO_DONE);
769
  U6 = ADRESH;
770
  U6 = (U6<<8);
771
  U6 = (U6|ADRESL);
772
}
773
774
775
void init (void)
776
{ 
777
  PORTA = 0;
778
  PORTB = 0;
779
  PORTC = 0;
780
  PORTD = 0;
781
  LATA = 0;
782
  LATB = 0;
783
  LATC = 0;
784
  LATD = 0;
785
  ANSELA = 0b00101100;             
786
  ANSELB = 0b00001101;
787
  ANSELC = 0b00000000;
788
  ANSELD = 0b10111111;
789
  TRISA = 0b11101100;           
790
  TRISB = 0b11101101;    
791
  TRISC = 0b10001011;   
792
  TRISD = 0b10111111;
793
  TRISE = 0b00000000;
794
  ADCON0 = 0b00000001;             // AD0 an
795
  ADCON1 = 0b00001000;             // Interne Referenz
796
  ADCON2 = 0b10100001;             // Rechts justiert 
797
  VREFCON0 = 0b11110000;           // Interne Referenz 4,096 Volt an
798
  OSCCON = 0b01100100;             // Internen Oszillator 4 MHz + 4xPLL = 32 MHz
799
  OSCTUNE = 0b01000000;
800
  INTCON = 0b11100000;             // Interrupts erlauben
801
  INTCON2 = 0b00000000;
802
  Delaylang();
803
  RCSTA1 = 0b10010000;
804
  SPBRGH1 =3;
805
  SPBRG1 = 66;                     // 9600 Baud = 832
806
  TXSTA1= 0b10100100;
807
  BAUDCON1 = 0b00001000;
808
  WPUB = 0b00100000;               // Pull Up PortB5 an
809
  
810
  CCPR1L = 0;
811
  CCP1CON = 0b00001100;         // PWM Mode  
812
  PR2 = 0b10111111;
813
  PIR2 = 0b00000000;
814
  T2CON = 0b00000100;         // Timer2 ON, kein Pre- kein Post-counter
815
816
  EEADR = 1;
817
  EELese();
818
  U_MIN = EEDATA;
819
  U_MIN = U_MIN<<8;
820
  EEADR = 2;
821
  EELese();
822
  U_MIN = (U_MIN | EEDATA);
823
  if (U_MIN > 1024)
824
  U_MIN = 350;
825
826
  EEADR = 3;
827
  EELese();
828
  U_MAX = EEDATA;
829
  U_MAX = U_MAX<<8;
830
  EEADR = 4;
831
  EELese();
832
  U_MAX = (U_MAX | EEDATA);
833
  if (U_MAX > 1024)
834
  U_MAX = 450;
835
836
  EEADR = 5;
837
  EELese();
838
  P_MAX = EEDATA;
839
  P_MAX = P_MAX<<8;
840
  EEADR = 6;
841
  EELese();
842
  P_MAX = (P_MAX | EEDATA);
843
  if (P_MAX > 1024)
844
  P_MAX = 100;
845
846
  EEADR = 7;
847
  EELese();
848
  INSEL = EEDATA;
849
  if (INSEL > 1)
850
  INSEL = 1;
851
852
} 
853
854
855
void LCDAD (void)               // konvertiert DATA1 nach TEMP2 und sendet auf LCD
856
{
857
  TEMP2 = DATA1;
858
  if (TEMP2 > 9999)   // größer 999, Tausender Stellen
859
  {
860
    
861
    TEMP2 = (TEMP2 / 10000);
862
    TEMP2 = (TEMP2 + 48);
863
    LCDWrite(TEMP2);
864
  }
865
  TEMP2 = DATA1;
866
  while (TEMP2 >= 10000)
867
  TEMP2 = (TEMP2 - 10000);      
868
869
  if (TEMP2 > 999)   // größer 999, Tausender Stellen
870
  {
871
    
872
    TEMP2 = (TEMP2 / 1000);
873
    TEMP2 = (TEMP2 + 48);
874
    LCDWrite(TEMP2);
875
  }
876
//  else LCDBefehl("0");
877
  TEMP2 = DATA1;
878
  while (TEMP2 >= 1000)
879
  TEMP2 = (TEMP2 - 1000); 
880
     
881
  if (TEMP2 > 99)   // größer 99, Hunderter Stellen
882
  {
883
    
884
    TEMP2 = (TEMP2 / 100);
885
    TEMP2 = (TEMP2 + 48);
886
    LCDWrite(TEMP2);
887
  }
888
//  else LCDBefehl("0"); 
889
890
  TEMP2 = DATA1;
891
  while (TEMP2 >= 100)
892
  TEMP2 = (TEMP2 - 100);
893
894
  if (TEMP2 > 9)   // Größer 9, Zehner Stellen
895
  {
896
    TEMP2 = (TEMP2 / 10);
897
    TEMP2 = (TEMP2 + 48);
898
    LCDWrite(TEMP2);
899
  }  
900
  else LCDBefehl("0");
901
902
  TEMP2 = DATA1;
903
  while (TEMP2 >= 100)
904
  TEMP2 = (TEMP2 -100);
905
  while (TEMP2 >= 10)
906
  TEMP2 = (TEMP2 -10);
907
  TEMP2 = (TEMP2 + 48);
908
  LCDWrite (TEMP2);
909
}
910
911
912
void LCDAD1 (void)               // konvertiert DATA1 nach TEMP2 und sendet auf LCD mit Komma
913
{
914
  DATA1 = (DATA1 * 0.645);
915
  TEMP2 = DATA1;
916
  while (TEMP2 >= 1000)
917
  TEMP2 = (TEMP2 - 1000); 
918
     
919
  if (TEMP2 > 99)   // größer 99, Hunderter Stellen
920
  {
921
    
922
    TEMP2 = (TEMP2 / 100);
923
    TEMP2 = (TEMP2 + 48);
924
    LCDWrite(TEMP2);
925
  }
926
  else LCDBefehl("0"); 
927
  TEMP2 = DATA1;
928
  while (TEMP2 >= 100)
929
  TEMP2 = (TEMP2 - 100);
930
931
  if (TEMP2 > 9)   // Größer 9, Zehner Stellen
932
  {
933
    TEMP2 = (TEMP2 / 10);
934
    TEMP2 = (TEMP2 + 48);
935
    LCDWrite(TEMP2);
936
  }  
937
  else LCDBefehl("0");
938
  LCDBefehl(",");
939
  TEMP2 = DATA1;
940
  while (TEMP2 >= 100)
941
  TEMP2 = (TEMP2 -100);
942
  while (TEMP2 >= 10)
943
  TEMP2 = (TEMP2 -10);
944
  TEMP2 = (TEMP2 + 48);
945
  LCDWrite (TEMP2);
946
}
947
948
949
void EELese (void)
950
{
951
  EECON1bits.EEPGD = 0;
952
  EECON1bits.CFGS = 0;
953
  EECON1bits.RD = 1;               // EEDATA = eingelesener Wert
954
}
955
956
957
void EESchreibe (void)
958
{
959
  EECON1bits.EEPGD = 0;
960
  EECON1bits.CFGS = 0;
961
  EECON1bits.WREN = 1;
962
  INTCONbits.GIE = 0; 
963
  EECON2 = 0b01010101;
964
  EECON2 = 0b10101010;
965
  EECON1bits.WR = 1;
966
  while (EECON1bits.WR == 1);      // Warten, bis Schreiben fertig
967
  INTCONbits.GIE = 1; 
968
  EECON1bits.WREN = 0;
969
}
970
971
972
void LCDWrite (char TEMP)
973
{
974
  TXREG = TEMP;             //Wert in TXREG rein und raus
975
  Delay();
976
}
977
978
979
void LCDBefehl (const rom char *buffer)
980
{
981
  while (*buffer)
982
  {
983
    LCDWrite(*buffer);
984
    *buffer++;
985
  } 
986
}
987
988
989
void FFF (void)
990
{
991
  Delay();
992
  TXREG = 255;
993
  Delay();
994
  TXREG = 255;
995
  Delay();
996
  TXREG = 255;
997
  Delay();
998
}
999
1000
1001
void Delaykurz (void)
1002
{
1003
  unsigned int i;
1004
  for (i = 0; i < 12000; i++);
1005
}
1006
1007
1008
void Delaylang (void)
1009
{
1010
  unsigned int i,a;
1011
  for (i = 0; i < 48000; i++)
1012
  ClrWdt();
1013
  for (a = 0; a < 10; a++);
1014
}
1015
1016
1017
void Delay(void)
1018
{
1019
  int i;
1020
  {
1021
    for(i=0;i<425;i++)
1022
    {
1023
      Nop();
1024
    }
1025
  } 
1026
  return;
1027
}

Beitrag #6565791 wurde vom Autor gelöscht.
von Meister E. (edson)


Bewertung
2 lesenswert
nicht lesenswert
Hallo Detlef,

man kann die Datei im XC8 kompilieren, wenn man:

* in Zeile 49 das #pragma code
* im Prototyp und in der Deklaration von LCDBefehl das 'rom' vom 'const 
rom char' weglässt

BTDT

von Meister E. (edson)


Bewertung
2 lesenswert
nicht lesenswert
Bevor einer schreit: im XC8-Compiler wird ein CONST automatisch im Flash 
abgelegt

von Meister E. (edson)


Angehängte Dateien:

Bewertung
2 lesenswert
nicht lesenswert
Achja, hier das hex-File.

von Detlef M. (dau)


Bewertung
0 lesenswert
nicht lesenswert
Meister E. schrieb:
> Achja, hier das hex-File.

WOW - Danke - ...ich bin gerade ein bisschen sprachlos.

Schade, dass meine Platine noch nicht bestückt ist und die Panels noch 
auf das Dach müssen, erst dann kann ich testen. Jedenfalls bin ich sehr 
beeindruckt von der Unterstützung hier und werde in den nächsten Tagen 
mal Eure Foren durchstöbern und schauen, ob ich mich auch einbringen 
kann.

von Route_66 H. (route_66)


Bewertung
1 lesenswert
nicht lesenswert
Detlef M. schrieb:
> und werde in den nächsten Tagen
> mal Eure Foren durchstöbern und schauen, ob ich mich auch einbringen
> kann.

Dann wirst Du hoffentlich den Hinweis bei den wichtigen Regeln zur 
Nutzung des Forums entdecken:

"Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang"

von Meister E. (edson)


Bewertung
0 lesenswert
nicht lesenswert
Route_66 H. schrieb:
> Detlef M. schrieb:
>> und werde in den nächsten Tagen
>> mal Eure Foren durchstöbern und schauen, ob ich mich auch einbringen
>> kann.
>
> Dann wirst Du hoffentlich den Hinweis bei den wichtigen Regeln zur
> Nutzung des Forums entdecken:
>
> "Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang"

War das jetzt nötig? Für die überflüssigen Leerzeilen kann er nichts und 
ich finde es positiv, dass er der Aufforderung  schnell gefolgt ist.

Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail, Yahoo oder Facebook? Keine Anmeldung erforderlich!
Mit Google-Account einloggen | Mit Facebook-Account einloggen
Noch kein Account? Hier anmelden.