Sensix Wireless Sensor Network Middleware    Home    Project Page    Download    CVS  Hosted by

/home/brennan/Software/sensix/source/C^4/sensix/SensixMarshalling.java Go to the documentation of this file. /* * Copyright 2008. Los Alamos National Security, LLC. This material * was produced under U.S. Government contract DE-AC52-06NA25396 for * Los Alamos National Laboratory (LANL), which is operated by Los * Alamos National Security, LLC, for the Department of Energy. The * U.S. Government has rights to use, reproduce, and distribute this * software. NEITHER THE GOVERNMENT NOR LOS ALAMOS NATIONAL SECURITY, * LLC, MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL * LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified to * produce derivative works, such modified software should be clearly * marked, so as not to confuse it with the version available from LANL. * * Additionally, this program 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; version 2 of * the License. Accordingly, this program is distributed in the hope * 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 this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ package sensix; import java.util.*; import java.lang.Math; import sensix.sensing.*; public class SensixMarshalling { public static final byte MAGIC = (byte)0xff; public static final byte VERSION = (byte)0x01; public static final byte HEADER_SIZE = 5; public static final byte WORDSIZE = (byte)4; public static final byte LITTLE_ENDIAN = (byte)0x80; public static final byte METADATA = (byte)1; public static final byte DATA = (byte)2; public static final byte CMD = (byte)3; public static final int MAX_CMD_SIZE = 4096; public static final int REDISCOVER_TIME = 100000; public static final int REDISCOVER_RESET = (3 * REDISCOVER_TIME / 4); public static final int MAX_PARENTS = 128; public static final int MAX_CHILDREN = 512; public static final int MAX_SIBLINGS = 128; public static final int MAX_PEERS = (MAX_CHILDREN + MAX_SIBLINGS); public static final int MAX_CAPABLE = 32; public static byte[] i2b(int i) { // locally always BE return i2b(i, 4); } public static byte[] i2b(int i, int size) { byte[] b = new byte[size]; for (int j = 0; j < size; j++) b[j] = (byte)(i >> (8 * ((size - 1) - j))); return b; } public static int b2i(byte b[]) { // BE conversion return b2i(b, 4); } public static int b2i(byte b[], int size) { int ret = 0; for (int j = 0; j < size; j++) ret += ((b[j] & 0x00000000ff) << (8 * ((size - 1) - j))); return ret; } public static int b2i_le(byte b[]) { // LE conversion return b2i_le(b, 4); } public static int b2i_le(byte b[], int size) { int ret = 0; for (int j = 0; j < size; j++) ret += ((b[j] & 0x00000000ff) << (8 * j)); return ret; } public static void short2byte_arraycopy(short[] shorts, int sidx, byte[] bytes, int bidx, int len) { for (int i = 0; i < len; i++) bytes[bidx + i] = (byte)(shorts[sidx + i] & 0xff); } public static void byte2short_arraycopy(byte[] bytes, int bidx, short[] shorts, int sidx, int len) { for (int i = 0; i < len; i++) shorts[sidx + i] = (short)(bytes[bidx + i] & 0xff); } public class ObjectReference { public static final int SIZE = 1024; public int id; public byte type; } public ObjectReference[] references; public int refs_size; public ObjectReference[] sib_database; public int sib_db_size; public ObjectReference[] desc_database; public int desc_db_size; public int[] ancestors_seen; public int ancestors_size; public int[] siblings_seen; public int siblings_size; public int[] descendants_seen; public int descendants_size; private Client client; private long last_ancestor, last_sibling, last_descendant; private Logger logger; private int identifier; private byte level; public SensixMarshalling(int id, byte lvl, Client c, String app, byte debug) { identifier = id; level = lvl; client = c; last_ancestor = 0; last_sibling = 0; last_descendant = 0; logger = new Logger(app, debug); references = new ObjectReference[MAX_CAPABLE]; refs_size = 0; sib_database = new ObjectReference[MAX_SIBLINGS]; sib_db_size = 0; desc_database = new ObjectReference[MAX_CHILDREN]; desc_db_size = 0; ancestors_seen = new int[MAX_PARENTS]; ancestors_size = 0; siblings_seen = new int[MAX_SIBLINGS]; siblings_size = 0; descendants_seen = new int[MAX_CHILDREN]; descendants_size = 0; } public void log(Logger.LOG type, String msg) { logger.log(type, msg); } public int identifier() { return identifier; } public byte level() { return level; } public byte[] load_header(byte what, byte data_size) { byte hdr[] = new byte[HEADER_SIZE]; hdr[0]= MAGIC; hdr[1] = VERSION; hdr[2] = WORDSIZE; // Java is always big-endian, so no LE flag hdr[3] = what; hdr[4] = data_size; return hdr; } public void xmit_data(Functor f) { xmit_data(f, false); } public void xmit_data(Functor f, boolean peer) { String res_str = ""; Data[] results = f.results(); int fsize = results.length; for (int i = 0; i < fsize; i++ ) { char d = results[i].discriminator(); if (d == 'd' || d == 'i' || d == 'u' || d == 'x') res_str += results[i].iresult() + " "; else res_str += results[i].fresult() + " "; } log(Logger.LOG.DEBUG, "xmit data: " + res_str); Sensory s = (Sensory)f; byte msg_size = (byte)((fsize + 2) * WORDSIZE + 1); byte[] msg = new byte[msg_size]; int idx = 0; byte[] id = i2b(client.identity()); System.arraycopy(id, 0, msg, idx, WORDSIZE); idx += WORDSIZE; // FIXME corba-free requestor id //byte[] req = i2b(s.requestor); //System.arraycopy(req, 0, msg, idx, WORDSIZE); idx += WORDSIZE; msg[idx] = Sensix.ENERGY; idx++; // volts to millivolts byte[] e = i2b((int)(s.energyused() * 1000)); System.arraycopy(e, 0, msg, idx, WORDSIZE); idx += WORDSIZE; msg[idx] = Sensix.TIME; idx++; byte[] t = i2b((int)s.timeused()); // milliseconds System.arraycopy(t, 0, msg, idx, WORDSIZE); idx += WORDSIZE; msg[idx] = s.identifier(); idx++; msg[idx] = (byte)s.sequencer(); idx++; byte[] s_bytes = i2b(fsize); System.arraycopy(s_bytes, 0, msg, idx, WORDSIZE); idx += WORDSIZE; for (int i = 0; i < fsize; i++) { byte[] d_bytes = null; char d = results[i].discriminator(); if (d == 'd' || d == 'i' || d == 'u' || d == 'x') d_bytes = i2b((int)results[i].iresult()); else d_bytes = i2b((int)results[i].fresult()); System.arraycopy(d_bytes, 0, msg, idx, WORDSIZE); idx += WORDSIZE; } if (peer) client.bcast(DATA, msg_size, msg); else client.send_up(DATA, msg_size, msg); } public void xmit_metadata(byte meta) { if (meta == Sensix.ANCESTORS) { long now = System.currentTimeMillis(); if ((now - last_ancestor) > REDISCOVER_RESET) { byte asize = (byte)(((ancestors_size + 1) * (WORDSIZE + 1)) + 1 + WORDSIZE); byte[] anc_msg = new byte[asize]; anc_msg[0] = meta; int idx = 1; int anc_size = ancestors_size + 1; byte[] sizebytes = i2b(anc_size); System.arraycopy(sizebytes, 0, anc_msg, idx, WORDSIZE); idx += WORDSIZE; // my id anc_msg[idx] = WORDSIZE; idx++; byte[] id = i2b(client.identity()); System.arraycopy(id, 0, anc_msg, idx, WORDSIZE); idx += WORDSIZE; // everybody else for (int i = 0; i < ancestors_size; i++) { anc_msg[idx] = WORDSIZE; idx++; byte[] o_id = i2b(ancestors_seen[i]); System.arraycopy(o_id, 0, anc_msg, idx, WORDSIZE); idx += WORDSIZE; } client.send_dn(METADATA, asize, anc_msg); last_ancestor = now; } } else if (meta == Sensix.SIBLINGS) { long now = System.currentTimeMillis(); if ((now - last_sibling) > REDISCOVER_RESET) { int cap_size = 0; SortedMap<Byte,Capability> capabilities = client.capabilities(); if (capabilities != null) cap_size = capabilities.size(); byte ssize = (byte)(WORDSIZE + 3 + cap_size); byte[] sib_msg = new byte[ssize]; sib_msg[0] = meta; sib_msg[1] = (byte)1; int idx = 2; byte[] id = i2b(client.identity()); System.arraycopy(id, 0, sib_msg, idx, WORDSIZE); idx += WORDSIZE; sib_msg[idx] = (byte)cap_size; idx++; if (capabilities != null) { Iterator iter = capabilities.keySet().iterator(); while (iter.hasNext()) { sib_msg[idx] = ((Byte)iter.next()).byteValue(); idx++; } } client.bcast(METADATA, ssize, sib_msg); last_sibling = now; } } else if (meta == Sensix.DESCENDANTS) { long now = System.currentTimeMillis(); if ((now - last_descendant) > REDISCOVER_RESET) { int cap_size = 0; SortedMap<Byte,Capability> capabilities = client.capabilities(); if (capabilities != null) cap_size = capabilities.size(); int dsize = (3 * WORDSIZE) + 3 + cap_size; byte desc_msg[] = new byte[dsize]; desc_msg[0] = meta; desc_msg[1] = (byte)1; int idx = 2; byte[] id = i2b(client.identity()); System.arraycopy(id, 0, desc_msg, idx, WORDSIZE); idx += WORDSIZE; desc_msg[idx] = (byte)cap_size; idx++; if (capabilities != null) { Iterator iter = capabilities.keySet().iterator(); while (iter.hasNext()) { desc_msg[idx] = ((Byte)iter.next()).byteValue(); idx++; } } desc_msg[idx] = Sensix.ENERGY; idx++; byte[] en = i2b((int)(client.check_energy() * 1000)); System.arraycopy(en, 0, desc_msg, idx, WORDSIZE); idx += WORDSIZE; client.send_up(METADATA, dsize, desc_msg); last_descendant = now; } } } public void xmit_command(Functor f) { xmit_command(f, false); } public void xmit_command(Functor f, boolean peer) { int hdr_size = WORDSIZE + 2; byte[] params = compile_params(f.identifier(), f); int msg_size = params.length + hdr_size; int idx = 0; byte[] msg = new byte[msg_size]; log(Logger.LOG.DEBUG, "xmit command"); byte[] id = i2b(client.identity()); System.arraycopy(id, 0, msg, idx, WORDSIZE); idx += WORDSIZE; msg[idx] = 0; // not peer_req idx++; msg[idx] = f.priority(); idx++; System.arraycopy(params, 0, msg, hdr_size, params.length); if (peer) client.bcast(CMD, msg_size, msg); else client.send_dn(CMD, msg_size, msg); } private byte[] compile_params(byte cmd, Functor f) { int size = 2; byte params[] = new byte[MAX_CMD_SIZE]; log(Logger.LOG.DEBUG, "compile params for " + f.asString()); params[0] = cmd; params[1] = (byte)f.sequencer(); switch(cmd) { case Sensix.ALPHA: { Sense s = (Sense)f; params[2] = 2; params[3] = Sensix.SENSOR; params[4] = s.sensor(); params[5] = Sensix.FREQ; size += 4; int rt = (int)s.rate(); if (rt == 0) rt = 1; byte[] rt_bytes = i2b(rt); System.arraycopy(rt_bytes, 0, params, size, WORDSIZE); size += WORDSIZE; } break; case Sensix.BETA: { PeakSense s = (PeakSense)f; params[2] = 4; params[3] = Sensix.SENSOR; params[4] = s.sensor(); params[5] = Sensix.FREQ; size += 4; int rt = (int)s.rate(); if (rt == 0) rt = 1; byte[] rt_bytes = i2b(rt); System.arraycopy(rt_bytes, 0, params, size, WORDSIZE); size += WORDSIZE; params[size] = Sensix.THR_PLUS; size++; byte[] ht = i2b((int)s.highthreshold()); System.arraycopy(ht, 0, params, size, WORDSIZE); size += WORDSIZE; params[size] = Sensix.THR_MINUS; size++; byte[] lt = i2b((int)s.lowthreshold()); System.arraycopy(lt, 0, params, size, WORDSIZE); size += WORDSIZE; } break; case Sensix.THETA: { TimeSeries s = (TimeSeries)f; params[2] = 2; params[3] = Sensix.TIME; size += 2; byte[] dur = i2b((int)s.duration()); System.arraycopy(dur, 0, params, size, WORDSIZE); size += WORDSIZE; byte[] subp = compile_params(s.subfunctors()[0].identifier(), s.subfunctors()[0]); System.arraycopy(subp, 0, params, size, subp.length); size += subp.length; } break; case Sensix.PSI: { SpatialSeries s = (SpatialSeries)f; params[2] = 3; size++; params[size] = Sensix.DIST; size++; byte[] dist = i2b((int)s.distance()); System.arraycopy(dist, 0, params, size, WORDSIZE); size += WORDSIZE; params[size] = Sensix.ANGLE; size++; byte[] angle = i2b((int)s.angle()); System.arraycopy(angle, 0, params, size, WORDSIZE); size += WORDSIZE; byte[] subp = compile_params(s.subfunctors()[0].identifier(), s.subfunctors()[0]); System.arraycopy(subp, 0, params, size, subp.length); size += subp.length; } break; case Sensix.IOTA: case Sensix.SUMMA: case Sensix.DELTA: case Sensix.BARX: case Sensix.SIGMA: { Aggregate s = (Aggregate)f; int subs = s.subfunctors().length; params[2] = (byte)subs; size++; for (int i = 0; i < subs; i++) { byte[] subp = compile_params(s.subfunctors()[i].identifier(), s.subfunctors()[i]); System.arraycopy(subp, 0, params, size, subp.length); size += subp.length; if (i < subs - 1) { params[size] = Sensix.AND; size++; } } } break; case Sensix.LAMBDA: log(Logger.LOG.ERROR, "Invalid attempt to marshal lambda aggregate"); default: return null; } return params; } public byte parse_packet(byte[] msg, int len) { byte hdr_size = HEADER_SIZE; byte what = msg[3]; byte data_size = msg[4]; byte base_len = (byte)(msg[2] & ~LITTLE_ENDIAN); boolean convert = false; log(Logger.LOG.DEBUG, "parse packet" ); if (msg[0] != MAGIC || msg[1] != VERSION) return -1 ; if ((msg[2] & LITTLE_ENDIAN) != 0) convert = true; if (what == METADATA) { parse_metadata(base_len, data_size, msg, convert); } else if (what == DATA) { parse_data(base_len, data_size, msg, convert); } else if (what == CMD) { Functor f = parse_command(base_len, msg, data_size, convert); if (f != null) client.apply(f); } return what; } private int parse_metadata(int base, int size, byte[] msg, boolean convert) { int idx = HEADER_SIZE; if (msg == null) return -1; switch(msg[idx]) { case Sensix.ANCESTORS: idx++; byte[] len_bytes = new byte[base]; System.arraycopy(msg, idx, len_bytes, 0, base); int num_ancestors = 0; if (convert) num_ancestors = b2i_le(len_bytes, base); else num_ancestors = b2i(len_bytes, base); idx += base; for (int i = 0; i < num_ancestors; i++) { int len = (msg[idx] & 0xff); idx++; byte[] id_bytes = new byte[len]; System.arraycopy(msg, idx, id_bytes, 0, len); idx += len; int a_id = 0; if (convert) a_id = b2i_le(id_bytes, len); else a_id = b2i(len_bytes, len); boolean found = false; int asize = ancestors_size; for (int j = 0; j < asize; j++) { if (ancestors_seen[j] == a_id) { found = true; break; } } if (found == false && asize < MAX_PARENTS) { int aidx = ancestors_size; ancestors_seen[aidx] = a_id; ancestors_size++; log(Logger.LOG.DEBUG, "Added ancestor " + a_id); } } xmit_metadata(Sensix.DESCENDANTS); break; case Sensix.SIBLINGS: { idx++; idx++; // ignore size = 1 byte[] id_bytes = new byte[base]; System.arraycopy(msg, idx, id_bytes, 0, base); idx += base; int s_id = 0; if (convert) s_id = b2i_le(id_bytes, base); else s_id = b2i(id_bytes, base); // mark sibling as seen boolean found = false; int ssize = siblings_size; for (int i = 0; i < ssize; i++) { if (siblings_seen[i] == s_id) { found = true; break; } } if (found == false && ssize < MAX_SIBLINGS) { int sidx = siblings_size; siblings_seen[sidx] = s_id; siblings_size++; log(Logger.LOG.DEBUG, "Added sibling " + s_id); } // add sibling capabilities to database int cap_size = (msg[idx] & 0xff); idx++; for (int j = 0; j < cap_size; j++) { byte s_cap = msg[idx]; idx++; found = false; for (int k = 0; k < sib_db_size; k++) { if (sib_database[k].id == s_id && sib_database[k].type == s_cap) { found = true; break; } } if (found == false) { int sidx = sib_db_size; sib_database[sidx] = new ObjectReference(); sib_database[sidx].id = s_id; sib_database[sidx].type = s_cap; sib_db_size++; log(Logger.LOG.DEBUG, "Added sibling capability " + SenseUtil.capabilityToString(s_cap)); } } xmit_metadata(Sensix.SIBLINGS); } break; case Sensix.DESCENDANTS: { idx++; idx++; // ignore size = 1 byte[] id_bytes = new byte[base]; System.arraycopy(msg, idx, id_bytes, 0, base); idx += base; int d_id = 0; if (convert) d_id = b2i_le(id_bytes, base); else d_id = b2i(id_bytes, base); // mark descendant as seen boolean found = false; int dsize = descendants_size; for (int i = 0; i < dsize; i++) { if (descendants_seen[i] == d_id) { found = true; break; } } if (found == false && dsize < MAX_CHILDREN) { int didx = descendants_size; descendants_seen[didx] = d_id; descendants_size++; log(Logger.LOG.DEBUG, "Added descendant " + d_id); } // add descendant capabilities to database int cap_size = (msg[idx] & 0xff); idx++; for (int j = 0; j < cap_size; j++) { byte d_cap = msg[idx]; idx++; found = false; for (int k = 0; k < desc_db_size; k++) { if (desc_database[k].id == d_id && desc_database[k].type == d_cap) { found = true; break; } } if (found == false) { int didx = desc_db_size; desc_database[didx] = new ObjectReference(); desc_database[didx].id = d_id; desc_database[didx].type = d_cap; desc_db_size++; log(Logger.LOG.DEBUG, "Added descendant capability " + SenseUtil.capabilityToString(d_cap)); } } if (msg[idx] != Sensix.ENERGY) break; idx++; byte[] energy_bytes = new byte[base]; System.arraycopy(msg, idx, energy_bytes, 0, base); double energy = 0; if (convert) energy = b2i_le(energy_bytes, base); else energy = b2i(energy_bytes, base); energy = energy / 1000.0; // mv to volts idx += base; xmit_metadata(Sensix.ANCESTORS); } break; } return 0; } private int parse_data(int base, int size, byte[] msg, boolean convert) { int idx = HEADER_SIZE; byte[] id_bytes = new byte[base]; System.arraycopy(msg, idx, id_bytes, 0, base); int node_id = 0; if (convert) node_id = b2i_le(id_bytes, base); else node_id = b2i(id_bytes, base); idx += base; byte[] to_bytes = new byte[base]; System.arraycopy(msg, idx, to_bytes, 0, base); int node_to = 0; if (convert) node_to = b2i_le(id_bytes, base); else node_to = b2i(id_bytes, base); idx += base; if (node_to != client.identity()) return 0; // not me: drop if (msg[idx] != Sensix.ENERGY) return -1; idx++; byte[] energy_bytes = new byte[base]; System.arraycopy(msg, idx, energy_bytes, 0, base); double energy = 0; if (convert) energy = b2i_le(energy_bytes, base); else energy = b2i(energy_bytes, base); energy = energy / 1000.0; // mv to volts idx += base; if (msg[idx] != Sensix.TIME) return -1; idx++; byte[] time_bytes = new byte[base]; System.arraycopy(msg, idx, time_bytes, 0, base); long time = 0; if (convert) time = b2i_le(time_bytes, base); else time = b2i(time_bytes, base); idx += base; int ftype = (msg[idx] & 0xff); int fid = (msg[idx+1] & 0xff); idx += 2; byte[] count_bytes = new byte[base]; System.arraycopy(msg, idx, count_bytes, 0, base); int num = 0; if (convert) num = b2i_le(count_bytes, base); else num = b2i(count_bytes, base); idx += base; Data[] array = new Data[num]; for (int i = 0; i < num; i++) { byte[] res_bytes = new byte[base]; System.arraycopy(msg, idx, res_bytes, 0, base); int result = 0; if (convert) result = b2i_le(res_bytes, base); else result = b2i(res_bytes, base); idx += base; array[i] = new Data(); array[i].iresult(result); } Task task = client.tracker().tree.get((int)fid); if (task == null) return -1; Sensory target = (Sensory)task.f(); if (target == null) return -1; target.energyused(energy + target.energyused()); if (time < target.timeused()) time = target.timeused(); target.timeused(time); target.results(array); task.callback().aggregate(target); return 0; } private Functor parse_command(int base, byte[] msg, int size, boolean convert) { int idx = 0; log(Logger.LOG.DEBUG, "parse command"); if (msg == null) return null; byte req_octet = (byte)base; byte[] requestor = new byte[base]; System.arraycopy(msg, idx, requestor, 0, base); idx += base; byte bits = 0; boolean peer_req = (msg[idx] != 0); idx++; int priority = (msg[idx] & 0xff); idx++; int f_type = (msg[idx] & 0xff); idx++; int f_id = (msg[idx] & 0xff); idx++; int num_params = (msg[idx] & 0xff); idx++; long f_t = System.currentTimeMillis(); int f_e = (int)client.check_energy(); byte sensor = Sensix.INVALID; byte level = Sensix.INVALID; double rate = 0.0; double hi_threshold = Double.POSITIVE_INFINITY; double lo_threshold = Double.NEGATIVE_INFINITY; long duration = 0; double distance = 0.0; double angle = 0.0; sensix.sensing.Collection[] collectors = new sensix.sensing.Collection[num_params]; for (int i = 0; i < num_params; i++) collectors[i] = null; int cidx = 0; for (int i = 0; i < num_params; i++) { int err; byte code = msg[idx]; idx++; switch(code) { case Sensix.AND: cidx++; break; case Sensix.LEVEL: level = msg[idx]; idx++; break; case Sensix.SENSOR: sensor = msg[idx]; idx++; break; case Sensix.FREQ: { byte[] rate_bytes = new byte[base]; System.arraycopy(msg, idx, rate_bytes, 0, base); if (convert) rate = b2i_le(rate_bytes, base); else rate = b2i(rate_bytes, base); idx += base; } break; case Sensix.THR_PLUS: { byte[] thresh_bytes = new byte[base]; System.arraycopy(msg, idx, thresh_bytes, 0, base); if (convert) hi_threshold = b2i_le(thresh_bytes, base); else hi_threshold = b2i(thresh_bytes, base); idx += base; } break; case Sensix.THR_MINUS: { byte[] thresh_bytes = new byte[base]; System.arraycopy(msg, idx, thresh_bytes, 0, base); if (convert) lo_threshold = b2i_le(thresh_bytes, base); else lo_threshold = b2i(thresh_bytes, base); idx += base; } break; case Sensix.TIME: { byte[] time_bytes = new byte[base]; System.arraycopy(msg, idx, time_bytes, 0, base); if (convert) duration = b2i_le(time_bytes, base); else duration = b2i(time_bytes, base); idx += base; } break; case Sensix.DIST: { byte[] dist_bytes = new byte[base]; System.arraycopy(msg, idx, dist_bytes, 0, base); if (convert) distance = b2i_le(dist_bytes, base); else distance = b2i(dist_bytes, base); idx += base; } break; case Sensix.ANGLE: { byte[] angle_bytes = new byte[base]; System.arraycopy(msg, idx, angle_bytes, 0, base); if (convert) angle = b2i_le(angle_bytes, base); else angle = b2i(angle_bytes, base); idx += base; } break; default: int nsize = size - idx; byte[] next = new byte[nsize]; System.arraycopy(msg, idx, next, 0, nsize); Sensory sub = (Sensory)parse_command(base, next, nsize, convert); if (sub == null) return null; collectors[cidx] = (sensix.sensing.Collection)sub; break; } } Sensory f = null; switch(f_type) { case Sensix.ALPHA: f = new Sense(level, sensor, rate); break; case Sensix.BETA: f = new PeakSense(level, sensor, rate, hi_threshold, lo_threshold); break; case Sensix.THETA: f = new TimeSeries(level, collectors[0], duration); break; case Sensix.PSI: f = new SpatialSeries(level, collectors[0], angle, distance); break; case Sensix.IOTA: f = new Recite(level, collectors); break; case Sensix.SUMMA: f = new Sum(level, collectors); break; case Sensix.DELTA: f = new Delta(level, collectors); break; case Sensix.BARX: f = new Mean(level, collectors); break; case Sensix.SIGMA: f = new Sigma(level, collectors); break; case Sensix.LAMBDA: f = new Lambda(level, collectors); //f.code(string); //break; default: return null; } return f; } }

© 2008, Los Alamos National Security, LLC.