forked from ishakalra/Kalaakriti
-
Notifications
You must be signed in to change notification settings - Fork 0
/
adioes.ino
774 lines (573 loc) · 25.6 KB
/
adioes.ino
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
/* Analog and Digital Input and Output Server for MATLAB */
/* Giampiero Campa, Copyright 2012 The MathWorks, Inc */
/* This file is meant to be used with the MATLAB arduino IO
package, however, it can be used from the IDE environment
(or any other serial terminal) by typing commands like:
0e0 : assigns digital pin #4 (e) as input
0f1 : assigns digital pin #5 (f) as output
0n1 : assigns digital pin #13 (n) as output
1c : reads digital pin #2 (c)
1e : reads digital pin #4 (e)
2n0 : sets digital pin #13 (n) low
2n1 : sets digital pin #13 (n) high
2f1 : sets digital pin #5 (f) high
2f0 : sets digital pin #5 (f) low
4j2 : sets digital pin #9 (j) to 50=ascii(2) over 255
4jz : sets digital pin #9 (j) to 122=ascii(z) over 255
3a : reads analog pin #0 (a)
3f : reads analog pin #5 (f)
5j : reads status (attached/detached) of servo on pin #9
5k : reads status (attached/detached) of servo on pin #10
6j1 : attaches servo on pin #9
8jz : moves servo on pin #9 of 122 degrees (122=ascii(z))
7j : reads angle of servo on pin #9
6j0 : detaches servo on pin #9
E0cd : attaches encoder #0 (0) on pins 2 (c) and 3 (d)
E1st : attaches encoder #1 on pins 18 (s) and 19 (t)
E2vu : attaches encoder #2 on pins 21 (v) and 20 (u)
G0 : gets 0 position of encoder #0
I0u : sets debounce delay to 20 (2ms) for encoder #0
H1 : resets position of encoder #1
F2 : detaches encoder #2
R0 : sets analog reference to DEFAULT
R1 : sets analog reference to INTERNAL
R2 : sets analog reference to EXTERNAL
X3 : roundtrip example case returning the input (ascii(3))
99 : returns script type (0 adio.pde ... 3 motor.pde ) */
#include <Servo.h>
/* define internal for the MEGA as 1.1V (as as for the 328) */
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define INTERNAL INTERNAL1V1
#endif
/* define encoder structure */
typedef struct { int pinA; int pinB; int pos; int del;} Encoder;
volatile Encoder Enc[3] = {{0,0,0,0}, {0,0,0,0}, {0,0,0,0}};
/* create servo vector */
Servo servo[70];
void setup() {
/* initialize serial */
Serial.begin(115200);
}
void loop() {
/* variables declaration and initialization */
static int s = -1; /* state */
static int pin = 13; /* generic pin number */
static int enc = 0; /* generic encoder number */
int val = 0; /* generic value read from serial */
int agv = 0; /* generic analog value */
int dgv = 0; /* generic digital value */
/* The following instruction constantly checks if anything
is available on the serial port. Nothing gets executed in
the loop if nothing is available to be read, but as soon
as anything becomes available, then the part coded after
the if statement (that is the real stuff) gets executed */
if (Serial.available() >0) {
/* whatever is available from the serial is read here */
val = Serial.read();
/* This part basically implements a state machine that
reads the serial port and makes just one transition
to a new state, depending on both the previous state
and the command that is read from the serial port.
Some commands need additional inputs from the serial
port, so they need 2 or 3 state transitions (each one
happening as soon as anything new is available from
the serial port) to be fully executed. After a command
is fully executed the state returns to its initial
value s=-1 */
switch (s) {
/* s=-1 means NOTHING RECEIVED YET ******************* */
case -1:
/* calculate next state */
if (val>47 && val<90) {
/* the first received value indicates the mode
49 is ascii for 1, ... 90 is ascii for Z
s=0 is change-pin mode;
s=10 is DI; s=20 is DO; s=30 is AI; s=40 is AO;
s=50 is servo status; s=60 is aervo attach/detach;
s=70 is servo read; s=80 is servo write;
s=90 is query script type (1 basic, 2 motor);
s=210 is encoder attach; s=220 is encoder detach;
s=230 is get encoder position; s=240 is encoder reset;
s=250 is set encoder debounce delay;
s=340 is change analog reference;
s=400 example echo returning the input argument;
*/
s=10*(val-48);
}
/* the following statements are needed to handle
unexpected first values coming from the serial (if
the value is unrecognized then it defaults to s=-1) */
if ((s>90 && s<210) || (s>250 && s!=340 && s!=400)) {
s=-1;
}
/* the break statements gets out of the switch-case, so
/* we go back and wait for new serial data */
break; /* s=-1 (initial state) taken care of */
/* s=0 or 1 means CHANGE PIN MODE */
case 0:
/* the second received value indicates the pin
from abs('c')=99, pin 2, to abs('¦')=166, pin 69 */
if (val>98 && val<167) {
pin=val-97; /* calculate pin */
s=1; /* next we will need to get 0 or 1 from serial */
}
else {
s=-1; /* if value is not a pin then return to -1 */
}
break; /* s=0 taken care of */
case 1:
/* the third received value indicates the value 0 or 1 */
if (val>47 && val<50) {
/* set pin mode */
if (val==48) {
pinMode(pin,INPUT);
}
else {
pinMode(pin,OUTPUT);
}
}
s=-1; /* we are done with CHANGE PIN so go to -1 */
break; /* s=1 taken care of */
/* s=10 means DIGITAL INPUT ************************** */
case 10:
/* the second received value indicates the pin
from abs('c')=99, pin 2, to abs('¦')=166, pin 69 */
if (val>98 && val<167) {
pin=val-97; /* calculate pin */
dgv=digitalRead(pin); /* perform Digital Input */
Serial.println(dgv); /* send value via serial */
}
s=-1; /* we are done with DI so next state is -1 */
break; /* s=10 taken care of */
/* s=20 or 21 means DIGITAL OUTPUT ******************* */
case 20:
/* the second received value indicates the pin
from abs('c')=99, pin 2, to abs('¦')=166, pin 69 */
if (val>98 && val<167) {
pin=val-97; /* calculate pin */
s=21; /* next we will need to get 0 or 1 from serial */
}
else {
s=-1; /* if value is not a pin then return to -1 */
}
break; /* s=20 taken care of */
case 21:
/* the third received value indicates the value 0 or 1 */
if (val>47 && val<50) {
dgv=val-48; /* calculate value */
digitalWrite(pin,dgv); /* perform Digital Output */
}
s=-1; /* we are done with DO so next state is -1 */
break; /* s=21 taken care of */
/* s=30 means ANALOG INPUT *************************** */
case 30:
/* the second received value indicates the pin
from abs('a')=97, pin 0, to abs('p')=112, pin 15 */
if (val>96 && val<113) {
pin=val-97; /* calculate pin */
agv=analogRead(pin); /* perform Analog Input */
Serial.println(agv); /* send value via serial */
}
s=-1; /* we are done with AI so next state is -1 */
break; /* s=30 taken care of */
/* s=40 or 41 means ANALOG OUTPUT ******************** */
case 40:
/* the second received value indicates the pin
from abs('c')=99, pin 2, to abs('¦')=166, pin 69 */
if (val>98 && val<167) {
pin=val-97; /* calculate pin */
s=41; /* next we will need to get value from serial */
}
else {
s=-1; /* if value is not a pin then return to -1 */
}
break; /* s=40 taken care of */
case 41:
/* the third received value indicates the analog value */
analogWrite(pin,val); /* perform Analog Output */
s=-1; /* we are done with AO so next state is -1 */
break; /* s=41 taken care of */
/* s=50 means SERVO STATUS (ATTACHED/DETACHED) ******* */
case 50:
/* the second value indicates the servo attachment pin
from abs('c')=99, pin 2, to abs('¦')=166, pin 69 */
if (val>98 && val<167) {
pin=val-97; /* calculate pin */
dgv=servo[pin].attached(); /* read status */
Serial.println(dgv); /* send value via serial */
}
s=-1; /* we are done with servo status so return to -1*/
break; /* s=50 taken care of */
/* s=60 or 61 means SERVO ATTACH/DETACH ************** */
case 60:
/* the second value indicates the servo attachment pin
from abs('c')=99, pin 2, to abs('¦')=166, pin 69 */
if (val>98 && val<167) {
pin=val-97; /* calculate pin */
s=61; /* next we will need to get 0 or 1 from serial */
}
else {
s=-1; /* if value is not a servo then return to -1 */
}
break; /* s=60 taken care of */
case 61:
/* the third received value indicates the value 0 or 1
0 for detach and 1 for attach */
if (val>47 && val<50) {
dgv=val-48; /* calculate value */
if (dgv) servo[pin].attach(pin); /* attach servo */
else servo[pin].detach(); /* detach servo */
}
s=-1; /* we are done with servo attach/detach so -1 */
break; /* s=61 taken care of */
/* s=70 means SERVO READ ***************************** */
case 70:
/* the second value indicates the servo attachment pin
from abs('c')=99, pin 2, to abs('¦')=166, pin 69 */
if (val>98 && val<167) {
pin=val-97; /* calculate pin */
agv=servo[pin].read(); /* read value */
Serial.println(agv); /* send value via serial */
}
s=-1; /* we are done with servo read so go to -1 next */
break; /* s=70 taken care of */
/* s=80 or 81 means SERVO WRITE ******************** */
case 80:
/* the second value indicates the servo attachment pin
from abs('c')=99, pin 2, to abs('¦')=166, pin 69 */
if (val>98 && val<167) {
pin=val-97; /* calculate pin */
s=81; /* next we will need to get value from serial */
}
else {
s=-1; /* if value is not a servo then return to -1 */
}
break; /* s=80 taken care of */
case 81:
/* the third received value indicates the servo angle */
val=10*val+600;
servo[pin].writeMicroseconds(val); /* write value */
s=-1; /* we are done with servo write so go to -1 next*/
break; /* s=81 taken care of */
/* s=90 means Query Script Type:
(0 adio, 1 adioenc, 2 adiosrv, 3 motor) */
case 90:
if (val==57) {
/* if string sent is 99 send script type via serial */
Serial.println(2);
}
s=-1; /* we are done with this so next state is -1 */
break; /* s=90 taken care of */
/* s=210 to 212 means ENCODER ATTACH ***************** */
case 210:
/* the second value indicates the encoder number:
either 0, 1 or 2 */
if (val>47 && val<51) {
enc=val-48; /* calculate encoder number */
s=211; /* next we need the first attachment pin */
}
else {
s=-1; /* if value is not an encoder then return to -1*/
}
break; /* s=210 taken care of */
case 211:
/* the third received value indicates the first pin
from abs('c')=99, pin 2, to abs('¦')=166, pin 69 */
if (val>98 && val<167) {
pin=val-97; /* calculate pin */
Enc[enc].pinA=pin; /* set pin A */
s=212; /* next we need the second attachment pin */
}
else {
s=-1; /* if value is not a servo then return to -1 */
}
break; /* s=211 taken care of */
case 212:
/* the fourth received value indicates the second pin
from abs('c')=99, pin 2, to abs('¦')=166, pin 69 */
if (val>98 && val<167) {
pin=val-97; /* calculate pin */
Enc[enc].pinB=pin; /* set pin B */
/* set encoder pins as inputs */
pinMode(Enc[enc].pinA, INPUT);
pinMode(Enc[enc].pinB, INPUT);
/* turn on pullup resistors */
digitalWrite(Enc[enc].pinA, HIGH);
digitalWrite(Enc[enc].pinB, HIGH);
/* attach interrupts */
switch(enc) {
case 0:
attachInterrupt(getIntNum(Enc[0].pinA), isrPinAEn0, CHANGE);
attachInterrupt(getIntNum(Enc[0].pinB), isrPinBEn0, CHANGE);
break;
case 1:
attachInterrupt(getIntNum(Enc[1].pinA), isrPinAEn1, CHANGE);
attachInterrupt(getIntNum(Enc[1].pinB), isrPinBEn1, CHANGE);
break;
case 2:
attachInterrupt(getIntNum(Enc[2].pinA), isrPinAEn2, CHANGE);
attachInterrupt(getIntNum(Enc[2].pinB), isrPinBEn2, CHANGE);
break;
}
}
s=-1; /* we are done with encoder attach so -1 */
break; /* s=212 taken care of */
/* s=220 means ENCODER DETACH *********************** */
case 220:
/* the second value indicates the encoder number:
either 0, 1 or 2 */
if (val>47 && val<51) {
enc=val-48; /* calculate encoder number */
/* detach interrupts */
detachInterrupt(getIntNum(Enc[enc].pinA));
detachInterrupt(getIntNum(Enc[enc].pinB));
}
s=-1; /* we are done with encoder detach so -1 */
break; /* s=220 taken care of */
/* s=230 means GET ENCODER POSITION ****************** */
case 230:
/* the second value indicates the encoder number:
either 0, 1 or 2 */
if (val>47 && val<51) {
enc=val-48; /* calculate encoder number */
/* send the value back */
Serial.println(Enc[enc].pos);
}
s=-1; /* we are done with encoder detach so -1 */
break; /* s=230 taken care of */
/* s=240 means RESET ENCODER POSITION **************** */
case 240:
/* the second value indicates the encoder number:
either 0, 1 or 2 */
if (val>47 && val<51) {
enc=val-48; /* calculate encoder number */
/* reset position */
Enc[enc].pos=0;
}
s=-1; /* we are done with encoder detach so -1 */
break; /* s=240 taken care of */
/* s=250 and 251 mean SET ENCODER DEBOUNCE DELAY ***** */
case 250:
/* the second value indicates the encoder number:
either 0, 1 or 2 */
if (val>47 && val<51) {
enc=val-48; /* calculate encoder number */
s=251; /* next we need the first attachment pin */
}
else {
s=-1; /* if value is not an encoder then return to -1*/
}
break; /* s=250 taken care of */
case 251:
/* the third received value indicates the debounce
delay value in units of approximately 0.1 ms each
from abs('a')=97, 0 units, to abs('¦')=166, 69 units*/
if (val>96 && val<167) {
Enc[enc].del=val-97; /* set debounce delay */
}
s=-1; /* we are done with this so next state is -1 */
break; /* s=251 taken care of */
/* s=340 or 341 means ANALOG REFERENCE *************** */
case 340:
/* the second received value indicates the reference,
which is encoded as is 0,1,2 for DEFAULT, INTERNAL
and EXTERNAL, respectively. Note that this function
is ignored for boards not featuring AVR or PIC32 */
#if defined(__AVR__) || defined(__PIC32MX__)
switch (val) {
case 48:
analogReference(DEFAULT);
break;
case 49:
analogReference(INTERNAL);
break;
case 50:
analogReference(EXTERNAL);
break;
default: /* unrecognized, no action */
break;
}
#endif
s=-1; /* we are done with this so next state is -1 */
break; /* s=341 taken care of */
/* s=400 roundtrip example function (returns the input)*/
case 400:
/* the second value (val) can really be anything here */
/* This is an auxiliary function that returns the ASCII
value of its first argument. It is provided as an
example for people that want to add their own code */
/* your own code goes here instead of the serial print */
Serial.println(val);
s=-1; /* we are done with the aux function so -1 */
break; /* s=400 taken care of */
/* ******* UNRECOGNIZED STATE, go back to s=-1 ******* */
default:
/* we should never get here but if we do it means we
are in an unexpected state so whatever is the second
received value we get out of here and back to s=-1 */
s=-1; /* go back to the initial state, break unneeded */
} /* end switch on state s */
} /* end if serial available */
} /* end loop statement */
/* auxiliary function to handle encoder attachment */
int getIntNum(int pin) {
/* returns the interrupt number for a given interrupt pin
see http://arduino.cc/it/Reference/AttachInterrupt */
switch(pin) {
case 2:
return 0;
case 3:
return 1;
case 21:
return 2;
case 20:
return 3;
case 19:
return 4;
case 18:
return 5;
default:
return -1;
}
}
/* auxiliary debouncing function */
void debounce(int del) {
int k;
for (k=0;k<del;k++) {
/* can't use delay in the ISR so need to waste some time
perfoming operations, this uses roughly 0.1ms on uno */
k = k +0.0 +0.0 -0.0 +3.0 -3.0;
}
}
/* Interrupt Service Routine: change on pin A for Encoder 0 */
void isrPinAEn0(){
/* read pin B right away */
int drB = digitalRead(Enc[0].pinB);
/* possibly wait before reading pin A, then read it */
debounce(Enc[0].del);
int drA = digitalRead(Enc[0].pinA);
/* this updates the counter */
if (drA == HIGH) { /* low->high on A? */
if (drB == LOW) { /* check pin B */
Enc[0].pos++; /* going clockwise: increment */
} else {
Enc[0].pos--; /* going counterclockwise: decrement */
}
} else { /* must be high to low on A */
if (drB == HIGH) { /* check pin B */
Enc[0].pos++; /* going clockwise: increment */
} else {
Enc[0].pos--; /* going counterclockwise: decrement */
}
} /* end counter update */
} /* end ISR pin A Encoder 0 */
/* Interrupt Service Routine: change on pin B for Encoder 0 */
void isrPinBEn0(){
/* read pin A right away */
int drA = digitalRead(Enc[0].pinA);
/* possibly wait before reading pin B, then read it */
debounce(Enc[0].del);
int drB = digitalRead(Enc[0].pinB);
/* this updates the counter */
if (drB == HIGH) { /* low->high on B? */
if (drA == HIGH) { /* check pin A */
Enc[0].pos++; /* going clockwise: increment */
} else {
Enc[0].pos--; /* going counterclockwise: decrement */
}
} else { /* must be high to low on B */
if (drA == LOW) { /* check pin A */
Enc[0].pos++; /* going clockwise: increment */
} else {
Enc[0].pos--; /* going counterclockwise: decrement */
}
} /* end counter update */
} /* end ISR pin B Encoder 0 */
/* Interrupt Service Routine: change on pin A for Encoder 1 */
void isrPinAEn1(){
/* read pin B right away */
int drB = digitalRead(Enc[1].pinB);
/* possibly wait before reading pin A, then read it */
debounce(Enc[1].del);
int drA = digitalRead(Enc[1].pinA);
/* this updates the counter */
if (drA == HIGH) { /* low->high on A? */
if (drB == LOW) { /* check pin B */
Enc[1].pos++; /* going clockwise: increment */
} else {
Enc[1].pos--; /* going counterclockwise: decrement */
}
} else { /* must be high to low on A */
if (drB == HIGH) { /* check pin B */
Enc[1].pos++; /* going clockwise: increment */
} else {
Enc[1].pos--; /* going counterclockwise: decrement */
}
} /* end counter update */
} /* end ISR pin A Encoder 1 */
/* Interrupt Service Routine: change on pin B for Encoder 1 */
void isrPinBEn1(){
/* read pin A right away */
int drA = digitalRead(Enc[1].pinA);
/* possibly wait before reading pin B, then read it */
debounce(Enc[1].del);
int drB = digitalRead(Enc[1].pinB);
/* this updates the counter */
if (drB == HIGH) { /* low->high on B? */
if (drA == HIGH) { /* check pin A */
Enc[1].pos++; /* going clockwise: increment */
} else {
Enc[1].pos--; /* going counterclockwise: decrement */
}
} else { /* must be high to low on B */
if (drA == LOW) { /* check pin A */
Enc[1].pos++; /* going clockwise: increment */
} else {
Enc[1].pos--; /* going counterclockwise: decrement */
}
} /* end counter update */
} /* end ISR pin B Encoder 1 */
/* Interrupt Service Routine: change on pin A for Encoder 2 */
void isrPinAEn2(){
/* read pin B right away */
int drB = digitalRead(Enc[2].pinB);
/* possibly wait before reading pin A, then read it */
debounce(Enc[2].del);
int drA = digitalRead(Enc[2].pinA);
/* this updates the counter */
if (drA == HIGH) { /* low->high on A? */
if (drB == LOW) { /* check pin B */
Enc[2].pos++; /* going clockwise: increment */
} else {
Enc[2].pos--; /* going counterclockwise: decrement */
}
} else { /* must be high to low on A */
if (drB == HIGH) { /* check pin B */
Enc[2].pos++; /* going clockwise: increment */
} else {
Enc[2].pos--; /* going counterclockwise: decrement */
}
} /* end counter update */
} /* end ISR pin A Encoder 2 */
/* Interrupt Service Routine: change on pin B for Encoder 2 */
void isrPinBEn2(){
/* read pin A right away */
int drA = digitalRead(Enc[2].pinA);
/* possibly wait before reading pin B, then read it */
debounce(Enc[2].del);
int drB = digitalRead(Enc[2].pinB);
/* this updates the counter */
if (drB == HIGH) { /* low->high on B? */
if (drA == HIGH) { /* check pin A */
Enc[2].pos++; /* going clockwise: increment */
} else {
Enc[2].pos--; /* going counterclockwise: decrement */
}
} else { /* must be high to low on B */
if (drA == LOW) { /* check pin A */
Enc[2].pos++; /* going clockwise: increment */
} else {
Enc[2].pos--; /* going counterclockwise: decrement */
}
} /* end counter update */
} /* end ISR pin B Encoder 2 */