Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "s", "*", "SHT3xDriver", ")", "SetHeater", "(", "enabled", "bool", ")", "(", "err", "error", ")", "{", "out", ":=", "[", "]", "byte", "{", "0x30", ",", "0x66", "}", "\n", "if", "true", "==", "enabled", "{", "out", "[", "1", "]", "=", "0x6d", "\n", "}", "\n", "_", ",", "err", "=", "s", ".", "connection", ".", "Write", "(", "out", ")", "\n", "return", "\n", "}" ]

[ "SetHeater", "enables", "or", "disables", "the", "heater", "on", "the", "device" ]

[ "func", "(", "s", "*", "SHT3xDriver", ")", "Sample", "(", ")", "(", "temp", "float32", ",", "rh", "float32", ",", "err", "error", ")", "{", "ret", ",", "err", ":=", "s", ".", "sendCommandDelayGetResponse", "(", "[", "]", "byte", "{", "0x24", ",", "s", ".", "accuracy", "}", ",", "&", "s", ".", "delay", ",", "2", ")", "\n", "if", "nil", "!=", "err", "{", "return", "\n", "}", "\n\n", "// From the datasheet:", "// RH = 100 * Srh / (2^16 - 1)", "rhSample", ":=", "uint64", "(", "ret", "[", "1", "]", ")", "\n", "rh", "=", "float32", "(", "(", "uint64", "(", "1000000", ")", "*", "rhSample", ")", "/", "uint64", "(", "0xffff", ")", ")", "/", "10000.0", "\n\n", "tempSample", ":=", "uint64", "(", "ret", "[", "0", "]", ")", "\n", "switch", "s", ".", "Units", "{", "case", "\"", "\"", ":", "// From the datasheet:", "// T[C] = -45 + 175 * (St / (2^16 - 1))", "temp", "=", "float32", "(", "(", "uint64", "(", "1750000", ")", "*", "tempSample", ")", "/", "uint64", "(", "0xffff", ")", "-", "uint64", "(", "450000", ")", ")", "/", "10000.0", "\n", "case", "\"", "\"", ":", "// From the datasheet:", "// T[F] = -49 + 315 * (St / (2^16 - 1))", "temp", "=", "float32", "(", "(", "uint64", "(", "3150000", ")", "*", "tempSample", ")", "/", "uint64", "(", "0xffff", ")", "-", "uint64", "(", "490000", ")", ")", "/", "10000.0", "\n", "default", ":", "err", "=", "ErrInvalidTemp", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "Sample", "returns", "the", "temperature", "in", "celsius", "and", "relative", "humidity", "for", "one", "sample" ]

[ "func", "(", "s", "*", "SHT3xDriver", ")", "getStatusRegister", "(", ")", "(", "status", "uint16", ",", "err", "error", ")", "{", "ret", ",", "err", ":=", "s", ".", "sendCommandDelayGetResponse", "(", "[", "]", "byte", "{", "0xf3", ",", "0x2d", "}", ",", "nil", ",", "1", ")", "\n", "if", "nil", "==", "err", "{", "status", "=", "ret", "[", "0", "]", "\n", "}", "\n", "return", "\n", "}" ]

[ "getStatusRegister", "returns", "the", "device", "status", "register" ]

[ "func", "(", "s", "*", "SHT3xDriver", ")", "sendCommandDelayGetResponse", "(", "send", "[", "]", "byte", ",", "delay", "*", "time", ".", "Duration", ",", "expect", "int", ")", "(", "read", "[", "]", "uint16", ",", "err", "error", ")", "{", "if", "_", ",", "err", "=", "s", ".", "connection", ".", "Write", "(", "send", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "if", "nil", "!=", "delay", "{", "time", ".", "Sleep", "(", "*", "delay", ")", "\n", "}", "\n\n", "buf", ":=", "make", "(", "[", "]", "byte", ",", "3", "*", "expect", ")", "\n", "got", ",", "err", ":=", "s", ".", "connection", ".", "Read", "(", "buf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "got", "!=", "(", "3", "*", "expect", ")", "{", "err", "=", "ErrNotEnoughBytes", "\n", "return", "\n", "}", "\n\n", "read", "=", "make", "(", "[", "]", "uint16", ",", "expect", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "expect", ";", "i", "++", "{", "crc", ":=", "crc8", ".", "Checksum", "(", "buf", "[", "i", "*", "3", ":", "i", "*", "3", "+", "2", "]", ",", "s", ".", "crcTable", ")", "\n", "if", "buf", "[", "i", "*", "3", "+", "2", "]", "!=", "crc", "{", "err", "=", "ErrInvalidCrc", "\n", "return", "\n", "}", "\n", "read", "[", "i", "]", "=", "uint16", "(", "buf", "[", "i", "*", "3", "]", ")", "<<", "8", "|", "uint16", "(", "buf", "[", "i", "*", "3", "+", "1", "]", ")", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "sendCommandDelayGetResponse", "is", "a", "helper", "function", "to", "reduce", "duplicated", "code" ]

[ "func", "NewAdaptor", "(", ")", "*", "Adaptor", "{", "return", "&", "Adaptor", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "connect", ":", "func", "(", "e", "*", "Adaptor", ")", "(", "err", "error", ")", "{", "return", "\n", "}", ",", "mutex", ":", "&", "sync", ".", "Mutex", "{", "}", ",", "}", "\n", "}" ]

[ "NewAdaptor", "returns", "a", "new", "Joule", "Adaptor" ]

[ "func", "(", "e", "*", "Adaptor", ")", "Connect", "(", ")", "(", "err", "error", ")", "{", "e", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "e", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "e", ".", "digitalPins", "=", "make", "(", "map", "[", "int", "]", "*", "sysfs", ".", "DigitalPin", ")", "\n", "e", ".", "pwmPins", "=", "make", "(", "map", "[", "int", "]", "*", "sysfs", ".", "PWMPin", ")", "\n", "err", "=", "e", ".", "connect", "(", "e", ")", "\n", "return", "\n", "}" ]

[ "Connect", "initializes", "the", "Joule", "for", "use", "with", "the", "Arduino", "beakout", "board" ]

[ "func", "(", "e", "*", "Adaptor", ")", "DigitalPin", "(", "pin", "string", ",", "dir", "string", ")", "(", "sysfsPin", "sysfs", ".", "DigitalPinner", ",", "err", "error", ")", "{", "e", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "e", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "i", ":=", "sysfsPinMap", "[", "pin", "]", "\n", "if", "e", ".", "digitalPins", "[", "i", ".", "pin", "]", "==", "nil", "{", "e", ".", "digitalPins", "[", "i", ".", "pin", "]", "=", "sysfs", ".", "NewDigitalPin", "(", "i", ".", "pin", ")", "\n", "if", "err", "=", "e", ".", "digitalPins", "[", "i", ".", "pin", "]", ".", "Export", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n\n", "if", "dir", "==", "\"", "\"", "{", "if", "err", "=", "e", ".", "digitalPins", "[", "i", ".", "pin", "]", ".", "Direction", "(", "sysfs", ".", "IN", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "else", "if", "dir", "==", "\"", "\"", "{", "if", "err", "=", "e", ".", "digitalPins", "[", "i", ".", "pin", "]", ".", "Direction", "(", "sysfs", ".", "OUT", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "return", "e", ".", "digitalPins", "[", "i", ".", "pin", "]", ",", "nil", "\n", "}" ]

[ "digitalPin", "returns", "matched", "digitalPin", "for", "specified", "values" ]

[ "func", "(", "h", "*", "MPU6050Driver", ")", "Start", "(", ")", "(", "err", "error", ")", "{", "if", "err", ":=", "h", ".", "initialize", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "Start", "writes", "initialization", "bytes", "to", "sensor" ]

[ "func", "(", "h", "*", "MPU6050Driver", ")", "GetData", "(", ")", "(", "err", "error", ")", "{", "if", "_", ",", "err", "=", "h", ".", "connection", ".", "Write", "(", "[", "]", "byte", "{", "MPU6050_RA_ACCEL_XOUT_H", "}", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "data", ":=", "make", "(", "[", "]", "byte", ",", "14", ")", "\n", "_", ",", "err", "=", "h", ".", "connection", ".", "Read", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "buf", ":=", "bytes", ".", "NewBuffer", "(", "data", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "BigEndian", ",", "&", "h", ".", "Accelerometer", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "BigEndian", ",", "&", "h", ".", "Temperature", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "BigEndian", ",", "&", "h", ".", "Gyroscope", ")", "\n", "h", ".", "convertToCelsius", "(", ")", "\n", "return", "\n", "}" ]

[ "GetData", "fetches", "the", "latest", "data", "from", "the", "MPU6050" ]

[ "func", "WithTSL2561Gain1X", "(", "c", "Config", ")", "{", "d", ",", "ok", ":=", "c", ".", "(", "*", "TSL2561Driver", ")", "\n", "if", "ok", "{", "d", ".", "gain", "=", "TSL2561Gain1X", "\n", "return", "\n", "}", "\n", "// TODO: return errors.New(\"Trying to set Gain for non-TSL2561Driver\")", "}" ]

[ "WithTSL2561Gain1X", "option", "sets", "the", "TSL2561Driver", "gain", "to", "1X" ]

[ "func", "WithTSL2561Gain16X", "(", "c", "Config", ")", "{", "d", ",", "ok", ":=", "c", ".", "(", "*", "TSL2561Driver", ")", "\n", "if", "ok", "{", "d", ".", "gain", "=", "TSL2561Gain16X", "\n", "return", "\n", "}", "\n", "// TODO: return errors.New(\"Trying to set Gain for non-TSL2561Driver\")", "}" ]

[ "WithTSL2561Gain16X", "option", "sets", "the", "TSL2561Driver", "gain", "to", "16X" ]

[ "func", "WithTSL2561AutoGain", "(", "c", "Config", ")", "{", "d", ",", "ok", ":=", "c", ".", "(", "*", "TSL2561Driver", ")", "\n", "if", "ok", "{", "d", ".", "autoGain", "=", "true", "\n", "return", "\n", "}", "\n", "// TODO: return errors.New(\"Trying to set Auto Gain for non-TSL2561Driver\")", "}" ]

[ "WithTSL2561AutoGain", "option", "turns", "on", "TSL2561Driver", "auto", "gain" ]

[ "func", "(", "d", "*", "TSL2561Driver", ")", "SetIntegrationTime", "(", "time", "TSL2561IntegrationTime", ")", "error", "{", "if", "err", ":=", "d", ".", "enable", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "timeGainVal", ":=", "uint8", "(", "time", ")", "|", "uint8", "(", "d", ".", "gain", ")", "\n", "if", "err", ":=", "d", ".", "connection", ".", "WriteByteData", "(", "tsl2561CommandBit", "|", "tsl2561RegisterTiming", ",", "timeGainVal", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "d", ".", "integrationTime", "=", "time", "\n\n", "return", "d", ".", "disable", "(", ")", "\n", "}" ]

[ "SetIntegrationTime", "sets", "integrations", "time", "for", "the", "TSL2561" ]

[ "func", "(", "d", "*", "TSL2561Driver", ")", "GetLuminocity", "(", ")", "(", "broadband", "uint16", ",", "ir", "uint16", ",", "err", "error", ")", "{", "// if auto gain disabled get a single reading and continue", "if", "!", "d", ".", "autoGain", "{", "broadband", ",", "ir", ",", "err", "=", "d", ".", "getData", "(", ")", "\n", "return", "\n", "}", "\n\n", "agcCheck", ":=", "false", "\n", "hi", ",", "lo", ":=", "d", ".", "getHiLo", "(", ")", "\n\n", "// Read data until we find a valid range", "valid", ":=", "false", "\n", "for", "{", "broadband", ",", "ir", ",", "err", "=", "d", ".", "getData", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "// Run an auto-gain check if we haven't already done so", "if", "!", "agcCheck", "{", "if", "(", "broadband", "<", "lo", ")", "&&", "(", "d", ".", "gain", "==", "TSL2561Gain1X", ")", "{", "// increase gain and try again", "err", "=", "d", ".", "SetGain", "(", "TSL2561Gain16X", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "agcCheck", "=", "true", "\n", "}", "else", "if", "(", "broadband", ">", "hi", ")", "&&", "(", "d", ".", "gain", "==", "TSL2561Gain16X", ")", "{", "// drop gain and try again", "err", "=", "d", ".", "SetGain", "(", "TSL2561Gain1X", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "agcCheck", "=", "true", "\n", "}", "else", "{", "// Reading is either valid, or we're already at the chips", "// limits", "valid", "=", "true", "\n", "}", "\n", "}", "else", "{", "// If we've already adjusted the gain once, just return the new results.", "// This avoids endless loops where a value is at one extreme pre-gain,", "// and the the other extreme post-gain", "valid", "=", "true", "\n", "}", "\n\n", "if", "valid", "{", "break", "\n", "}", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "GetLuminocity", "gets", "the", "broadband", "and", "IR", "only", "values", "from", "the", "TSL2561", "adjusting", "gain", "if", "auto", "-", "gain", "is", "enabled" ]

[ "func", "(", "d", "*", "TSL2561Driver", ")", "CalculateLux", "(", "broadband", "uint16", ",", "ir", "uint16", ")", "(", "lux", "uint32", ")", "{", "var", "channel1", "uint32", "\n", "var", "channel0", "uint32", "\n\n", "// Set cliplevel and scaling based on integration time", "clipThreshold", ",", "chScale", ":=", "d", ".", "getClipScaling", "(", ")", "\n\n", "// Saturated sensor", "if", "(", "broadband", ">", "clipThreshold", ")", "||", "(", "ir", ">", "clipThreshold", ")", "{", "return", "65536", "\n", "}", "\n\n", "// Adjust scale for gain", "if", "d", ".", "gain", "==", "TSL2561Gain1X", "{", "chScale", "=", "chScale", "*", "16", "\n", "}", "\n\n", "channel0", "=", "(", "uint32", "(", "broadband", ")", "*", "chScale", ")", ">>", "tsl2561LuxChScale", "\n", "channel1", "=", "(", "uint32", "(", "ir", ")", "*", "chScale", ")", ">>", "tsl2561LuxChScale", "\n\n", "// Find the ratio of the channel values (channel1 / channel0)", "var", "ratio1", "uint32", "\n", "if", "channel0", "!=", "0", "{", "ratio1", "=", "(", "channel1", "<<", "(", "tsl2561LuxRatioScale", "+", "1", ")", ")", "/", "channel0", "\n", "}", "\n\n", "// Round the ratio value", "ratio", ":=", "(", "ratio1", "+", "1", ")", "/", "2", "\n\n", "b", ",", "m", ":=", "d", ".", "getBM", "(", "ratio", ")", "\n", "temp", ":=", "(", "channel0", "*", "b", ")", "-", "(", "channel1", "*", "m", ")", "\n\n", "// Negative lux not allowed", "if", "temp", "<", "0", "{", "temp", "=", "0", "\n", "}", "\n\n", "// Round lsb (2^(LUX_SCALE+1))", "temp", "+=", "(", "1", "<<", "(", "tsl2561LuxLuxScale", "-", "1", ")", ")", "\n\n", "// Strip off fractional portion", "lux", "=", "temp", ">>", "tsl2561LuxLuxScale", "\n\n", "return", "lux", "\n", "}" ]

[ "CalculateLux", "converts", "raw", "sensor", "values", "to", "the", "standard", "SI", "Lux", "equivalent", ".", "Returns", "65536", "if", "the", "sensor", "is", "saturated", "." ]

[ "func", "loadCascadeClassifier", "(", "haar", "string", ")", "*", "gocv", ".", "CascadeClassifier", "{", "if", "classifier", "!=", "nil", "{", "return", "classifier", "\n", "}", "\n\n", "c", ":=", "gocv", ".", "NewCascadeClassifier", "(", ")", "\n", "c", ".", "Load", "(", "haar", ")", "\n", "classifier", "=", "&", "c", "\n", "return", "classifier", "\n", "}" ]

[ "loadHaarClassifierCascade", "returns", "open", "cv", "HaarCascade", "loaded" ]

[ "func", "DetectObjects", "(", "haar", "string", ",", "img", "gocv", ".", "Mat", ")", "[", "]", "image", ".", "Rectangle", "{", "return", "loadCascadeClassifier", "(", "haar", ")", ".", "DetectMultiScale", "(", "img", ")", "\n", "}" ]

[ "DetectObjects", "loads", "Haar", "cascade", "to", "detect", "face", "objects", "in", "image" ]

[ "func", "DrawRectangles", "(", "img", "gocv", ".", "Mat", ",", "rects", "[", "]", "image", ".", "Rectangle", ",", "r", "int", ",", "g", "int", ",", "b", "int", ",", "thickness", "int", ")", "{", "for", "_", ",", "rect", ":=", "range", "rects", "{", "gocv", ".", "Rectangle", "(", "&", "img", ",", "rect", ",", "color", ".", "RGBA", "{", "uint8", "(", "r", ")", ",", "uint8", "(", "g", ")", ",", "uint8", "(", "b", ")", ",", "0", "}", ",", "thickness", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "DrawRectangles", "uses", "Rect", "array", "values", "to", "return", "image", "with", "rectangles", "drawn", "." ]

[ "func", "NewJSONDevice", "(", "device", "Device", ")", "*", "JSONDevice", "{", "jsonDevice", ":=", "&", "JSONDevice", "{", "Name", ":", "device", ".", "Name", "(", ")", ",", "Driver", ":", "reflect", ".", "TypeOf", "(", "device", ")", ".", "String", "(", ")", ",", "Commands", ":", "[", "]", "string", "{", "}", ",", "Connection", ":", "\"", "\"", ",", "}", "\n", "if", "device", ".", "Connection", "(", ")", "!=", "nil", "{", "jsonDevice", ".", "Connection", "=", "device", ".", "Connection", "(", ")", ".", "Name", "(", ")", "\n", "}", "\n", "if", "commander", ",", "ok", ":=", "device", ".", "(", "Commander", ")", ";", "ok", "{", "for", "command", ":=", "range", "commander", ".", "Commands", "(", ")", "{", "jsonDevice", ".", "Commands", "=", "append", "(", "jsonDevice", ".", "Commands", ",", "command", ")", "\n", "}", "\n", "}", "\n", "return", "jsonDevice", "\n", "}" ]

[ "NewJSONDevice", "returns", "a", "JSONDevice", "given", "a", "Device", "." ]

[ "func", "(", "d", "*", "Devices", ")", "Each", "(", "f", "func", "(", "Device", ")", ")", "{", "for", "_", ",", "device", ":=", "range", "*", "d", "{", "f", "(", "device", ")", "\n", "}", "\n", "}" ]

[ "Each", "enumerates", "through", "the", "Devices", "and", "calls", "specified", "callback", "function", "." ]

[ "func", "(", "d", "*", "Devices", ")", "Start", "(", ")", "(", "err", "error", ")", "{", "log", ".", "Println", "(", "\"", "\"", ")", "\n", "for", "_", ",", "device", ":=", "range", "*", "d", "{", "info", ":=", "\"", "\"", "+", "device", ".", "Name", "(", ")", "\n\n", "if", "pinner", ",", "ok", ":=", "device", ".", "(", "Pinner", ")", ";", "ok", "{", "info", "=", "info", "+", "\"", "\"", "+", "pinner", ".", "Pin", "(", ")", "\n", "}", "\n\n", "log", ".", "Println", "(", "info", "+", "\"", "\"", ")", "\n", "if", "derr", ":=", "device", ".", "Start", "(", ")", ";", "derr", "!=", "nil", "{", "err", "=", "multierror", ".", "Append", "(", "err", ",", "derr", ")", "\n", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "Start", "calls", "Start", "on", "each", "Device", "in", "d" ]

[ "func", "(", "d", "*", "Devices", ")", "Halt", "(", ")", "(", "err", "error", ")", "{", "for", "_", ",", "device", ":=", "range", "*", "d", "{", "if", "derr", ":=", "device", ".", "Halt", "(", ")", ";", "derr", "!=", "nil", "{", "err", "=", "multierror", ".", "Append", "(", "err", ",", "derr", ")", "\n", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "Halt", "calls", "Halt", "on", "each", "Device", "in", "d" ]

[ "func", "NewDigitalPin", "(", "pin", "int", ",", "v", "...", "string", ")", "*", "DigitalPin", "{", "d", ":=", "&", "DigitalPin", "{", "pin", ":", "strconv", ".", "Itoa", "(", "pin", ")", "}", "\n", "if", "len", "(", "v", ")", ">", "0", "{", "d", ".", "label", "=", "v", "[", "0", "]", "\n", "}", "else", "{", "d", ".", "label", "=", "\"", "\"", "+", "d", ".", "pin", "\n", "}", "\n\n", "return", "d", "\n", "}" ]

[ "NewDigitalPin", "returns", "a", "DigitalPin", "given", "the", "pin", "number", "and", "an", "optional", "sysfs", "pin", "label", ".", "If", "no", "label", "is", "supplied", "the", "default", "label", "will", "prepend", "gpio", "to", "the", "pin", "number", "eg", ".", "a", "pin", "number", "of", "10", "will", "have", "a", "label", "of", "gpio10" ]

[ "func", "(", "d", "*", "BME280Driver", ")", "Humidity", "(", ")", "(", "humidity", "float32", ",", "err", "error", ")", "{", "var", "rawH", "uint32", "\n", "if", "rawH", ",", "err", "=", "d", ".", "rawHumidity", "(", ")", ";", "err", "!=", "nil", "{", "return", "0.0", ",", "err", "\n", "}", "\n", "humidity", "=", "d", ".", "calculateHumidity", "(", "rawH", ")", "\n", "return", "\n", "}" ]

[ "Humidity", "returns", "the", "current", "humidity", "in", "percentage", "of", "relative", "humidity" ]

[ "func", "(", "d", "*", "BME280Driver", ")", "initHumidity", "(", ")", "(", "err", "error", ")", "{", "var", "coefficients", "[", "]", "byte", "\n", "if", "coefficients", ",", "err", "=", "d", ".", "read", "(", "bme280RegisterCalibDigH1", ",", "1", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "buf", ":=", "bytes", ".", "NewBuffer", "(", "coefficients", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "BigEndian", ",", "&", "d", ".", "hc", ".", "h1", ")", "\n\n", "if", "coefficients", ",", "err", "=", "d", ".", "read", "(", "bme280RegisterCalibDigH2LSB", ",", "7", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "buf", "=", "bytes", ".", "NewBuffer", "(", "coefficients", ")", "\n\n", "// H4 and H5 laid out strangely on the bme280", "var", "addrE4", "byte", "\n", "var", "addrE5", "byte", "\n", "var", "addrE6", "byte", "\n\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "d", ".", "hc", ".", "h2", ")", "// E1 ...", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "BigEndian", ",", "&", "d", ".", "hc", ".", "h3", ")", "// E3", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "BigEndian", ",", "&", "addrE4", ")", "// E4", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "BigEndian", ",", "&", "addrE5", ")", "// E5", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "BigEndian", ",", "&", "addrE6", ")", "// E6", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "BigEndian", ",", "&", "d", ".", "hc", ".", "h6", ")", "// ... E7", "\n\n", "d", ".", "hc", ".", "h4", "=", "0", "+", "(", "int16", "(", "addrE4", ")", "<<", "4", ")", "|", "(", "int16", "(", "addrE5", "&", "0x0F", ")", ")", "\n", "d", ".", "hc", ".", "h5", "=", "0", "+", "(", "int16", "(", "addrE6", ")", "<<", "4", ")", "|", "(", "int16", "(", "addrE5", ")", ">>", "4", ")", "\n\n", "d", ".", "connection", ".", "WriteByteData", "(", "bme280RegisterControlHumidity", ",", "0x3F", ")", "\n\n", "// The 'ctrl_hum' register sets the humidity data acquisition options of", "// the device. Changes to this register only become effective after a write", "// operation to 'ctrl_meas'. Read the current value in, then write it back", "var", "cmr", "uint8", "\n", "cmr", ",", "err", "=", "d", ".", "connection", ".", "ReadByteData", "(", "bmp280RegisterControl", ")", "\n", "if", "err", "==", "nil", "{", "err", "=", "d", ".", "connection", ".", "WriteByteData", "(", "bmp280RegisterControl", ",", "cmr", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "read", "the", "humidity", "calibration", "coefficients", "." ]

[ "func", "(", "c", "*", "Adaptor", ")", "SetBoard", "(", "n", "string", ")", "(", "err", "error", ")", "{", "if", "n", "==", "\"", "\"", "||", "n", "==", "\"", "\"", "{", "c", ".", "board", "=", "n", "\n", "c", ".", "setPins", "(", ")", "\n", "return", "\n", "}", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "SetBoard", "sets", "the", "name", "of", "the", "type", "of", "board" ]

[ "func", "(", "l", "*", "LedDriver", ")", "On", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "l", ".", "connection", ".", "DigitalWrite", "(", "l", ".", "Pin", "(", ")", ",", "1", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "l", ".", "high", "=", "true", "\n", "return", "\n", "}" ]

[ "On", "sets", "the", "led", "to", "a", "high", "state", "." ]

[ "func", "(", "l", "*", "LedDriver", ")", "Off", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "l", ".", "connection", ".", "DigitalWrite", "(", "l", ".", "Pin", "(", ")", ",", "0", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "l", ".", "high", "=", "false", "\n", "return", "\n", "}" ]

[ "Off", "sets", "the", "led", "to", "a", "low", "state", "." ]

[ "func", "(", "l", "*", "LedDriver", ")", "Brightness", "(", "level", "byte", ")", "(", "err", "error", ")", "{", "if", "writer", ",", "ok", ":=", "l", ".", "connection", ".", "(", "PwmWriter", ")", ";", "ok", "{", "return", "writer", ".", "PwmWrite", "(", "l", ".", "Pin", "(", ")", ",", "level", ")", "\n", "}", "\n", "return", "ErrPwmWriteUnsupported", "\n", "}" ]

[ "Brightness", "sets", "the", "led", "to", "the", "specified", "level", "of", "brightness" ]

[ "func", "NewAdaptor", "(", ")", "*", "Adaptor", "{", "return", "&", "Adaptor", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "connect", ":", "func", "(", "d", "*", "Adaptor", ")", "(", "err", "error", ")", "{", "d", ".", "littleWire", "=", "littleWireConnect", "(", ")", "\n", "if", "d", ".", "littleWire", ".", "(", "*", "littleWire", ")", ".", "lwHandle", "==", "nil", "{", "return", "ErrConnection", "\n", "}", "\n", "return", "\n", "}", ",", "}", "\n", "}" ]

[ "NewAdaptor", "returns", "a", "new", "Digispark", "Adaptor" ]

[ "func", "(", "d", "*", "Adaptor", ")", "ServoWrite", "(", "pin", "string", ",", "angle", "uint8", ")", "(", "err", "error", ")", "{", "if", "!", "d", ".", "servo", "{", "if", "err", "=", "d", ".", "littleWire", ".", "servoInit", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "d", ".", "servo", "=", "true", "\n", "}", "\n", "return", "d", ".", "littleWire", ".", "servoUpdateLocation", "(", "angle", ",", "angle", ")", "\n", "}" ]

[ "ServoWrite", "writes", "the", "0", "-", "180", "degree", "val", "to", "the", "specified", "pin", "." ]

[ "func", "NewAdaptor", "(", ")", "*", "Adaptor", "{", "return", "&", "Adaptor", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "connect", ":", "func", "(", "j", "*", "Adaptor", ")", "(", "err", "error", ")", "{", "sdl", ".", "Init", "(", "sdl", ".", "INIT_JOYSTICK", ")", "\n", "if", "sdl", ".", "NumJoysticks", "(", ")", ">", "0", "{", "j", ".", "joystick", "=", "sdl", ".", "JoystickOpen", "(", "0", ")", "\n", "return", "\n", "}", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "NewAdaptor", "returns", "a", "new", "Joystick", "Adaptor", "." ]

[ "func", "(", "h", "*", "MMA7660Driver", ")", "Start", "(", ")", "(", "err", "error", ")", "{", "bus", ":=", "h", ".", "GetBusOrDefault", "(", "h", ".", "connector", ".", "GetDefaultBus", "(", ")", ")", "\n", "address", ":=", "h", ".", "GetAddressOrDefault", "(", "mma7660Address", ")", "\n\n", "h", ".", "connection", ",", "err", "=", "h", ".", "connector", ".", "GetConnection", "(", "address", ",", "bus", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "h", ".", "connection", ".", "Write", "(", "[", "]", "byte", "{", "MMA7660_MODE", ",", "MMA7660_STAND_BY", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "h", ".", "connection", ".", "Write", "(", "[", "]", "byte", "{", "MMA7660_SR", ",", "MMA7660_AUTO_SLEEP_32", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "h", ".", "connection", ".", "Write", "(", "[", "]", "byte", "{", "MMA7660_MODE", ",", "MMA7660_ACTIVE", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "Start", "initialized", "the", "mma7660" ]

[ "func", "(", "h", "*", "MMA7660Driver", ")", "Acceleration", "(", "x", ",", "y", ",", "z", "float64", ")", "(", "ax", ",", "ay", ",", "az", "float64", ")", "{", "return", "x", "/", "21.0", ",", "y", "/", "21.0", ",", "z", "/", "21.0", "\n", "}" ]

[ "Acceleration", "returns", "the", "acceleration", "of", "the", "provided", "x", "y", "z" ]

[ "func", "(", "h", "*", "MMA7660Driver", ")", "XYZ", "(", ")", "(", "x", "float64", ",", "y", "float64", ",", "z", "float64", ",", "err", "error", ")", "{", "buf", ":=", "[", "]", "byte", "{", "0", ",", "0", ",", "0", "}", "\n", "bytesRead", ",", "err", ":=", "h", ".", "connection", ".", "Read", "(", "buf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "if", "bytesRead", "!=", "3", "{", "err", "=", "ErrNotEnoughBytes", "\n", "return", "\n", "}", "\n\n", "for", "_", ",", "val", ":=", "range", "buf", "{", "if", "(", "(", "val", ">>", "6", ")", "&", "0x01", ")", "==", "1", "{", "err", "=", "ErrNotReady", "\n", "return", "\n", "}", "\n", "}", "\n\n", "x", "=", "float64", "(", "(", "int8", "(", "buf", "[", "0", "]", ")", "<<", "2", ")", ")", "/", "4.0", "\n", "y", "=", "float64", "(", "(", "int8", "(", "buf", "[", "1", "]", ")", "<<", "2", ")", ")", "/", "4.0", "\n", "z", "=", "float64", "(", "(", "int8", "(", "buf", "[", "2", "]", ")", "<<", "2", ")", ")", "/", "4.0", "\n\n", "return", "\n", "}" ]

[ "XYZ", "returns", "the", "raw", "x", "y", "and", "z", "axis", "from", "the", "mma7660" ]

[ "func", "(", "i", "*", "INA3221Driver", ")", "Start", "(", ")", "error", "{", "var", "err", "error", "\n", "bus", ":=", "i", ".", "GetBusOrDefault", "(", "i", ".", "connector", ".", "GetDefaultBus", "(", ")", ")", "\n", "address", ":=", "i", ".", "GetAddressOrDefault", "(", "int", "(", "ina3221Address", ")", ")", "\n\n", "if", "i", ".", "connection", ",", "err", "=", "i", ".", "connector", ".", "GetConnection", "(", "address", ",", "bus", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "i", ".", "initialize", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Start", "initializes", "the", "INA3221" ]

[ "func", "(", "i", "*", "INA3221Driver", ")", "GetBusVoltage", "(", "channel", "INA3221Channel", ")", "(", "float64", ",", "error", ")", "{", "value", ",", "err", ":=", "i", ".", "getBusVoltageRaw", "(", "channel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "return", "float64", "(", "value", ")", "*", ".001", ",", "nil", "\n", "}" ]

[ "GetBusVoltage", "gets", "the", "bus", "voltage", "in", "Volts" ]

[ "func", "(", "i", "*", "INA3221Driver", ")", "GetShuntVoltage", "(", "channel", "INA3221Channel", ")", "(", "float64", ",", "error", ")", "{", "value", ",", "err", ":=", "i", ".", "getShuntVoltageRaw", "(", "channel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "return", "float64", "(", "value", ")", "*", "float64", "(", ".005", ")", ",", "nil", "\n", "}" ]

[ "GetShuntVoltage", "Gets", "the", "shunt", "voltage", "in", "mV" ]

[ "func", "(", "i", "*", "INA3221Driver", ")", "GetCurrent", "(", "channel", "INA3221Channel", ")", "(", "float64", ",", "error", ")", "{", "value", ",", "err", ":=", "i", ".", "GetShuntVoltage", "(", "channel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "ma", ":=", "value", "/", "ina3221ShuntResistorValue", "\n", "return", "ma", ",", "nil", "\n", "}" ]

[ "GetCurrent", "gets", "the", "current", "value", "in", "mA", "taking", "into", "account", "the", "config", "settings", "and", "current", "LSB" ]

[ "func", "(", "i", "*", "INA3221Driver", ")", "GetLoadVoltage", "(", "channel", "INA3221Channel", ")", "(", "float64", ",", "error", ")", "{", "bv", ",", "err", ":=", "i", ".", "GetBusVoltage", "(", "channel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "sv", ",", "err", ":=", "i", ".", "GetShuntVoltage", "(", "channel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "return", "bv", "+", "(", "sv", "/", "1000.0", ")", ",", "nil", "\n", "}" ]

[ "GetLoadVoltage", "gets", "the", "load", "voltage", "in", "mV" ]

[ "func", "(", "i", "*", "INA3221Driver", ")", "readWordFromRegister", "(", "reg", "uint8", ")", "(", "uint16", ",", "error", ")", "{", "val", ",", "err", ":=", "i", ".", "connection", ".", "ReadWordData", "(", "reg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "return", "uint16", "(", "(", "(", "val", "&", "0x00FF", ")", "<<", "8", ")", "|", "(", "(", "val", "&", "0xFF00", ")", ">>", "8", ")", ")", ",", "nil", "\n", "}" ]

[ "reads", "word", "from", "supplied", "register", "address" ]

[ "func", "(", "i", "*", "INA3221Driver", ")", "initialize", "(", ")", "error", "{", "config", ":=", "ina3221ConfigEnableChan1", "|", "ina3221ConfigEnableChan2", "|", "ina3221ConfigEnableChan3", "|", "ina3221ConfigAvg1", "|", "ina3221ConfigVBusCT2", "|", "ina3221ConfigVShCT2", "|", "ina3221ConfigMode2", "|", "ina3221ConfigMode1", "|", "ina3221ConfigMode0", "\n\n", "return", "i", ".", "connection", ".", "WriteBlockData", "(", "ina3221RegConfig", ",", "[", "]", "byte", "{", "byte", "(", "config", ">>", "8", ")", ",", "byte", "(", "config", "&", "0x00FF", ")", "}", ")", "\n", "}" ]

[ "initialize", "initializes", "the", "INA3221", "device" ]

[ "func", "NewAdaptor", "(", "host", "string", ",", "clientID", "int", ",", "options", "...", "nats", ".", "Option", ")", "*", "Adaptor", "{", "hosts", ",", "err", ":=", "processHostString", "(", "host", ")", "\n\n", "return", "&", "Adaptor", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "Host", ":", "hosts", ",", "clientID", ":", "clientID", ",", "connect", ":", "func", "(", ")", "(", "*", "nats", ".", "Conn", ",", "error", ")", "{", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "nats", ".", "Connect", "(", "hosts", ",", "options", "...", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "NewAdaptor", "populates", "a", "new", "NATS", "Adaptor", "." ]

[ "func", "NewAdaptorWithAuth", "(", "host", "string", ",", "clientID", "int", ",", "username", "string", ",", "password", "string", ",", "options", "...", "nats", ".", "Option", ")", "*", "Adaptor", "{", "hosts", ",", "err", ":=", "processHostString", "(", "host", ")", "\n\n", "return", "&", "Adaptor", "{", "Host", ":", "hosts", ",", "clientID", ":", "clientID", ",", "username", ":", "username", ",", "password", ":", "password", ",", "connect", ":", "func", "(", ")", "(", "*", "nats", ".", "Conn", ",", "error", ")", "{", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "nats", ".", "Connect", "(", "hosts", ",", "append", "(", "options", ",", "nats", ".", "UserInfo", "(", "username", ",", "password", ")", ")", "...", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "NewAdaptorWithAuth", "populates", "a", "NATS", "Adaptor", "including", "username", "and", "password", "." ]

[ "func", "(", "a", "*", "Adaptor", ")", "Connect", "(", ")", "(", "err", "error", ")", "{", "a", ".", "client", ",", "err", "=", "a", ".", "connect", "(", ")", "\n", "return", "\n", "}" ]

[ "Connect", "makes", "a", "connection", "to", "the", "Nats", "server", "." ]

[ "func", "(", "a", "*", "Adaptor", ")", "Publish", "(", "topic", "string", ",", "message", "[", "]", "byte", ")", "bool", "{", "if", "a", ".", "client", "==", "nil", "{", "return", "false", "\n", "}", "\n", "a", ".", "client", ".", "Publish", "(", "topic", ",", "message", ")", "\n", "return", "true", "\n", "}" ]

[ "Publish", "sends", "a", "message", "with", "the", "particular", "topic", "to", "the", "nats", "server", "." ]

[ "func", "(", "d", "*", "BMP180Driver", ")", "Pressure", "(", ")", "(", "pressure", "float32", ",", "err", "error", ")", "{", "var", "rawTemp", "int16", "\n", "var", "rawPressure", "int32", "\n", "if", "rawTemp", ",", "err", "=", "d", ".", "rawTemp", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "if", "rawPressure", ",", "err", "=", "d", ".", "rawPressure", "(", "d", ".", "Mode", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "d", ".", "calculatePressure", "(", "rawTemp", ",", "rawPressure", ",", "d", ".", "Mode", ")", ",", "nil", "\n", "}" ]

[ "Pressure", "returns", "the", "current", "pressure", "in", "pascals", "." ]

[ "func", "NewMAX7219Driver", "(", "a", "gobot", ".", "Connection", ",", "clockPin", "string", ",", "dataPin", "string", ",", "csPin", "string", ",", "count", "uint", ")", "*", "MAX7219Driver", "{", "t", ":=", "&", "MAX7219Driver", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "pinClock", ":", "NewDirectPinDriver", "(", "a", ",", "clockPin", ")", ",", "pinData", ":", "NewDirectPinDriver", "(", "a", ",", "dataPin", ")", ",", "pinCS", ":", "NewDirectPinDriver", "(", "a", ",", "csPin", ")", ",", "count", ":", "count", ",", "connection", ":", "a", ",", "Commander", ":", "gobot", ".", "NewCommander", "(", ")", ",", "}", "\n\n", "/* TODO : Add commands */", "return", "t", "\n", "}" ]

[ "NewMAX7219Driver", "return", "a", "new", "MAX7219Driver", "given", "a", "gobot", ".", "Connection", "pins", "and", "how", "many", "chips", "are", "chained" ]

[ "func", "(", "a", "*", "MAX7219Driver", ")", "Start", "(", ")", "(", "err", "error", ")", "{", "a", ".", "pinData", ".", "On", "(", ")", "\n", "a", ".", "pinClock", ".", "On", "(", ")", "\n", "a", ".", "pinCS", ".", "On", "(", ")", "\n\n", "a", ".", "All", "(", "MAX7219ScanLimit", ",", "0x07", ")", "\n", "a", ".", "All", "(", "MAX7219DecodeMode", ",", "0x00", ")", "\n", "a", ".", "All", "(", "MAX7219Shutdown", ",", "0x01", ")", "\n", "a", ".", "All", "(", "MAX7219DisplayTest", ",", "0x00", ")", "\n", "a", ".", "ClearAll", "(", ")", "\n", "a", ".", "All", "(", "MAX7219Intensity", ",", "0x0f", "&", "0x0f", ")", "\n\n", "return", "\n", "}" ]

[ "Start", "initializes", "the", "max7219", "it", "uses", "a", "SPI", "-", "like", "communication", "protocol" ]

[ "func", "(", "a", "*", "MAX7219Driver", ")", "ClearAll", "(", ")", "{", "for", "i", ":=", "1", ";", "i", "<=", "8", ";", "i", "++", "{", "a", ".", "All", "(", "byte", "(", "i", ")", ",", "0", ")", "\n", "}", "\n", "}" ]

[ "ClearAll", "turns", "off", "all", "LEDs", "of", "all", "modules" ]

[ "func", "(", "a", "*", "MAX7219Driver", ")", "ClearOne", "(", "which", "uint", ")", "{", "for", "i", ":=", "1", ";", "i", "<=", "8", ";", "i", "++", "{", "a", ".", "One", "(", "which", ",", "byte", "(", "i", ")", ",", "0", ")", "\n", "}", "\n", "}" ]

[ "ClearAll", "turns", "off", "all", "LEDs", "of", "the", "given", "module" ]

[ "func", "(", "a", "*", "MAX7219Driver", ")", "sendData", "(", "address", "byte", ",", "data", "byte", ")", "{", "a", ".", "pinCS", ".", "Off", "(", ")", "\n", "a", ".", "send", "(", "address", ")", "\n", "a", ".", "send", "(", "data", ")", "\n", "a", ".", "pinCS", ".", "On", "(", ")", "\n", "}" ]

[ "sendData", "is", "an", "auxiliary", "function", "to", "send", "data", "to", "the", "MAX7219Driver", "module" ]

[ "func", "(", "a", "*", "MAX7219Driver", ")", "All", "(", "address", "byte", ",", "data", "byte", ")", "{", "a", ".", "pinCS", ".", "Off", "(", ")", "\n", "var", "c", "uint", "\n", "for", "c", "=", "0", ";", "c", "<", "a", ".", "count", ";", "c", "++", "{", "a", ".", "send", "(", "address", ")", "\n", "a", ".", "send", "(", "data", ")", "\n", "}", "\n", "a", ".", "pinCS", ".", "On", "(", ")", "\n", "}" ]

[ "All", "sends", "the", "same", "data", "to", "all", "the", "modules" ]

[ "func", "NewAdaptor", "(", "device", "string", ")", "*", "Adaptor", "{", "c", ":=", "&", "serial", ".", "Mode", "{", "BaudRate", ":", "115200", "}", "\n", "return", "&", "Adaptor", "{", "name", ":", "\"", "\"", ",", "connection", ":", "nil", ",", "port", ":", "device", ",", "serialMode", ":", "c", ",", "writeBytesChannel", ":", "make", "(", "chan", "[", "]", "byte", ")", ",", "finalizeChannel", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n", "}" ]

[ "NewAdaptor", "returns", "a", "new", "MegaPi", "Adaptor", "with", "specified", "serial", "port", "used", "to", "talk", "to", "the", "MegaPi", "with", "a", "baud", "rate", "of", "115200" ]

[ "func", "(", "megaPi", "*", "Adaptor", ")", "Connect", "(", ")", "error", "{", "if", "megaPi", ".", "connection", "==", "nil", "{", "sp", ",", "err", ":=", "serial", ".", "Open", "(", "megaPi", ".", "port", ",", "megaPi", ".", "serialMode", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// sleeping is required to give the board a chance to reset", "time", ".", "Sleep", "(", "2", "*", "time", ".", "Second", ")", "\n", "megaPi", ".", "connection", "=", "sp", "\n", "}", "\n\n", "// kick off thread to send bytes to the board", "go", "func", "(", ")", "{", "for", "{", "select", "{", "case", "bytes", ":=", "<-", "megaPi", ".", "writeBytesChannel", ":", "megaPi", ".", "connection", ".", "Write", "(", "bytes", ")", "\n", "time", ".", "Sleep", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "case", "<-", "megaPi", ".", "finalizeChannel", ":", "megaPi", ".", "finalizeChannel", "<-", "struct", "{", "}", "{", "}", "\n", "return", "\n", "default", ":", "time", ".", "Sleep", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Connect", "starts", "a", "connection", "to", "the", "board" ]

[ "func", "(", "megaPi", "*", "Adaptor", ")", "Finalize", "(", ")", "error", "{", "megaPi", ".", "finalizeChannel", "<-", "struct", "{", "}", "{", "}", "\n", "<-", "megaPi", ".", "finalizeChannel", "\n", "if", "err", ":=", "megaPi", ".", "connection", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Finalize", "terminates", "the", "connection", "to", "the", "board" ]

[ "func", "ReadMAVLinkPacket", "(", "r", "io", ".", "Reader", ")", "(", "*", "MAVLinkPacket", ",", "error", ")", "{", "for", "{", "header", ",", "err", ":=", "read", "(", "r", ",", "1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "header", "[", "0", "]", "==", "254", "{", "length", ",", "err", ":=", "read", "(", "r", ",", "1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "if", "length", "[", "0", "]", ">", "250", "{", "continue", "\n", "}", "\n", "m", ":=", "&", "MAVLinkPacket", "{", "}", "\n", "data", ",", "err", ":=", "read", "(", "r", ",", "int", "(", "length", "[", "0", "]", ")", "+", "7", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "data", "=", "append", "(", "[", "]", "byte", "{", "header", "[", "0", "]", ",", "length", "[", "0", "]", "}", ",", "data", "...", ")", "\n", "m", ".", "Decode", "(", "data", ")", "\n", "return", "m", ",", "nil", "\n", "}", "\n", "}", "\n", "}" ]

[ "ReadMAVLinkPacket", "reads", "an", "io", ".", "Reader", "for", "a", "new", "packet", "and", "returns", "a", "new", "MAVLink", "packet", "or", "returns", "the", "error", "received", "by", "the", "io", ".", "Reader" ]

[ "func", "CraftMAVLinkPacket", "(", "SystemID", "uint8", ",", "ComponentID", "uint8", ",", "Message", "MAVLinkMessage", ")", "*", "MAVLinkPacket", "{", "return", "NewMAVLinkPacket", "(", "0xFE", ",", "Message", ".", "Len", "(", ")", ",", "generateSequence", "(", ")", ",", "SystemID", ",", "ComponentID", ",", "Message", ".", "Id", "(", ")", ",", "Message", ".", "Pack", "(", ")", ",", ")", "\n", "}" ]

[ "CraftMAVLinkPacket", "returns", "a", "new", "MAVLinkPacket", "from", "a", "MAVLinkMessage" ]

[ "func", "NewMAVLinkPacket", "(", "Protocol", "uint8", ",", "Length", "uint8", ",", "Sequence", "uint8", ",", "SystemID", "uint8", ",", "ComponentID", "uint8", ",", "MessageID", "uint8", ",", "Data", "[", "]", "uint8", ")", "*", "MAVLinkPacket", "{", "m", ":=", "&", "MAVLinkPacket", "{", "Protocol", ":", "Protocol", ",", "Length", ":", "Length", ",", "Sequence", ":", "Sequence", ",", "SystemID", ":", "SystemID", ",", "ComponentID", ":", "ComponentID", ",", "MessageID", ":", "MessageID", ",", "Data", ":", "Data", ",", "}", "\n", "m", ".", "Checksum", "=", "crcCalculate", "(", "m", ")", "\n", "return", "m", "\n", "}" ]

[ "NewMAVLinkPacket", "returns", "a", "new", "MAVLinkPacket" ]

[ "func", "(", "m", "*", "MAVLinkPacket", ")", "MAVLinkMessage", "(", ")", "(", "MAVLinkMessage", ",", "error", ")", "{", "return", "NewMAVLinkMessage", "(", "m", ".", "MessageID", ",", "m", ".", "Data", ")", "\n", "}" ]

[ "MAVLinkMessage", "returns", "the", "decoded", "MAVLinkMessage", "from", "the", "MAVLinkPacket", "or", "returns", "an", "error", "generated", "from", "the", "MAVLinkMessage" ]

[ "func", "(", "m", "*", "MAVLinkPacket", ")", "Pack", "(", ")", "[", "]", "byte", "{", "data", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "binary", ".", "Write", "(", "data", ",", "binary", ".", "LittleEndian", ",", "m", ".", "Protocol", ")", "\n", "binary", ".", "Write", "(", "data", ",", "binary", ".", "LittleEndian", ",", "m", ".", "Length", ")", "\n", "binary", ".", "Write", "(", "data", ",", "binary", ".", "LittleEndian", ",", "m", ".", "Sequence", ")", "\n", "binary", ".", "Write", "(", "data", ",", "binary", ".", "LittleEndian", ",", "m", ".", "SystemID", ")", "\n", "binary", ".", "Write", "(", "data", ",", "binary", ".", "LittleEndian", ",", "m", ".", "ComponentID", ")", "\n", "binary", ".", "Write", "(", "data", ",", "binary", ".", "LittleEndian", ",", "m", ".", "MessageID", ")", "\n", "data", ".", "Write", "(", "m", ".", "Data", ")", "\n", "binary", ".", "Write", "(", "data", ",", "binary", ".", "LittleEndian", ",", "m", ".", "Checksum", ")", "\n", "return", "data", ".", "Bytes", "(", ")", "\n", "}" ]

[ "Pack", "returns", "a", "packed", "byte", "array", "which", "represents", "the", "MAVLinkPacket" ]

[ "func", "(", "m", "*", "MAVLinkPacket", ")", "Decode", "(", "buf", "[", "]", "byte", ")", "{", "m", ".", "Protocol", "=", "buf", "[", "0", "]", "\n", "m", ".", "Length", "=", "buf", "[", "1", "]", "\n", "m", ".", "Sequence", "=", "buf", "[", "2", "]", "\n", "m", ".", "SystemID", "=", "buf", "[", "3", "]", "\n", "m", ".", "ComponentID", "=", "buf", "[", "4", "]", "\n", "m", ".", "MessageID", "=", "buf", "[", "5", "]", "\n", "m", ".", "Data", "=", "buf", "[", "6", ":", "6", "+", "int", "(", "m", ".", "Length", ")", "]", "\n", "checksum", ":=", "buf", "[", "7", "+", "int", "(", "m", ".", "Length", ")", ":", "]", "\n", "m", ".", "Checksum", "=", "uint16", "(", "checksum", "[", "1", "]", ")", "<<", "8", "|", "uint16", "(", "checksum", "[", "0", "]", ")", "\n", "}" ]

[ "Decode", "accepts", "a", "packed", "byte", "array", "and", "populates", "the", "fields", "of", "the", "MAVLinkPacket" ]

[ "func", "crcCalculate", "(", "m", "*", "MAVLinkPacket", ")", "uint16", "{", "crc", ":=", "crcInit", "(", ")", "\n\n", "for", "_", ",", "v", ":=", "range", "m", ".", "Pack", "(", ")", "[", "1", ":", "m", ".", "Length", "+", "6", "]", "{", "crc", "=", "crcAccumulate", "(", "v", ",", "crc", ")", "\n", "}", "\n", "message", ",", "_", ":=", "m", ".", "MAVLinkMessage", "(", ")", "\n", "crc", "=", "crcAccumulate", "(", "message", ".", "Crc", "(", ")", ",", "crc", ")", "\n", "return", "crc", "\n", "}" ]

[ "Calculates", "the", "X", ".", "25", "checksum", "on", "a", "byte", "buffer", "return", "the", "checksum", "over", "the", "buffer", "bytes" ]

[ "func", "NewPocketBeagleAdaptor", "(", ")", "*", "PocketBeagleAdaptor", "{", "a", ":=", "NewAdaptor", "(", ")", "\n", "a", ".", "SetName", "(", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ")", "\n", "a", ".", "pinMap", "=", "pocketBeaglePinMap", "\n", "a", ".", "pwmPinMap", "=", "pocketBeaglePwmPinMap", "\n", "a", ".", "analogPinMap", "=", "pocketBeagleAnalogPinMap", "\n\n", "return", "&", "PocketBeagleAdaptor", "{", "Adaptor", ":", "a", ",", "}", "\n", "}" ]

[ "NewPocketBeagleAdaptor", "creates", "a", "new", "Adaptor", "for", "the", "PocketBeagle" ]

[ "func", "NewDriver", "(", "a", "ble", ".", "BLEConnector", ")", "*", "BB8Driver", "{", "d", ":=", "ollie", ".", "NewDriver", "(", "a", ")", "\n", "d", ".", "SetName", "(", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ")", "\n\n", "return", "&", "BB8Driver", "{", "Driver", ":", "d", ",", "}", "\n", "}" ]

[ "NewDriver", "creates", "a", "Driver", "for", "a", "Sphero", "BB", "-", "8" ]

[ "func", "NewEventer", "(", ")", "Eventer", "{", "evtr", ":=", "&", "eventer", "{", "eventnames", ":", "make", "(", "map", "[", "string", "]", "string", ")", ",", "in", ":", "make", "(", "eventChannel", ",", "eventChanBufferSize", ")", ",", "outs", ":", "make", "(", "map", "[", "eventChannel", "]", "eventChannel", ")", ",", "}", "\n\n", "// goroutine to cascade \"in\" events to all \"out\" event channels", "go", "func", "(", ")", "{", "for", "{", "select", "{", "case", "evt", ":=", "<-", "evtr", ".", "in", ":", "evtr", ".", "eventsMutex", ".", "Lock", "(", ")", "\n", "for", "_", ",", "out", ":=", "range", "evtr", ".", "outs", "{", "out", "<-", "evt", "\n", "}", "\n", "evtr", ".", "eventsMutex", ".", "Unlock", "(", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "return", "evtr", "\n", "}" ]

[ "NewEventer", "returns", "a", "new", "Eventer", "." ]

[ "func", "(", "e", "*", "eventer", ")", "Publish", "(", "name", "string", ",", "data", "interface", "{", "}", ")", "{", "evt", ":=", "NewEvent", "(", "name", ",", "data", ")", "\n", "e", ".", "in", "<-", "evt", "\n", "}" ]

[ "Publish", "new", "events", "to", "anyone", "that", "is", "subscribed" ]

[ "func", "(", "e", "*", "eventer", ")", "Subscribe", "(", ")", "eventChannel", "{", "e", ".", "eventsMutex", ".", "Lock", "(", ")", "\n", "defer", "e", ".", "eventsMutex", ".", "Unlock", "(", ")", "\n", "out", ":=", "make", "(", "eventChannel", ",", "eventChanBufferSize", ")", "\n", "e", ".", "outs", "[", "out", "]", "=", "out", "\n", "return", "out", "\n", "}" ]

[ "Subscribe", "to", "any", "events", "from", "this", "eventer" ]

[ "func", "(", "e", "*", "eventer", ")", "Unsubscribe", "(", "events", "eventChannel", ")", "{", "e", ".", "eventsMutex", ".", "Lock", "(", ")", "\n", "defer", "e", ".", "eventsMutex", ".", "Unlock", "(", ")", "\n", "delete", "(", "e", ".", "outs", ",", "events", ")", "\n", "}" ]

[ "Unsubscribe", "from", "the", "event", "channel" ]

[ "func", "(", "e", "*", "eventer", ")", "On", "(", "n", "string", ",", "f", "func", "(", "s", "interface", "{", "}", ")", ")", "(", "err", "error", ")", "{", "out", ":=", "e", ".", "Subscribe", "(", ")", "\n", "go", "func", "(", ")", "{", "for", "{", "select", "{", "case", "evt", ":=", "<-", "out", ":", "if", "evt", ".", "Name", "==", "n", "{", "f", "(", "evt", ".", "Data", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "return", "\n", "}" ]

[ "On", "executes", "the", "event", "handler", "f", "when", "e", "is", "Published", "to", "." ]

[ "func", "(", "e", "*", "eventer", ")", "Once", "(", "n", "string", ",", "f", "func", "(", "s", "interface", "{", "}", ")", ")", "(", "err", "error", ")", "{", "out", ":=", "e", ".", "Subscribe", "(", ")", "\n", "go", "func", "(", ")", "{", "ProcessEvents", ":", "for", "evt", ":=", "range", "out", "{", "if", "evt", ".", "Name", "==", "n", "{", "f", "(", "evt", ".", "Data", ")", "\n", "e", ".", "Unsubscribe", "(", "out", ")", "\n", "break", "ProcessEvents", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "return", "\n", "}" ]

[ "Once", "is", "similar", "to", "On", "except", "that", "it", "only", "executes", "f", "one", "time", "." ]

[ "func", "NewTM1638Driver", "(", "a", "gobot", ".", "Connection", ",", "clockPin", "string", ",", "dataPin", "string", ",", "strobePin", "string", ")", "*", "TM1638Driver", "{", "t", ":=", "&", "TM1638Driver", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "pinClock", ":", "NewDirectPinDriver", "(", "a", ",", "clockPin", ")", ",", "pinData", ":", "NewDirectPinDriver", "(", "a", ",", "dataPin", ")", ",", "pinStrobe", ":", "NewDirectPinDriver", "(", "a", ",", "strobePin", ")", ",", "fonts", ":", "NewTM1638Fonts", "(", ")", ",", "connection", ":", "a", ",", "Commander", ":", "gobot", ".", "NewCommander", "(", ")", ",", "}", "\n\n", "/* TODO : Add commands */", "return", "t", "\n", "}" ]

[ "NewTM1638Driver", "return", "a", "new", "TM1638Driver", "given", "a", "gobot", ".", "Connection", "and", "the", "clock", "data", "and", "strobe", "pins" ]

[ "func", "(", "t", "*", "TM1638Driver", ")", "sendCommand", "(", "cmd", "byte", ")", "{", "t", ".", "pinStrobe", ".", "Off", "(", ")", "\n", "t", ".", "send", "(", "cmd", ")", "\n", "t", ".", "pinStrobe", ".", "On", "(", ")", "\n", "}" ]

[ "sendCommand", "is", "an", "auxiliary", "function", "to", "send", "commands", "to", "the", "TM1638", "module" ]

[ "func", "(", "t", "*", "TM1638Driver", ")", "sendData", "(", "address", "byte", ",", "data", "byte", ")", "{", "t", ".", "sendCommand", "(", "TM1638DataCmd", "|", "TM1638FixedAddr", ")", "\n", "t", ".", "pinStrobe", ".", "Off", "(", ")", "\n", "t", ".", "send", "(", "TM1638AddrCmd", "|", "address", ")", "\n", "t", ".", "send", "(", "data", ")", "\n", "t", ".", "pinStrobe", ".", "On", "(", ")", "\n", "}" ]

[ "sendData", "is", "an", "auxiliary", "function", "to", "send", "data", "to", "the", "TM1638", "module" ]

[ "func", "(", "t", "*", "TM1638Driver", ")", "SendChar", "(", "pos", "byte", ",", "data", "byte", ",", "dot", "bool", ")", "{", "if", "pos", ">", "7", "{", "return", "\n", "}", "\n", "var", "dotData", "byte", "\n", "if", "dot", "{", "dotData", "=", "TM1638DispCtrl", "\n", "}", "\n", "t", ".", "sendData", "(", "pos", "<<", "1", ",", "data", "|", "(", "dotData", ")", ")", "\n", "}" ]

[ "SendChar", "sends", "one", "byte", "to", "the", "specific", "position", "in", "the", "display" ]

[ "func", "(", "t", "*", "TM1638Driver", ")", "fromStringToByteArray", "(", "str", "string", ")", "[", "]", "byte", "{", "chars", ":=", "strings", ".", "Split", "(", "str", ",", "\"", "\"", ")", "\n", "data", ":=", "make", "(", "[", "]", "byte", ",", "len", "(", "chars", ")", ")", "\n\n", "for", "index", ",", "char", ":=", "range", "chars", "{", "if", "val", ",", "ok", ":=", "t", ".", "fonts", "[", "char", "]", ";", "ok", "{", "data", "[", "index", "]", "=", "val", "\n", "}", "\n", "}", "\n", "return", "data", "\n", "}" ]

[ "fromStringToByteArray", "translates", "a", "string", "to", "a", "byte", "array", "with", "the", "corresponding", "representation", "for", "the", "7", "-", "segment", "LCD", "return", "and", "empty", "character", "if", "the", "font", "is", "not", "available" ]

[ "func", "(", "t", "*", "TM1638Driver", ")", "AddFonts", "(", "fonts", "map", "[", "string", "]", "byte", ")", "{", "for", "k", ",", "v", ":=", "range", "fonts", "{", "t", ".", "fonts", "[", "k", "]", "=", "v", "\n", "}", "\n", "}" ]

[ "AddFonts", "adds", "new", "custom", "fonts", "or", "modify", "the", "representation", "of", "existing", "ones" ]

[ "func", "(", "p", "*", "Namespaces", ")", "Register", "(", "ns", "Namespace", ")", "{", "if", "!", "p", ".", "Safe", "{", "p", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "mu", ".", "Unlock", "(", ")", "\n", "}", "\n", "if", "p", ".", "prefixes", "==", "nil", "{", "p", ".", "prefixes", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "}", "\n", "p", ".", "prefixes", "[", "ns", ".", "Prefix", "]", "=", "ns", ".", "Full", "\n", "}" ]

[ "Register", "adds", "namespace", "to", "registered", "list", "." ]

[ "func", "(", "p", "*", "Namespaces", ")", "List", "(", ")", "(", "out", "[", "]", "Namespace", ")", "{", "if", "!", "p", ".", "Safe", "{", "p", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "p", ".", "mu", ".", "RUnlock", "(", ")", "\n", "}", "\n", "out", "=", "make", "(", "[", "]", "Namespace", ",", "0", ",", "len", "(", "p", ".", "prefixes", ")", ")", "\n", "for", "pref", ",", "ns", ":=", "range", "p", ".", "prefixes", "{", "out", "=", "append", "(", "out", ",", "Namespace", "{", "Prefix", ":", "pref", ",", "Full", ":", "ns", "}", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "List", "enumerates", "all", "registered", "namespace", "pairs", "." ]

[ "func", "(", "p", "*", "Namespaces", ")", "Clone", "(", ")", "*", "Namespaces", "{", "if", "!", "p", ".", "Safe", "{", "p", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "p", ".", "mu", ".", "RUnlock", "(", ")", "\n", "}", "\n", "p2", ":=", "Namespaces", "{", "prefixes", ":", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "p", ".", "prefixes", ")", ")", ",", "}", "\n", "for", "pref", ",", "ns", ":=", "range", "p", ".", "prefixes", "{", "p2", ".", "prefixes", "[", "pref", "]", "=", "ns", "\n", "}", "\n", "return", "&", "p2", "\n", "}" ]

[ "Clone", "makes", "a", "copy", "of", "namespaces", "list", "." ]

[ "func", "(", "p", "*", "Namespaces", ")", "CloneTo", "(", "p2", "*", "Namespaces", ")", "{", "if", "p", "==", "p2", "{", "return", "\n", "}", "\n", "if", "!", "p", ".", "Safe", "{", "p", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "p", ".", "mu", ".", "RUnlock", "(", ")", "\n", "}", "\n", "if", "!", "p2", ".", "Safe", "{", "p2", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "p2", ".", "mu", ".", "Unlock", "(", ")", "\n", "}", "\n", "if", "p2", ".", "prefixes", "==", "nil", "{", "p2", ".", "prefixes", "=", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "p", ".", "prefixes", ")", ")", "\n", "}", "\n", "for", "pref", ",", "ns", ":=", "range", "p", ".", "prefixes", "{", "p2", ".", "prefixes", "[", "pref", "]", "=", "ns", "\n", "}", "\n", "}" ]

[ "CloneTo", "adds", "registered", "namespaces", "to", "a", "given", "list", "." ]

[ "func", "RegisterPrefix", "(", "pref", "string", ",", "ns", "string", ")", "{", "Register", "(", "Namespace", "{", "Prefix", ":", "pref", ",", "Full", ":", "ns", "}", ")", "\n", "}" ]

[ "RegisterPrefix", "globally", "associates", "a", "given", "prefix", "with", "a", "base", "vocabulary", "IRI", "." ]

[ "func", "(", "it", "*", "Limit", ")", "Next", "(", "ctx", "context", ".", "Context", ")", "bool", "{", "graph", ".", "NextLogIn", "(", "it", ")", "\n", "if", "it", ".", "limit", ">", "0", "&&", "it", ".", "count", ">=", "it", ".", "limit", "{", "return", "graph", ".", "NextLogOut", "(", "it", ",", "false", ")", "\n", "}", "\n", "if", "it", ".", "primaryIt", ".", "Next", "(", "ctx", ")", "{", "it", ".", "count", "++", "\n", "return", "graph", ".", "NextLogOut", "(", "it", ",", "true", ")", "\n", "}", "\n", "return", "graph", ".", "NextLogOut", "(", "it", ",", "false", ")", "\n", "}" ]

[ "Next", "advances", "the", "Limit", "iterator", ".", "It", "will", "stop", "iteration", "if", "limit", "was", "reached", "." ]

[ "func", "(", "it", "*", "Limit", ")", "NextPath", "(", "ctx", "context", ".", "Context", ")", "bool", "{", "if", "it", ".", "limit", ">", "0", "&&", "it", ".", "count", ">=", "it", ".", "limit", "{", "return", "false", "\n", "}", "\n", "if", "it", ".", "primaryIt", ".", "NextPath", "(", "ctx", ")", "{", "it", ".", "count", "++", "\n", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "NextPath", "checks", "whether", "there", "is", "another", "path", ".", "Will", "call", "primary", "iterator", "if", "limit", "is", "not", "reached", "yet", "." ]

[ "func", "Predicates", "(", "from", "Shape", ",", "in", "bool", ")", "Shape", "{", "dir", ":=", "quad", ".", "Subject", "\n", "if", "in", "{", "dir", "=", "quad", ".", "Object", "\n", "}", "\n", "return", "Unique", "{", "NodesFrom", "{", "Quads", ":", "Quads", "{", "{", "Dir", ":", "dir", ",", "Values", ":", "from", "}", ",", "}", ",", "Dir", ":", "quad", ".", "Predicate", ",", "}", "}", "\n", "}" ]

[ "InWithTags", "OutWithTags", "Both", "BothWithTags" ]

[ "func", "Optimize", "(", "s", "Shape", ",", "qs", "graph", ".", "QuadStore", ")", "(", "Shape", ",", "bool", ")", "{", "if", "s", "==", "nil", "{", "return", "nil", ",", "false", "\n", "}", "\n", "qs", "=", "graph", ".", "Unwrap", "(", "qs", ")", "\n", "var", "opt", "bool", "\n", "if", "qs", "!=", "nil", "{", "// resolve all lookups earlier", "s", ",", "opt", "=", "s", ".", "Optimize", "(", "resolveValues", "{", "qs", ":", "qs", "}", ")", "\n", "}", "\n", "if", "s", "==", "nil", "{", "return", "Null", "{", "}", ",", "true", "\n", "}", "\n", "// generic optimizations", "var", "opt1", "bool", "\n", "s", ",", "opt1", "=", "s", ".", "Optimize", "(", "nil", ")", "\n", "if", "s", "==", "nil", "{", "return", "Null", "{", "}", ",", "true", "\n", "}", "\n", "opt", "=", "opt", "||", "opt1", "\n", "// apply quadstore-specific optimizations", "if", "so", ",", "ok", ":=", "qs", ".", "(", "Optimizer", ")", ";", "ok", "&&", "s", "!=", "nil", "{", "var", "opt2", "bool", "\n", "s", ",", "opt2", "=", "s", ".", "Optimize", "(", "so", ")", "\n", "opt", "=", "opt", "||", "opt2", "\n", "}", "\n", "if", "s", "==", "nil", "{", "return", "Null", "{", "}", ",", "true", "\n", "}", "\n", "return", "s", ",", "opt", "\n", "}" ]

[ "Optimize", "applies", "generic", "optimizations", "for", "the", "tree", ".", "If", "quad", "store", "is", "specified", "it", "will", "also", "resolve", "Lookups", "and", "apply", "any", "specific", "optimizations", ".", "Should", "not", "be", "used", "with", "Simplify", "-", "it", "will", "fold", "query", "to", "a", "compact", "form", "again", "." ]

[ "func", "Walk", "(", "s", "Shape", ",", "fnc", "WalkFunc", ")", "{", "if", "s", "==", "nil", "{", "return", "\n", "}", "\n", "if", "!", "fnc", "(", "s", ")", "{", "return", "\n", "}", "\n", "walkReflect", "(", "reflect", ".", "ValueOf", "(", "s", ")", ",", "fnc", ")", "\n", "}" ]

[ "Walk", "calls", "provided", "function", "for", "each", "shape", "in", "the", "tree", "." ]

[ "func", "(", "q", "InternalQuad", ")", "Get", "(", "d", "quad", ".", "Direction", ")", "graph", ".", "Value", "{", "switch", "d", "{", "case", "quad", ".", "Subject", ":", "return", "q", ".", "Subject", "\n", "case", "quad", ".", "Predicate", ":", "return", "q", ".", "Predicate", "\n", "case", "quad", ".", "Object", ":", "return", "q", ".", "Object", "\n", "case", "quad", ".", "Label", ":", "return", "q", ".", "Label", "\n", "default", ":", "return", "nil", "\n", "}", "\n", "}" ]

[ "Get", "returns", "a", "specified", "direction", "of", "the", "quad", "." ]

[ "func", "(", "q", "InternalQuad", ")", "Set", "(", "d", "quad", ".", "Direction", ",", "v", "graph", ".", "Value", ")", "{", "switch", "d", "{", "case", "quad", ".", "Subject", ":", "q", ".", "Subject", "=", "v", "\n", "case", "quad", ".", "Predicate", ":", "q", ".", "Predicate", "=", "v", "\n", "case", "quad", ".", "Object", ":", "q", ".", "Object", "=", "v", "\n", "case", "quad", ".", "Label", ":", "q", ".", "Label", "=", "v", "\n", "default", ":", "panic", "(", "d", ")", "\n", "}", "\n", "}" ]

[ "Set", "assigns", "a", "specified", "direction", "of", "the", "quad", "to", "a", "given", "value", "." ]

[ "func", "IsNull", "(", "s", "Shape", ")", "bool", "{", "_", ",", "ok", ":=", "s", ".", "(", "Null", ")", "\n", "return", "s", "==", "nil", "||", "ok", "\n", "}" ]

[ "IsNull", "safely", "checks", "if", "shape", "represents", "an", "empty", "set", ".", "It", "accounts", "for", "both", "Null", "and", "nil", "." ]

[ "func", "BuildIterator", "(", "qs", "graph", ".", "QuadStore", ",", "s", "Shape", ")", "graph", ".", "Iterator", "{", "qs", "=", "graph", ".", "Unwrap", "(", "qs", ")", "\n", "if", "s", "!=", "nil", "{", "if", "debugShapes", "||", "clog", ".", "V", "(", "2", ")", "{", "clog", ".", "Infof", "(", "\"", "\"", ",", "s", ")", "\n", "}", "\n", "s", ",", "_", "=", "Optimize", "(", "s", ",", "qs", ")", "\n", "if", "debugOptimizer", "||", "clog", ".", "V", "(", "2", ")", "{", "clog", ".", "Infof", "(", "\"", "\"", ",", "s", ")", "\n", "}", "\n", "}", "\n", "if", "IsNull", "(", "s", ")", "{", "return", "iterator", ".", "NewNull", "(", ")", "\n", "}", "\n", "return", "s", ".", "BuildIterator", "(", "qs", ")", "\n", "}" ]

[ "BuildIterator", "optimizes", "the", "shape", "and", "builds", "a", "corresponding", "iterator", "tree", "." ]

[ "func", "(", "s", "QuadFilter", ")", "buildIterator", "(", "qs", "graph", ".", "QuadStore", ")", "graph", ".", "Iterator", "{", "if", "s", ".", "Values", "==", "nil", "{", "return", "iterator", ".", "NewNull", "(", ")", "\n", "}", "else", "if", "v", ",", "ok", ":=", "One", "(", "s", ".", "Values", ")", ";", "ok", "{", "return", "qs", ".", "QuadIterator", "(", "s", ".", "Dir", ",", "v", ")", "\n", "}", "\n", "if", "s", ".", "Dir", "==", "quad", ".", "Any", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "sub", ":=", "s", ".", "Values", ".", "BuildIterator", "(", "qs", ")", "\n", "return", "iterator", ".", "NewLinksTo", "(", "qs", ",", "sub", ",", "s", ".", "Dir", ")", "\n", "}" ]

[ "buildIterator", "is", "not", "exposed", "to", "force", "to", "use", "Quads", "and", "group", "filters", "together", "." ]

[ "func", "One", "(", "s", "Shape", ")", "(", "graph", ".", "Value", ",", "bool", ")", "{", "switch", "s", ":=", "s", ".", "(", "type", ")", "{", "case", "Fixed", ":", "if", "len", "(", "s", ")", "==", "1", "{", "return", "s", "[", "0", "]", ",", "true", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "false", "\n", "}" ]

[ "One", "checks", "if", "Shape", "represents", "a", "single", "fixed", "value", "and", "returns", "it", "." ]

[ "func", "NewWriter", "(", "w", "io", ".", "Writer", ",", "opts", "*", "Options", ")", "*", "Writer", "{", "// Write file magic and version", "buf", ":=", "make", "(", "[", "]", "byte", ",", "8", ")", "\n", "copy", "(", "buf", "[", ":", "4", "]", ",", "magic", "[", ":", "]", ")", "\n", "binary", ".", "LittleEndian", ".", "PutUint32", "(", "buf", "[", "4", ":", "]", ",", "currentVersion", ")", "\n", "if", "_", ",", "err", ":=", "w", ".", "Write", "(", "buf", ")", ";", "err", "!=", "nil", "{", "return", "&", "Writer", "{", "err", ":", "err", "}", "\n", "}", "\n", "pw", ":=", "pio", ".", "NewWriter", "(", "w", ")", "\n", "if", "opts", "==", "nil", "{", "opts", "=", "&", "Options", "{", "}", "\n", "}", "\n", "// Write options header", "_", ",", "err", ":=", "pw", ".", "WriteMsg", "(", "&", "Header", "{", "Full", ":", "opts", ".", "Full", ",", "NotStrict", ":", "!", "opts", ".", "Strict", ",", "}", ")", "\n", "return", "&", "Writer", "{", "pw", ":", "pw", ",", "err", ":", "err", ",", "opts", ":", "*", "opts", "}", "\n", "}" ]

[ "NewWriter", "creates", "protobuf", "quads", "encoder", "." ]

[ "func", "NewReader", "(", "r", "io", ".", "Reader", ",", "maxSize", "int", ")", "*", "Reader", "{", "if", "maxSize", "<=", "0", "{", "maxSize", "=", "DefaultMaxSize", "\n", "}", "\n", "qr", ":=", "&", "Reader", "{", "}", "\n", "buf", ":=", "make", "(", "[", "]", "byte", ",", "8", ")", "\n", "if", "_", ",", "err", ":=", "io", ".", "ReadFull", "(", "r", ",", "buf", ")", ";", "err", "!=", "nil", "{", "qr", ".", "err", "=", "err", "\n", "return", "qr", "\n", "}", "else", "if", "bytes", ".", "Compare", "(", "magic", "[", ":", "]", ",", "buf", "[", ":", "4", "]", ")", "!=", "0", "{", "qr", ".", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "return", "qr", "\n", "}", "\n", "vers", ":=", "binary", ".", "LittleEndian", ".", "Uint32", "(", "buf", "[", "4", ":", "]", ")", "\n", "if", "vers", "!=", "currentVersion", "{", "qr", ".", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "vers", ")", "\n", "return", "qr", "\n", "}", "\n\n", "qr", ".", "pr", "=", "pio", ".", "NewReader", "(", "r", ",", "maxSize", ")", "\n", "var", "h", "Header", "\n", "if", "err", ":=", "qr", ".", "pr", ".", "ReadMsg", "(", "&", "h", ")", ";", "err", "!=", "nil", "{", "qr", ".", "err", "=", "err", "\n", "}", "\n", "qr", ".", "opts", "=", "Options", "{", "Full", ":", "h", ".", "Full", ",", "Strict", ":", "!", "h", ".", "NotStrict", ",", "}", "\n", "return", "qr", "\n", "}" ]

[ "NewReader", "creates", "protobuf", "quads", "decoder", ".", "MaxSize", "argument", "limits", "maximal", "size", "of", "the", "buffer", "used", "to", "read", "quads", "." ]

[ "func", "KeyFrom", "(", "fields", "[", "]", "string", ",", "doc", "Document", ")", "Key", "{", "key", ":=", "make", "(", "Key", ",", "0", ",", "len", "(", "fields", ")", ")", "\n", "for", "_", ",", "f", ":=", "range", "fields", "{", "if", "s", ",", "ok", ":=", "doc", "[", "f", "]", ".", "(", "String", ")", ";", "ok", "{", "key", "=", "append", "(", "key", ",", "string", "(", "s", ")", ")", "\n", "}", "\n", "}", "\n", "return", "key", "\n", "}" ]

[ "KeyFrom", "extracts", "a", "set", "of", "fields", "as", "a", "Key", "from", "Document", "." ]

[ "func", "BatchInsert", "(", "db", "Database", ",", "col", "string", ")", "DocWriter", "{", "if", "bi", ",", "ok", ":=", "db", ".", "(", "BatchInserter", ")", ";", "ok", "{", "return", "bi", ".", "BatchInsert", "(", "col", ")", "\n", "}", "\n", "return", "&", "seqInsert", "{", "db", ":", "db", ",", "col", ":", "col", "}", "\n", "}" ]

[ "BatchInsert", "returns", "a", "streaming", "writer", "for", "database", "or", "emulates", "it", "if", "database", "has", "no", "support", "for", "batch", "inserts", "." ]

[ "func", "Load", "(", "qw", "graph", ".", "QuadWriter", ",", "batch", "int", ",", "path", ",", "typ", "string", ")", "error", "{", "return", "DecompressAndLoad", "(", "qw", ",", "batch", ",", "path", ",", "typ", ",", "nil", ")", "\n", "}" ]

[ "Load", "loads", "a", "graph", "from", "the", "given", "path", "and", "write", "it", "to", "qw", ".", "See", "DecompressAndLoad", "for", "more", "information", "." ]

[ "func", "DecompressAndLoad", "(", "qw", "graph", ".", "QuadWriter", ",", "batch", "int", ",", "path", ",", "typ", "string", ",", "writerFunc", "func", "(", "graph", ".", "QuadWriter", ")", "graph", ".", "BatchWriter", ")", "error", "{", "if", "path", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n", "qr", ",", "err", ":=", "QuadReaderFor", "(", "path", ",", "typ", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "qr", ".", "Close", "(", ")", "\n\n", "if", "writerFunc", "==", "nil", "{", "writerFunc", "=", "graph", ".", "NewWriter", "\n", "}", "\n", "dest", ":=", "writerFunc", "(", "qw", ")", "\n\n", "_", ",", "err", "=", "quad", ".", "CopyBatch", "(", "&", "batchLogger", "{", "BatchWriter", ":", "dest", "}", ",", "qr", ",", "batch", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "dest", ".", "Close", "(", ")", "\n", "}" ]

[ "DecompressAndLoad", "will", "load", "or", "fetch", "a", "graph", "from", "the", "given", "path", "decompress", "it", "and", "then", "call", "the", "given", "load", "function", "to", "process", "the", "decompressed", "graph", ".", "If", "no", "loadFn", "is", "provided", "db", ".", "Load", "is", "called", "." ]

[ "func", "NewSession", "(", "qs", "graph", ".", "QuadStore", ",", "lang", "string", ")", "Session", "{", "if", "l", ":=", "languages", "[", "lang", "]", ";", "l", ".", "Session", "!=", "nil", "{", "return", "l", ".", "Session", "(", "qs", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "NewSession", "creates", "a", "new", "session", "for", "specified", "query", "language", ".", "It", "returns", "nil", "if", "language", "was", "not", "registered", "." ]