version ccu4_78
This commit is contained in:
@@ -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) {
|
||||
+16
-14
@@ -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");
|
||||
|
||||
@@ -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++;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -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;
|
||||
/*
|
||||
|
||||
+19
-9
@@ -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();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -50,7 +50,7 @@ void ValveSet(byte pin, byte high) {
|
||||
}
|
||||
}
|
||||
digitalWrite(pin, high);
|
||||
valveState[i] = high;
|
||||
ARRAY(valveState,i) = high;
|
||||
}
|
||||
|
||||
void ValveFastHandler() {
|
||||
|
||||
+20
-20
@@ -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);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user