From 846925063d85e725cc62f5bb0ceed721ed61d850 Mon Sep 17 00:00:00 2001
From: Markus Zolliker <markus.zolliker@psi.ch>
Date: Mon, 11 Sep 2023 18:04:36 +0200
Subject: [PATCH] version ccu4_78

---
 ccu4_77.ino => ccu4_78.ino | 14 ++++-----
 config.ino                 | 30 +++++++++---------
 he.ino                     | 62 +++++++++++++++++++-------------------
 instr.ino                  |  2 +-
 par.ino                    | 52 ++++++++++++++++----------------
 parser.ino                 | 28 +++++++++++------
 utils.h                    |  2 +-
 utils.ino                  | 21 ++++++++++---
 valve.ino                  |  2 +-
 valveUnit.ino              | 40 ++++++++++++------------
 10 files changed, 139 insertions(+), 114 deletions(-)
 rename ccu4_77.ino => ccu4_78.ino (98%)

diff --git a/ccu4_77.ino b/ccu4_78.ino
similarity index 98%
rename from ccu4_77.ino
rename to ccu4_78.ino
index 0d38cee..530b7a9 100644
--- a/ccu4_77.ino
+++ b/ccu4_78.ino
@@ -1,17 +1,17 @@
+#define ARRAY_CHECK 1
 #include "utils.h"
 #include "DispSerial.h"
 #include "SerialWrapper.h"
 #include "dipdisplay.h"
 #include "motor.h"
 #include "parser.h"
-#define ARRAY_CHECK
 #include "par.h"
 
 #define RAMTEST 0
 // define SERIALCOMMON 1 for testing the serial connection over usb
 #define SERIALCOMMON 0
 
-PAR_TEXT configSoft[16] = "7.7";
+PAR_TEXT configSoft[16] = "7.8";
 
 long now; // global variable, updated by FastHandler
 byte inside;
@@ -560,10 +560,10 @@ void HardHandler() {
   case 7: if (extension == valve_extension) VuHandler(); break;
   }
   t = micros() - t;
-  times[hdl] += t;
-  cnt[hdl] ++;
+  ARRAY(times, hdl) += t;
+  ARRAY(cnt, hdl) ++;
   if (cnt[hdl] >= 10) {
-    m = times[hdl] * 0.001;
+    m = ARRAY(times, hdl) * 0.001;
     switch (hdl) {
     case 0: ParSet(timC, m); break;
     case 1: ParSet(timN, m); break;
@@ -572,8 +572,8 @@ void HardHandler() {
     case 4: ParSet(timM, m); break;
     case 5: ParSet(timV, m); break;
     }
-    cnt[hdl] = 0;
-    times[hdl] = 0;
+    ARRAY(cnt, hdl) = 0;
+    ARRAY(times, hdl) = 0;
   }
   hdl++;
   if (hdl >= N_hdl) {
diff --git a/config.ino b/config.ino
index 597cd5f..2de4f69 100644
--- a/config.ino
+++ b/config.ino
@@ -175,7 +175,9 @@ void ConfigInit() {
     EESTORE(configSpecial, ee_read);
     l = textcopyuntil((char *)configIdn, sizeof configIdn, configIdn, '.'); // find dot
     if (l < sizeof configIdn - 2) {
-      ((char *)configIdn)[l] = '.';
+      #if PARCHECK == 0
+      ARRAY(configIdn,l) = '.'; // exception of PARCHECK, no complain about usage outside ParSet
+      #endif
       l++;
       l = textcopy((char *)configIdn + l, sizeof configIdn - l, ParFmt(p_configSpecial));
     }
@@ -321,7 +323,7 @@ byte ConfigGetCode(byte chan, word adc) {
   int8_t pos;
   struct config_stat_s *s;
   
-  s = &config_stat[chan];  
+  s = &ARRAY(config_stat, chan);  
   adc *= 10;
   
   if (adc < s->v1) {
@@ -375,7 +377,7 @@ void ConfigDevice(byte devno, byte state) {
   if (devno >= configMaxDev) {
     devno = 0;
   }
-  d = &deviceTable[devno];
+  d = &ARRAY(deviceTable, devno);
   if (d->name[0] == 0) {
     ParSetText(configDevice, "unknown");
   } else {
@@ -456,7 +458,7 @@ void ConfigHandler() {
   d = 0;
   for (devno1 = 0; devno1 < configNdevices; devno1++) {
     FastHandler();
-    d = &deviceTable[devno1];
+    d = &ARRAY(deviceTable,devno1);
     if (d->rescode[0] == ca && d->rescode[1] == cb) {
       break;
     }
@@ -477,10 +479,10 @@ void ConfigHandler() {
 int8_t ConfigItemText(char *text, byte maxlen) {
   int8_t len;
   if (configItemIndex != 0) {
-    if (configItem[configItemIndex] != ',') return -1; // bad syntax
+    if (ARRAY(configItem,configItemIndex) != ',') return -1; // bad syntax
     configItemIndex++;
   }
-  len = textcopyuntil(text, maxlen, &configItem[configItemIndex], ',');
+  len = textcopyuntil(text, maxlen, &ARRAY(configItem,configItemIndex), ',');
   if (len == maxlen) return -1; // too long
   configItemIndex += len;
   return len;
@@ -490,10 +492,10 @@ int8_t ConfigItemNum(long *result, byte dig) {
   byte len;
   
   if (configItemIndex != 0) {
-    if (configItem[configItemIndex] != ',') return -1; // bad syntax
+    if (ARRAY(configItem,configItemIndex) != ',') return -1; // bad syntax
     configItemIndex++;
   }
-  *result = text2fix(&configItem[configItemIndex], dig, &len);
+  *result = text2fix(&ARRAY(configItem,configItemIndex), dig, &len);
   configItemIndex += len;
   return len;
 }
@@ -502,7 +504,7 @@ byte ConfigFindItem(char *name) {
   byte devno;
   
   for (devno = 0; devno < configNdevices; devno++) {
-    if (strcmp(deviceTable[devno].name, name) == 0) {
+    if (strcmp(ARRAY(deviceTable,devno).name, name) == 0) {
       break;
     }
   }
@@ -544,13 +546,13 @@ void ConfigItem() {
     return;
   } 
   configItemIndex = 0;
-  d = &deviceTable[configNdevices];
+  d = &ARRAY(deviceTable,configNdevices);
   if (ConfigItemText(d->name, sizeof d->name) < 0) {
     SerialC.write('?');
     Serial.print(F("device name too long\n"));
     return;
   }
-  if (configItem[configItemIndex] == 0) { // end of data
+  if (ARRAY(configItem,configItemIndex) == 0) { // end of data
     switch (d->name[0]) {
     case 'c': configNdevices = 0; return;
     case 's': ConfigSave(); return;
@@ -561,7 +563,7 @@ void ConfigItem() {
       configDevIdx = 0;
       return;
     }
-    d = &deviceTable[configDevIdx];
+    d = &ARRAY(deviceTable,configDevIdx);
     configDevIdx++;
     // configItem is reconstructed in a standardized way
     textcopy(configItem, sizeof configItem, d->name);
@@ -696,7 +698,7 @@ void ConfigItem() {
     configNdevices++;
 //    Serial.println("added");
   } else {
-    deviceTable[devno] = *d;
+    ARRAY(deviceTable,devno) = *d;
 //    Serial.println("replaced");
   }
   return;
@@ -765,7 +767,7 @@ void ConfigDeviceDisp() {
   }
   for (pos = 13, devno = base; pos > 0 && devno < configNdevices; pos -= 2, devno++) {
     if (pos == 1) pos = 12; // next column
-    DispButton(pos, m_device, devno, deviceTable[devno].name);
+    DispButton(pos, m_device, devno, ARRAY(deviceTable,devno).name);
   }
   DispButton(0, m_device, device_other, "other");
   DispButton(1, m_menu, m_home, "home");
diff --git a/he.ino b/he.ino
index a082b46..2a1f9f3 100644
--- a/he.ino
+++ b/he.ino
@@ -108,7 +108,7 @@ void HePars() {
       ParArraySet(heExtState, 0, he_not_yet);
     } else {
       for (byte n = 0; n < 6; n++) {
-        if (heExtState[n] != he_disabled) {
+        if (ARRAY(heExtState,n) != he_disabled) {
           ParArraySet(heExtState, n, he_not_yet);
         }
       }
@@ -174,7 +174,7 @@ void HeSetState(byte channel, byte value) {
 
 byte HeGetState(byte channel) {
   if (channel >= 0 && channel < heExtAvailable) {
-    return heExtState[channel];
+    return ARRAY(heExtState,channel);
   } else if (channel == 6) {
     return heSensState;
   }
@@ -183,7 +183,7 @@ byte HeGetState(byte channel) {
 
 long HeGetLevel(byte channel) {
   if (channel >= 0 && channel < 6) {
-    return heExtLevel[channel];
+    return ARRAY(heExtLevel,channel);
   } else if (channel == 6) {
     return heLevel;
   }
@@ -194,7 +194,7 @@ void HeLoadChannel() {
   heIntState = HeGetState(heChannel);
   heIntLevel = HeGetLevel(heChannel);
   if (heChannel >= 0 && heChannel <= 6) {
-    heMinLevel = heMinLev[heChannel];
+    heMinLevel = ARRAY(heMinLev,heChannel);
   }
 }
 
@@ -222,18 +222,18 @@ void HeDispExt() {
   for (channel = 0; channel <= 6; channel++) {
     st = HeGetState(channel);
     if (st == he_disabled) {
-      shown[channel] = 0;
+      ARRAY(shown,channel) = 0;
     } else {
-      used += shown[channel];
+      used += ARRAY(shown,channel);
       if (st == he_sens_ok) {
-        if (shown[channel] == 0) {
+        if (ARRAY(shown,channel) == 0) {
           need++;
           want++;
-        } else if (shown[channel] == 1) {
+        } else if (ARRAY(shown,channel) == 1) {
           want++;
         }
       } else {
-        if (shown[channel] == 0) {
+        if (ARRAY(shown,channel) == 0) {
           need ++;
         }
       }
@@ -246,34 +246,34 @@ void HeDispExt() {
     if (st != he_disabled) {
       if (st == he_sens_ok) {
         cutatend = false;
-        if (shown[channel] == 0) {
+        if (ARRAY(shown,channel) == 0) {
           used++;
           need--;
-          shown[channel] = 1;
+          ARRAY(shown,channel) = 1;
         }
-      } else if (shown[channel] == 0) {
+      } else if (ARRAY(shown,channel) == 0) {
         if (cutatend && used + need + want >= 10) {
           need--;
         } else {
           used++;
           need--;
-          shown[channel] = 1;
+          ARRAY(shown,channel) = 1;
         }
       } else if (used + need + want > 10) {
         if (cutatend) {
-          if (shown[channel] > 0) {
-            if (shown[channel] == 2 && used + need + want == 11) {
+          if (ARRAY(shown,channel) > 0) {
+            if (ARRAY(shown,channel) == 2 && used + need + want == 11) {
               used -= 1;
-              shown[channel] = 1;
+              ARRAY(shown,channel) = 1;
             } else {
-              used -= shown[channel];
-              shown[channel] = 0;
+              used -= ARRAY(shown,channel);
+              ARRAY(shown,channel) = 0;
             }
           }
         } else {
-          if (shown[channel] == 2) {
+          if (ARRAY(shown,channel) == 2) {
             used--;
-            shown[channel] = 1;
+            ARRAY(shown,channel) = 1;
           }
         }
       }
@@ -289,21 +289,21 @@ void HeDispExt() {
   while (channel > 0 && used + need > 10) {
     channel--;
     if (HeGetState(channel) == he_sens_ok) {
-      if (shown[channel] == 2) {
-        shown[channel] = 1;
+      if (ARRAY(shown,channel) == 2) {
+        ARRAY(shown,channel) = 1;
         used--;
       }
     }
   }
   for (channel = 0; channel < 7; channel++) {
     head[0] = '0' + channel;
-    if (shown[channel] == 1 && used < 10 && HeGetState(channel) == he_sens_ok) {
-      shown[channel] = 2;
+    if (ARRAY(shown,channel) == 1 && used < 10 && HeGetState(channel) == he_sens_ok) {
+      ARRAY(shown,channel) = 2;
       used++;
     }
-    if (shown[channel] == 1) {
+    if (ARRAY(shown,channel) == 1) {
       DispValue(head, HeValueNr(channel), HeStateNr(channel));
-    } else if (shown[channel] == 2) {
+    } else if (ARRAY(shown,channel) == 2) {
       DispLargeValue(head, HeValueNr(channel), HeStateNr(channel));
     }
   }
@@ -417,7 +417,7 @@ void HeEndMeas() {
     // saving result
     HeSetState(heChannel, heIntState);
     if (heChannel >= 0 && heChannel <= 6) {
-      heMinLev[heChannel] = heMinLevel;
+      ARRAY(heMinLev,heChannel) = heMinLevel;
     }
     if (heIntState == he_sens_ok) {
       if (heMeas == 1) HeSetLev(heChannel, heIntLevel);
@@ -600,7 +600,7 @@ void HeHandler() {
     pinMode(io_lev_enable, INPUT);
     digitalWrite(io_lev_enable, HIGH); // input pullup
     for (i = 0; i < 4; i++) {
-      lastLevels[i] = undef_mm;
+      ARRAY(lastLevels,i) = undef_mm;
     }
   }
   tim = now;
@@ -689,7 +689,7 @@ void HeHandler() {
     stab--;
   }
   pos = (pos + 1) % 4;
-  lastLevels[pos] = lev;
+  ARRAY(lastLevels,pos) = lev;
   if (HEDEBUG && 0) {Serial.print(lev); Serial.print("\n"); }
   if (lev > empty_10um + empty_10um / 33) { // value more than 3% more than empty length:
     heIntState = he_sens_warm;
@@ -719,8 +719,8 @@ void HeHandler() {
   // finished measuring
   n = 1;
   for (i = 0; i < 4; i++) {
-    if (lastLevels[i] != undef_mm) {
-      lev += lastLevels[i];
+    if (ARRAY(lastLevels,i) != undef_mm) {
+      lev += ARRAY(lastLevels,i);
       n++;
     }
   }
diff --git a/instr.ino b/instr.ino
index bd3d7b2..d51212f 100644
--- a/instr.ino
+++ b/instr.ino
@@ -62,7 +62,7 @@ void InstrDisp() {
   if (!online) { // we are offline
     if (time_ge(now, 5000) || instrState != instr_startup) {
       DispTextRow(fmt_medium, 0, "offline");
-      if (instrRack[0] != 0) {
+      if (instrRack[0] > ' ') {
         DispTextRow(fmt_rsmall, "please","connect");
         DispText("rack to LAN");
         DispText("and choose");
diff --git a/par.ino b/par.ino
index dcfe4c8..3b13496 100644
--- a/par.ino
+++ b/par.ino
@@ -21,12 +21,12 @@ ParAction *action = 0;
 //byte unchangedSerial[p_nPar / 8 + 1] = {0}; // for serial connection
 //byte unchangedDisplay[p_nPar / 8 + 1] = {0}; // for display
 
-byte flags[p_nPar] = {0};
+byte flags[p_nPar+1] = {0};
 
 void ParClrAll(byte flag) {
   byte i;
   for (i = 0; i <= p_nPar; i++) {
-    bitClear(flags[i], flag);
+    bitClear(ARRAY(flags,i), flag);
   }
 }
   
@@ -39,19 +39,19 @@ void ParSetAllChangedDisp() {
 }
 
 boolean ParChanged(byte nr) {
-  if (bitRead(flags[nr], par_display_unchanged)) return false;
-  bitSet(flags[nr], par_display_unchanged);
+  if (bitRead(ARRAY(flags,nr), par_display_unchanged)) return false;
+  bitSet(ARRAY(flags,nr), par_display_unchanged);
   return true;
 }
 
 /*
 boolean ParHasChanged(byte nr) {
-  return !bitRead(flags[nr], par_serial_unchanged);
+  return !bitRead(ARRAY(flags,nr), par_serial_unchanged);
 }
 */
 
 void ParSetChanged(byte nr) {
-  bitClear(flags[nr], par_serial_unchanged);
+  bitClear(ARRAY(flags,nr), par_serial_unchanged);
 }
 
 void ParSet_(byte nr, void *ptr, byte siz, long value) {
@@ -67,20 +67,20 @@ void ParSet_(byte nr, void *ptr, byte siz, long value) {
   } else {
     DispError(c40(nr % 10 + 1 + 40 * (nr / 10 + 1)), "bad siz");
   }
-  bitClear(flags[nr], par_serial_unchanged);
+  bitClear(ARRAY(flags,nr), par_serial_unchanged);
   if (PARDEBUG) {
-    if (bitRead(flags[nr], par_display_unchanged)) {
+    if (bitRead(ARRAY(flags,nr), par_display_unchanged)) {
       Serial.print(nr); Serial.print("/"); Serial.print(siz); Serial.println(" changed");
     }
   }
   if (siz == 4 && (value + 5) / 10 == (old + 5) / 10) return;
-  bitClear(flags[nr], par_display_unchanged);
+  bitClear(ARRAY(flags,nr), par_display_unchanged);
 }
 
 void ParSetText_(byte nr, char *ptr, byte siz, char *value) {
   textcopy(ptr, siz, value);
-  bitClear(flags[nr], par_serial_unchanged);
-  bitClear(flags[nr], par_display_unchanged);
+  bitClear(ARRAY(flags,nr), par_serial_unchanged);
+  bitClear(ARRAY(flags,nr), par_display_unchanged);
 }
 
 long ParGet(byte nr) {
@@ -192,14 +192,14 @@ byte ParFixed_(byte nr, name_t name, long *ptr, byte dig) {
   case par_hide:
     if (name != action->name) return par_none;
     //Serial.print("hide "); Serial.println(c40(name));
-    bitSet(flags[nr], par_hidden);
+    bitSet(ARRAY(flags,nr), par_hidden);
     action->action = par_done;
     break;
   case par_scan:
-    if (bitRead(flags[nr], par_hidden)) return par_none;
+    if (bitRead(ARRAY(flags,nr), par_hidden)) return par_none;
     fix2str(*ptr, dig, ctx.scanform, sizeof ctx.scanform);
-    if (ctx.scan(nr, name, ctx.scanform, 0, bitRead(flags[nr], par_serial_unchanged))) {
-      bitSet(flags[nr], par_serial_unchanged);
+    if (ctx.scan(nr, name, ctx.scanform, 0, bitRead(ARRAY(flags,nr), par_serial_unchanged))) {
+      bitSet(ARRAY(flags,nr), par_serial_unchanged);
     }
     break;
   case par_command:
@@ -229,7 +229,7 @@ byte ParFixed_(byte nr, name_t name, long *ptr, byte dig) {
   case par_fmt:
     if (name != action->name) return par_none;
     //Serial.print("show "); Serial.println(c40(name));
-    bitClear(flags[nr], par_hidden);
+    bitClear(ARRAY(flags,nr), par_hidden);
     value = *ptr;
     fix2str(value, dig, ctx.formattedbuf, sizeof ctx.formattedbuf);
     ctx.formatted = ctx.formattedbuf;
@@ -261,15 +261,15 @@ byte ParEnum_(byte nr, name_t name, byte *ptr, flash_str list) {
   case par_done: return par_none;
   case par_hide:
     if (name != action->name) return par_none;
-    bitSet(flags[nr], par_hidden);
+    bitSet(ARRAY(flags,nr), par_hidden);
     action->action = par_done;
     break;
   case par_scan:
-    if (bitRead(flags[nr], par_hidden)) return par_none;
+    if (bitRead(ARRAY(flags,nr), par_hidden)) return par_none;
     enum2str(*ptr, list, ctx.scantext, sizeof ctx.scantext);
     fix2str(*ptr, 0, ctx.scanform, sizeof ctx.scanform);
-    if (ctx.scan(nr, name, ctx.scanform, ctx.scantext, bitRead(flags[nr], par_serial_unchanged))) {
-      bitSet(flags[nr], par_serial_unchanged);
+    if (ctx.scan(nr, name, ctx.scanform, ctx.scantext, bitRead(ARRAY(flags,nr), par_serial_unchanged))) {
+      bitSet(ARRAY(flags,nr), par_serial_unchanged);
       //if(PARDEBUG) { Serial.print('('); Serial.print(c40(name)); Serial.print(":"); Serial.print(nr); Serial.print(')'); };
     }
     break;
@@ -296,7 +296,7 @@ byte ParEnum_(byte nr, name_t name, byte *ptr, flash_str list) {
     break;
   case par_fmt:
     if (name != action->name) return par_none;
-    bitClear(flags[nr], par_hidden); 
+    bitClear(ARRAY(flags,nr), par_hidden); 
     fix2str(*ptr, 0, ctx.formattedbuf, sizeof ctx.formattedbuf);
     ctx.formatted = ctx.formattedbuf;
     action->action = par_done;
@@ -323,18 +323,18 @@ byte ParText_(byte nr, name_t name, char *ptr, byte siz, boolean update) {
   case par_done: return par_none;
   case par_hide:
     if (name != action->name) return par_none;
-    bitSet(flags[nr], par_hidden);
+    bitSet(ARRAY(flags,nr), par_hidden);
     action->action = par_done;
     break;
   case par_scan:
-    if (bitRead(flags[nr], par_hidden)) return par_none;
+    if (bitRead(ARRAY(flags,nr), par_hidden)) return par_none;
     if (update) {
       p = ptr;
     } else {
       p = 0;
     }
-    if (ctx.scan(nr, name, p, ptr, bitRead(flags[nr], par_serial_unchanged))) {
-      bitSet(flags[nr], par_serial_unchanged);
+    if (ctx.scan(nr, name, p, ptr, bitRead(ARRAY(flags,nr), par_serial_unchanged))) {
+      bitSet(ARRAY(flags,nr), par_serial_unchanged);
     }
     return true;
   case par_command:
@@ -354,7 +354,7 @@ byte ParText_(byte nr, name_t name, char *ptr, byte siz, boolean update) {
     break;
   case par_fmt:
     if (name != action->name) return par_none;
-    bitClear(flags[nr], par_hidden); 
+    bitClear(ARRAY(flags,nr), par_hidden); 
     //textcopy(ctx.formatted, sizeof(ctx.formatted), ptr);
     ctx.formatted = ptr;
     /*
diff --git a/parser.ino b/parser.ino
index c8f64d0..dfd6f32 100644
--- a/parser.ino
+++ b/parser.ino
@@ -14,13 +14,23 @@ struct {
   char value[254];
 } parser = {-1};
 
+#define PARSEDEBUG 0
+
+int ParserRd() {
+  int ch = SerialC.read();
+  if (PARSEDEBUG && ch > 0) {
+    Serial.write(ch);
+  }
+  return ch;
+}
+
 ParserType Parser() {
   int ch;
   ParserType result = parser_none;
   
   ch = parser.nextChar;
   if (ch < 0) {
-    ch = SerialC.read();
+    ch = ParserRd();
   }
   while (ch >= 0 && result == parser_none) {
     switch (parser.state) {
@@ -40,7 +50,7 @@ ParserType Parser() {
         parser.symbol = ch;
       }
       parser.state = parser_idle;
-      ch = SerialC.read();
+      ch = ParserRd();
       break;
     case parser_id:
       if (ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z' || ch >= '0' && ch <= '9') {
@@ -53,7 +63,7 @@ ParserType Parser() {
           parser.pos++;
         }
         */
-        ch = SerialC.read();
+        ch = ParserRd();
       } else {
         if (parser.ident >= 64000*64000) {
           result = parser_error;
@@ -64,7 +74,7 @@ ParserType Parser() {
         if (ch == '=') {
           parser.state = parser_val;
           parser.valPos = 0;
-          ch = SerialC.read();
+          ch = ParserRd();
         } else {
           parser.state = parser_idle;
         }
@@ -81,21 +91,21 @@ ParserType Parser() {
     case parser_val:
       if (ch == '{') {
         parser.quote++;
-        ch = SerialC.read();
+        ch = ParserRd();
       } else if (ch == '}') {
         if (parser.quote > 0) parser.quote--;
-        ch = SerialC.read();
+        ch = ParserRd();
       } else if (ch < ' ' || (parser.quote == 0 && ch == ' ')) {
-        parser.value[parser.valPos] = 0;
+        ARRAY(parser.value,parser.valPos) = 0;
         parser.quote = 0;
         result = parser_value;
         parser.state = parser_idle;
       } else {
         if (parser.valPos < sizeof(parser.value) - 1) {
-          parser.value[parser.valPos] = ch;
+          ARRAY(parser.value,parser.valPos) = ch;
           parser.valPos++;
         }
-        ch = SerialC.read();
+        ch = ParserRd();
       }
     }
   }
diff --git a/utils.h b/utils.h
index 3982394..58f8496 100644
--- a/utils.h
+++ b/utils.h
@@ -1,5 +1,5 @@
 #ifdef ARRAY_CHECK
-#define ARRAY(ARR, POS) ARR[(size_t)(POS) * sizeof(*ARR) < sizeof(ARR) ?(POS):array_out_of_bounds(__FUNCTION__,#ARR,(POS))]
+#define ARRAY(ARR, POS) ARR[(size_t)(POS) * sizeof(*ARR) < sizeof(ARR) ?(POS):array_out_of_bounds(__FUNCTION__,__LINE__,(POS))]
 #else
 #define ARRAY(ARR, POS) ARR[POS]
 #endif
diff --git a/utils.ino b/utils.ino
index 05a1669..9de7f7e 100644
--- a/utils.ino
+++ b/utils.ino
@@ -123,15 +123,28 @@ boolean textContainsBlanks(const char *text) {
   return (*text != 0);
 }
 
-size_t array_out_of_bounds(const char *func, const char *arrayname, size_t index) {
+void DummyHandler() {
+}
+
+size_t array_out_of_bounds(const char *func, long line, size_t index) {
   Serial.println();
   Serial.print(F("error in "));
   Serial.print(func);
-  Serial.print(": ");
-  Serial.print(arrayname);
-  Serial.print("[");
+  Serial.print(':');
+  Serial.print(line);
+  Serial.print('[');
   Serial.print(index);
   Serial.print(F("] invalid"));
+  SerialD.handler = DummyHandler;
+  SerialD.print("\033DL\033TE\014"); // clear display, terminal mode, clear terminal
+  SerialD.print("index\r\nerror:\r\n");
+  SerialD.print(func);
+  SerialD.print(':');
+  SerialD.print(line);
+  SerialD.print("\r\n[");
+  SerialD.print(index);
+  SerialD.print("]\r\n");
+  SerialD.send();
   while (1);
   //DispError("array out","of bounds");
   return 0;
diff --git a/valve.ino b/valve.ino
index ad136d6..92547b8 100644
--- a/valve.ino
+++ b/valve.ino
@@ -50,7 +50,7 @@ void ValveSet(byte pin, byte high) {
     }
   }
   digitalWrite(pin, high);
-  valveState[i] = high;
+  ARRAY(valveState,i) = high;
 }
 
 void ValveFastHandler() {
diff --git a/valveUnit.ino b/valveUnit.ino
index 181b9ab..a154fbc 100644
--- a/valveUnit.ino
+++ b/valveUnit.ino
@@ -16,7 +16,7 @@ void VuInit() {
 }
 
 void VuParCmd(byte v) {
-  switch (vuCmd[v]) {
+  switch (ARRAY(vuCmd,v)) {
   case valve_on: VuSet(v, valve_boost); break;
   case valve_off: VuSet(v, valve_off); break;
   }
@@ -37,7 +37,7 @@ void VuSet(byte v, byte valveState) {
     pinMode(pin+1, INPUT);
     break;
   case valve_boost:
-    booststart[v] = now;
+    ARRAY(booststart,v) = now;
     if (VUDEBUG) { Serial.print(v); Serial.println(" BOOST"); };
     digitalWrite(pin, LOW);
     digitalWrite(pin+1, HIGH);
@@ -54,7 +54,7 @@ void VuSet(byte v, byte valveState) {
     if (VUDEBUG) { Serial.print(v); Serial.println(" ELSE"); };
   }
   ParArraySet(vu, v, valveState);
-  //ParNrSet(p_vu0 + v, vu[v], valveState);
+  //ParNrSet(p_vu0 + v, ARRAY(vu,v), valveState);
 }
 
 byte VuPin(byte v) {
@@ -81,11 +81,11 @@ char *VuText(char result[8], byte v) {
     pos = 2;
   }
   result[pos ++]=' ';
-  if (vu[v] == valve_on) {
+  if (ARRAY(vu,v) == valve_on) {
     result[pos ++] = 'x';
-  } else if (vu[v] == valve_boost) {
+  } else if (ARRAY(vu,v) == valve_boost) {
     result[pos ++] = '*';
-  } else if (vu[v] == valve_off) {
+  } else if (ARRAY(vu,v) == valve_off) {
     result[pos ++] = '_';
   }
   result[pos ++] = 0;
@@ -99,7 +99,7 @@ void VuDispShort() {
   
   va = 0;
   for (v = 1; v <= 12; v++) {
-    if (vu[v] != no_valve) {
+    if (ARRAY(vu,v) != no_valve) {
       if (va == 0) {
         va = v;
       } else {
@@ -124,7 +124,7 @@ void VuDisp() {
   
   //VuDispShort();
   for (v = 1; v <= 12; v++) {
-    if (vu[v] != no_valve) {
+    if (ARRAY(vu,v) != no_valve) {
       DispButton(pos, m_ext, v, VuText(res1, v));
       pos++;
     }
@@ -140,27 +140,27 @@ void VuHandler() {
   static byte cnt[13]={0};
   
   for (v = 1; v <= 12; v++) {
-    if (vu[v] == valve_boost) {
-      if (time_ge(now, booststart[v] + boostdelay)) {
+    if (ARRAY(vu,v) == valve_boost) {
+      if (time_ge(now, ARRAY(booststart,v) + boostdelay)) {
         VuSet(v, valve_on);
       }
     } else {
       pin = VuPin(v);
       if (digitalRead(pin)) { // valve seems to be disconnected
-        if (cnt[v] >= 100) {
-          if (vu[v] == valve_off) {
+        if (ARRAY(cnt,v) >= 100) {
+          if (ARRAY(vu,v) == valve_off) {
             VuSet(v, no_valve);
           }
         } else {
-          cnt[v]++;
+          ARRAY(cnt,v)++;
         }
       } else {
-        if (cnt[v] > 0) {
-          if (vu[v] == no_valve) {
+        if (ARRAY(cnt,v) > 0) {
+          if (ARRAY(vu,v) == no_valve) {
             VuSet(v, valve_off);
           }
         } else {
-          cnt[v]--;
+          ARRAY(cnt,v)--;
         }
       }
     }
@@ -168,12 +168,12 @@ void VuHandler() {
 }
 
 void VuCmd(byte v) {
-  if (vu[v] == valve_off) {
-    //ParNrSet(p_vuCmd0 + v, vuCmd[v], valve_on);
+  if (ARRAY(vu,v) == valve_off) {
+    //ParNrSet(p_vuCmd0 + v, ARRAY(vuCmd,v), valve_on);
     ParArraySet(vuCmd, v, valve_on);
     VuSet(v, valve_boost);
-  } else if (vu[v] == valve_on || vu[v] == valve_boost) {
-    //ParNrSet(p_vuCmd0 + v, vuCmd[v], valve_off);
+  } else if (ARRAY(vu,v) == valve_on || ARRAY(vu,v) == valve_boost) {
+    //ParNrSet(p_vuCmd0 + v, ARRAY(vuCmd,v), valve_off);
     ParArraySet(vuCmd, v, valve_off);
     VuSet(v, valve_off);
   }