[S] Suche Dienstleistung für PIC18F45K22

Detlef M. OP #6565736
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.
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Detlef M. OP #6565782
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
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Beitrag #6565791 wurde von einem Moderator gelöscht.
Detlef M. OP #6565876
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Meister E. #6566907
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.
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