Forum: Mikrocontroller und Digitale Elektronik Victron MPPT Register 200E setzen.


Victron MPPT Register 200E setzen.
von Markus A. (calimero_123)

Angehängte Dateien:
Lesenswert?
• ▲
▼ 
Guten Morgen Forum.

Ich versuche schon seit langen an einem Victron MPPT das Register 200E 
auf Charge Master zu setzen (siehe PDF Seite 19).

Mit meinem Code bin ich schon recht weit, nur das setzen dieses 
Registers "Charge master Set 0x200E to b0100001, charger uses internal 
charge profile" bekomme ich nicht hin.

Könnte da mal bitte jemand drüberschauen?

Danke

Gruss Markus

1
/*

2
  Victron1   MPPT 12 V

3
  Victron2   MPPT 24 V

4
  Victron3   BMV  24 V

5
6
  D5ED   V_MPPT   un16   0.01 V

7
  D7ED   I_MPPT   un16   0.1  A

8
  BBED VPV_MPPT   un16   0.01 V

9
  BCED PPV_MPPT   un32   0.01 W

10
  0102  CS_MPPT    un8

11
  D3ED H20_MPPT   un16   0.01 KWH

12
13
  8DED   V_BMV    un16   0.01  V

14
  8CED   I_BMV    un32   0.001 A

15
  8EED   P_BMV    un16   1     W

16
  1003 H17_BMV    un32   0.01  KWH

17
  1103 H18_BMV    un32   0.01  KWH

18
  0603  H7_BMV    un32   0.01  V

19
  0703  H8_BMV    un32   0.01  V

20
  FF0F SOC_BMV    un16   0.01  %

21
22
  Checksum:

23
  :70010003E<LF>     -> Command; checksum 0x55 – 0x7 – 0x0 – 0x10 – 0x0 = 0x3E

24
  :7001000C80076<LF> -> Response; checksum 0x55 – 0x7 – 0x0 – 0x10 – 0x0 – 0xC8 – 0x0 = 0x76

25
*/

26
27
#include <Wire.h>

28
#include <stdio.h>

29
#include <stdlib.h>

30
31
#include <LiquidCrystal_I2C.h>

32
LiquidCrystal_I2C lcd(0x27, 20, 4);

33
34
#include <Adafruit_Sensor.h>

35
#include <Adafruit_BME280.h>

36
Adafruit_BME280 bme;

37
38
#include <RunningMedian.h>

39
RunningMedian samples1 = RunningMedian(11);

40
RunningMedian samples2 = RunningMedian(11);

41
42
int interruptPin = 3;

43
int counter;

44
int Status;

45
46
#include <SoftwareSerial.h>

47
SoftwareSerial Serial_SIM900(52, 53); // RX, TX

48
49
const int vicbuf = 25;

50
const int sim900buf = 180;

51
char  vic1_ser[vicbuf];

52
char  vic2_ser[vicbuf];

53
char  vic3_ser[vicbuf];

54
char  sim900_ser[sim900buf];

55
56
float vic1_v_mppt;

57
float vic1_i_mppt;

58
float vic1_vpv_mppt;

59
long  vic1_ppv_mppt;

60
long  vic1_cs_mppt;

61
long  vic1_h20_mppt;

62
63
float vic2_v_mppt;

64
float vic2_i_mppt;

65
float vic2_vpv_mppt;

66
long  vic2_ppv_mppt;

67
long  vic2_cs_mppt;

68
long  vic2_h20_mppt;

69
long  vic2_v_mppt_r;

70
71
float vic3_v_bmv;

72
float vic3_i_bmv;

73
long  vic3_p_bmv;

74
float vic3_h17_bmv;

75
float vic3_h18_bmv;

76
float vic3_h7_bmv;

77
float vic3_h8_bmv;

78
float vic3_soc_bmv;

79
80
long  ergebniss;

81
82
float temperatur;

83
float luftfeuchtigkeit;

84
float luftdruck;

85
86
int   ina226_addr = 0x40;

87
int   shunt;

88
int   shunt_logger;

89
int   p_map;

90
int   p_ueber;

91
volatile int regel;

92
int   schalter;

93
int   error;

94
int   error_counter;

95
96
int   zaehler;

97
int   messung_1;

98
int   messung_2;

99
int   mess;

100
101
int   status_absorption;

102
int   status_float;

103
int   up_down;

104
105
int   ledPin =  LED_BUILTIN;

106
int   sim900_pin = 9;

107
108
int   K1 = 59;

109
int   K2 = 58;

110
int   K3 = 57;

111
int   K4 = 56;

112
113
byte  status_K1 = HIGH;

114
byte  status_K2 = HIGH;

115
byte  status_K3 = HIGH;

116
byte  status_K4 = HIGH;

117
118
int   p_K1 =  5;  //<<<<----p AN K1 FESTLEGEN

119
int   p_K2 = 10;  //<<<<----p AN K2 FESTLEGEN

120
int   p_K3 = 15;  //<<<<----p AN K3 FESTLEGEN

121
int   p_K4 = 20;  //<<<<----p AN K4 FESTLEGEN

122
123
byte  lcd_char_up_down[8] = {B00100, B01110, B10101, B00100, B10101, B01110, B00100, B00000};

124
byte  lcd_char_up[8]      = {B00100, B01110, B10101, B00100, B00100, B00100, B00100, B00000};

125
byte  lcd_char_down[8]    = {B00100, B00100, B00100, B00100, B10101, B01110, B00100, B00000};

126
//****************

127
void setup()

128
{

129
  Serial.begin (19200);        //USB

130
  Serial1.begin(19200);        //Victron1_MPPT 12 Volt

131
  Serial2.begin(19200);        //Victron2_MPPT 24 Volt

132
  Serial3.begin(19200);        //Victron3_BMV  24 Volt

133
  Serial_SIM900.begin(19200);  //SIM900

134
135
  Wire.begin();

136
  Wire.setClock(400000L);

137
138
  //writeRegister(0x00, 0x4E35);

139
  writeRegister(0x00, 0x4E3D);

140
141
  lcd.init();

142
  lcd.backlight();

143
  lcd.clear();

144
  fest_display();

145
146
  bme.begin(0x76);

147
148
  pinMode(sim900_pin, OUTPUT);

149
  digitalWrite(sim900_pin, LOW);

150
  pinMode(ledPin, OUTPUT);

151
  digitalWrite(ledPin, LOW);

152
153
  pinMode(K1, OUTPUT);

154
  pinMode(K2, OUTPUT);

155
  pinMode(K3, OUTPUT);

156
  pinMode(K4, OUTPUT);

157
  relais();

158
159
  lcd.createChar(0, lcd_char_up_down);

160
  lcd.createChar(1, lcd_char_up);

161
  lcd.createChar(2, lcd_char_down);

162
163
  pinMode(interruptPin, INPUT);

164
  attachInterrupt(digitalPinToInterrupt(interruptPin), nulldurchgang, RISING);

165
  DDRA |= (1 << PA0);

166
}

167
//****************

168
void loop()

169
{

170
  //Serial.print("Ram frei: "); Serial.println(freeRam());  //4014

171
172
  vic1_serial();

173
  vic2_serial();

174
  vic3_serial();

175
  sim900_error();

176
177
  time1();

178
  time2();

179
  time3();

180
  time4();

181
}

182
//****************

183
int freeRam()

184
{

185
  extern int __heap_start, *__brkval;

186
  int v;

187
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);

188
}

189
//****************

190
void time1()

191
{

192
  static unsigned long prev_millis;

193
  if (millis() - prev_millis > 500)

194
  {

195
    vic2_anfragen();

196
    vic2_display();

197
    ina_226();

198
    ueberschuss();

199
    ueberschuss_display();

200
    prev_millis = millis();

201
  }

202
}

203
void time2()

204
{

205
  static unsigned long prev_millis;

206
  if (millis() - prev_millis > 750)

207
  {

208
    vic1_anfragen();

209
    vic1_display();

210
    vic3_anfragen();

211
    vic3_display();

212
    prev_millis = millis();

213
  }

214
}

215
void time3()

216
{

217
  static unsigned long prev_millis;

218
  if (millis() - prev_millis > 1000)

219
  {

220
    thingspeak();

221
    bme280();

222
    bme280_display();

223
    prev_millis = millis();

224
  }

225
}

226
void time4()

227
{

228
  static unsigned long prev_millis;

229
  if (millis() - prev_millis > 300000)

230
  {

231
    lcd.clear();

232
    fest_display();

233
    prev_millis = millis();

234
  }

235
}

236
//****************

237
void vic1_anfragen()

238
{

239
  Serial1.println(F(":7D3ED008E"));

240
}

241
//****************

242
void vic2_anfragen()

243
{

244
  Serial2.println(F(":7D3ED008E"));

245
}

246
//****************

247
void vic3_anfragen()

248
{

249
  Serial3.println(F(":78DED00D4"));

250
  Serial3.println(F(":78CED00D5"));

251
  Serial3.println(F(":78EED00D3"));

252
  Serial3.println(F(":71003003B"));

253
  Serial3.println(F(":71103003A"));

254
  Serial3.println(F(":706030045"));

255
  Serial3.println(F(":707030044"));

256
  Serial3.println(F(":7FF0F0040"));

257
}

258
//****************

259
void vic1_serial()

260
{

261
  static byte index;

262
  while (Serial1.available())

263
  {

264
    char c = Serial1.read();

265
    if (c == '\n' && index > 0)

266
    {

267
      vic1_ser[index] = '\0';

268
      index = 0;

269
      if (((strncmp(vic1_ser, ":7", 2) == 0) || (strncmp(vic1_ser, ":A", 2) == 0)) && (strncmp(vic1_ser, "Checksum", 8) != 0))

270
      {

271
        vic1_auswerten();

272
      }

273
    }

274
    else if (index < vicbuf - 1)

275
    {

276
      vic1_ser[index++] = c;

277
    }

278
  }

279
}

280
//****************

281
void vic2_serial()

282
{

283
  static byte index;

284
  while (Serial2.available())

285
  {

286
    char c = Serial2.read();

287
    if (c == '\n' && index > 0)

288
    {

289
      vic2_ser[index] = '\0';

290
      index = 0;

291
      //Serial.println(vic2_ser);

292
      if (((strncmp(vic2_ser, ":7", 2) == 0) || (strncmp(vic2_ser, ":A", 2) == 0)) && (strncmp(vic2_ser, "Checksum", 8) != 0))

293
      {

294
        vic2_auswerten();

295
      }

296
    }

297
    else if (index < vicbuf - 1)

298
    {

299
      vic2_ser[index++] = c;

300
    }

301
  }

302
}

303
//****************

304
void vic3_serial()

305
{

306
  static byte index;

307
  while (Serial3.available())

308
  {

309
    char c = Serial3.read();

310
    if (c == '\n' && index > 0)

311
    {

312
      vic3_ser[index] = '\0';

313
      index = 0;

314
      vic3_auswerten();

315
    }

316
    else if (index < vicbuf - 1)

317
    {

318
      vic3_ser[index++] = c;

319
    }

320
  }

321
}

322
//********************

323
void sim900_error()

324
{

325
  static byte index;

326
  while (Serial_SIM900.available())

327
  {

328
    char c = Serial_SIM900.read();

329
    if (c == '\r' && index > 0)

330
    {

331
      sim900_ser[index] = '\0';

332
      index = 0;

333
      if (strncmp(sim900_ser, "\nERROR", 6) == 0)

334
      {

335
        error++;

336
        error_counter++;

337
      }

338
    }

339
    else if (index < sim900buf - 1)

340
    {

341
      sim900_ser[index++] = c;

342
    }

343
  }

344
}

345
//********************

346
void vic1_auswerten()

347
{

348
  if (strncmp(vic1_ser, ":AD5ED00", 8) == 0)

349
  {

350
    char str[5] = "";

351
    char sub3[3] = "";

352
    strncpy(sub3, &vic1_ser[12], 2);

353
    sub3[2] = '\0';

354
    hextodec(sub3);

355
    int checksum = ergebniss;

356
    char sub2[3] = "";

357
    strncpy(sub2, &vic1_ser[10], 2);

358
    sub2[2] = '\0';

359
    hextodec(sub2);

360
    int b = ergebniss;

361
    strcpy (str, sub2);

362
    char sub1[3] = "";

363
    strncpy(sub1, &vic1_ser[8], 2);

364
    sub1[2] = '\0';

365
    hextodec(sub1);

366
    int a = ergebniss;

367
    strcat (str, sub1);

368
    byte xxx = -375 - a - b;

369
    if (xxx == checksum)

370
    {

371
      hextodec(str);

372
      vic1_v_mppt = ergebniss / 100.0;

373
    }

374
    return;

375
  }

376
  if (strncmp(vic1_ser, ":AD7ED00", 8) == 0)

377
  {

378
    char str[5] = "";

379
    char sub3[3] = "";

380
    strncpy(sub3, &vic1_ser[12], 2);

381
    sub3[2] = '\0';

382
    hextodec(sub3);

383
    int checksum = ergebniss;

384
    char sub2[3] = "";

385
    strncpy(sub2, &vic1_ser[10], 2);

386
    sub2[2] = '\0';

387
    hextodec(sub2);

388
    int b = ergebniss;

389
    strcpy (str, sub2);

390
    char sub1[3] = "";

391
    strncpy(sub1, &vic1_ser[8], 2);

392
    sub1[2] = '\0';

393
    hextodec(sub1);

394
    int a = ergebniss;

395
    strcat (str, sub1);

396
    byte xxx = -377 - a - b;

397
    if (xxx == checksum)

398
    {

399
      hextodec(str);

400
      vic1_i_mppt = ergebniss / 10.0;

401
    }

402
    return;

403
  }

404
  if (strncmp(vic1_ser, ":ABBED00", 8) == 0)

405
  {

406
    char str[5] = "";

407
    char sub3[3] = "";

408
    strncpy(sub3, &vic1_ser[12], 2);

409
    sub3[2] = '\0';

410
    hextodec(sub3);

411
    int checksum = ergebniss;

412
    char sub2[3] = "";

413
    strncpy(sub2, &vic1_ser[10], 2);

414
    sub2[2] = '\0';

415
    hextodec(sub2);

416
    int b = ergebniss;

417
    strcpy (str, sub2);

418
    char sub1[3] = "";

419
    strncpy(sub1, &vic1_ser[8], 2);

420
    sub1[2] = '\0';

421
    hextodec(sub1);

422
    int a = ergebniss;

423
    strcat (str, sub1);

424
    byte xxx = -349 - a - b;

425
    if (xxx == checksum)

426
    {

427
      hextodec(str);

428
      vic1_vpv_mppt = ergebniss / 100.0;

429
    }

430
    return;

431
  }

432
  if (strncmp(vic1_ser, ":ABCED00", 8) == 0)

433
  {

434
    char str[9] = "";

435
    char sub5[3] = "";

436
    strncpy(sub5, &vic1_ser[16], 2);

437
    sub5[2] = '\0';

438
    hextodec(sub5);

439
    int checksum = ergebniss;

440
    char sub4[3] = "";

441
    strncpy(sub4, &vic1_ser[14], 2);

442
    sub4[2] = '\0';

443
    hextodec(sub4);

444
    int d = ergebniss;

445
    strcpy (str, sub4);

446
    char sub3[3] = "";

447
    strncpy(sub3, &vic1_ser[12], 2);

448
    sub3[2] = '\0';

449
    hextodec(sub3);

450
    int c = ergebniss;

451
    strcat (str, sub3);

452
    char sub2[3] = "";

453
    strncpy(sub2, &vic1_ser[10], 2);

454
    sub2[2] = '\0';

455
    hextodec(sub2);

456
    int b = ergebniss;

457
    strcat (str, sub2);

458
    char sub1[3] = "";

459
    strncpy(sub1, &vic1_ser[8], 2);

460
    sub1[2] = '\0';

461
    hextodec(sub1);

462
    int a = ergebniss;

463
    strcat (str, sub1);

464
    byte xxx = -350 - a - b - c - d;

465
    if (xxx == checksum)

466
    {

467
      hextodec(str);

468
      vic1_ppv_mppt = ergebniss / 100;

469
    }

470
    return;

471
  }

472
  if (strncmp(vic1_ser, ":A010200", 8) == 0)

473
  {

474
    char sub2[3] = "";

475
    strncpy(sub2, &vic1_ser[10], 2);

476
    sub2[2] = '\0';

477
    hextodec(sub2);

478
    int checksum = ergebniss;

479
    char sub1[3] = "";

480
    strncpy(sub1, &vic1_ser[8], 2);

481
    sub1[2] = '\0';

482
    hextodec(sub1);

483
    int a = ergebniss;

484
    byte xxx = 72 - a;

485
    if (xxx == checksum)

486
    {

487
      vic1_cs_mppt = ergebniss;

488
    }

489
    return;

490
  }

491
  if (strncmp(vic1_ser, ":7D3ED00", 8) == 0)

492
  {

493
    char str[5] = "";

494
    char sub3[3] = "";

495
    strncpy(sub3, &vic1_ser[12], 2);

496
    sub3[2] = '\0';

497
    hextodec(sub3);

498
    int checksum = ergebniss;

499
    char sub2[3] = "";

500
    strncpy(sub2, &vic1_ser[10], 2);

501
    sub2[2] = '\0';

502
    hextodec(sub2);

503
    int b = ergebniss;

504
    strcpy (str, sub2);

505
    char sub1[3] = "";

506
    strncpy(sub1, &vic1_ser[8], 2);

507
    sub1[2] = '\0';

508
    hextodec(sub1);

509
    int a = ergebniss;

510
    strcat (str, sub1);

511
    byte xxx = -370 - a - b;

512
    if (xxx == checksum)

513
    {

514
      hextodec(str);

515
      vic1_h20_mppt = ergebniss * 10;

516
    }

517
    return;

518
  }

519
}

520
//****************

521
void vic2_auswerten()

522
{

523
  if (strncmp(vic2_ser, ":AD5ED00", 8) == 0)

524
  {

525
    char str[5];

526
    char sub3[3] = "";

527
    strncpy(sub3, &vic2_ser[12], 2);

528
    sub3[2] = '\0';

529
    hextodec(sub3);

530
    int checksum = ergebniss;

531
    char sub2[3] = "";

532
    strncpy(sub2, &vic2_ser[10], 2);

533
    sub2[2] = '\0';

534
    hextodec(sub2);

535
    int b = ergebniss;

536
    strcpy (str, sub2);

537
    char sub1[3] = "";

538
    strncpy(sub1, &vic2_ser[8], 2);

539
    sub1[2] = '\0';

540
    hextodec(sub1);

541
    int a = ergebniss;

542
    strcat (str, sub1);

543
    byte xxx = -375 - a - b;

544
    if (xxx == checksum)

545
    {

546
      hextodec(str);

547
      vic2_v_mppt_r = ergebniss;

548
      vic2_v_mppt = ergebniss / 100.0;

549
    }

550
    return;

551
  }

552
  if (strncmp(vic2_ser, ":AD7ED00", 8) == 0)

553
  {

554
    char str[5];

555
    char sub3[3] = "";

556
    strncpy(sub3, &vic2_ser[12], 2);

557
    sub3[2] = '\0';

558
    hextodec(sub3);

559
    int checksum = ergebniss;

560
    char sub2[3] = "";

561
    strncpy(sub2, &vic2_ser[10], 2);

562
    sub2[2] = '\0';

563
    hextodec(sub2);

564
    int b = ergebniss;

565
    strcpy (str, sub2);

566
    char sub1[3] = "";

567
    strncpy(sub1, &vic2_ser[8], 2);

568
    sub1[2] = '\0';

569
    hextodec(sub1);

570
    int a = ergebniss;

571
    strcat (str, sub1);

572
    byte xxx = -377 - a - b;

573
    if (xxx == checksum)

574
    {

575
      hextodec(str);

576
      vic2_i_mppt = ergebniss / 10.0;

577
    }

578
    return;

579
  }

580
  if (strncmp(vic2_ser, ":ABBED00", 8) == 0)

581
  {

582
    char str[5];

583
    char sub3[3] = "";

584
    strncpy(sub3, &vic2_ser[12], 2);

585
    sub3[2] = '\0';

586
    hextodec(sub3);

587
    int checksum = ergebniss;

588
    char sub2[3] = "";

589
    strncpy(sub2, &vic2_ser[10], 2);

590
    sub2[2] = '\0';

591
    hextodec(sub2);

592
    int b = ergebniss;

593
    strcpy (str, sub2);

594
    char sub1[3] = "";

595
    strncpy(sub1, &vic2_ser[8], 2);

596
    sub1[2] = '\0';

597
    hextodec(sub1);

598
    int a = ergebniss;

599
    strcat (str, sub1);

600
    byte xxx = -349 - a - b;

601
    if (xxx == checksum)

602
    {

603
      hextodec(str);

604
      vic2_vpv_mppt = ergebniss / 100.0;

605
    }

606
    return;

607
  }

608
  if (strncmp(vic2_ser, ":ABCED00", 8) == 0)

609
  {

610
    digitalWrite(ledPin, HIGH);

611
    char str[9];

612
    char sub5[3] = "";

613
    strncpy(sub5, &vic2_ser[16], 2);

614
    sub5[2] = '\0';

615
    hextodec(sub5);

616
    int checksum = ergebniss;

617
    char sub4[3] = "";

618
    strncpy(sub4, &vic2_ser[14], 2);

619
    sub4[2] = '\0';

620
    hextodec(sub4);

621
    int d = ergebniss;

622
    strcpy (str, sub4);

623
    char sub3[3] = "";

624
    strncpy(sub3, &vic2_ser[12], 2);

625
    sub3[2] = '\0';

626
    hextodec(sub3);

627
    int c = ergebniss;

628
    strcat (str, sub3);

629
    char sub2[3] = "";

630
    strncpy(sub2, &vic2_ser[10], 2);

631
    sub2[2] = '\0';

632
    hextodec(sub2);

633
    int b = ergebniss;

634
    strcat (str, sub2);

635
    char sub1[3] = "";

636
    strncpy(sub1, &vic2_ser[8], 2);

637
    sub1[2] = '\0';

638
    hextodec(sub1);

639
    int a = ergebniss;

640
    strcat (str, sub1);

641
    byte xxx = -350 - a - b - c - d;

642
    if (xxx == checksum)

643
    {

644
      hextodec(str);

645
      vic2_ppv_mppt = ergebniss / 100;

646
    }

647
    digitalWrite(ledPin, LOW);

648
    return;

649
  }

650
  if (strncmp(vic2_ser, ":A010200", 8) == 0)

651
  {

652
    char sub2[3] = "";

653
    strncpy(sub2, &vic2_ser[10], 2);

654
    sub2[2] = '\0';

655
    hextodec(sub2);

656
    int checksum = ergebniss;

657
    char sub1[3] = "";

658
    strncpy(sub1, &vic2_ser[8], 2);

659
    sub1[2] = '\0';

660
    hextodec(sub1);

661
    int a = ergebniss;

662
    byte xxx = 72 - a;

663
    if (xxx == checksum)

664
    {

665
      vic2_cs_mppt = ergebniss;

666
    }

667
    return;

668
  }

669
  if (strncmp(vic2_ser, ":7D3ED00", 8) == 0)

670
  {

671
    char str[5];

672
    char sub3[3] = "";

673
    strncpy(sub3, &vic2_ser[12], 2);

674
    sub3[2] = '\0';

675
    hextodec(sub3);

676
    int checksum = ergebniss;

677
    char sub2[3] = "";

678
    strncpy(sub2, &vic2_ser[10], 2);

679
    sub2[2] = '\0';

680
    hextodec(sub2);

681
    int b = ergebniss;

682
    strcpy (str, sub2);

683
    char sub1[3] = "";

684
    strncpy(sub1, &vic2_ser[8], 2);

685
    sub1[2] = '\0';

686
    hextodec(sub1);

687
    int a = ergebniss;

688
    strcat (str, sub1);

689
    byte xxx = -370 - a - b;

690
    if (xxx == checksum)

691
    {

692
      hextodec(str);

693
      vic2_h20_mppt = ergebniss * 10;

694
    }

695
    return;

696
  }

697
}

698
//****************

699
void vic3_auswerten()

700
{

701
  if (strncmp(vic3_ser, ":78DED00", 8) == 0)

702
  {

703
    char str[5];

704
    char sub3[3] = "";

705
    strncpy(sub3, &vic3_ser[12], 2);

706
    sub3[2] = '\0';

707
    hextodec(sub3);

708
    int checksum = ergebniss;

709
    char sub2[3] = "";

710
    strncpy(sub2, &vic3_ser[10], 2);

711
    sub2[2] = '\0';

712
    hextodec(sub2);

713
    int b = ergebniss;

714
    strcpy (str, sub2);

715
    char sub1[3] = "";

716
    strncpy(sub1, &vic3_ser[8], 2);

717
    sub1[2] = '\0';

718
    hextodec(sub1);

719
    int a = ergebniss;

720
    strcat (str, sub1);

721
    byte xxx = -300 - a - b;

722
    if (xxx == checksum)

723
    {

724
      hextodec(str);

725
      vic3_v_bmv = ergebniss / 100.0;

726
    }

727
    return;

728
  }

729
  if (strncmp(vic3_ser, ":78CED00", 8) == 0)

730
  {

731
    char str[9];

732
    char sub5[3] = "";

733
    strncpy(sub5, &vic3_ser[16], 2);

734
    sub5[2] = '\0';

735
    hextodec(sub5);

736
    int checksum = ergebniss;

737
    char sub4[3] = "";

738
    strncpy(sub4, &vic3_ser[14], 2);

739
    sub4[2] = '\0';

740
    hextodec(sub4);

741
    int d = ergebniss;

742
    strcpy (str, sub4);

743
    char sub3[3] = "";

744
    strncpy(sub3, &vic3_ser[12], 2);

745
    sub3[2] = '\0';

746
    hextodec(sub3);

747
    int c = ergebniss;

748
    strcat (str, sub3);

749
    char sub2[3] = "";

750
    strncpy(sub2, &vic3_ser[10], 2);

751
    sub2[2] = '\0';

752
    hextodec(sub2);

753
    int b = ergebniss;

754
    strcat (str, sub2);

755
    char sub1[3] = "";

756
    strncpy(sub1, &vic3_ser[8], 2);

757
    sub1[2] = '\0';

758
    hextodec(sub1);

759
    int a = ergebniss;

760
    strcat (str, sub1);

761
    byte xxx = -299 - a - b - c - d;

762
    if (xxx == checksum)

763
    {

764
      hextodec(str);

765
      vic3_i_bmv = ergebniss / 1000.0;

766
    }

767
    return;

768
  }

769
  if (strncmp(vic3_ser, ":78EED00", 8) == 0)

770
  {

771
    char str[5];

772
    char sub3[3] = "";

773
    strncpy(sub3, &vic3_ser[12], 2);

774
    sub3[2] = '\0';

775
    hextodec(sub3);

776
    int checksum = ergebniss;

777
    char sub2[3] = "";

778
    strncpy(sub2, &vic3_ser[10], 2);

779
    sub2[2] = '\0';

780
    hextodec(sub2);

781
    int b = ergebniss;

782
    strcpy (str, sub2);

783
    char sub1[3] = "";

784
    strncpy(sub1, &vic3_ser[8], 2);

785
    sub1[2] = '\0';

786
    hextodec(sub1);

787
    int a = ergebniss;

788
    strcat (str, sub1);

789
    byte xxx = -301 - a - b;

790
    if (xxx == checksum)

791
    {

792
      hextodec(str);

793
      vic3_p_bmv = ergebniss;

794
    }

795
    return;

796
  }

797
  if (strncmp(vic3_ser, ":7100300", 8) == 0)

798
  {

799
    char str[9];

800
    char sub5[3] = "";

801
    strncpy(sub5, &vic3_ser[16], 2);

802
    sub5[2] = '\0';

803
    hextodec(sub5);

804
    int checksum = ergebniss;

805
    char sub4[3] = "";

806
    strncpy(sub4, &vic3_ser[14], 2);

807
    sub4[2] = '\0';

808
    hextodec(sub4);

809
    int d = ergebniss;

810
    strcpy (str, sub4);

811
    char sub3[3] = "";

812
    strncpy(sub3, &vic3_ser[12], 2);

813
    sub3[2] = '\0';

814
    hextodec(sub3);

815
    int c = ergebniss;

816
    strcat (str, sub3);

817
    char sub2[3] = "";

818
    strncpy(sub2, &vic3_ser[10], 2);

819
    sub2[2] = '\0';

820
    hextodec(sub2);

821
    int b = ergebniss;

822
    strcat (str, sub2);

823
    char sub1[3] = "";

824
    strncpy(sub1, &vic3_ser[8], 2);

825
    sub1[2] = '\0';

826
    hextodec(sub1);

827
    int a = ergebniss;

828
    strcat (str, sub1);

829
    byte xxx = 59 - a - b - c - d;

830
    if (xxx == checksum)

831
    {

832
      hextodec(str);

833
      vic3_h17_bmv = ergebniss / 100.0;

834
    }

835
    return;

836
  }

837
  if (strncmp(vic3_ser, ":7110300", 8) == 0)

838
  {

839
    char str[9];

840
    char sub5[3] = "";

841
    strncpy(sub5, &vic3_ser[16], 2);

842
    sub5[2] = '\0';

843
    hextodec(sub5);

844
    int checksum = ergebniss;

845
    char sub4[3] = "";

846
    strncpy(sub4, &vic3_ser[14], 2);

847
    sub4[2] = '\0';

848
    hextodec(sub4);

849
    int d = ergebniss;

850
    strcpy (str, sub4);

851
    char sub3[3] = "";

852
    strncpy(sub3, &vic3_ser[12], 2);

853
    sub3[2] = '\0';

854
    hextodec(sub3);

855
    int c = ergebniss;

856
    strcat (str, sub3);

857
    char sub2[3] = "";

858
    strncpy(sub2, &vic3_ser[10], 2);

859
    sub2[2] = '\0';

860
    hextodec(sub2);

861
    int b = ergebniss;

862
    strcat (str, sub2);

863
    char sub1[3] = "";

864
    strncpy(sub1, &vic3_ser[8], 2);

865
    sub1[2] = '\0';

866
    hextodec(sub1);

867
    int a = ergebniss;

868
    strcat (str, sub1);

869
    byte xxx = 58 - a - b - c - d;

870
    if (xxx == checksum)

871
    {

872
      hextodec(str);

873
      vic3_h18_bmv = ergebniss / 100.0;

874
    }

875
    return;

876
  }

877
  if (strncmp(vic3_ser, ":7060300", 8) == 0)

878
  {

879
    char str[9];

880
    char sub5[3] = "";

881
    strncpy(sub5, &vic3_ser[16], 2);

882
    sub5[2] = '\0';

883
    hextodec(sub5);

884
    int checksum = ergebniss;

885
    char sub4[3] = "";

886
    strncpy(sub4, &vic3_ser[14], 2);

887
    sub4[2] = '\0';

888
    hextodec(sub4);

889
    int d = ergebniss;

890
    strcpy (str, sub4);

891
    char sub3[3] = "";

892
    strncpy(sub3, &vic3_ser[12], 2);

893
    sub3[2] = '\0';

894
    hextodec(sub3);

895
    int c = ergebniss;

896
    strcat (str, sub3);

897
    char sub2[3] = "";

898
    strncpy(sub2, &vic3_ser[10], 2);

899
    sub2[2] = '\0';

900
    hextodec(sub2);

901
    int b = ergebniss;

902
    strcat (str, sub2);

903
    char sub1[3] = "";

904
    strncpy(sub1, &vic3_ser[8], 2);

905
    sub1[2] = '\0';

906
    hextodec(sub1);

907
    int a = ergebniss;

908
    strcat (str, sub1);

909
    byte xxx = 69 - a - b - c - d;

910
911
    if (xxx == checksum)

912
    {

913
      hextodec(str);

914
      vic3_h7_bmv = ergebniss / 100.0;

915
    }

916
    return;

917
  }

918
  if (strncmp(vic3_ser, ":7070300", 8) == 0)

919
  {

920
    char str[9];

921
    char sub5[3] = "";

922
    strncpy(sub5, &vic3_ser[16], 2);

923
    sub5[2] = '\0';

924
    hextodec(sub5);

925
    int checksum = ergebniss;

926
    char sub4[3] = "";

927
    strncpy(sub4, &vic3_ser[14], 2);

928
    sub4[2] = '\0';

929
    hextodec(sub4);

930
    int d = ergebniss;

931
    strcpy (str, sub4);

932
    char sub3[3] = "";

933
    strncpy(sub3, &vic3_ser[12], 2);

934
    sub3[2] = '\0';

935
    hextodec(sub3);

936
    int c = ergebniss;

937
    strcat (str, sub3);

938
    char sub2[3] = "";

939
    strncpy(sub2, &vic3_ser[10], 2);

940
    sub2[2] = '\0';

941
    hextodec(sub2);

942
    int b = ergebniss;

943
    strcat (str, sub2);

944
    char sub1[3] = "";

945
    strncpy(sub1, &vic3_ser[8], 2);

946
    sub1[2] = '\0';

947
    hextodec(sub1);

948
    int a = ergebniss;

949
    strcat (str, sub1);

950
    byte xxx = 68 - a - b - c - d;

951
    if (xxx == checksum)

952
    {

953
      hextodec(str);

954
      vic3_h8_bmv = ergebniss / 100.0;

955
    }

956
    return;

957
  }

958
  if (strncmp(vic3_ser, ":7FF0F00", 8) == 0)

959
  {

960
    char str[5];

961
    char sub3[3] = "";

962
    strncpy(sub3, &vic3_ser[12], 2);

963
    sub3[2] = '\0';

964
    hextodec(sub3);

965
    int checksum = ergebniss;

966
    char sub2[3] = "";

967
    strncpy(sub2, &vic3_ser[10], 2);

968
    sub2[2] = '\0';

969
    hextodec(sub2);

970
    int b = ergebniss;

971
    strcpy (str, sub2);

972
    char sub1[3] = "";

973
    strncpy(sub1, &vic3_ser[8], 2);

974
    sub1[2] = '\0';

975
    hextodec(sub1);

976
    int a = ergebniss;

977
    strcat (str, sub1);

978
    byte xxx = -192 - a - b;

979
    if (xxx == checksum)

980
    {

981
      hextodec(str);

982
      vic3_soc_bmv = ergebniss / 100.0;

983
    }

984
    return;

985
  }

986
}

987
//****************

988
long hextodec(char*hdec)

989
{

990
  ergebniss = 0;

991
  while (*hdec)

992
  {

993
    long onebyte = *hdec++;

994
    if (onebyte >= '0' && onebyte <= '9')

995
    {

996
      onebyte = onebyte - '0';

997
    }

998
    else if (onebyte >= 'a' && onebyte <= 'f')

999
    {

1000
      onebyte = onebyte - 'a' + 10;

1001
    }

1002
    else if (onebyte >= 'A' && onebyte <= 'F')

1003
    {

1004
      onebyte = onebyte - 'A' + 10;

1005
    }

1006
    ergebniss = (ergebniss << 4) | (onebyte & 0xF);

1007
  }

1008
  return ergebniss;

1009
}

1010
//********************

1011
void ina_226()

1012
{

1013
  shunt = readRegister(0x01);

1014
  if (shunt && 0x8000)

1015
  {

1016
    shunt = ~shunt;

1017
    shunt += 1;

1018
    shunt *= -1 ;

1019
  }

1020
  shunt_logger = shunt;

1021
  shunt   = constrain(shunt, 3000, 17500);

1022
  p_map   = (map(shunt, 3000, 17500, 0, 13000 )) / 10;

1023
  p_ueber = (p_map - vic2_ppv_mppt);

1024
  //p_ueber = constrain(p_ueber, 0, 1300);

1025
}

1026
//********************

1027
void ueberschuss()

1028
{

1029
  if (vic2_cs_mppt != 4 && vic2_cs_mppt != 5)

1030
  {

1031
    reset();

1032
    relais();

1033
    return;

1034
  }

1035
  if (vic2_cs_mppt == 4 && status_float == 0)

1036
  {

1037
    status_absorption = 0;

1038
    status_float = 1;

1039
    reset();

1040
    relais();

1041
  }

1042
  if (vic2_cs_mppt == 5 && status_absorption == 0)

1043
  {

1044
    status_absorption = 1;

1045
    status_float = 0;

1046
    reset();

1047
    relais();

1048
  }

1049
  if (zaehler < 120)

1050
  {

1051
    if (zaehler < 60)

1052
    {

1053
      messung_1 = samples1.getMedian();

1054
      mess = 1;

1055
    }

1056
    if (zaehler >= 60)

1057
    {

1058
      messung_2 = samples2.getMedian();

1059
      mess = 2;

1060
    }

1061
    samples1.add(vic2_v_mppt_r);

1062
    samples2.add(vic2_v_mppt_r);

1063
    zaehler++;

1064
  }

1065
  if (zaehler == 120)

1066
  {

1067
    mess = 3;

1068
    if (abs(messung_1 - messung_2) <= 3)  //<<<<<----- 0.03 Volt

1069
    {

1070
      if (vic2_v_mppt_r > (min(messung_1, messung_2)) - 20)  //<<<<<-----0.2 Volt

1071
      {

1072
        if (p_ueber > p_K1 && status_K2 == HIGH && status_K3 == HIGH && status_K4 == HIGH)

1073
        {

1074
          status_K1 = LOW;

1075
        }

1076
        if (p_ueber <= 0 && status_K2 == HIGH && status_K3 == HIGH && status_K4 == HIGH)

1077
        {

1078
          status_K1 = HIGH;

1079
        }

1080
        if (p_ueber > p_K2 && status_K1 == LOW && status_K3 == HIGH && status_K4 == HIGH)

1081
        {

1082
          status_K2 = LOW;

1083
        }

1084
        if (p_ueber <= 0 && status_K1 == LOW && status_K3 == HIGH && status_K4 == HIGH)

1085
        {

1086
          status_K2 = HIGH;

1087
        }

1088
        if (p_ueber > p_K3 && status_K1 == LOW && status_K2 == LOW && status_K4 == HIGH)

1089
        {

1090
          status_K3 = LOW;

1091
        }

1092
        if (p_ueber <= 0 && status_K1 == LOW && status_K2 == LOW && status_K4 == HIGH)

1093
        {

1094
          status_K3 = HIGH;

1095
        }

1096
        if (p_ueber > p_K4 && status_K1 == LOW && status_K2 == LOW && status_K3 == LOW)

1097
        {

1098
          status_K4 = LOW;

1099
        }

1100
        if (p_ueber <= 0 && regel == 0 && status_K1 == LOW && status_K2 == LOW && status_K3 == LOW)

1101
        {

1102
          status_K4 = HIGH;

1103
          up_down = 0;

1104
        }

1105
        if (p_ueber > 100 && status_K1 == LOW && status_K2 == LOW && status_K3 == LOW && status_K4 == LOW)

1106
        {

1107
          static unsigned long prev_millis;

1108
          if (millis() - prev_millis > 2000)

1109
          {

1110
            prev_millis = millis();

1111
          }

1112
          regel++;

1113
          up_down = 1;

1114
        }

1115
        if (p_ueber <= 20 && status_K1 == LOW && status_K2 == LOW && status_K3 == LOW && status_K4 == LOW)

1116
        {

1117
          regel--;

1118
          up_down = 2;

1119
        }

1120
      }

1121
      else

1122
      {

1123
        regel = regel - 2;

1124
        up_down = 2;

1125
      }

1126
    }

1127
    else

1128
    {

1129
      reset();

1130
    }

1131
  }

1132
  relais();

1133
  regel = constrain(regel, 0, 20);

1134
}

1135
//****************

1136
void nulldurchgang()

1137
{

1138
  //regel = 8;

1139
  if (counter == 20) counter = 0;

1140
  if (counter == 0) Status = 1;

1141
  if (counter == regel) Status = 0;

1142
  PORTA = (Status << PA0);

1143
  counter++;

1144
}

1145
//********************

1146
void reset()

1147
{

1148
  zaehler = 0;

1149
  messung_1 = 0;

1150
  messung_2 = 0;

1151
  mess = 0;

1152
  regel = 0;

1153
  up_down = 0;

1154
  status_K1 = HIGH;

1155
  status_K2 = HIGH;

1156
  status_K3 = HIGH;

1157
  status_K4 = HIGH;

1158
}

1159
//********************

1160
void relais()

1161
{

1162
  digitalWrite(K1, status_K1);

1163
  digitalWrite(K2, status_K2);

1164
  digitalWrite(K3, status_K3);

1165
  digitalWrite(K4, status_K4);

1166
}

1167
//********************

1168
void thingspeak()

1169
{

1170
  schalter++;

1171
  switch (schalter)

1172
  {

1173
    case   1: digitalWrite(sim900_pin, HIGH); break;

1174
    case   2: digitalWrite(sim900_pin, LOW); break;

1175
    case  22: Serial_SIM900.println(F("AT+CIPSHUT")); break;

1176
    case  24: Serial_SIM900.println(F("ATE0")); break;

1177
    case  26: Serial_SIM900.println(F("AT+CIPMUX=0")); break;

1178
    case  28: Serial_SIM900.println(F("AT+CSTT=\"internet\"")); break;

1179
    case  30: Serial_SIM900.println(F("AT+CIICR")); break;

1180
    case  32: Serial_SIM900.println(F("AT+CIFSR")); break;

1181
    case  34: Serial_SIM900.println(F("AT+CIPSPRT=0")); break;

1182
    case  36: Serial_SIM900.println(F("AT+CSQ")); break;

1183
    case  38: Serial_SIM900.println(F("AT+CIPSTART=\"TCP\",\"api.thingspeak.com\",\"80\"")); break;

1184
    case  41: Serial_SIM900.println(F("AT+CIPSEND")); break;

1185
    case  43: daten1(); break;

1186
    case  45: Serial_SIM900.println((char)26); break;

1187
    case  53: Serial_SIM900.println(F("AT+CIPSTART=\"TCP\",\"api.thingspeak.com\",\"80\"")); break;

1188
    case  56: Serial_SIM900.println(F("AT+CIPSEND")); break;

1189
    case  58: daten2(); break;

1190
    case  60: Serial_SIM900.println((char)26); break;

1191
    case  68: Serial_SIM900.println(F("AT+CIPSTART=\"TCP\",\"api.thingspeak.com\",\"80\"")); break;

1192
    case  71: Serial_SIM900.println(F("AT+CIPSEND")); break;

1193
    case  73: daten3(); break;

1194
    case  75: Serial_SIM900.println((char)26); break;

1195
    case  83: Serial_SIM900.println(F("AT+CIPSTART=\"TCP\",\"api.thingspeak.com\",\"80\"")); break;

1196
    case  86: Serial_SIM900.println(F("AT+CIPSEND")); break;

1197
    case  88: daten4(); break;

1198
    case  90: Serial_SIM900.println((char)26); break;

1199
    case  98:

1200
      schalter = 37;

1201
      if (error >= 1)

1202
      {

1203
        schalter = 21;

1204
        error = 0;

1205
      }

1206
      break;

1207
  }

1208
}

1209
//................

1210
void daten1()

1211
//MPPT 100/50 12 Volt

1212
{

1213
  char v[10];

1214
  char i[10];

1215
  char vpv[10];

1216
  char ppv[10];

1217
  char h20[10];

1218
  char cs[10];

1219
1220
  dtostrf(vic1_v_mppt, 1, 2, v );

1221
  dtostrf(vic1_i_mppt, 1, 2, i );

1222
  dtostrf(vic1_vpv_mppt, 1, 2, vpv );

1223
  itoa(vic1_ppv_mppt, ppv, 10 );

1224
  itoa(vic1_h20_mppt, h20, 10 );

1225
  itoa(vic1_cs_mppt, cs, 10 );

1226
1227
  char daten1[180] = "GET http://api.thingspeak.com/update?api_key=MC6V8698TB8GXDS3&field1=";

1228
  strcat (daten1, v);  //MPPT Spannung

1229
  strcat (daten1, "&field2=");

1230
  strcat (daten1, i);  //MPPT Strom

1231
  strcat (daten1, "&field3=");

1232
  strcat (daten1, vpv);  //PV Spannung

1233
  strcat (daten1, "&field4=");

1234
  strcat (daten1, ppv);  //PV Leistung

1235
  strcat (daten1, "&field5=");

1236
  strcat (daten1, h20);  //Wh/Tag

1237
  strcat (daten1, "&field6=");

1238
  strcat (daten1, cs);  //Status

1239
  Serial_SIM900.println(daten1);

1240
}

1241
//................

1242
void daten2()

1243
//MPPT 100/50 24 Volt

1244
{

1245
  char v[10];

1246
  char i[10];

1247
  char vpv[10];

1248
  char ppv[10];

1249
  char h20[10];

1250
  char cs[10];

1251
  char p_ueber_[10];

1252
  char regel_[10];

1253
1254
  dtostrf(vic2_v_mppt, 1, 2, v );

1255
  dtostrf(vic2_i_mppt, 1, 2, i );

1256
  dtostrf(vic2_vpv_mppt, 1, 2, vpv );

1257
  itoa(vic2_ppv_mppt, ppv, 10 );

1258
  itoa(vic2_h20_mppt, h20, 10 );

1259
  itoa(vic2_cs_mppt, cs, 10 );

1260
  itoa(p_ueber, p_ueber_, 10 );

1261
  itoa(regel, regel_, 10 );

1262
1263
  char daten2[180] = "GET http://api.thingspeak.com/update?api_key=5Y645SG09QQZ3NA8&field1=";

1264
  strcat (daten2, v);  //MPPT Spannung

1265
  strcat (daten2, "&field2=");

1266
  strcat (daten2, i);  //MPPT Strom

1267
  strcat (daten2, "&field3=");

1268
  strcat (daten2, vpv);  //PV Spannung

1269
  strcat (daten2, "&field4=");

1270
  strcat (daten2, ppv);  //PV Leistung

1271
  strcat (daten2, "&field5=");

1272
  strcat (daten2, h20);  //Wh/Tag

1273
  strcat (daten2, "&field6=");

1274
  strcat (daten2, cs);  //Status

1275
  strcat (daten2, "&field7=");

1276
  strcat (daten2, p_ueber_); // Überschuss Leistung

1277
  strcat (daten2, "&field8=");

1278
  strcat (daten2, regel_);  // Last 0 - 255

1279
  Serial_SIM900.println(daten2);

1280
}

1281
//................

1282
void daten3()

1283
//BMV 702 24 Volt

1284
{

1285
  char v[10];

1286
  char i[10];

1287
  char p[10];

1288
  char h18[10];

1289
  char h17[10];

1290
  char h8[10];

1291
  char h7[10];

1292
  char soc[10];

1293
1294
  dtostrf(vic3_v_bmv, 1, 2, v );

1295
  dtostrf(vic3_i_bmv, 1, 2, i );

1296
  itoa(vic3_p_bmv, p , 10 );

1297
  dtostrf(vic3_h18_bmv, 1, 2, h18 );

1298
  dtostrf(vic3_h17_bmv, 1, 2, h17 );

1299
  dtostrf(vic3_h8_bmv, 1, 2, h8 );

1300
  dtostrf(vic3_h7_bmv, 1, 2, h7 );

1301
  dtostrf(vic3_soc_bmv, 1, 2, soc );

1302
1303
  char daten3[180] = "GET http://api.thingspeak.com/update?api_key=XDJ604T15I5ZNIWS&field1=";

1304
  strcat (daten3, v);  //BMV Spannung

1305
  strcat (daten3, "&field2=");

1306
  strcat (daten3, i);  //BMV Strom

1307
  strcat (daten3, "&field3=");

1308
  strcat (daten3, p);  //BMV Leistung

1309
  strcat (daten3, "&field4=");

1310
  strcat (daten3, h18);  //KWH geladen

1311
  strcat (daten3, "&field5=");

1312
  strcat (daten3, h17);  //KWH entladen

1313
  strcat (daten3, "&field6=");

1314
  strcat (daten3, h8);  //höchste Spannung

1315
  strcat (daten3, "&field7=");

1316
  strcat (daten3, h7);  //niedrigste Spannung

1317
  strcat (daten3, "&field8=");

1318
  strcat (daten3, soc);  //SOC

1319
  Serial_SIM900.println(daten3);

1320
}

1321
//................

1322
void daten4()

1323
//BME 280 / SIM 900

1324
{

1325
  char temperatur_[10];

1326
  char luftfeuchtigkeit_[10];

1327
  char luftdruck_[10];

1328
  char error_counter_[10];

1329
  char shunt_logger_[10];

1330
1331
  dtostrf(temperatur, 1, 2, temperatur_);

1332
  dtostrf(luftfeuchtigkeit, 1, 2, luftfeuchtigkeit_);

1333
  dtostrf(luftdruck, 1, 2, luftdruck_);

1334
  itoa(error_counter, error_counter_ , 10 );

1335
  itoa(shunt_logger, shunt_logger_ , 10 );

1336
1337
  char daten4[180] = "GET http://api.thingspeak.com/update?api_key=YNYKLGS425SLZ828&field1=";

1338
  strcat (daten4, temperatur_);  //Temperatur

1339
  strcat (daten4, "&field2=");

1340
  strcat (daten4, luftfeuchtigkeit_);  //Luftfeuchtigkeit

1341
  strcat (daten4, "&field3=");

1342
  strcat (daten4, luftdruck_);  //Luftdruck

1343
  strcat (daten4, "&field4=");

1344
  strcat (daten4, error_counter_);  //SIM 900 Error

1345
  strcat (daten4, "&field5=");

1346
  strcat (daten4, shunt_logger_);  //Einstrahlung

1347
  Serial_SIM900.println(daten4);

1348
}

1349
//********************

1350
void fest_display()

1351
{

1352
  lcd.clear();

1353
1354
  lcd.setCursor (5, 0);

1355
  lcd.print(F("V"));

1356
  lcd.setCursor (13, 0);

1357
  lcd.print(F("A"));

1358
1359
  lcd.setCursor (5, 1);

1360
  lcd.print(F("V"));

1361
  lcd.setCursor (13, 1);

1362
  lcd.print(F("A"));

1363
1364
  lcd.setCursor (5, 2);

1365
  lcd.print(F("V"));

1366
  lcd.setCursor (13, 2);

1367
  lcd.print(F("A"));

1368
1369
  lcd.setCursor (5, 3);

1370
  lcd.print(F("W"));

1371
1372
  lcd.setCursor (18, 3);

1373
  lcd.write(0xdf); //Grad Zeichen

1374
  lcd.setCursor (19, 3);

1375
  lcd.print(F("C"));

1376
}

1377
//********************

1378
void vic1_display()

1379
{

1380
  lcd.setCursor (0, 0);

1381
  lcd.print(vic1_v_mppt);

1382
1383
  lcd.setCursor (9, 0);

1384
  if (vic1_i_mppt < 9.995) lcd.print(F(" "));

1385
  lcd.print(vic1_i_mppt, 1);

1386
1387
  lcd.setCursor (15, 0);

1388
  if (vic1_cs_mppt == 0)   lcd.print(F("AUS  "));

1389
  if (vic1_cs_mppt == 2)   lcd.print(F("FAULT"));

1390
  if (vic1_cs_mppt == 3)   lcd.print(F("BULK "));

1391
  if (vic1_cs_mppt == 4)   lcd.print(F("ABS  "));

1392
  if (vic1_cs_mppt == 5)   lcd.print(F("FLOAT"));

1393
  if (vic1_cs_mppt == 7)   lcd.print(F("EQU M"));

1394
  if (vic1_cs_mppt == 245) lcd.print(F("START"));

1395
  if (vic1_cs_mppt == 247) lcd.print(F("EQU A"));

1396
  if (vic1_cs_mppt == 252) lcd.print(F("EXT  "));

1397
}

1398
//********************

1399
void vic2_display()

1400
{

1401
  lcd.setCursor (0, 1);

1402
  lcd.print(vic2_v_mppt);

1403
1404
  lcd.setCursor (9, 1);

1405
  if (vic2_i_mppt < 9.995) lcd.print(F(" "));

1406
  lcd.print(vic2_i_mppt, 1);

1407
1408
  lcd.setCursor (15, 1);

1409
  if (vic2_cs_mppt == 0)   lcd.print(F("AUS  "));

1410
  if (vic2_cs_mppt == 2)   lcd.print(F("FAULT"));

1411
  if (vic2_cs_mppt == 3)   lcd.print(F("BULK "));

1412
  if (vic2_cs_mppt == 4)   lcd.print(F("ABS  "));

1413
  if (vic2_cs_mppt == 5)   lcd.print(F("FLOAT"));

1414
  if (vic2_cs_mppt == 7)   lcd.print(F("EQU M"));

1415
  if (vic2_cs_mppt == 245) lcd.print(F("START"));

1416
  if (vic2_cs_mppt == 247) lcd.print(F("EQU A"));

1417
  if (vic2_cs_mppt == 252) lcd.print(F("EXT  "));

1418
}

1419
//********************

1420
void vic3_display()

1421
{

1422
  lcd.setCursor (0, 2);

1423
  lcd.print(vic3_v_bmv);

1424
1425
  lcd.setCursor (7, 2);

1426
  if (abs(vic3_i_bmv) < 99.995) lcd.print(F(" "));

1427
  if (abs(vic3_i_bmv) < 9.995) lcd.print(F(" "));

1428
  if (vic3_i_bmv >= 0) lcd.print(F(" "));

1429
  lcd.print(vic3_i_bmv, 1);

1430
}

1431
//********************

1432
void ueberschuss_display()

1433
{

1434
  lcd.setCursor (15, 2);

1435
  if (mess == 0) lcd.print(F("     "));

1436
  if (mess == 1) lcd.print(F("MESS1"));

1437
  if (mess == 2) lcd.print(F("MESS2"));

1438
  if (mess == 3) lcd.print(F("UEBER"));

1439
1440
  lcd.setCursor (0, 3);

1441
  if (abs(p_ueber) < 1000) lcd.print(F(" "));

1442
  if (abs(p_ueber) < 100) lcd.print(F(" "));

1443
  if (abs(p_ueber) < 10) lcd.print(F(" "));

1444
  if (p_ueber >= 0) lcd.print(F(" "));

1445
  lcd.print(p_ueber);

1446
1447
  lcd.setCursor (7, 3);

1448
  if (regel < 100) lcd.print(F(" "));

1449
  if (regel < 10) lcd.print(F(" "));

1450
  lcd.print(regel);

1451
1452
  lcd.setCursor (10, 3);

1453
  if (up_down == 0) lcd.write(byte(0));

1454
  if (up_down == 1) lcd.write(byte(1));

1455
  if (up_down == 2) lcd.write(byte(2));

1456
}

1457
//********************

1458
void bme280_display()

1459
{

1460
  lcd.setCursor (12, 3);

1461
  if (abs(temperatur < 9.995)) lcd.print(F(" "));

1462
  if (temperatur >= 0) lcd.print(F(" "));

1463
  lcd.print(temperatur);

1464
}

1465
//********************

1466
static void writeRegister(byte reg, word value)

1467
{

1468
  Wire.beginTransmission(ina226_addr);

1469
  Wire.write(reg);

1470
  Wire.write((value >> 8) & 0xFF);

1471
  Wire.write(value & 0xFF);

1472
  Wire.endTransmission();

1473
}

1474
//********************

1475
static word readRegister(byte reg)

1476
{

1477
  word res = 0x0000;

1478
  Wire.beginTransmission(ina226_addr);

1479
  Wire.write(reg);

1480
  if (Wire.endTransmission() == 0)

1481
  {

1482
    if (Wire.requestFrom(ina226_addr, 2) >= 2)

1483
    {

1484
      res  = Wire.read() * 256;

1485
      res += Wire.read();

1486
    }

1487
  }

1488
  return res;

1489
}

1490
//********************

1491
void bme280()

1492
{

1493
  temperatur = (bme.readTemperature());

1494
  luftfeuchtigkeit = (bme.readHumidity());

1495
  luftdruck = ((bme.readPressure() / 100.0F) + 12.8); //Luftdruck umgerechnet von 103m ueber Meereshoehe auf Meereshoehe

1496
}


  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        Forist (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Markus A. schrieb:
> Könnte da mal bitte jemand drüberschauen?

Was meinst du wohl, was mit dem Hinweis "Längeren Sourcecode nicht im 
Text einfügen, sondern als Dateianhang" gemeint sein könnte?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        Markus A.
        (calimero_123)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Besser ?!

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        Dietrich L.
        (dietrichl)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Markus A. schrieb:
> Besser ?!

Und wo ist der Anhang?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        Markus A.
        (calimero_123)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Dietrich L. schrieb:
> Markus A. schrieb:
>> Besser ?!
>
> Und wo ist der Anhang?

Ganz oben.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        Melben (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Sofort nachschauen, ob Du noch alle Tassen im Schrank hast.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        Markus A.
        (calimero_123)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Melben schrieb:
> Sofort nachschauen, ob Du noch alle Tassen im Schrank hast.

Vielleicht schlägst du mal einen anderen Ton an:

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        OMG (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Markus A. schrieb:
> Guten Morgen Forum.

Deine Art und Weise hier einen Sourcecode zu posten ist eine
Frechheit die kaum zu überbieten ist.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        OMG (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Markus A. schrieb:
> Vielleicht schlägst du mal einen anderen Ton an

Vielleicht übst du erst mal ein bisschen Bescheidenheit, wenn
du überhaupt weisst was das ist.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        Markus A.
        (calimero_123)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
OMG schrieb:
> Markus A. schrieb:
>> Guten Morgen Forum.
>
> Deine Art und Weise hier einen Sourcecode zu posten ist eine
> Frechheit die kaum zu überbieten ist.

Vielleicht schlägst auch DU mal einen anderen Ton an.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        Markus A.
        (calimero_123)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
An alle die mich hier gerade blöd angemacht haben.
Gerne könnt ihr per PN meine Adresse haben und vorbeikommen.
Mal sehen ob ihr dann auch noch eine so ein große Klappe habt.

Gruss Markus

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        OMG (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Ich wünsche dir erfolgreiches Weiterkommen hier wie auch
im restlichen Leben.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        Forist (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Markus A. schrieb:
> Besser ?!

Welches der vier Worte "nicht im Text einfügen" verstehst du nicht?

Zeig ein Minimalbeispiel, aus dem dein Problem ersichtlich wird.
Mit "Drüberschauen" bei fast 1500 Zeilen unkommentiertem Code ist das so 
eine Sache.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        Markus A.
        (calimero_123)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Forist schrieb:

> Zeig ein Minimalbeispiel, aus dem dein Problem ersichtlich wird.

Wie muss ich das...
"Charge master Set 0x200E to b0100001, charger uses internal charge 
profile"
im Code schreiben?

Das müsste da hin.
void vic2_anfragen()
{
  Serial2.println(F(":7D3ED008E"));
}

Hier die Beschreibung des Protokolls:

1 VE.Direct Protocol

The frame format of the VE.Direct protocol has the following general 
format:

: [command] [data][data][…] [check]\n

Where the colon indicates the start of the frame and the newline is the 
end of frame.

The sum of all data bytes and the check must equal 0x55.

Since the normal protocol is in text values the frames are
sent in their hexadecimal ASCII representation, [‘0’ .. ’9’], [‘A’ .. 
’F’], must be uppercase.

There is no need to escape any characters.

: [command] [dataHighNibble, dataLowNibble][……] [checkHigh, checkLow] \n

Note: The command is only send as a single nibble. Numbers are sent in 
Little Endian format.

An error response with value 0xAAAA is sent on framing errors.

Command Description
0
Enter boot 0x51FA51FA51FA51FA51FA as payload will enable bootloader 
mode.
1
Ping Check for presence, the response is an ‘Rsp ping’ containing 
version and firmware type. See the response ping message.
3
App version
Returns the version of the firmware as stored in the header in an
‘RspDone’ message.
4
Product Id Returns the Product Id of the firmware as stored in the 
header in an ‘RspDone’ message.
6
Restart
Restarts the device, no response is sent.
7
Get
Returns a get response with the requested data or error is returned.
uint16 the id of the value to get uint8 flags, should be set to zero
8
Set
Returns a set response with the requested data or error is returned.
uint16 the id of the value to setuint8 flags, should be set to zero
type depends on id value
A
Async
Asynchronous data message. Should not be replied. uint16 the id of the 
value being returned uint8 flags, defined belowtype depends on id value.

2, 5, 9, B-F reserved

  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        Forist (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Markus A. schrieb:
> Serial2.println(F(":7D3ED008E"));

> : [command] [data][data][…] [check]\n

In der Beschreibung steht als Abschluss des Kommandos ein "\n" und du 
schickst wahrscheinlich ein "\r\n".
Muss kein Problem sein, kann aber.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        Markus A.
        (calimero_123)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Ich muss da glaube ich noch was klarstellen.

Das....
void vic1_anfragen()
{
  Serial1.println(F(":7D3ED008E"));
}
//****************
void vic2_anfragen()
{
  Serial2.println(F(":7D3ED008E"));  //Register EDD3
}
//****************
void vic3_anfragen()
{
  Serial3.println(F(":78DED00D4"));  //Register ED8D
  Serial3.println(F(":78CED00D5"));  //Register ED8C
  Serial3.println(F(":78EED00D3"));  //Register ED8E
  Serial3.println(F(":71003003B"));  //Register 0310
  Serial3.println(F(":71103003A"));  //Register 0311
  Serial3.println(F(":706030045"));  //Register 0306
  Serial3.println(F(":707030044"));  //Register 0307
  Serial3.println(F(":7FF0F0040"));  //Register 0FFF
}
...ist alles funktionierender code.
Damit frage ich Werte ab.

Das setzen des Registers 200E macht mir Schwierigkeiten.

Es müsste so anfangen

: 8 0E20 00 und dann ? b0100001 ? checksum ? \n

  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        Forist (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Markus A. schrieb:
> Es müsste so anfangen
> : 8 0E20 00 und dann ? b0100001 ? checksum ? \n

Probiere mal eher ":80E200021[check]"\n mit der passend berechneten 
Checksumme.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        Forist (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
... also ":80E200021FE"

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Victron MPPT Register 200E setzen.
  


  

    

      von
      
        Markus A.
        (calimero_123)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Das müsste dann sein:
Serial2.println(F(":80E200021FE"));
Ich werde testen.

warst schneller :-)

  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  








    

    

       Thread beobachten

      |
         Seitenaufteilung abschalten

    

        


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? Keine Anmeldung erforderlich!

  Mit Google-Account einloggen
  





  Noch kein Account? Hier anmelden.