FUNCTION(func_control_menu_ischecked,Checked)
{
setmemberfunction(SC_valname_control_menu);
addvar(_qstr("ID"),SC_valname_string);
setreturntype(SC_valname_boolean);
setcanassign();
}
/* list flags and values that you want to receive via -x */
void upsdrv_makevartable(void)
{
char buf[SMALLBUF];
snprintf(buf, sizeof(buf), "network timeout (default: %d seconds)", timeout);
addvar(VAR_VALUE, "timeout", buf);
addvar(VAR_FLAG, "subscribe", "authenticated subscription on NMC");
addvar(VAR_VALUE | VAR_SENSITIVE, "login", "login value for authenticated mode");
addvar(VAR_VALUE | VAR_SENSITIVE, "password", "password value for authenticated mode");
snprintf(buf, sizeof(buf), "shutdown duration in second (default: %d seconds)", shutdown_duration);
addvar(VAR_VALUE, "shutdown_duration", buf);
if( shutdown_timer > 0 ) {
snprintf(buf, sizeof(buf), "shutdown timer in second (default: %d seconds)", shutdown_timer);
}
else {
snprintf(buf, sizeof(buf), "shutdown timer in second (default: none)");
}
addvar(VAR_VALUE, "shutdown_timer", buf);
/* Legacy MGE-XML conversion from 2000's, not needed in modern firmwares */
addvar(VAR_FLAG, "do_convert_deci", "enable legacy convert_deci() for certain measurements 10x too large");
}
ssize_t
addvard(struct dhcpcd_ctx *ctx,
char ***e, const char *prefix, const char *var, size_t value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%zu", value);
return addvar(ctx, e, prefix, var, buffer);
}
FUNCTION(func_starglobe_getconlines,GetConLines)
{
setmemberfunction(SC_valname_starglobe);
addvar(_qstr("ConstellationID"),SC_valname_string);
setreturntype(SC_valname_list);
//addvar(_qstr("Content"),SC_valname_string);
//addvar(_qstr("ID"),SC_valname_string,false);
//addvar(_qstr("CanCheck"),SC_valname_boolean,false);
}
TSC_script_customfunc::TSC_script_customfunc(StrPtr ifuncname, Tarray<QString> &argnames, TSC_script_block *iblock)
: TSC_func(ifuncname)
{
setreturntype(SC_valname_any);
for (int i=0; i<argnames.G_count(); i++)
addvar(*argnames[i],SC_valname_any);
block=iblock;
block->Set_isfunctionblock(ifuncname);
}
/* list flags and values that you want to receive via -x */
void upsdrv_makevartable(void)
{
/* allow '-x xyzzy' */
/* addvar(VAR_FLAG, "xyzzy", "Enable xyzzy mode"); */
/* allow '-x foo=<some value>' */
/* addvar(VAR_VALUE, "foo", "Override foo setting"); */
addvar(VAR_VALUE, "model", "Regular Expression to match power source model name");
}
/* list flags and values that you want to receive via -x */
void upsdrv_makevartable(void)
{
addvar(VAR_VALUE, "manufacturer", "manufacturer [unknown]");
addvar(VAR_VALUE, "baudrate", "Serial interface baudrate [1200]");
addvar(VAR_VALUE, "input_timeout", "Command response timeout [2]");
addvar(VAR_VALUE, "output_pace", "Output character delay in usecs [200]");
addvar(VAR_VALUE, "full_update", "Delay between full value downloads [60]");
addvar(VAR_FLAG, "use_crlf", "Use CR-LF to terminate commands to UPS");
addvar(VAR_FLAG, "use_pre_lf", "Use LF to introduce commands to UPS");
}
void upsdrv_makevartable(void)
{
addvar(VAR_VALUE, "panel.voltage", "Override nominal battery voltage");
addvar(VAR_VALUE, "panel.current", "Battery voltage multiplier");
addvar(VAR_VALUE, "panel.kw", "Override nominal battery voltage");
addvar(VAR_VALUE, "panel.kwh", "Battery voltage multiplier");
addvar(VAR_VALUE, "inverter.status", "Battery voltage multiplier");
addvar(VAR_VALUE, "charge.solar", "Battery voltage multiplier");
addvar(VAR_VALUE, "error.status", "Battery voltage multiplier");
}
void blazer_makevartable(void)
{
addvar(VAR_VALUE, "ondelay", "Delay before UPS startup (minutes)");
addvar(VAR_VALUE, "offdelay", "Delay before UPS shutdown (seconds)");
addvar(VAR_VALUE, "runtimecal", "Parameters used for runtime calculation");
addvar(VAR_VALUE, "chargetime", "Nominal charge time for UPS battery");
addvar(VAR_VALUE, "idleload", "Minimum load to be used for runtime calculation");
addvar(VAR_FLAG, "norating", "Skip reading rating information from UPS");
addvar(VAR_FLAG, "novendor", "Skip reading vendor information from UPS");
addvar(VAR_FLAG, "protocol", "Preselect communication protocol (skip autodetection)");
}
static Node*
staticname(Type *t, int ctxt)
{
Node *n;
snprint(namebuf, sizeof(namebuf), "statictmp_%.4d", statuniqgen);
statuniqgen++;
n = newname(lookup(namebuf));
if(!ctxt)
n->readonly = 1;
addvar(n, t, PEXTERN);
return n;
}
int colgen_generate (colgen_t* colgenp, int commodity)
// attempts to generate a new column for the master problem, with a negative reduced cost,
// returns 1 on success, 0 on failure.
{
int i, c;
int size, col_nzcnt = 0;
double ucost = 0.0; // unit cost of the path
// walk through the shortest path
for (c = colgenp->instp->commod_dest_node[commodity]; c != colgenp->instp->commod_orig_node[commodity]; c = colgenp->graph[commodity].pred_node[c]) {
i = colgenp->graph[commodity].pred_arc[c];
if (i == colgenp->instp->n_arcs) // test if the shortest path has the artificial arc
return 0;
ucost += colgenp->instp->arc_commod_ucost[i][commodity] + colgenp->commod_arc_lfactor[commodity][i]; // update path unit cost
colgenp->col_ind[col_nzcnt++] = i; // add index to constraint coefficient matrix column
}
qsort(colgenp->col_ind, col_nzcnt, sizeof(int), arc_cmp); // sort column indices in ascending order
colgenp->col_ind[col_nzcnt++] = colgenp->instp->n_arcs + commodity; // add bundle constraint coefficient
// reallocate array space for path attributes, using a fibonacci sequence: new_size = old_size + older_size;
if (colgenp->n_paths == colgenp->current_alloc) {
size = colgenp->current_alloc;
colgenp->current_alloc += colgenp->prev_alloc;
colgenp->prev_alloc = size;
colgenp->path_ucost = (realloc(colgenp->path_ucost, colgenp->current_alloc * sizeof(double)));
colgenp->path_flow = (realloc(colgenp->path_flow, colgenp->current_alloc * sizeof(double)));
colgenp->path_commod = (realloc(colgenp->path_commod, colgenp->current_alloc * sizeof(int)));
colgenp->path_arcs = (realloc(colgenp->path_arcs, colgenp->current_alloc * sizeof(char*)));
for (c = size; c < colgenp->current_alloc; c++)
colgenp->path_arcs[c] = (calloc(colgenp->instp->n_arcs, sizeof(char)));
}
// store the arc composition of the new column
for (i = 0; i < colgenp->instp->n_arcs; i++)
colgenp->path_arcs[colgenp->n_paths][i] = 0;
for (c = 0; c < col_nzcnt - 1; c++) {
i = colgenp->col_ind[c];
colgenp->path_arcs[colgenp->n_paths][i] = 1;
}
// store its other attributes
colgenp->path_ucost[colgenp->n_paths] = ucost;
colgenp->path_flow[colgenp->n_paths] = 0.0;
colgenp->path_commod[colgenp->n_paths] = commodity;
++colgenp->n_paths;
// add the column
GRB(addvar(colgenp->lp, col_nzcnt, colgenp->col_ind, colgenp->col_val, ucost, 0.0, colgenp->instp->commod_supply[commodity], GRB_CONTINUOUS, NULL));
return 1;
}
void upsdrv_makevartable(void)
{
addvar(VAR_VALUE, "offdelay", "Delay before outlet shutdown (seconds)");
addvar(VAR_VALUE, "ondelay", "Delay before outlet startup (seconds)");
addvar(VAR_VALUE, "mincharge", "Remaining battery level when UPS switches to LB (percent)");
addvar(VAR_VALUE, "minruntime", "Remaining battery runtime when UPS switches to LB (seconds)");
addvar(VAR_VALUE, "load.off", "Command to switch off outlet");
addvar(VAR_VALUE, "load.on", "Command to switch on outlet");
addvar(VAR_VALUE, "load.status", "Variable that indicates outlet is on/off");
}
void upsdrv_makevartable(void)
{
addvar(VAR_VALUE, "subdriver", "Serial-over-USB subdriver selection");
addvar(VAR_VALUE, "vendorid", "Regular expression to match UPS Manufacturer numerical ID (4 digits hexadecimal)");
addvar(VAR_VALUE, "productid", "Regular expression to match UPS Product numerical ID (4 digits hexadecimal)");
addvar(VAR_VALUE, "vendor", "Regular expression to match UPS Manufacturer string");
addvar(VAR_VALUE, "product", "Regular expression to match UPS Product string");
addvar(VAR_VALUE, "serial", "Regular expression to match UPS Serial number");
addvar(VAR_VALUE, "bus", "Regular expression to match USB bus name");
addvar(VAR_VALUE, "langid_fix", "Apply the language ID workaround to the krauler subdriver (0x409 or 0x4095)");
blazer_makevartable();
}
void upsdrv_makevartable(void)
{
addvar(VAR_VALUE, "ondelay", "Delay before UPS startup");
addvar(VAR_VALUE, "offdelay", "Delay before UPS shutdown");
addvar(VAR_VALUE, "manufacturer", "manufacturer");
addvar(VAR_VALUE, "model", "modelname");
addvar(VAR_VALUE, "serial", "serialnumber");
addvar(VAR_VALUE, "protocol", "protocol to use [text|binary] (default: autodection)");
}
static int newnum(char *name, char *arg) {
numvar_t *n = NULL;
int res = 0;
if (!(n = calloc(sizeof(numvar_t))))
return ERRNOMEM;
n->num = str2int(arg);
res = addvar((var_t*)n, name, NUMTYPE);
if(res)
free(n);
return res;
}
size_t ebasearrayof::unserial(const estr& data,size_t i)
{
unsigned int count;
evar keyvar,var;
i=unserialint(count,data,i);
if (i==-1) return(-1);
while(count && i<data.len()){
keyvar.clear(); var.clear();
i=keyvar.unserial(data,i);
if (i==-1) return(-1);
i=var.unserial(data,i);
if (i==-1) return(-1);
addvar(keyvar,var);
--count;
}
if (count) return(-1);
return(i);
}
int main(int argc, char **argv)
{
int n = 0;
if (*++argv) {
n = atoi(*argv);
}
n = (n)?n:6;
struct tnode *root;
char vname[MAXVAR];
root = NULL;
while (getvariable(vname)) {
root = addvar(root, vname, n);
}
treeprint(root);
return 0;
}
static int newview(char *name, char *arg) {
viewvar_t *v = NULL;
arrvar_t *a = NULL;
int i = 0;
int res = 0;
char *type = strtok(NULL,' ');
if (!type || strlen(type) == 0)
return ERRNOTYPE;
if (!(a = (arrvar_t*)getvar(arg)))
return ERRNOSUCHVAR;
if (a->v.type != ARRTYPE)
return ERRWRONGTYPE;
if (!(v = calloc(sizeof(viewvar_t))))
return ERRNOMEM;
for (i=0; i < sizeof(viewtypes)/sizeof(viewtype_t); i++) {
if (streq(type,viewtypes[i].name)) {
v->view = &viewtypes[i];
break;
}
}
if (!v->view) {
free(v);
return ERRNOSUCHTYPE;
}
v->arr = a;
res = addvar((var_t*)v, name, VIEWTYPE);
if (res)
free(v);
return res;
}
static int newarr(char *name, char *arg) {
arrvar_t *a = NULL;
int res = 0;
uint32_t size = str2uint(arg);
if (size > MAXARRSIZE)
return ERRTOOBIG;
if (!(a = calloc(sizeof(arrvar_t)+(size*sizeof(int)))))
return ERRNOMEM;
a->size = size*sizeof(int);
res = addvar((var_t*)a, name, ARRTYPE);
if (res)
free(a);
return res;
}
FUNCTION(func_2dcontourset_create,Contour)
{
setclasspath_fromtype(SC_valname_2dcontourset);
addvar(_qstr("pointlist"),SC_valname_list);
setreturntype(SC_valname_2dcontourset);
}
FUNCTION(func_2dcontourset_addpoint,addpoint)
{
setmemberfunction(SC_valname_2dcontourset);
addvar(_qstr("point"),SC_valname_vertex);
addvar(_qstr("normal"),SC_valname_vector,false);
}
void upsdrv_makevartable(void)
{
addvar(VAR_VALUE, "cablepower", "Set cable power for serial interface");
blazer_makevartable();
}
colgen_t colgen_create (cmnd_t* instp)
{
colgen_t colgen;
int i, k;
char* sense = (char*) (malloc((instp->n_commods + instp->n_arcs) * sizeof(char)));
colgen.instp = instp;
colgen.graph = (malloc(instp->n_commods * sizeof(simple_graph_t)));
colgen.overflow = 1;
colgen.n_paths = colgen.prev_alloc = colgen.current_alloc = instp->n_commods;
colgen.arc_cap = (malloc((instp->n_arcs + instp->n_commods) * sizeof(double)));
colgen.arc_mul = (malloc(instp->n_arcs * sizeof(double)));
colgen.overflow_mul = (malloc(instp->n_commods* sizeof(double)));
colgen.commod_mul = (malloc(instp->n_commods * sizeof(double)));
colgen.col_val = (malloc((2 + instp->n_arcs) * sizeof(double)));
colgen.col_ind = (malloc((2 + instp->n_arcs) * sizeof(int)));
colgen.path_ucost = (malloc(instp->n_commods * sizeof(double)));
colgen.path_flow = (malloc(instp->n_commods * sizeof(double)));
colgen.path_commod = (malloc(instp->n_commods * sizeof(int)));
colgen.arc_total_flow = (malloc(instp->n_arcs * sizeof(double)));
colgen.arc_total_ucost = (malloc(instp->n_arcs * sizeof(double)));
colgen.arc_open = (malloc(instp->n_arcs * sizeof(int)));
colgen.best_arc_open = (malloc(instp->n_arcs * sizeof(int)));
colgen.commod_arc_flow = (malloc(instp->n_commods * sizeof(double*)));
colgen.path_arcs = (malloc(colgen.current_alloc * sizeof(char*)));
colgen.commod_arc_lfactor = (malloc(instp->n_commods * sizeof(double*)));
for (i = 0; i < instp->n_arcs; i++) {
sense[i] = GRB_LESS_EQUAL; // sense of capacity constraints
colgen.arc_cap[i] = instp->arc_capacity[i]; // initial right-hand sides of capacity constraints
colgen.col_val[i] = 1.0;
}
colgen.col_val[instp->n_arcs] = 1.0;
for (k = 0; k < instp->n_commods; k++) {
colgen.commod_arc_lfactor[k] = (malloc(instp->n_arcs * sizeof(double)));
for (i = 0; i < instp->n_arcs; i++)
colgen.commod_arc_lfactor[k][i] = 0.0; // default linearization factors
colgen.path_arcs[k] = (calloc(instp->n_arcs, sizeof(char)));
sense[instp->n_arcs + k] = GRB_EQUAL; // sense of bundle constraints
colgen.arc_cap[instp->n_arcs + k] = instp->commod_supply[k]; // right-hand sides of bundle constraints
colgen.graph[k] = simple_graph_create(instp); // pricing graph creation
colgen.commod_arc_flow[k] = (malloc(instp->n_arcs * sizeof(double)));
}
// master problem creation
GRB(newmodel(env, &colgen.lp, "CMNF path-based formulation", 0, NULL, NULL, NULL, NULL, NULL));
// the first n_arcs constraints are the capacity constraints
GRB(addconstrs(colgen.lp, instp->n_arcs, 0, NULL, NULL, NULL, sense, colgen.arc_cap, NULL));
// followed by n_commods bundle constraints
GRB(addconstrs(colgen.lp, instp->n_commods, 0, NULL, NULL, NULL, &sense[instp->n_arcs], instp->commod_supply, NULL));
GRB(updatemodel(colgen.lp));
// overflow paths creation (paths containing only the artificial arc from source to sink for each commodity)
for (k = 0; k < instp->n_commods; k++) {
colgen.path_ucost[k] = instp->commod_overflow_ucost[k];
colgen.path_flow[k] = 0.0;
colgen.path_commod[k] = k;
colgen.col_ind[0] = instp->n_arcs + k;
GRB(addvar(colgen.lp, 1, colgen.col_ind, colgen.col_val, colgen.path_ucost[k], 0.0, instp->commod_supply[k], GRB_CONTINUOUS, NULL));
}
GRB(updatemodel(colgen.lp));
// solver parameter settings
GRB(setintparam(env, GRB_INT_PAR_METHOD, 1));
// optimization
GRB(optimize(colgen.lp));
GRB(getintattr(colgen.lp, GRB_INT_ATTR_STATUS, &grb_status));
assert(grb_status == GRB_OPTIMAL);
// initial primal and dual values
GRB(getdblattrarray(colgen.lp, GRB_DBL_ATTR_X, 0, colgen.n_paths, colgen.path_flow));
GRB(getdblattrarray(colgen.lp, GRB_DBL_ATTR_PI, 0, instp->n_arcs, colgen.arc_mul));
GRB(getdblattrarray(colgen.lp, GRB_DBL_ATTR_PI, instp->n_arcs, instp->n_commods, colgen.commod_mul));
// initial bounds on the optimal objective value
colgen.z_lb = 0.0;
colgen.z_ub = inf;
return colgen;
}
void symmodel::addivars( const string& s, const string& t, const vector<size_t>& i )
{
addvar( s, t );
vars[ vars.size() - 1 ]->addivalus( i );
}
void symmodel::addfvars( const string& s, const string& t, const vector<real_t>& f )
{
addvar( s, t );
vars[ vars.size() - 1 ]->addfvalus( f );
}
/* list flags and values that you want to receive via -x */
void upsdrv_makevartable(void)
{
addvar (VAR_VALUE, "baudrate", "serial line speed");
}
/* list flags and values that you want to receive via -x or ups.conf */
void upsdrv_makevartable(void)
{
addvar(VAR_VALUE, "lowbatt", "Set low battery level, in percent");
}
/* Subdriver-specific flags/vars
* NOTE: this 'light' version only handles vars/flags related to UPS status query (Q1/QS/D/...) */
void blazer_makevartable_light(void)
{
addvar(VAR_FLAG, "ignoresab", "Ignore 'Shutdown Active' bit in UPS status");
}
/* define possible arguments */
void upsdrv_makevartable(void)
{
// 1 2 3 4 5 6 7 8
//2345678901234567890123456789012345678901234567890123456789012345678901234567890 MAX
addvar(VAR_VALUE, "type",
"Type of UPS: 'Trust','Egys','KP625AP','IMP','KIN','BNT','BNT-other','OPTI'\n"
" (default: 'Trust')");
addvar(VAR_VALUE, "manufacturer",
"Manufacturer name (default: 'PowerCom')");
addvar(VAR_VALUE, "modelname",
"Model name [cannot be detected] (default: Unknown)");
addvar(VAR_VALUE, "serialnumber",
"Serial number [cannot be detected] (default: Unknown)");
addvar(VAR_VALUE, "shutdownArguments",
"Delay values for shutdown: Minutes, Seconds, UseMinutes?'y'or'n'");
addvar(VAR_VALUE, "linevoltage",
"Line voltage 110-120 or 220-240 V (default: 230)");
addvar(VAR_VALUE, "numOfBytesFromUPS",
"The number of bytes in a UPS frame");
addvar(VAR_VALUE, "methodOfFlowControl",
"Flow control method for UPS: 'dtr0rts1' or 'no_flow_control'");
addvar(VAR_VALUE, "validationSequence",
"Validation values: ByteIndex, ByteValue x 3");
if ( strcmp(types[type].name, "KIN") && strcmp(types[type].name, "BNT") && strcmp(types[type].name, "IMP")) {
addvar(VAR_VALUE, "frequency",
"Frequency conversion values: FreqFactor, FreqConst");
addvar(VAR_VALUE, "loadPercentage",
"Load conversion values: OffFactor, OffConst, OnFactor, OnConst");
addvar(VAR_VALUE, "batteryPercentage",
"Battery conversion values: OffFactor, LoadFactor, OffConst, OnFactor, OnConst");
addvar(VAR_VALUE, "voltage",
"Voltage conversion values: 240VFactor, 240VConst, 120VFactor, 120VConst");
}
}
FUNCTION(func_control_select,ActivateControl)
{
addvar(_qstr("control"),SC_valname_any);
extendclasspath(SC_treeclass_controls);
}
