-
Notifications
You must be signed in to change notification settings - Fork 71
/
iolist.cpp
1875 lines (1703 loc) · 69.8 KB
/
iolist.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
//-----------------------------------------------------------------------------
// Copyright 2007 Jonathan Westhues
// Copyright 2015 Nehrutsa Ihor
//
// This file is part of LDmicro.
//
// LDmicro is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// LDmicro is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with LDmicro. If not, see <http://www.gnu.org/licenses/>.
//------
//
// Routines to maintain the processor I/O list. Whenever the user changes the
// name of an element, rebuild the I/O list from the PLC program, so that new
// assigned names are automatically reflected in the I/O list. Also keep a
// list of old I/Os that have been deleted, so that if the user deletes a
// a name and then recreates it the associated settings (e.g. pin number)
// will not be forgotten. Also the dialog box for assigning I/O pins.
// Jonathan Westhues, Oct 2004
//-----------------------------------------------------------------------------
#include "stdafx.h"
#include "ldmicro.h"
//#include "display.h"
// I/O that we have seen recently, so that we don't forget pin assignments
// when we re-extract the list
#define MAX_IO_SEEN_PREVIOUSLY 1024
static struct {
char name[MAX_NAME_LEN];
int type;
int pin;
ModbusAddr_t modbus;
} IoSeenPreviously[MAX_IO_SEEN_PREVIOUSLY];
static int IoSeenPreviouslyCount;
static int SpiErrors = 0; ///// Added by JG
static int I2cErrors = 0; ///// Added by JG
// stuff for the dialog box that lets you choose pin assignments
static HWND IoDialog;
static HWND PinList;
static HWND ModbusSlave;
static HWND ModbusRegister;
// stuff for the popup that lets you set the simulated value of an analog in
static HWND AnalogSliderMain;
static HWND AnalogSliderTrackbar;
static bool AnalogSliderDone;
static bool AnalogSliderCancel;
//-----------------------------------------------------------------------------
// Only this types can connect name to I/O pins.
//-----------------------------------------------------------------------------
int IsIoType(int type)
{
// clang-format off
if((type == IO_TYPE_INT_INPUT)
|| (type == IO_TYPE_DIG_INPUT)
|| (type == IO_TYPE_DIG_OUTPUT)
|| (type == IO_TYPE_READ_ADC)
|| (type == IO_TYPE_PWM_OUTPUT)
|| (type == IO_TYPE_SPI_MOSI)
|| (type == IO_TYPE_SPI_MISO)
|| (type == IO_TYPE_SPI_SCK)
|| (type == IO_TYPE_SPI__SS)
|| (type == IO_TYPE_I2C_SCL) ///// Added by JG
|| (type == IO_TYPE_I2C_SDA) /////
// || (type == IO_TYPE_MODBUS_CONTACT) //???
// || (type == IO_TYPE_MODBUS_COIL) //???
|| (type == IO_TYPE_UART_TX)
|| (type == IO_TYPE_UART_RX))
return type;
return 0;
// clang-format on
}
//-----------------------------------------------------------------------------
// Append an I/O to the I/O list if it is not in there already.
//-----------------------------------------------------------------------------
static void AppendIo(const char *name, int type)
{
if(!name || !strlen(name))
return;
if(IsNumber(name))
return;
if(!IsNumber(name)) {
if(strchr(name, '-')) {
Error(_("Rename '%s': Replace the character '-' by the '_'."), name);
return;
}
}
if(name[0] == '#') {
if(strspn(name, "#PORT") == 5)
type = IO_TYPE_PORT_OUTPUT;
else if(strspn(name, "#PIN") == 4)
type = IO_TYPE_PORT_INPUT;
else
type = IO_TYPE_MCU_REG;
}
SetVariableType(name, type);
int i;
for(i = 0; i < Prog.io.count; i++) {
if(strcmp(Prog.io.assignment[i].name, name) == 0) {
if((Prog.io.assignment[i].type == IO_TYPE_COUNTER) && (type == IO_TYPE_GENERAL)) {
return;
} else if((Prog.io.assignment[i].type == IO_TYPE_GENERAL) && (type == IO_TYPE_COUNTER)) {
Prog.io.assignment[i].type = type; // replace // see compilercommon.cpp
}
}
if((strcmp(Prog.io.assignment[i].name, name) == 0) && (Prog.io.assignment[i].type == type))
return;
/*
if(strcmp(Prog.io.assignment[i].name, name)==0) {
if(type != IO_TYPE_GENERAL && Prog.io.assignment[i].type ==
IO_TYPE_GENERAL)
{
Prog.io.assignment[i].type = type;
}
// already in there
return;
}
*/
}
if(i < MAX_IO) {
Prog.io.assignment[i].type = type;
Prog.io.assignment[i].pin = NO_PIN_ASSIGNED;
Prog.io.assignment[i].modbus.Slave = 0;
Prog.io.assignment[i].modbus.Address = 0;
strcpy(Prog.io.assignment[i].name, name);
(Prog.io.count)++;
}
}
//-----------------------------------------------------------------------------
// Move an I/O pin into the `seen previously' list. This means that if the
// user creates input Xasd, assigns it a pin, deletes, and then recreates it,
// then it will come back with the correct pin assigned.
//-----------------------------------------------------------------------------
static void AppendIoSeenPreviously(char *name, int type, int pin, ModbusAddr_t modbus)
{
if(strcmp(name + 1, "new") == 0)
return;
for(int i = 0; i < IoSeenPreviouslyCount; i++) {
if(strcmp(name, IoSeenPreviously[i].name) == 0 && type == IoSeenPreviously[i].type) {
if(pin != NO_PIN_ASSIGNED) {
IoSeenPreviously[i].pin = pin;
}
IoSeenPreviously[i].modbus = modbus;
return;
}
}
if(IoSeenPreviouslyCount >= MAX_IO_SEEN_PREVIOUSLY) {
// maybe improve later; just throw away all our old information, and
// the user might have to reenter the pin if they delete and recreate
// things
IoSeenPreviouslyCount = 0;
}
IoSeenPreviously[IoSeenPreviouslyCount].type = type;
IoSeenPreviously[IoSeenPreviouslyCount].pin = pin;
IoSeenPreviously[IoSeenPreviouslyCount].modbus = modbus;
strcpy(IoSeenPreviously[IoSeenPreviouslyCount].name, name);
IoSeenPreviouslyCount++;
}
static void AppendIoAutoType(char *name, int default_type)
{
int type;
// clang-format off
switch (name[0]) {
case 'X': type = IO_TYPE_DIG_INPUT; break;
case 'Y': type = IO_TYPE_DIG_OUTPUT; break;
case 'A': type = IO_TYPE_READ_ADC; break;
//case 'P': type = IO_TYPE_PWM_OUTPUT; break;
//case 'I': type = IO_TYPE_MODBUS_CONTACT; break; // conflict if IO_TYPE_GENERAL variable start with 'I'
case 'M': type = IO_TYPE_MODBUS_COIL; break;
case 'H': type = IO_TYPE_MODBUS_HREG; break;
case 'G': type = IO_TYPE_GENERAL; break;
default: type = default_type;
};
// clang-format on
// type = default_type; // rewert
AppendIo(name, type);
}
//-----------------------------------------------------------------------------
// Walk a subcircuit, calling ourselves recursively and extracting all the
// I/O names out of it.
//-----------------------------------------------------------------------------
static void ExtractNamesFromCircuit(int which, void *any)
{
ElemLeaf *l = (ElemLeaf *)any;
char str[MAX_NAME_LEN];
switch(which) {
case ELEM_PARALLEL_SUBCKT: {
ElemSubcktParallel *p = (ElemSubcktParallel *)any;
for(int i = 0; i < p->count; i++) {
ExtractNamesFromCircuit(p->contents[i].which, p->contents[i].data.any);
}
break;
}
case ELEM_SERIES_SUBCKT: {
ElemSubcktSeries *s = (ElemSubcktSeries *)any;
for(int i = 0; i < s->count; i++) {
ExtractNamesFromCircuit(s->contents[i].which, s->contents[i].data.any);
}
break;
}
case ELEM_CONTACTS:
switch(l->d.contacts.name[0]) {
case 'R':
AppendIo(l->d.contacts.name, IO_TYPE_INTERNAL_RELAY);
break;
case 'Y':
AppendIo(l->d.contacts.name, IO_TYPE_DIG_OUTPUT);
break;
case 'X':
AppendIo(l->d.contacts.name, IO_TYPE_DIG_INPUT);
break;
case 'P':
AppendIo(l->d.contacts.name, IO_TYPE_PWM_OUTPUT);
break;
case 'I':
AppendIo(l->d.contacts.name, IO_TYPE_MODBUS_CONTACT);
break;
case 'M':
AppendIo(l->d.contacts.name, IO_TYPE_MODBUS_COIL);
break;
default:
oops();
break;
}
break;
case ELEM_COIL:
switch(l->d.contacts.name[0]) {
case 'R':
AppendIo(l->d.coil.name, IO_TYPE_INTERNAL_RELAY);
break;
case 'Y':
AppendIo(l->d.coil.name, IO_TYPE_DIG_OUTPUT);
break;
case 'M':
AppendIo(l->d.coil.name, IO_TYPE_MODBUS_COIL);
break;
default:
oops();
break;
}
break;
case ELEM_QUAD_ENCOD:
/*
switch(l->d.QuadEncod.inputA[0]) {
case 'I':
AppendIo(l->d.QuadEncod.inputA, IO_TYPE_INT_INPUT);
break;
default:
Error(_("Connect QUAD ENCOD input A to INTs input pin IqAn."));
break;
}
*/
switch(l->d.QuadEncod.inputA[0]) {
case 'X':
AppendIo(l->d.QuadEncod.inputA, IO_TYPE_DIG_INPUT);
break;
default:
Error(_("Connect QUAD ENCOD input A to input pin XqAn."));
break;
}
switch(l->d.QuadEncod.inputB[0]) {
case 'X':
AppendIo(l->d.QuadEncod.inputB, IO_TYPE_DIG_INPUT);
break;
default:
Error(_("Connect QUAD ENCOD input B to input pin XqBn."));
break;
}
if(strlen(l->d.QuadEncod.inputZ) > 0)
switch(l->d.QuadEncod.inputZ[0]) {
case 'X':
AppendIo(l->d.QuadEncod.inputZ, IO_TYPE_DIG_INPUT);
break;
default:
Error(_("Connect QUAD ENCOD input Z to input pin XqZn."));
break;
}
if(strlen(l->d.QuadEncod.dir) > 0)
switch(l->d.QuadEncod.dir[0]) {
case 'R':
AppendIo(l->d.QuadEncod.dir, IO_TYPE_INTERNAL_RELAY);
break;
case 'Y':
AppendIo(l->d.QuadEncod.dir, IO_TYPE_DIG_OUTPUT);
break;
default:
Error(_("Connect QUAD ENCOD dir flag to output pin YsomeName or internal relay RsomeName."));
break;
}
/*
AppendIo("ELEM_QUAD_ENCOD", IO_TYPE_TABLE_IN_FLASH);
SetSizeOfVar("ELEM_QUAD_ENCOD", 16);
*/
break;
case ELEM_NPULSE:
AppendIo(l->d.Npulse.counter, IO_TYPE_GENERAL);
switch(l->d.Npulse.coil[0]) {
case 'Y':
AppendIo(l->d.Npulse.coil, IO_TYPE_DIG_OUTPUT);
break;
default:
Error(_("Connect NPULSE to output pin YsomeName."));
break;
}
break;
case ELEM_STEPPER:
sprintf(str, "C%s%s", l->d.stepper.name, "Dec");
AppendIo(str, IO_TYPE_COUNTER);
if(IsNumber(l->d.stepper.P) && (CheckMakeNumber(l->d.stepper.P) > 1) //
|| (l->d.stepper.graph > 0) // &&(l->d.stepper.n>1)
|| (!IsNumber(l->d.stepper.P))) {
sprintf(str, "C%s%s", l->d.stepper.name, "Inc");
AppendIo(str, IO_TYPE_COUNTER);
sprintf(str, "C%s%s", l->d.stepper.name, "P");
AppendIo(str, IO_TYPE_COUNTER);
}
switch(l->d.stepper.coil[0]) {
case 'Y':
AppendIo(l->d.stepper.coil, IO_TYPE_DIG_OUTPUT);
break;
default:
Error(_("Connect STEPPER coil to output pin YsomeName."));
break;
}
break;
case ELEM_PULSER:
switch(l->d.pulser.busy[0]) {
case 'R':
AppendIo(l->d.pulser.busy, IO_TYPE_INTERNAL_RELAY);
break;
case 'Y':
AppendIo(l->d.pulser.busy, IO_TYPE_DIG_OUTPUT);
break;
default:
Error(_("Connect PULSER busy flag to output pin YsomeName or internal relay RsomeName."));
break;
}
break;
case ELEM_TIME2DELAY:
case ELEM_TIME2COUNT:
AppendIo(l->d.timer.name, IO_TYPE_GENERAL);
break;
case ELEM_TCY:
AppendIo(l->d.timer.name, IO_TYPE_TCY);
break;
case ELEM_TON:
AppendIo(l->d.timer.name, IO_TYPE_TON);
break;
case ELEM_TOF:
AppendIo(l->d.timer.name, IO_TYPE_TOF);
break;
case ELEM_RTO:
AppendIo(l->d.timer.name, IO_TYPE_RTO);
break;
case ELEM_RTL:
AppendIo(l->d.timer.name, IO_TYPE_RTL);
break;
case ELEM_THI:
AppendIo(l->d.timer.name, IO_TYPE_THI);
break;
case ELEM_TLO:
AppendIo(l->d.timer.name, IO_TYPE_TLO);
break;
case ELEM_BIN2BCD:
AppendIo(l->d.move.dest, IO_TYPE_BCD);
if(CheckForNumber(l->d.move.src) == false) {
AppendIo(l->d.move.src, IO_TYPE_GENERAL);
}
break;
case ELEM_BCD2BIN:
AppendIo(l->d.move.dest, IO_TYPE_GENERAL);
if(CheckForNumber(l->d.move.src) == false) {
AppendIo(l->d.move.src, IO_TYPE_BCD);
}
break;
case ELEM_SEED_RANDOM: {
sprintf(str, "$seed_%s", l->d.move.dest);
AppendIo(str, IO_TYPE_GENERAL);
break;
}
case ELEM_SPI_WR: ///// Added by JG
case ELEM_SPI: {
sprintf(str, "%s_MOSI", l->d.spi.name);
AppendIo(str, IO_TYPE_SPI_MOSI);
sprintf(str, "%s_MISO", l->d.spi.name);
AppendIo(str, IO_TYPE_SPI_MISO);
sprintf(str, "%s_SCK", l->d.spi.name);
AppendIo(str, IO_TYPE_SPI_SCK);
sprintf(str, "%s__SS", l->d.spi.name);
AppendIo(str, IO_TYPE_SPI__SS);
McuSpiInfo *spiInfo = GetMcuSpiInfo(l->d.spi.name);
if(spiInfo) {
if(spiInfo->MOSI) {
// assign
}
}
///// Added by JG
else {
SpiErrors++;
if(SpiErrors == 1)
Error(_("Invalid SPI name in ladder."));
}
_ltoa(Prog.spiRate, l->d.spi.bitrate, 10); // set frequency field
/////
if(!CheckForNumber(l->d.spi.send)) {
// Not need ???
// Need if you add only one MOV or get erroneously other src name
// then you can see l->d.move.src in IOlist
if(which != ELEM_SPI_WR) ///// Added by JG : no send var for SPI_WRITE (literal string instead)
AppendIo(l->d.spi.send, IO_TYPE_GENERAL);
}
if(!CheckForNumber(l->d.spi.recv)) {
// Not need ???
// Need if you add only one MOV or get erroneously other src name
// then you can see l->d.move.src in IOlist
if(which != ELEM_SPI_WR) ///// Added by JG : no recv var for SPI_WRITE
AppendIo(l->d.spi.recv, IO_TYPE_GENERAL);
}
break;
}
///// Added by JG
case ELEM_I2C_RD: {
sprintf(str, "%s_SCL", l->d.i2c.name);
AppendIo(str, IO_TYPE_I2C_SCL);
sprintf(str, "%s_SDA", l->d.i2c.name);
AppendIo(str, IO_TYPE_I2C_SDA);
McuI2cInfo *i2cInfo = GetMcuI2cInfo(l->d.i2c.name);
if(i2cInfo) {
if(i2cInfo->SCL) {
// assign
}
}
///// Added by JG
else {
I2cErrors++;
if(I2cErrors == 1)
Error(_("Invalid I2C name in ladder."));
}
_ltoa(Prog.i2cRate, l->d.i2c.bitrate, 10); // set frequency field
if(!CheckForNumber(l->d.i2c.recv)) {
// Not need ???
// Need if you add only one MOV or get erroneously other src name
// then you can see l->d.move.src in IOlist
AppendIo(l->d.i2c.recv, IO_TYPE_GENERAL); // only recv var for I2C_READ
}
break;
}
case ELEM_I2C_WR: {
sprintf(str, "%s_SCL", l->d.i2c.name);
AppendIo(str, IO_TYPE_I2C_SCL);
sprintf(str, "%s_SDA", l->d.i2c.name);
AppendIo(str, IO_TYPE_I2C_SDA);
McuI2cInfo *i2cInfo = GetMcuI2cInfo(l->d.i2c.name);
if(i2cInfo) {
if(i2cInfo->SCL) {
// assign
}
}
///// Added by JG
else {
I2cErrors++;
if(I2cErrors == 1)
Error(_("Invalid I2C name in ladder."));
}
_ltoa(Prog.i2cRate, l->d.i2c.bitrate, 10); // set frequency field
if(!CheckForNumber(l->d.i2c.send)) {
// Not need ???
// Need if you add only one MOV or get erroneously other src name
// then you can see l->d.move.src in IOlist
AppendIo(l->d.spi.send, IO_TYPE_GENERAL); // only send var for I2C_WRITE
}
break;
}
/////
case ELEM_OPPOSITE:
case ELEM_SWAP:
case ELEM_BUS:
case ELEM_MOVE: {
AppendIoAutoType(l->d.move.dest, IO_TYPE_GENERAL);
if(CheckForNumber(l->d.move.src) == false) {
// Not need ???
// Need if you add only one MOV or get erroneously other src name
// then you can see l->d.move.src in IOlist
AppendIoAutoType(l->d.move.src, IO_TYPE_GENERAL);
}
break;
}
{
int n, n0;
const char *nameTable;
// clang-format off
case ELEM_7SEG: nameTable = "char7seg"; n = LEN7SEG; n0=1; goto xseg;
case ELEM_9SEG: nameTable = "char9seg"; n = LEN9SEG; n0=2; goto xseg;
case ELEM_14SEG:nameTable = "char14seg"; n = LEN14SEG; n0=2; goto xseg;
case ELEM_16SEG:nameTable = "char16seg"; n = LEN16SEG; n0=3; goto xseg;
// clang-format on
xseg:
AppendIoAutoType(l->d.segments.dest, IO_TYPE_GENERAL);
/*
if (CheckForNumber(l->d.segments.src) == false) {
AppendIo(l->d.segments.src, IO_TYPE_GENERAL); // not need ???
}
*/
SetSizeOfVar(nameTable, n);
AppendIo(nameTable, IO_TYPE_TABLE_IN_FLASH);
sprintf(str, "%s[0]", nameTable);
SetSizeOfVar(str, n0);
AppendIo(str, IO_TYPE_VAL_IN_FLASH);
break;
}
case ELEM_SET_BIT:
case ELEM_CLEAR_BIT:
AppendIoAutoType(l->d.move.dest, IO_TYPE_GENERAL);
break;
case ELEM_IF_BIT_SET:
case ELEM_IF_BIT_CLEAR:
AppendIoAutoType(l->d.move.dest, IO_TYPE_GENERAL);
break;
case ELEM_SHL:
case ELEM_SHR:
case ELEM_SR0:
case ELEM_ROL:
case ELEM_ROR:
case ELEM_AND:
case ELEM_OR:
case ELEM_XOR:
case ELEM_NEG:
case ELEM_NOT:
case ELEM_ADD:
case ELEM_SUB:
case ELEM_MUL:
case ELEM_DIV:
case ELEM_MOD:
if(CheckForNumber(l->d.math.op1) == false) {
AppendIoAutoType(l->d.math.op1, IO_TYPE_GENERAL);
}
if(which != ELEM_NOT)
if(which != ELEM_NEG)
if(CheckForNumber(l->d.math.op2) == false) {
AppendIoAutoType(l->d.math.op2, IO_TYPE_GENERAL);
}
AppendIoAutoType(l->d.math.dest, IO_TYPE_GENERAL);
break;
case ELEM_STRING:
if(strlen(l->d.fmtdStr.dest) > 0) {
AppendIo(l->d.fmtdStr.dest, IO_TYPE_STRING);
}
if(strlen(l->d.fmtdStr.var) > 0) {
AppendIo(l->d.fmtdStr.var, IO_TYPE_GENERAL);
}
break;
case ELEM_FORMATTED_STRING:
if(strlen(l->d.fmtdStr.var) > 0) {
AppendIo(l->d.fmtdStr.var, IO_TYPE_UART_TX);
}
break;
/*
case ELEM_UART_WR:
// if(l->d.fmtdStr.string[0] != '"') {
// AppendIo(l->d.fmtdStr.string, IO_TYPE_STRING);
// }
break;
*/
// case ELEM_UART_SENDn:
case ELEM_UART_SEND:
//AppendIo(l->d.uart.name, IO_TYPE_GENERAL);
AppendIo(l->d.uart.name, IO_TYPE_UART_TX);
break;
// case ELEM_UART_RECVn:
case ELEM_UART_RECV:
AppendIo(l->d.uart.name, IO_TYPE_GENERAL);
AppendIo(l->d.uart.name, IO_TYPE_UART_RX);
break;
case ELEM_SET_PWM:
AppendIo(l->d.setPwm.name, IO_TYPE_PWM_OUTPUT);
if(!IsNumber(l->d.setPwm.duty_cycle))
AppendIo(l->d.setPwm.duty_cycle, IO_TYPE_GENERAL);
break;
case ELEM_CTU:
case ELEM_CTD:
case ELEM_CTC:
case ELEM_CTR:
AppendIo(l->d.counter.name, IO_TYPE_COUNTER);
if(CheckForNumber(l->d.counter.max) == false) {
// Not need ??? See ELEM_MOV
AppendIoAutoType(l->d.counter.max, IO_TYPE_GENERAL);
}
break;
case ELEM_READ_ADC:
AppendIo(l->d.readAdc.name, IO_TYPE_READ_ADC);
break;
case ELEM_RANDOM:
AppendIo(l->d.readAdc.name, IO_TYPE_GENERAL);
break;
case ELEM_SHIFT_REGISTER: {
for(int i = 0; i < l->d.shiftRegister.stages; i++) {
sprintf(str, "%s%d", l->d.shiftRegister.name, i);
AppendIo(str, IO_TYPE_GENERAL);
}
break;
}
case ELEM_LOOK_UP_TABLE: {
if(l->d.lookUpTable.count > 0)
MemForVariable(l->d.lookUpTable.name, nullptr, l->d.lookUpTable.count);
AppendIo(l->d.lookUpTable.name, IO_TYPE_TABLE_IN_FLASH);
sprintf(str, "%s[0]", l->d.lookUpTable.name);
int sovElement = TestByteNeeded(l->d.lookUpTable.count, l->d.lookUpTable.vals);
if(sovElement > 0)
SetSizeOfVar(str, sovElement);
AppendIo(str, IO_TYPE_VAL_IN_FLASH);
AppendIo(l->d.lookUpTable.dest, IO_TYPE_GENERAL);
AppendIo(l->d.lookUpTable.index, IO_TYPE_GENERAL);
break;
}
case ELEM_PIECEWISE_LINEAR:
AppendIo(l->d.piecewiseLinear.dest, IO_TYPE_GENERAL);
AppendIo(l->d.lookUpTable.index, IO_TYPE_GENERAL);
break;
case ELEM_PLACEHOLDER:
case ELEM_COMMENT:
case ELEM_SHORT:
case ELEM_OPEN:
case ELEM_MASTER_RELAY:
case ELEM_SLEEP:
case ELEM_DELAY:
case ELEM_CLRWDT:
case ELEM_LOCK:
case ELEM_GOTO:
case ELEM_GOSUB:
case ELEM_LABEL:
case ELEM_SUBPROG:
case ELEM_RETURN:
case ELEM_ENDSUB:
case ELEM_ONE_SHOT_RISING:
case ELEM_ONE_SHOT_FALLING:
case ELEM_ONE_SHOT_LOW:
case ELEM_OSC:
case ELEM_UART_SEND_READY:
case ELEM_UART_RECV_AVAIL:
case ELEM_EQU:
case ELEM_NEQ:
case ELEM_GRT:
case ELEM_GEQ:
case ELEM_LES:
case ELEM_LEQ:
case ELEM_RES:
#ifdef USE_SFR
case ELEM_RSFR:
case ELEM_WSFR:
case ELEM_SSFR:
case ELEM_CSFR:
case ELEM_TSFR:
case ELEM_T_C_SFR:
#endif
// case ELEM_PWM_OFF:
case ELEM_NPULSE_OFF:
break;
case ELEM_PADDING:
break;
case ELEM_PERSIST:
AppendIo(l->d.persist.var, IO_TYPE_PERSIST);
break;
default:
ooops("which=%d", which);
}
}
//-----------------------------------------------------------------------------
// Compare function to qsort() the I/O list. Group by type, then
// alphabetically within each section.
//-----------------------------------------------------------------------------
static int CompareIo(const void *av, const void *bv)
{
PlcProgramSingleIo *a = (PlcProgramSingleIo *)av;
PlcProgramSingleIo *b = (PlcProgramSingleIo *)bv;
if(a->type != b->type) {
return a->type - b->type;
}
/*
if(a->pin == NO_PIN_ASSIGNED && b->pin != NO_PIN_ASSIGNED) return 1;
if(b->pin == NO_PIN_ASSIGNED && a->pin != NO_PIN_ASSIGNED) return -1;
*/
return strcmp(a->name, b->name);
}
//-----------------------------------------------------------------------------
// Wipe the I/O list and then re-extract it from the PLC program, taking
// care not to forget the pin assignments. Gets passed the selected item
// as an index into the list; modifies the list, so returns the new selected
// item as an index into the new list.
//-----------------------------------------------------------------------------
int GenerateIoList(int prevSel)
{
int i, j;
SpiErrors = 0; ///// Added by JG
I2cErrors = 0; ///// Added by JG
char selName[MAX_NAME_LEN];
if(prevSel >= 0) {
strcpy(selName, Prog.io.assignment[prevSel].name);
}
if(IoSeenPreviouslyCount > MAX_IO_SEEN_PREVIOUSLY / 2) {
// flush it so there's lots of room, and we don't run out and
// forget important things
IoSeenPreviouslyCount = 0;
}
// remember the pin assignments
for(i = 0; i < Prog.io.count; i++) {
AppendIoSeenPreviously(Prog.io.assignment[i].name, Prog.io.assignment[i].type, Prog.io.assignment[i].pin, Prog.io.assignment[i].modbus);
}
// wipe the list
Prog.io.count = 0;
// extract the new list so that it must be up to date
for(i = 0; i < Prog.numRungs; i++) {
ExtractNamesFromCircuit(ELEM_SERIES_SUBCKT, Prog.rungs(i));
}
// AppendIo("ROverflowFlagV", IO_TYPE_INTERNAL_RELAY);
if(Prog.cycleDuty) {
AppendIo(YPlcCycleDuty, IO_TYPE_DIG_OUTPUT);
}
for(i = 0; i < Prog.io.count; i++) {
// clang-format off
if(Prog.io.assignment[i].type == IO_TYPE_DIG_INPUT ||
Prog.io.assignment[i].type == IO_TYPE_INT_INPUT ||
Prog.io.assignment[i].type == IO_TYPE_DIG_OUTPUT ||
Prog.io.assignment[i].type == IO_TYPE_PWM_OUTPUT ||
Prog.io.assignment[i].type == IO_TYPE_MODBUS_CONTACT ||
Prog.io.assignment[i].type == IO_TYPE_MODBUS_COIL ||
Prog.io.assignment[i].type == IO_TYPE_MODBUS_HREG ||
Prog.io.assignment[i].type == IO_TYPE_SPI_MOSI ||
Prog.io.assignment[i].type == IO_TYPE_SPI_MISO ||
Prog.io.assignment[i].type == IO_TYPE_SPI_SCK ||
Prog.io.assignment[i].type == IO_TYPE_SPI__SS ||
Prog.io.assignment[i].type == IO_TYPE_I2C_SCL || ///// Added by JG
Prog.io.assignment[i].type == IO_TYPE_I2C_SDA || /////
Prog.io.assignment[i].type == IO_TYPE_READ_ADC)
{
// clang-format on
for(j = 0; j < IoSeenPreviouslyCount; j++) {
if(strcmp(Prog.io.assignment[i].name, IoSeenPreviously[j].name) == 0) {
Prog.io.assignment[i].pin = IoSeenPreviously[j].pin;
Prog.io.assignment[i].modbus = IoSeenPreviously[j].modbus;
break;
}
}
}
}
qsort(Prog.io.assignment, Prog.io.count, sizeof(PlcProgramSingleIo), CompareIo);
if(prevSel >= 0) {
for(i = 0; i < Prog.io.count; i++) {
if(strlen(IoListSelectionName)) {
if(strcmp(Prog.io.assignment[i].name, IoListSelectionName) == 0)
return i;
} else if(strcmp(Prog.io.assignment[i].name, selName) == 0)
return i;
}
if(i < Prog.io.count)
return i;
}
// no previous, or selected was deleted
return -1;
}
//-----------------------------------------------------------------------------
// Load the I/O list from a file. Since we are just loading pin assignments,
// put it into IoSeenPreviously so that it will get used on the next
// extraction.
//-----------------------------------------------------------------------------
bool LoadIoListFromFile(FileTracker &f)
{
char line[MAX_NAME_LEN];
char name[MAX_NAME_LEN];
char pinName[MAX_NAME_LEN];
int pin;
ModbusAddr_t modbus;
while(fgets(line, sizeof(line), f)) {
if(!strlen(strspace(line)))
continue;
if(strcmp(line, "END") == 0) {
return true;
}
modbus.Slave = 0;
modbus.Address = 0;
int type = 0;
if(strstr(line, "_MOSI")) {
type = IO_TYPE_SPI_MOSI;
} else if(strstr(line, "_MISO")) {
type = IO_TYPE_SPI_MISO;
} else if(strstr(line, "_SCK")) {
type = IO_TYPE_SPI_SCK;
} else if(strstr(line, "__SS")) {
type = IO_TYPE_SPI__SS;
} else if(strstr(line, "_SCL")) { ///// Added by JG
type = IO_TYPE_I2C_SCL;
} else if(strstr(line, "_SDA")) {
type = IO_TYPE_I2C_SDA; /////
} else {
switch(strspace(line)[0]) {
//case 'I': type = IO_TYPE_INT_INPUT; break;
case 'X':
type = IO_TYPE_DIG_INPUT;
break;
case 'Y':
type = IO_TYPE_DIG_OUTPUT;
break;
case 'A':
type = IO_TYPE_READ_ADC;
break;
case 'P':
type = IO_TYPE_PWM_OUTPUT;
break;
case 'I':
type = IO_TYPE_MODBUS_CONTACT;
break;
case 'M':
type = IO_TYPE_MODBUS_COIL;
break;
case 'C':
type = IO_TYPE_COUNTER;
break;
case 'H':
type = IO_TYPE_MODBUS_HREG;
break;
default:
Warning(_("Line\n'%s'\nis skipped in IO LIST section from '%s'"), strspace(line), f.name());
continue;
}
}
char *s = strstr(line, " at ");
if((s) && (isdigit(s[4]))) {
// Don't internationalize this! It's the file format, not UI.
if(sscanf(line, " %s at %d %hhu %hu", name, &pin, &modbus.Slave, &modbus.Address) >= 2) {
AppendIoSeenPreviously(name, type, pin, modbus);
}
} else {
// Don't internationalize this! It's the file format, not UI.
if(sscanf(line, " %s at %s", name, pinName) == 2) {
// PC ports
pin = NameToPin(pinName);
AppendIoSeenPreviously(name, type, pin, modbus);
}
}
}
return false;
}
//-----------------------------------------------------------------------------
// Write the I/O list to a file. Since everything except the pin assignment
// can be extracted from the schematic, just write the Xs and Ys.
//-----------------------------------------------------------------------------
void SaveIoListToFile(FileTracker &f)
{
int i, j1 = 0, j2 = 0;
for(i = 0; i < Prog.io.count; i++) {
// clang-format off
if(Prog.io.assignment[i].type == IO_TYPE_DIG_INPUT ||
Prog.io.assignment[i].type == IO_TYPE_DIG_OUTPUT ||
Prog.io.assignment[i].type == IO_TYPE_INT_INPUT ||
Prog.io.assignment[i].type == IO_TYPE_PWM_OUTPUT ||
Prog.io.assignment[i].type == IO_TYPE_MODBUS_CONTACT ||
Prog.io.assignment[i].type == IO_TYPE_MODBUS_COIL ||
Prog.io.assignment[i].type == IO_TYPE_MODBUS_HREG ||
Prog.io.assignment[i].type == IO_TYPE_SPI_MOSI ||
Prog.io.assignment[i].type == IO_TYPE_SPI_MISO ||
Prog.io.assignment[i].type == IO_TYPE_SPI_SCK ||
Prog.io.assignment[i].type == IO_TYPE_SPI__SS ||
Prog.io.assignment[i].type == IO_TYPE_I2C_SCL || ///// Added by JG
Prog.io.assignment[i].type == IO_TYPE_I2C_SDA || /////
Prog.io.assignment[i].type == IO_TYPE_READ_ADC)
{
// clang-format on
j1++;
if((Prog.LDversion == "0.1") //
&& (Prog.io.assignment[i].name[0] != 'X') //
&& (Prog.io.assignment[i].name[0] != 'Y') //
&& (Prog.io.assignment[i].name[0] != 'A'))
continue;
j2++;
// Don't internationalize this! It's the file format, not UI.
if(Prog.mcu() && (Prog.mcu()->whichIsa == ISA_PC) && (Prog.io.assignment[i].pin))
fprintf(f, " %s at %s\n", Prog.io.assignment[i].name, PinToName(Prog.io.assignment[i].pin));
else
fprintf(f, " %s at %d %d %d\n", Prog.io.assignment[i].name, Prog.io.assignment[i].pin, Prog.io.assignment[i].modbus.Slave, Prog.io.assignment[i].modbus.Address);
}
}
if(j1 != j2) {
Warning("%s%s", _("Not all I/O pins are saved! Use menu:\n"), _("File->Save LDmicro0.2 file format"));
}
}
//-----------------------------------------------------------------------------
// Dialog proc for the popup that lets you set the value of an analog input for
// simulation.
//-----------------------------------------------------------------------------
static LRESULT CALLBACK AnalogSliderDialogProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch(msg) {
case WM_CLOSE:
case WM_DESTROY:
AnalogSliderDone = true;
AnalogSliderCancel = true;
return 1;
default:
return DefWindowProc(hwnd, msg, wParam, lParam);
}
}
//-----------------------------------------------------------------------------
// A little toolbar-style window that pops up to allow the user to set the
// simulated value of an ADC pin.
//-----------------------------------------------------------------------------
void ShowAnalogSliderPopup(char *name)