Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "a", "*", "AIP1640Driver", ")", "DrawPixel", "(", "x", ",", "y", "byte", ",", "enabled", "bool", ")", "{", "if", "x", ">=", "8", "||", "y", ">=", "8", "{", "return", "\n", "}", "\n", "y", "=", "7", "-", "y", "\n", "if", "enabled", "{", "a", ".", "buffer", "[", "y", "]", "|=", "1", "<<", "x", "\n", "}", "else", "{", "a", ".", "buffer", "[", "y", "]", "&^=", "1", "<<", "x", "\n", "}", "\n", "}" ]

[ "DrawPixel", "turns", "on", "or", "off", "a", "specific", "in", "the", "buffer" ]

[ "func", "(", "a", "*", "AIP1640Driver", ")", "DrawRow", "(", "row", ",", "data", "byte", ")", "{", "if", "row", ">=", "8", "{", "return", "\n", "}", "\n", "a", ".", "buffer", "[", "7", "-", "row", "]", "=", "data", "\n", "}" ]

[ "DrawRow", "sets", "any", "given", "row", "of", "LEDs", "in", "the", "buffer" ]

[ "func", "(", "a", "*", "AIP1640Driver", ")", "DrawMatrix", "(", "data", "[", "8", "]", "byte", ")", "{", "for", "i", ":=", "0", ";", "i", "<", "8", ";", "i", "++", "{", "a", ".", "buffer", "[", "7", "-", "i", "]", "=", "data", "[", "i", "]", "\n", "}", "\n", "}" ]

[ "DrawMatrix", "sets", "the", "whole", "buffer" ]

[ "func", "(", "a", "*", "AIP1640Driver", ")", "sendCommand", "(", "cmd", "byte", ")", "{", "a", ".", "pinData", ".", "Off", "(", ")", "\n", "a", ".", "send", "(", "cmd", ")", "\n", "a", ".", "pinData", ".", "On", "(", ")", "\n", "}" ]

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

[ "func", "(", "a", "*", "AIP1640Driver", ")", "sendData", "(", "address", "byte", ",", "data", "byte", ")", "{", "a", ".", "sendCommand", "(", "AIP1640DataCmd", "|", "AIP1640FixedAddr", ")", "\n", "a", ".", "pinData", ".", "Off", "(", ")", "\n", "a", ".", "send", "(", "AIP1640AddrCmd", "|", "address", ")", "\n", "a", ".", "send", "(", "data", ")", "\n", "a", ".", "pinData", ".", "On", "(", ")", "\n", "}" ]

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

[ "func", "NewGenericAccessDriver", "(", "a", "BLEConnector", ")", "*", "GenericAccessDriver", "{", "n", ":=", "&", "GenericAccessDriver", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "connection", ":", "a", ",", "Eventer", ":", "gobot", ".", "NewEventer", "(", ")", ",", "}", "\n\n", "return", "n", "\n", "}" ]

[ "NewGenericAccessDriver", "creates", "a", "GenericAccessDriver" ]

[ "func", "(", "b", "*", "GenericAccessDriver", ")", "GetDeviceName", "(", ")", "string", "{", "c", ",", "_", ":=", "b", ".", "adaptor", "(", ")", ".", "ReadCharacteristic", "(", "\"", "\"", ")", "\n", "buf", ":=", "bytes", ".", "NewBuffer", "(", "c", ")", "\n", "val", ":=", "buf", ".", "String", "(", ")", "\n", "return", "val", "\n", "}" ]

[ "GetDeviceName", "returns", "the", "device", "name", "for", "the", "BLE", "Peripheral" ]

[ "func", "(", "b", "*", "GenericAccessDriver", ")", "GetAppearance", "(", ")", "string", "{", "c", ",", "_", ":=", "b", ".", "adaptor", "(", ")", ".", "ReadCharacteristic", "(", "\"", "\"", ")", "\n", "buf", ":=", "bytes", ".", "NewBuffer", "(", "c", ")", "\n\n", "var", "val", "uint16", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "val", ")", "\n", "return", "appearances", "[", "val", "]", "\n", "}" ]

[ "GetAppearance", "returns", "the", "appearance", "string", "for", "the", "BLE", "Peripheral" ]

[ "func", "(", "l", "*", "RelayDriver", ")", "Toggle", "(", ")", "(", "err", "error", ")", "{", "if", "l", ".", "State", "(", ")", "{", "err", "=", "l", ".", "Off", "(", ")", "\n", "}", "else", "{", "err", "=", "l", ".", "On", "(", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Toggle", "sets", "the", "relay", "to", "the", "opposite", "of", "it", "s", "current", "state" ]

[ "func", "NewDriver", "(", "port", "string", ")", "*", "Driver", "{", "d", ":=", "&", "Driver", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "reqAddr", ":", "\"", "\"", ",", "respPort", ":", "port", ",", "videoPort", ":", "\"", "\"", ",", "Eventer", ":", "gobot", ".", "NewEventer", "(", ")", ",", "}", "\n\n", "d", ".", "AddEvent", "(", "ConnectedEvent", ")", "\n", "d", ".", "AddEvent", "(", "FlightDataEvent", ")", "\n", "d", ".", "AddEvent", "(", "TakeoffEvent", ")", "\n", "d", ".", "AddEvent", "(", "LandingEvent", ")", "\n", "d", ".", "AddEvent", "(", "PalmLandingEvent", ")", "\n", "d", ".", "AddEvent", "(", "BounceEvent", ")", "\n", "d", ".", "AddEvent", "(", "FlipEvent", ")", "\n", "d", ".", "AddEvent", "(", "TimeEvent", ")", "\n", "d", ".", "AddEvent", "(", "LogEvent", ")", "\n", "d", ".", "AddEvent", "(", "WifiDataEvent", ")", "\n", "d", ".", "AddEvent", "(", "LightStrengthEvent", ")", "\n", "d", ".", "AddEvent", "(", "SetExposureEvent", ")", "\n", "d", ".", "AddEvent", "(", "VideoFrameEvent", ")", "\n", "d", ".", "AddEvent", "(", "SetVideoEncoderRateEvent", ")", "\n\n", "return", "d", "\n", "}" ]

[ "NewDriver", "creates", "a", "driver", "for", "the", "Tello", "drone", ".", "Pass", "in", "the", "UDP", "port", "to", "use", "for", "the", "responses", "from", "the", "drone", "." ]

[ "func", "(", "d", "*", "Driver", ")", "TakeOff", "(", ")", "(", "err", "error", ")", "{", "buf", ",", "_", ":=", "d", ".", "createPacket", "(", "takeoffCommand", ",", "0x68", ",", "0", ")", "\n", "d", ".", "seq", "++", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "d", ".", "seq", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "CalculateCRC16", "(", "buf", ".", "Bytes", "(", ")", ")", ")", "\n\n", "_", ",", "err", "=", "d", ".", "cmdConn", ".", "Write", "(", "buf", ".", "Bytes", "(", ")", ")", "\n", "return", "\n", "}" ]

[ "TakeOff", "tells", "drones", "to", "liftoff", "and", "start", "flying", "." ]

[ "func", "(", "d", "*", "Driver", ")", "ThrowTakeOff", "(", ")", "(", "err", "error", ")", "{", "buf", ",", "_", ":=", "d", ".", "createPacket", "(", "throwtakeoffCommand", ",", "0x48", ",", "0", ")", "\n", "d", ".", "seq", "++", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "d", ".", "seq", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "CalculateCRC16", "(", "buf", ".", "Bytes", "(", ")", ")", ")", "\n\n", "_", ",", "err", "=", "d", ".", "cmdConn", ".", "Write", "(", "buf", ".", "Bytes", "(", ")", ")", "\n", "return", "\n", "}" ]

[ "Throw", "&", "Go", "support" ]

[ "func", "(", "d", "*", "Driver", ")", "PalmLand", "(", ")", "(", "err", "error", ")", "{", "buf", ",", "_", ":=", "d", ".", "createPacket", "(", "palmLandCommand", ",", "0x68", ",", "1", ")", "\n", "d", ".", "seq", "++", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "d", ".", "seq", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "byte", "(", "0x00", ")", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "CalculateCRC16", "(", "buf", ".", "Bytes", "(", ")", ")", ")", "\n\n", "_", ",", "err", "=", "d", ".", "cmdConn", ".", "Write", "(", "buf", ".", "Bytes", "(", ")", ")", "\n", "return", "\n", "}" ]

[ "PalmLand", "tells", "drone", "to", "come", "in", "for", "a", "hand", "landing", "." ]

[ "func", "(", "d", "*", "Driver", ")", "SetExposure", "(", "level", "int", ")", "(", "err", "error", ")", "{", "if", "level", "<", "0", "||", "level", ">", "2", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "buf", ",", "_", ":=", "d", ".", "createPacket", "(", "exposureCommand", ",", "0x48", ",", "1", ")", "\n", "d", ".", "seq", "++", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "d", ".", "seq", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "byte", "(", "level", ")", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "CalculateCRC16", "(", "buf", ".", "Bytes", "(", ")", ")", ")", "\n\n", "_", ",", "err", "=", "d", ".", "cmdConn", ".", "Write", "(", "buf", ".", "Bytes", "(", ")", ")", "\n", "return", "\n", "}" ]

[ "SetExposure", "sets", "the", "drone", "camera", "exposure", "level", ".", "Valid", "levels", "are", "0", "1", "and", "2", "." ]

[ "func", "(", "d", "*", "Driver", ")", "SetVideoEncoderRate", "(", "rate", "VideoBitRate", ")", "(", "err", "error", ")", "{", "buf", ",", "_", ":=", "d", ".", "createPacket", "(", "videoEncoderRateCommand", ",", "0x68", ",", "1", ")", "\n", "d", ".", "seq", "++", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "d", ".", "seq", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "byte", "(", "rate", ")", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "CalculateCRC16", "(", "buf", ".", "Bytes", "(", ")", ")", ")", "\n\n", "_", ",", "err", "=", "d", ".", "cmdConn", ".", "Write", "(", "buf", ".", "Bytes", "(", ")", ")", "\n", "return", "\n", "}" ]

[ "SetVideoEncoderRate", "sets", "the", "drone", "video", "encoder", "rate", "." ]

[ "func", "(", "d", "*", "Driver", ")", "SetFastMode", "(", ")", "error", "{", "d", ".", "cmdMutex", ".", "Lock", "(", ")", "\n", "defer", "d", ".", "cmdMutex", ".", "Unlock", "(", ")", "\n\n", "d", ".", "throttle", "=", "1", "\n", "return", "nil", "\n", "}" ]

[ "SetFastMode", "sets", "the", "drone", "throttle", "to", "1", "." ]

[ "func", "(", "d", "*", "Driver", ")", "Rate", "(", ")", "(", "err", "error", ")", "{", "buf", ",", "_", ":=", "d", ".", "createPacket", "(", "videoRateQuery", ",", "0x48", ",", "0", ")", "\n", "d", ".", "seq", "++", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "d", ".", "seq", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "CalculateCRC16", "(", "buf", ".", "Bytes", "(", ")", ")", ")", "\n\n", "_", ",", "err", "=", "d", ".", "cmdConn", ".", "Write", "(", "buf", ".", "Bytes", "(", ")", ")", "\n", "return", "\n", "}" ]

[ "Rate", "queries", "the", "current", "video", "bit", "rate", "." ]

[ "func", "(", "d", "*", "Driver", ")", "Hover", "(", ")", "{", "d", ".", "cmdMutex", ".", "Lock", "(", ")", "\n", "defer", "d", ".", "cmdMutex", ".", "Unlock", "(", ")", "\n\n", "d", ".", "rx", "=", "float32", "(", "0", ")", "\n", "d", ".", "ry", "=", "float32", "(", "0", ")", "\n", "d", ".", "lx", "=", "float32", "(", "0", ")", "\n", "d", ".", "ly", "=", "float32", "(", "0", ")", "\n", "}" ]

[ "Hover", "tells", "the", "drone", "to", "stop", "moving", "on", "the", "X", "Y", "and", "Z", "axes", "and", "stay", "in", "place" ]

[ "func", "(", "d", "*", "Driver", ")", "CeaseRotation", "(", ")", "{", "d", ".", "cmdMutex", ".", "Lock", "(", ")", "\n", "defer", "d", ".", "cmdMutex", ".", "Unlock", "(", ")", "\n\n", "d", ".", "lx", "=", "float32", "(", "0", ")", "\n", "}" ]

[ "CeaseRotation", "stops", "any", "rotational", "motion" ]

[ "func", "(", "d", "*", "Driver", ")", "Flip", "(", "direction", "FlipType", ")", "(", "err", "error", ")", "{", "buf", ",", "_", ":=", "d", ".", "createPacket", "(", "flipCommand", ",", "0x70", ",", "1", ")", "\n", "d", ".", "seq", "++", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "d", ".", "seq", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "byte", "(", "direction", ")", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "CalculateCRC16", "(", "buf", ".", "Bytes", "(", ")", ")", ")", "\n\n", "_", ",", "err", "=", "d", ".", "cmdConn", ".", "Write", "(", "buf", ".", "Bytes", "(", ")", ")", "\n", "return", "\n", "}" ]

[ "Flip", "tells", "drone", "to", "flip" ]

[ "func", "(", "d", "*", "Driver", ")", "SendStickCommand", "(", ")", "(", "err", "error", ")", "{", "d", ".", "cmdMutex", ".", "Lock", "(", ")", "\n", "defer", "d", ".", "cmdMutex", ".", "Unlock", "(", ")", "\n\n", "buf", ",", "_", ":=", "d", ".", "createPacket", "(", "stickCommand", ",", "0x60", ",", "11", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "int16", "(", "0x00", ")", ")", "// seq = 0", "\n\n", "// RightX center=1024 left =364 right =-364", "axis1", ":=", "int16", "(", "660.0", "*", "d", ".", "rx", "+", "1024.0", ")", "\n\n", "// RightY down =364 up =-364", "axis2", ":=", "int16", "(", "660.0", "*", "d", ".", "ry", "+", "1024.0", ")", "\n\n", "// LeftY down =364 up =-364", "axis3", ":=", "int16", "(", "660.0", "*", "d", ".", "ly", "+", "1024.0", ")", "\n\n", "// LeftX left =364 right =-364", "axis4", ":=", "int16", "(", "660.0", "*", "d", ".", "lx", "+", "1024.0", ")", "\n\n", "// speed control", "axis5", ":=", "int16", "(", "d", ".", "throttle", ")", "\n\n", "packedAxis", ":=", "int64", "(", "axis1", ")", "&", "0x7FF", "|", "int64", "(", "axis2", "&", "0x7FF", ")", "<<", "11", "|", "0x7FF", "&", "int64", "(", "axis3", ")", "<<", "22", "|", "0x7FF", "&", "int64", "(", "axis4", ")", "<<", "33", "|", "int64", "(", "axis5", ")", "<<", "44", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "byte", "(", "0xFF", "&", "packedAxis", ")", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "byte", "(", "packedAxis", ">>", "8", "&", "0xFF", ")", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "byte", "(", "packedAxis", ">>", "16", "&", "0xFF", ")", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "byte", "(", "packedAxis", ">>", "24", "&", "0xFF", ")", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "byte", "(", "packedAxis", ">>", "32", "&", "0xFF", ")", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "byte", "(", "packedAxis", ">>", "40", "&", "0xFF", ")", ")", "\n\n", "now", ":=", "time", ".", "Now", "(", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "byte", "(", "now", ".", "Hour", "(", ")", ")", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "byte", "(", "now", ".", "Minute", "(", ")", ")", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "byte", "(", "now", ".", "Second", "(", ")", ")", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "byte", "(", "now", ".", "UnixNano", "(", ")", "/", "int64", "(", "time", ".", "Millisecond", ")", "&", "0xff", ")", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "byte", "(", "now", ".", "UnixNano", "(", ")", "/", "int64", "(", "time", ".", "Millisecond", ")", ">>", "8", ")", ")", "\n\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "CalculateCRC16", "(", "buf", ".", "Bytes", "(", ")", ")", ")", "\n\n", "_", ",", "err", "=", "d", ".", "cmdConn", ".", "Write", "(", "buf", ".", "Bytes", "(", ")", ")", "\n\n", "return", "\n", "}" ]

[ "SendStickCommand", "sends", "the", "joystick", "command", "packet", "to", "the", "drone", "." ]

[ "func", "(", "d", "*", "Driver", ")", "SendCommand", "(", "cmd", "string", ")", "(", "err", "error", ")", "{", "_", ",", "err", "=", "d", ".", "cmdConn", ".", "Write", "(", "[", "]", "byte", "(", "cmd", ")", ")", "\n", "return", "\n", "}" ]

[ "SendCommand", "is", "used", "to", "send", "a", "text", "command", "such", "as", "the", "initial", "connection", "request", "to", "the", "drone", "." ]

[ "func", "NewJSONRobot", "(", "robot", "*", "Robot", ")", "*", "JSONRobot", "{", "jsonRobot", ":=", "&", "JSONRobot", "{", "Name", ":", "robot", ".", "Name", ",", "Commands", ":", "[", "]", "string", "{", "}", ",", "Connections", ":", "[", "]", "*", "JSONConnection", "{", "}", ",", "Devices", ":", "[", "]", "*", "JSONDevice", "{", "}", ",", "}", "\n\n", "for", "command", ":=", "range", "robot", ".", "Commands", "(", ")", "{", "jsonRobot", ".", "Commands", "=", "append", "(", "jsonRobot", ".", "Commands", ",", "command", ")", "\n", "}", "\n\n", "robot", ".", "Devices", "(", ")", ".", "Each", "(", "func", "(", "device", "Device", ")", "{", "jsonDevice", ":=", "NewJSONDevice", "(", "device", ")", "\n", "jsonRobot", ".", "Connections", "=", "append", "(", "jsonRobot", ".", "Connections", ",", "NewJSONConnection", "(", "robot", ".", "Connection", "(", "jsonDevice", ".", "Connection", ")", ")", ")", "\n", "jsonRobot", ".", "Devices", "=", "append", "(", "jsonRobot", ".", "Devices", ",", "jsonDevice", ")", "\n", "}", ")", "\n", "return", "jsonRobot", "\n", "}" ]

[ "NewJSONRobot", "returns", "a", "JSONRobot", "given", "a", "Robot", "." ]

[ "func", "(", "r", "*", "Robots", ")", "Start", "(", "args", "...", "interface", "{", "}", ")", "(", "err", "error", ")", "{", "autoRun", ":=", "true", "\n", "if", "args", "[", "0", "]", "!=", "nil", "{", "autoRun", "=", "args", "[", "0", "]", ".", "(", "bool", ")", "\n", "}", "\n", "for", "_", ",", "robot", ":=", "range", "*", "r", "{", "if", "rerr", ":=", "robot", ".", "Start", "(", "autoRun", ")", ";", "rerr", "!=", "nil", "{", "err", "=", "multierror", ".", "Append", "(", "err", ",", "rerr", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Start", "calls", "the", "Start", "method", "of", "each", "Robot", "in", "the", "collection" ]

[ "func", "(", "r", "*", "Robots", ")", "Stop", "(", ")", "(", "err", "error", ")", "{", "for", "_", ",", "robot", ":=", "range", "*", "r", "{", "if", "rerr", ":=", "robot", ".", "Stop", "(", ")", ";", "rerr", "!=", "nil", "{", "err", "=", "multierror", ".", "Append", "(", "err", ",", "rerr", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Stop", "calls", "the", "Stop", "method", "of", "each", "Robot", "in", "the", "collection" ]

[ "func", "(", "r", "*", "Robots", ")", "Each", "(", "f", "func", "(", "*", "Robot", ")", ")", "{", "for", "_", ",", "robot", ":=", "range", "*", "r", "{", "f", "(", "robot", ")", "\n", "}", "\n", "}" ]

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

[ "func", "(", "r", "*", "Robot", ")", "Start", "(", "args", "...", "interface", "{", "}", ")", "(", "err", "error", ")", "{", "if", "len", "(", "args", ")", ">", "0", "&&", "args", "[", "0", "]", "!=", "nil", "{", "r", ".", "AutoRun", "=", "args", "[", "0", "]", ".", "(", "bool", ")", "\n", "}", "\n", "log", ".", "Println", "(", "\"", "\"", ",", "r", ".", "Name", ",", "\"", "\"", ")", "\n", "if", "cerr", ":=", "r", ".", "Connections", "(", ")", ".", "Start", "(", ")", ";", "cerr", "!=", "nil", "{", "err", "=", "multierror", ".", "Append", "(", "err", ",", "cerr", ")", "\n", "log", ".", "Println", "(", "err", ")", "\n", "return", "\n", "}", "\n", "if", "derr", ":=", "r", ".", "Devices", "(", ")", ".", "Start", "(", ")", ";", "derr", "!=", "nil", "{", "err", "=", "multierror", ".", "Append", "(", "err", ",", "derr", ")", "\n", "log", ".", "Println", "(", "err", ")", "\n", "return", "\n", "}", "\n", "if", "r", ".", "Work", "==", "nil", "{", "r", ".", "Work", "=", "func", "(", ")", "{", "}", "\n", "}", "\n\n", "log", ".", "Println", "(", "\"", "\"", ")", "\n", "go", "func", "(", ")", "{", "r", ".", "Work", "(", ")", "\n", "<-", "r", ".", "done", "\n", "}", "(", ")", "\n\n", "r", ".", "running", ".", "Store", "(", "true", ")", "\n", "if", "r", ".", "AutoRun", "{", "c", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "r", ".", "trap", "(", "c", ")", "\n\n", "// waiting for interrupt coming on the channel", "<-", "c", "\n\n", "// Stop calls the Stop method on itself, if we are \"auto-running\".", "r", ".", "Stop", "(", ")", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "Start", "a", "Robot", "s", "Connections", "Devices", "and", "work", "." ]

[ "func", "(", "r", "*", "Robot", ")", "Stop", "(", ")", "error", "{", "var", "result", "error", "\n", "log", ".", "Println", "(", "\"", "\"", ",", "r", ".", "Name", ",", "\"", "\"", ")", "\n", "err", ":=", "r", ".", "Devices", "(", ")", ".", "Halt", "(", ")", "\n", "if", "err", "!=", "nil", "{", "result", "=", "multierror", ".", "Append", "(", "result", ",", "err", ")", "\n", "}", "\n", "err", "=", "r", ".", "Connections", "(", ")", ".", "Finalize", "(", ")", "\n", "if", "err", "!=", "nil", "{", "result", "=", "multierror", ".", "Append", "(", "result", ",", "err", ")", "\n", "}", "\n\n", "r", ".", "done", "<-", "true", "\n", "r", ".", "running", ".", "Store", "(", "false", ")", "\n", "return", "result", "\n", "}" ]

[ "Stop", "stops", "a", "Robot", "s", "connections", "and", "Devices" ]

[ "func", "(", "r", "*", "Robot", ")", "AddDevice", "(", "d", "Device", ")", "Device", "{", "*", "r", ".", "devices", "=", "append", "(", "*", "r", ".", "Devices", "(", ")", ",", "d", ")", "\n", "return", "d", "\n", "}" ]

[ "AddDevice", "adds", "a", "new", "Device", "to", "the", "robots", "collection", "of", "devices", ".", "Returns", "the", "added", "device", "." ]

[ "func", "(", "r", "*", "Robot", ")", "Device", "(", "name", "string", ")", "Device", "{", "if", "r", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "for", "_", ",", "device", ":=", "range", "*", "r", ".", "devices", "{", "if", "device", ".", "Name", "(", ")", "==", "name", "{", "return", "device", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Device", "returns", "a", "device", "given", "a", "name", ".", "Returns", "nil", "if", "the", "Device", "does", "not", "exist", "." ]

[ "func", "(", "r", "*", "Robot", ")", "AddConnection", "(", "c", "Connection", ")", "Connection", "{", "*", "r", ".", "connections", "=", "append", "(", "*", "r", ".", "Connections", "(", ")", ",", "c", ")", "\n", "return", "c", "\n", "}" ]

[ "AddConnection", "adds", "a", "new", "connection", "to", "the", "robots", "collection", "of", "connections", ".", "Returns", "the", "added", "connection", "." ]

[ "func", "(", "r", "*", "Robot", ")", "Connection", "(", "name", "string", ")", "Connection", "{", "if", "r", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "for", "_", ",", "connection", ":=", "range", "*", "r", ".", "connections", "{", "if", "connection", ".", "Name", "(", ")", "==", "name", "{", "return", "connection", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Connection", "returns", "a", "connection", "given", "a", "name", ".", "Returns", "nil", "if", "the", "Connection", "does", "not", "exist", "." ]

[ "func", "(", "d", "*", "L3GD20HDriver", ")", "XYZ", "(", ")", "(", "x", "float32", ",", "y", "float32", ",", "z", "float32", ",", "err", "error", ")", "{", "if", "_", ",", "err", "=", "d", ".", "connection", ".", "Write", "(", "[", "]", "byte", "{", "l3gd20hRegisterOutXLSB", "}", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "0", ",", "err", "\n", "}", "\n", "measurements", ":=", "make", "(", "[", "]", "byte", ",", "6", ")", "\n", "if", "_", ",", "err", "=", "d", ".", "connection", ".", "Read", "(", "measurements", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "0", ",", "err", "\n", "}", "\n\n", "var", "rawX", "int16", "\n", "var", "rawY", "int16", "\n", "var", "rawZ", "int16", "\n", "buf", ":=", "bytes", ".", "NewBuffer", "(", "measurements", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "rawX", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "rawY", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "rawZ", ")", "\n\n", "// Sensitivity values from the mechanical characteristics in the datasheet.", "sensitivity", ":=", "d", ".", "getSensitivity", "(", ")", "\n\n", "return", "float32", "(", "rawX", ")", "*", "sensitivity", ",", "float32", "(", "rawY", ")", "*", "sensitivity", ",", "float32", "(", "rawZ", ")", "*", "sensitivity", ",", "nil", "\n", "}" ]

[ "XYZ", "returns", "the", "current", "change", "in", "degrees", "per", "second", "for", "the", "3", "axis", "." ]

[ "func", "(", "d", "*", "DirectPinDriver", ")", "Off", "(", ")", "(", "err", "error", ")", "{", "if", "writer", ",", "ok", ":=", "d", ".", "Connection", "(", ")", ".", "(", "DigitalWriter", ")", ";", "ok", "{", "return", "writer", ".", "DigitalWrite", "(", "d", ".", "Pin", "(", ")", ",", "byte", "(", "0", ")", ")", "\n", "}", "\n", "err", "=", "ErrDigitalWriteUnsupported", "\n", "return", "\n", "}" ]

[ "Turn", "Off", "pin" ]

[ "func", "(", "d", "*", "DirectPinDriver", ")", "DigitalRead", "(", ")", "(", "val", "int", ",", "err", "error", ")", "{", "if", "reader", ",", "ok", ":=", "d", ".", "Connection", "(", ")", ".", "(", "DigitalReader", ")", ";", "ok", "{", "return", "reader", ".", "DigitalRead", "(", "d", ".", "Pin", "(", ")", ")", "\n", "}", "\n", "err", "=", "ErrDigitalReadUnsupported", "\n", "return", "\n", "}" ]

[ "DigitalRead", "returns", "the", "current", "digital", "state", "of", "the", "pin" ]

[ "func", "(", "d", "*", "DirectPinDriver", ")", "ServoWrite", "(", "level", "byte", ")", "(", "err", "error", ")", "{", "if", "writer", ",", "ok", ":=", "d", ".", "Connection", "(", ")", ".", "(", "ServoWriter", ")", ";", "ok", "{", "return", "writer", ".", "ServoWrite", "(", "d", ".", "Pin", "(", ")", ",", "level", ")", "\n", "}", "\n", "err", "=", "ErrServoWriteUnsupported", "\n", "return", "\n", "}" ]

[ "ServoWrite", "writes", "value", "to", "the", "specified", "pin" ]

[ "func", "NewJSONConnection", "(", "connection", "Connection", ")", "*", "JSONConnection", "{", "return", "&", "JSONConnection", "{", "Name", ":", "connection", ".", "Name", "(", ")", ",", "Adaptor", ":", "reflect", ".", "TypeOf", "(", "connection", ")", ".", "String", "(", ")", ",", "}", "\n", "}" ]

[ "NewJSONConnection", "returns", "a", "JSONConnection", "given", "a", "Connection", "." ]

[ "func", "(", "c", "*", "Connections", ")", "Each", "(", "f", "func", "(", "Connection", ")", ")", "{", "for", "_", ",", "connection", ":=", "range", "*", "c", "{", "f", "(", "connection", ")", "\n", "}", "\n", "}" ]

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

[ "func", "(", "c", "*", "Connections", ")", "Start", "(", ")", "(", "err", "error", ")", "{", "log", ".", "Println", "(", "\"", "\"", ")", "\n", "for", "_", ",", "connection", ":=", "range", "*", "c", "{", "info", ":=", "\"", "\"", "+", "connection", ".", "Name", "(", ")", "\n\n", "if", "porter", ",", "ok", ":=", "connection", ".", "(", "Porter", ")", ";", "ok", "{", "info", "=", "info", "+", "\"", "\"", "+", "porter", ".", "Port", "(", ")", "\n", "}", "\n\n", "log", ".", "Println", "(", "info", "+", "\"", "\"", ")", "\n\n", "if", "cerr", ":=", "connection", ".", "Connect", "(", ")", ";", "cerr", "!=", "nil", "{", "err", "=", "multierror", ".", "Append", "(", "err", ",", "cerr", ")", "\n", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "Start", "calls", "Connect", "on", "each", "Connection", "in", "c" ]

[ "func", "(", "c", "*", "Connections", ")", "Finalize", "(", ")", "(", "err", "error", ")", "{", "for", "_", ",", "connection", ":=", "range", "*", "c", "{", "if", "cerr", ":=", "connection", ".", "Finalize", "(", ")", ";", "cerr", "!=", "nil", "{", "err", "=", "multierror", ".", "Append", "(", "err", ",", "cerr", ")", "\n", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "Finalize", "calls", "Finalize", "on", "each", "Connection", "in", "c" ]

[ "func", "DefaultCollisionConfig", "(", ")", "sphero", ".", "CollisionConfig", "{", "return", "sphero", ".", "CollisionConfig", "{", "Method", ":", "0x01", ",", "Xt", ":", "0x20", ",", "Yt", ":", "0x20", ",", "Xs", ":", "0x20", ",", "Ys", ":", "0x20", ",", "Dead", ":", "0x01", ",", "}", "\n", "}" ]

[ "DefaultCollisionConfig", "returns", "a", "CollisionConfig", "with", "sensible", "collision", "defaults" ]

[ "func", "NewAdaptor", "(", ")", "*", "Adaptor", "{", "c", ":=", "&", "Adaptor", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "mutex", ":", "&", "sync", ".", "Mutex", "{", "}", ",", "}", "\n\n", "c", ".", "setPins", "(", ")", "\n", "return", "c", "\n", "}" ]

[ "NewAdaptor", "creates", "a", "Tinkerboard", "Adaptor" ]

[ "func", "NewGroveBuzzerDriver", "(", "a", "DigitalWriter", ",", "pin", "string", ")", "*", "GroveBuzzerDriver", "{", "return", "&", "GroveBuzzerDriver", "{", "BuzzerDriver", ":", "NewBuzzerDriver", "(", "a", ",", "pin", ")", ",", "}", "\n", "}" ]

[ "NewGroveBuzzerDriver", "return", "a", "new", "GroveBuzzerDriver", "given", "a", "DigitalWriter", "and", "pin", "." ]

[ "func", "NewIOPinDriver", "(", "a", "ble", ".", "BLEConnector", ")", "*", "IOPinDriver", "{", "n", ":=", "&", "IOPinDriver", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "connection", ":", "a", ",", "Eventer", ":", "gobot", ".", "NewEventer", "(", ")", ",", "}", "\n\n", "return", "n", "\n", "}" ]

[ "NewIOPinDriver", "creates", "a", "Microbit", "IOPinDriver" ]

[ "func", "(", "b", "*", "IOPinDriver", ")", "ReadAllPinData", "(", ")", "(", "pins", "[", "]", "PinData", ")", "{", "c", ",", "_", ":=", "b", ".", "adaptor", "(", ")", ".", "ReadCharacteristic", "(", "pinDataCharacteristic", ")", "\n", "buf", ":=", "bytes", ".", "NewBuffer", "(", "c", ")", "\n", "pinsData", ":=", "make", "(", "[", "]", "PinData", ",", "buf", ".", "Len", "(", ")", "/", "2", ")", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "buf", ".", "Len", "(", ")", "/", "2", ";", "i", "++", "{", "pinData", ":=", "PinData", "{", "}", "\n", "pinData", ".", "pin", ",", "_", "=", "buf", ".", "ReadByte", "(", ")", "\n", "pinData", ".", "value", ",", "_", "=", "buf", ".", "ReadByte", "(", ")", "\n", "pinsData", "[", "i", "]", "=", "pinData", "\n", "}", "\n\n", "return", "pinsData", "\n", "}" ]

[ "ReadAllPinData", "reads", "and", "returns", "the", "pin", "data", "for", "all", "pins" ]

[ "func", "(", "b", "*", "IOPinDriver", ")", "WritePinData", "(", "pin", "string", ",", "data", "byte", ")", "(", "err", "error", ")", "{", "i", ",", "err", ":=", "strconv", ".", "Atoi", "(", "pin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "buf", ":=", "[", "]", "byte", "{", "byte", "(", "i", ")", ",", "data", "}", "\n", "err", "=", "b", ".", "adaptor", "(", ")", ".", "WriteCharacteristic", "(", "pinDataCharacteristic", ",", "buf", ")", "\n", "return", "err", "\n", "}" ]

[ "WritePinData", "writes", "the", "pin", "data", "for", "a", "single", "pin" ]

[ "func", "(", "b", "*", "IOPinDriver", ")", "ReadPinIOConfig", "(", ")", "(", "config", "int", ",", "err", "error", ")", "{", "c", ",", "e", ":=", "b", ".", "adaptor", "(", ")", ".", "ReadCharacteristic", "(", "pinIOConfigCharacteristic", ")", "\n", "if", "e", "!=", "nil", "{", "return", "0", ",", "e", "\n", "}", "\n\n", "var", "result", "byte", "\n", "for", "i", ":=", "0", ";", "i", "<", "4", ";", "i", "++", "{", "result", "|=", "c", "[", "i", "]", "<<", "uint", "(", "i", ")", "\n", "}", "\n\n", "b", ".", "ioMask", "=", "int", "(", "result", ")", "\n", "return", "int", "(", "result", ")", ",", "nil", "\n", "}" ]

[ "ReadPinIOConfig", "reads", "and", "returns", "the", "pin", "IO", "config", "mask", "for", "all", "pins" ]

[ "func", "(", "b", "*", "IOPinDriver", ")", "DigitalRead", "(", "pin", "string", ")", "(", "val", "int", ",", "err", "error", ")", "{", "p", ",", "err", ":=", "validatedPin", "(", "pin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "b", ".", "ensureDigital", "(", "p", ")", "\n", "b", ".", "ensureInput", "(", "p", ")", "\n\n", "pins", ":=", "b", ".", "ReadAllPinData", "(", ")", "\n", "return", "int", "(", "pins", "[", "p", "]", ".", "value", ")", ",", "nil", "\n", "}" ]

[ "DigitalRead", "reads", "from", "a", "pin" ]

[ "func", "(", "b", "*", "IOPinDriver", ")", "DigitalWrite", "(", "pin", "string", ",", "level", "byte", ")", "(", "err", "error", ")", "{", "p", ",", "err", ":=", "validatedPin", "(", "pin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "b", ".", "ensureDigital", "(", "p", ")", "\n", "b", ".", "ensureOutput", "(", "p", ")", "\n\n", "return", "b", ".", "WritePinData", "(", "pin", ",", "level", ")", "\n", "}" ]

[ "DigitalWrite", "writes", "to", "a", "pin" ]

[ "func", "(", "b", "*", "IOPinDriver", ")", "AnalogRead", "(", "pin", "string", ")", "(", "val", "int", ",", "err", "error", ")", "{", "p", ",", "err", ":=", "validatedPin", "(", "pin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "b", ".", "ensureAnalog", "(", "p", ")", "\n", "b", ".", "ensureInput", "(", "p", ")", "\n\n", "pins", ":=", "b", ".", "ReadAllPinData", "(", ")", "\n", "return", "int", "(", "pins", "[", "p", "]", ".", "value", ")", ",", "nil", "\n", "}" ]

[ "AnalogRead", "reads", "from", "a", "pin" ]

[ "func", "hasBit", "(", "n", "int", ",", "pos", "int", ")", "bool", "{", "val", ":=", "n", "&", "(", "1", "<<", "uint", "(", "pos", ")", ")", "\n", "return", "(", "val", ">", "0", ")", "\n", "}" ]

[ "Test", "if", "the", "bit", "at", "pos", "is", "set", "in", "the", "integer", "n", "." ]

[ "func", "(", "g", "*", "Driver", ")", "Start", "(", ")", "(", "err", "error", ")", "{", "bus", ":=", "g", ".", "GetBusOrDefault", "(", "g", ".", "connector", ".", "GetSpiDefaultBus", "(", ")", ")", "\n", "chip", ":=", "g", ".", "GetChipOrDefault", "(", "g", ".", "connector", ".", "GetSpiDefaultChip", "(", ")", ")", "\n", "mode", ":=", "g", ".", "GetModeOrDefault", "(", "g", ".", "connector", ".", "GetSpiDefaultMode", "(", ")", ")", "\n", "bits", ":=", "g", ".", "GetBitsOrDefault", "(", "g", ".", "connector", ".", "GetSpiDefaultBits", "(", ")", ")", "\n", "maxSpeed", ":=", "g", ".", "GetSpeedOrDefault", "(", "g", ".", "connector", ".", "GetSpiDefaultMaxSpeed", "(", ")", ")", "\n\n", "g", ".", "connection", ",", "err", "=", "g", ".", "connector", ".", "GetSpiConnection", "(", "bus", ",", "chip", ",", "mode", ",", "bits", ",", "maxSpeed", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Start", "initializes", "the", "GoPiGo3" ]

[ "func", "(", "g", "*", "Driver", ")", "GetManufacturerName", "(", ")", "(", "mName", "string", ",", "err", "error", ")", "{", "// read 24 bytes to get manufacturer name", "response", ",", "err", ":=", "g", ".", "readBytes", "(", "goPiGo3Address", ",", "GET_MANUFACTURER", ",", "24", ")", "\n", "if", "err", "!=", "nil", "{", "return", "mName", ",", "err", "\n", "}", "\n", "if", "err", ":=", "g", ".", "responseValid", "(", "response", ")", ";", "err", "!=", "nil", "{", "return", "mName", ",", "err", "\n", "}", "\n", "mf", ":=", "response", "[", "4", ":", "23", "]", "\n", "mf", "=", "bytes", ".", "Trim", "(", "mf", ",", "\"", "\\x00", "\"", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "string", "(", "mf", ")", ")", ",", "nil", "\n", "}" ]

[ "GetManufacturerName", "returns", "the", "manufacturer", "from", "the", "firmware", "." ]

[ "func", "(", "g", "*", "Driver", ")", "GetBoardName", "(", ")", "(", "bName", "string", ",", "err", "error", ")", "{", "// read 24 bytes to get board name", "response", ",", "err", ":=", "g", ".", "readBytes", "(", "goPiGo3Address", ",", "GET_NAME", ",", "24", ")", "\n", "if", "err", "!=", "nil", "{", "return", "bName", ",", "err", "\n", "}", "\n", "if", "err", ":=", "g", ".", "responseValid", "(", "response", ")", ";", "err", "!=", "nil", "{", "return", "bName", ",", "err", "\n", "}", "\n", "mf", ":=", "response", "[", "4", ":", "23", "]", "\n", "mf", "=", "bytes", ".", "Trim", "(", "mf", ",", "\"", "\\x00", "\"", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "string", "(", "mf", ")", ")", ",", "nil", "\n", "}" ]

[ "GetBoardName", "returns", "the", "board", "name", "from", "the", "firmware", "." ]

[ "func", "(", "g", "*", "Driver", ")", "GetHardwareVersion", "(", ")", "(", "hVer", "string", ",", "err", "error", ")", "{", "response", ",", "err", ":=", "g", ".", "readUint32", "(", "goPiGo3Address", ",", "GET_HARDWARE_VERSION", ")", "\n", "if", "err", "!=", "nil", "{", "return", "hVer", ",", "err", "\n", "}", "\n", "major", ":=", "response", "/", "1000000", "\n", "minor", ":=", "response", "/", "1000", "%", "1000", "\n", "patch", ":=", "response", "%", "1000", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "major", ",", "minor", ",", "patch", ")", ",", "nil", "\n", "}" ]

[ "GetHardwareVersion", "returns", "the", "hardware", "version", "from", "the", "firmware", "." ]

[ "func", "(", "g", "*", "Driver", ")", "GetFirmwareVersion", "(", ")", "(", "fVer", "string", ",", "err", "error", ")", "{", "response", ",", "err", ":=", "g", ".", "readUint32", "(", "goPiGo3Address", ",", "GET_FIRMWARE_VERSION", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fVer", ",", "err", "\n", "}", "\n", "major", ":=", "response", "/", "1000000", "\n", "minor", ":=", "response", "/", "1000", "%", "1000", "\n", "patch", ":=", "response", "%", "1000", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "major", ",", "minor", ",", "patch", ")", ",", "nil", "\n", "}" ]

[ "GetFirmwareVersion", "returns", "the", "current", "firmware", "version", "." ]

[ "func", "(", "g", "*", "Driver", ")", "GetSerialNumber", "(", ")", "(", "sNum", "string", ",", "err", "error", ")", "{", "// read 20 bytes to get the serial number", "response", ",", "err", ":=", "g", ".", "readBytes", "(", "goPiGo3Address", ",", "GET_ID", ",", "20", ")", "\n", "if", "err", "!=", "nil", "{", "return", "sNum", ",", "err", "\n", "}", "\n", "if", "err", ":=", "g", ".", "responseValid", "(", "response", ")", ";", "err", "!=", "nil", "{", "return", "sNum", ",", "err", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "response", "[", "4", "]", ",", "response", "[", "5", "]", ",", "response", "[", "6", "]", ",", "response", "[", "7", "]", ",", "response", "[", "8", "]", ",", "response", "[", "9", "]", ",", "response", "[", "10", "]", ",", "response", "[", "11", "]", ",", "response", "[", "12", "]", ",", "response", "[", "13", "]", ",", "response", "[", "14", "]", ",", "response", "[", "15", "]", ",", "response", "[", "16", "]", ",", "response", "[", "17", "]", ",", "response", "[", "18", "]", ",", "response", "[", "19", "]", ")", ",", "nil", "\n", "}" ]

[ "GetSerialNumber", "returns", "the", "128", "-", "bit", "hardware", "serial", "number", "of", "the", "board", "." ]

[ "func", "(", "g", "*", "Driver", ")", "Get5vVoltage", "(", ")", "(", "voltage", "float32", ",", "err", "error", ")", "{", "val", ",", "err", ":=", "g", ".", "readUint16", "(", "goPiGo3Address", ",", "GET_VOLTAGE_5V", ")", "\n", "return", "(", "float32", "(", "val", ")", "/", "1000.0", ")", ",", "err", "\n", "}" ]

[ "Get5vVoltage", "returns", "the", "current", "voltage", "on", "the", "5v", "line", "." ]

[ "func", "(", "g", "*", "Driver", ")", "SetLED", "(", "led", "Led", ",", "red", ",", "green", ",", "blue", "uint8", ")", "error", "{", "return", "g", ".", "writeBytes", "(", "[", "]", "byte", "{", "goPiGo3Address", ",", "SET_LED", ",", "byte", "(", "led", ")", ",", "byte", "(", "red", ")", ",", "byte", "(", "green", ")", ",", "byte", "(", "blue", ")", ",", "}", ")", "\n", "}" ]

[ "SetLED", "sets", "rgb", "values", "from", "0", "to", "255", "." ]

[ "func", "(", "g", "*", "Driver", ")", "SetMotorPower", "(", "motor", "Motor", ",", "power", "int8", ")", "error", "{", "return", "g", ".", "writeBytes", "(", "[", "]", "byte", "{", "goPiGo3Address", ",", "SET_MOTOR_PWM", ",", "byte", "(", "motor", ")", ",", "byte", "(", "power", ")", ",", "}", ")", "\n", "}" ]

[ "SetMotorPower", "sets", "a", "motor", "s", "power", "from", "-", "128", "to", "127", "." ]

[ "func", "(", "g", "*", "Driver", ")", "SetMotorPosition", "(", "motor", "Motor", ",", "position", "int", ")", "error", "{", "positionRaw", ":=", "position", "*", "MOTOR_TICKS_PER_DEGREE", "\n", "return", "g", ".", "writeBytes", "(", "[", "]", "byte", "{", "goPiGo3Address", ",", "SET_MOTOR_POSITION", ",", "byte", "(", "motor", ")", ",", "byte", "(", "(", "positionRaw", ">>", "24", ")", "&", "0xFF", ")", ",", "byte", "(", "(", "positionRaw", ">>", "16", ")", "&", "0xFF", ")", ",", "byte", "(", "(", "positionRaw", ">>", "8", ")", "&", "0xFF", ")", ",", "byte", "(", "positionRaw", "&", "0xFF", ")", ",", "}", ")", "\n", "}" ]

[ "SetMotorPosition", "sets", "the", "motor", "s", "position", "in", "degrees", "." ]

[ "func", "(", "g", "*", "Driver", ")", "SetMotorDps", "(", "motor", "Motor", ",", "dps", "int", ")", "error", "{", "d", ":=", "dps", "*", "MOTOR_TICKS_PER_DEGREE", "\n", "return", "g", ".", "writeBytes", "(", "[", "]", "byte", "{", "goPiGo3Address", ",", "SET_MOTOR_DPS", ",", "byte", "(", "motor", ")", ",", "byte", "(", "(", "d", ">>", "8", ")", "&", "0xFF", ")", ",", "byte", "(", "d", "&", "0xFF", ")", ",", "}", ")", "\n", "}" ]

[ "SetMotorDps", "sets", "the", "motor", "target", "speed", "in", "degrees", "per", "second", "." ]

[ "func", "(", "g", "*", "Driver", ")", "SetMotorLimits", "(", "motor", "Motor", ",", "power", "int8", ",", "dps", "int", ")", "error", "{", "dpsUint", ":=", "dps", "*", "MOTOR_TICKS_PER_DEGREE", "\n", "return", "g", ".", "writeBytes", "(", "[", "]", "byte", "{", "goPiGo3Address", ",", "SET_MOTOR_LIMITS", ",", "byte", "(", "motor", ")", ",", "byte", "(", "power", ")", ",", "byte", "(", "(", "dpsUint", ">>", "8", ")", "&", "0xFF", ")", ",", "byte", "(", "dpsUint", "&", "0xFF", ")", ",", "}", ")", "\n", "}" ]

[ "SetMotorLimits", "sets", "the", "speed", "limits", "for", "a", "motor", "." ]

[ "func", "(", "g", "*", "Driver", ")", "GetMotorStatus", "(", "motor", "Motor", ")", "(", "flags", "uint8", ",", "power", "uint16", ",", "encoder", ",", "dps", "int", ",", "err", "error", ")", "{", "message", ":=", "GET_MOTOR_STATUS_RIGHT", "\n", "if", "motor", "==", "MOTOR_LEFT", "{", "message", "=", "GET_MOTOR_STATUS_LEFT", "\n", "}", "\n", "response", ",", "err", ":=", "g", ".", "readBytes", "(", "goPiGo3Address", ",", "message", ",", "12", ")", "\n", "if", "err", "!=", "nil", "{", "return", "flags", ",", "power", ",", "encoder", ",", "dps", ",", "err", "\n", "}", "\n", "if", "err", ":=", "g", ".", "responseValid", "(", "response", ")", ";", "err", "!=", "nil", "{", "return", "flags", ",", "power", ",", "encoder", ",", "dps", ",", "err", "\n", "}", "\n", "// get flags", "flags", "=", "uint8", "(", "response", "[", "4", "]", ")", "\n", "// get power", "power", "=", "uint16", "(", "response", "[", "5", "]", ")", "\n", "if", "power", "&", "0x80", "==", "0x80", "{", "power", "=", "power", "-", "0x100", "\n", "}", "\n", "// get encoder", "enc", ":=", "make", "(", "[", "]", "byte", ",", "4", ")", "\n", "enc", "[", "3", "]", "=", "response", "[", "6", "]", "\n", "enc", "[", "2", "]", "=", "response", "[", "7", "]", "\n", "enc", "[", "1", "]", "=", "response", "[", "8", "]", "\n", "enc", "[", "0", "]", "=", "response", "[", "9", "]", "\n", "e", ":=", "binary", ".", "LittleEndian", ".", "Uint32", "(", "enc", ")", "\n", "if", "e", "&", "0x80000000", "==", "0x80000000", "{", "encoder", "=", "int", "(", "uint64", "(", "e", ")", "-", "0x100000000", ")", "\n", "}", "\n", "encoder", "=", "int", "(", "e", ")", "\n", "//get dps", "d", ":=", "make", "(", "[", "]", "byte", ",", "4", ")", "\n", "d", "[", "1", "]", "=", "response", "[", "10", "]", "\n", "d", "[", "0", "]", "=", "response", "[", "11", "]", "\n", "ds", ":=", "binary", ".", "LittleEndian", ".", "Uint32", "(", "d", ")", "\n", "if", "ds", "&", "0x8000", "==", "0x8000", "{", "dps", "=", "int", "(", "ds", "-", "0x10000", ")", "\n", "}", "\n", "dps", "=", "int", "(", "ds", ")", "\n", "return", "flags", ",", "power", ",", "encoder", "/", "MOTOR_TICKS_PER_DEGREE", ",", "dps", "/", "MOTOR_TICKS_PER_DEGREE", ",", "nil", "\n", "}" ]

[ "GetMotorStatus", "returns", "the", "status", "for", "the", "given", "motor", "." ]

[ "func", "(", "g", "*", "Driver", ")", "GetMotorEncoder", "(", "motor", "Motor", ")", "(", "encoder", "int64", ",", "err", "error", ")", "{", "message", ":=", "GET_MOTOR_ENCODER_RIGHT", "\n", "if", "motor", "==", "MOTOR_LEFT", "{", "message", "=", "GET_MOTOR_ENCODER_LEFT", "\n", "}", "\n", "response", ",", "err", ":=", "g", ".", "readUint32", "(", "goPiGo3Address", ",", "message", ")", "\n", "if", "err", "!=", "nil", "{", "return", "encoder", ",", "err", "\n", "}", "\n", "encoder", "=", "int64", "(", "response", ")", "\n", "if", "response", "&", "0x80000000", "!=", "0", "{", "encoder", "=", "encoder", "-", "0x100000000", "\n", "}", "\n", "encoder", "=", "encoder", "/", "MOTOR_TICKS_PER_DEGREE", "\n", "return", "encoder", ",", "nil", "\n", "}" ]

[ "GetMotorEncoder", "reads", "a", "motor", "s", "encoder", "in", "degrees", "." ]

[ "func", "(", "g", "*", "Driver", ")", "OffsetMotorEncoder", "(", "motor", "Motor", ",", "offset", "float64", ")", "error", "{", "offsetUint", ":=", "math", ".", "Float64bits", "(", "offset", "*", "MOTOR_TICKS_PER_DEGREE", ")", "\n", "return", "g", ".", "writeBytes", "(", "[", "]", "byte", "{", "goPiGo3Address", ",", "OFFSET_MOTOR_ENCODER", ",", "byte", "(", "motor", ")", ",", "byte", "(", "(", "offsetUint", ">>", "24", ")", "&", "0xFF", ")", ",", "byte", "(", "(", "offsetUint", ">>", "16", ")", "&", "0xFF", ")", ",", "byte", "(", "(", "offsetUint", ">>", "8", ")", "&", "0xFF", ")", ",", "byte", "(", "offsetUint", "&", "0xFF", ")", ",", "}", ")", "\n", "}" ]

[ "OffsetMotorEncoder", "offsets", "a", "motor", "s", "encoder", "for", "calibration", "purposes", "." ]

[ "func", "(", "g", "*", "Driver", ")", "SetGroveType", "(", "port", "Grove", ",", "gType", "GroveType", ")", "error", "{", "return", "g", ".", "writeBytes", "(", "[", "]", "byte", "{", "goPiGo3Address", ",", "SET_GROVE_TYPE", ",", "byte", "(", "port", ")", ",", "byte", "(", "gType", ")", ",", "}", ")", "\n", "}" ]

[ "SetGroveType", "sets", "the", "given", "port", "to", "a", "grove", "device", "type", "." ]

[ "func", "(", "g", "*", "Driver", ")", "PwmWrite", "(", "pin", "string", ",", "val", "byte", ")", "(", "err", "error", ")", "{", "var", "(", "grovePin", ",", "grovePort", "Grove", "\n", ")", "\n", "grovePin", ",", "grovePort", ",", "_", ",", "_", ",", "err", "=", "getGroveAddresses", "(", "pin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "g", ".", "SetGroveType", "(", "grovePort", ",", "CUSTOM", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "time", ".", "Sleep", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "err", "=", "g", ".", "SetGroveMode", "(", "grovePin", ",", "GROVE_OUTPUT_PWM", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "time", ".", "Sleep", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "err", "=", "g", ".", "SetPWMFreq", "(", "grovePin", ",", "24000", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "val64", ":=", "math", ".", "Float64frombits", "(", "uint64", "(", "val", ")", ")", "\n", "dutyCycle", ":=", "uint16", "(", "math", ".", "Float64bits", "(", "(", "100.0", "/", "255.0", ")", "*", "val64", ")", ")", "\n", "return", "g", ".", "SetPWMDuty", "(", "grovePin", ",", "dutyCycle", ")", "\n", "}" ]

[ "PwmWrite", "implents", "the", "pwm", "interface", "for", "the", "gopigo3", "." ]

[ "func", "(", "g", "*", "Driver", ")", "AnalogRead", "(", "pin", "string", ")", "(", "value", "int", ",", "err", "error", ")", "{", "var", "(", "grovePin", ",", "grovePort", "Grove", "\n", "analogCmd", "byte", "\n", ")", "\n", "grovePin", ",", "grovePort", ",", "analogCmd", ",", "_", ",", "err", "=", "getGroveAddresses", "(", "pin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "value", ",", "err", "\n", "}", "\n", "err", "=", "g", ".", "SetGroveType", "(", "grovePort", ",", "CUSTOM", ")", "\n", "if", "err", "!=", "nil", "{", "return", "value", ",", "err", "\n", "}", "\n", "time", ".", "Sleep", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "err", "=", "g", ".", "SetGroveMode", "(", "grovePin", ",", "GROVE_INPUT_ANALOG", ")", "\n", "if", "err", "!=", "nil", "{", "return", "value", ",", "err", "\n", "}", "\n", "time", ".", "Sleep", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "response", ",", "err", ":=", "g", ".", "readBytes", "(", "goPiGo3Address", ",", "analogCmd", ",", "7", ")", "\n", "if", "err", "!=", "nil", "{", "return", "value", ",", "err", "\n", "}", "\n", "if", "err", ":=", "g", ".", "responseValid", "(", "response", ")", ";", "err", "!=", "nil", "{", "return", "value", ",", "err", "\n", "}", "\n", "if", "err", ":=", "g", ".", "valueValid", "(", "response", ")", ";", "err", "!=", "nil", "{", "return", "value", ",", "err", "\n", "}", "\n", "highBytes", ":=", "uint16", "(", "response", "[", "5", "]", ")", "\n", "lowBytes", ":=", "uint16", "(", "response", "[", "6", "]", ")", "\n", "return", "int", "(", "(", "highBytes", "<<", "8", ")", "&", "0xFF00", ")", "|", "int", "(", "lowBytes", "&", "0xFF", ")", ",", "nil", "\n", "}" ]

[ "AnalogRead", "returns", "the", "analog", "value", "of", "the", "given", "pin", "." ]

[ "func", "(", "s", "*", "SpheroDriver", ")", "Halt", "(", ")", "(", "err", "error", ")", "{", "if", "s", ".", "adaptor", "(", ")", ".", "connected", "{", "gobot", ".", "Every", "(", "10", "*", "time", ".", "Millisecond", ",", "func", "(", ")", "{", "s", ".", "Stop", "(", ")", "\n", "}", ")", "\n", "time", ".", "Sleep", "(", "1", "*", "time", ".", "Second", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Halt", "halts", "the", "SpheroDriver", "and", "sends", "a", "SpheroDriver", ".", "Stop", "command", "to", "the", "Sphero", ".", "Returns", "true", "on", "successful", "halt", "." ]

[ "func", "(", "s", "*", "SpheroDriver", ")", "SetRGB", "(", "r", "uint8", ",", "g", "uint8", ",", "b", "uint8", ")", "{", "s", ".", "packetChannel", "<-", "s", ".", "craftPacket", "(", "[", "]", "uint8", "{", "r", ",", "g", ",", "b", ",", "0x01", "}", ",", "0x02", ",", "0x20", ")", "\n", "}" ]

[ "SetRGB", "sets", "the", "Sphero", "to", "the", "given", "r", "g", "and", "b", "values" ]

[ "func", "(", "s", "*", "SpheroDriver", ")", "GetRGB", "(", ")", "[", "]", "uint8", "{", "buf", ":=", "s", ".", "getSyncResponse", "(", "s", ".", "craftPacket", "(", "[", "]", "uint8", "{", "}", ",", "0x02", ",", "0x22", ")", ")", "\n", "if", "len", "(", "buf", ")", "==", "9", "{", "return", "[", "]", "uint8", "{", "buf", "[", "5", "]", ",", "buf", "[", "6", "]", ",", "buf", "[", "7", "]", "}", "\n", "}", "\n", "return", "[", "]", "uint8", "{", "}", "\n", "}" ]

[ "GetRGB", "returns", "the", "current", "r", "g", "b", "value", "of", "the", "Sphero" ]

[ "func", "(", "s", "*", "SpheroDriver", ")", "SetBackLED", "(", "level", "uint8", ")", "{", "s", ".", "packetChannel", "<-", "s", ".", "craftPacket", "(", "[", "]", "uint8", "{", "level", "}", ",", "0x02", ",", "0x21", ")", "\n", "}" ]

[ "SetBackLED", "sets", "the", "Sphero", "Back", "LED", "to", "the", "specified", "brightness" ]

[ "func", "(", "s", "*", "SpheroDriver", ")", "SetHeading", "(", "heading", "uint16", ")", "{", "s", ".", "packetChannel", "<-", "s", ".", "craftPacket", "(", "[", "]", "uint8", "{", "uint8", "(", "heading", ">>", "8", ")", ",", "uint8", "(", "heading", "&", "0xFF", ")", "}", ",", "0x02", ",", "0x01", ")", "\n", "}" ]

[ "SetHeading", "sets", "the", "heading", "of", "the", "Sphero" ]

[ "func", "(", "s", "*", "SpheroDriver", ")", "SetStabilization", "(", "on", "bool", ")", "{", "b", ":=", "uint8", "(", "0x01", ")", "\n", "if", "!", "on", "{", "b", "=", "0x00", "\n", "}", "\n", "s", ".", "packetChannel", "<-", "s", ".", "craftPacket", "(", "[", "]", "uint8", "{", "b", "}", ",", "0x02", ",", "0x02", ")", "\n", "}" ]

[ "SetStabilization", "enables", "or", "disables", "the", "built", "-", "in", "auto", "stabilizing", "features", "of", "the", "Sphero" ]

[ "func", "(", "s", "*", "SpheroDriver", ")", "Roll", "(", "speed", "uint8", ",", "heading", "uint16", ")", "{", "s", ".", "packetChannel", "<-", "s", ".", "craftPacket", "(", "[", "]", "uint8", "{", "speed", ",", "uint8", "(", "heading", ">>", "8", ")", ",", "uint8", "(", "heading", "&", "0xFF", ")", ",", "0x01", "}", ",", "0x02", ",", "0x30", ")", "\n", "}" ]

[ "Roll", "sends", "a", "roll", "command", "to", "the", "Sphero", "gives", "a", "speed", "and", "heading" ]

[ "func", "(", "s", "*", "SpheroDriver", ")", "ConfigureLocator", "(", "d", "LocatorConfig", ")", "{", "buf", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "BigEndian", ",", "d", ")", "\n\n", "s", ".", "packetChannel", "<-", "s", ".", "craftPacket", "(", "buf", ".", "Bytes", "(", ")", ",", "0x02", ",", "0x13", ")", "\n", "}" ]

[ "ConfigureLocator", "configures", "and", "enables", "the", "Locator" ]

[ "func", "(", "s", "*", "SpheroDriver", ")", "SetDataStreaming", "(", "d", "DataStreamingConfig", ")", "{", "buf", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "BigEndian", ",", "d", ")", "\n\n", "s", ".", "packetChannel", "<-", "s", ".", "craftPacket", "(", "buf", ".", "Bytes", "(", ")", ",", "0x02", ",", "0x11", ")", "\n", "}" ]

[ "SetDataStreaming", "enables", "sensor", "data", "streaming" ]

[ "func", "(", "f", "*", "Adaptor", ")", "Connect", "(", ")", "(", "err", "error", ")", "{", "if", "f", ".", "conn", "==", "nil", "{", "sp", ",", "e", ":=", "f", ".", "PortOpener", "(", "f", ".", "Port", "(", ")", ")", "\n", "if", "e", "!=", "nil", "{", "return", "e", "\n", "}", "\n", "f", ".", "conn", "=", "sp", "\n", "}", "\n", "if", "err", "=", "f", ".", "Board", ".", "Connect", "(", "f", ".", "conn", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "f", ".", "Board", ".", "On", "(", "\"", "\"", ",", "func", "(", "data", "interface", "{", "}", ")", "{", "f", ".", "Publish", "(", "\"", "\"", ",", "data", ")", "\n", "}", ")", "\n\n", "return", "\n", "}" ]

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

[ "func", "(", "f", "*", "Adaptor", ")", "Disconnect", "(", ")", "(", "err", "error", ")", "{", "if", "f", ".", "Board", "!=", "nil", "{", "return", "f", ".", "Board", ".", "Disconnect", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Disconnect", "closes", "the", "io", "connection", "to", "the", "Board" ]

[ "func", "(", "f", "*", "Adaptor", ")", "ServoConfig", "(", "pin", "string", ",", "min", ",", "max", "int", ")", "error", "{", "p", ",", "err", ":=", "strconv", ".", "Atoi", "(", "pin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "f", ".", "Board", ".", "ServoConfig", "(", "p", ",", "max", ",", "min", ")", "\n", "}" ]

[ "ServoConfig", "sets", "the", "pulse", "width", "in", "microseconds", "for", "a", "pin", "attached", "to", "a", "servo" ]

[ "func", "(", "f", "*", "Adaptor", ")", "ServoWrite", "(", "pin", "string", ",", "angle", "byte", ")", "(", "err", "error", ")", "{", "p", ",", "err", ":=", "strconv", ".", "Atoi", "(", "pin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "f", ".", "Board", ".", "Pins", "(", ")", "[", "p", "]", ".", "Mode", "!=", "client", ".", "Servo", "{", "err", "=", "f", ".", "Board", ".", "SetPinMode", "(", "p", ",", "client", ".", "Servo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "err", "=", "f", ".", "Board", ".", "AnalogWrite", "(", "p", ",", "int", "(", "angle", ")", ")", "\n", "return", "\n", "}" ]

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

[ "func", "(", "f", "*", "Adaptor", ")", "DigitalRead", "(", "pin", "string", ")", "(", "val", "int", ",", "err", "error", ")", "{", "p", ",", "err", ":=", "strconv", ".", "Atoi", "(", "pin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "if", "f", ".", "Board", ".", "Pins", "(", ")", "[", "p", "]", ".", "Mode", "!=", "client", ".", "Input", "{", "if", "err", "=", "f", ".", "Board", ".", "SetPinMode", "(", "p", ",", "client", ".", "Input", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "err", "=", "f", ".", "Board", ".", "ReportDigital", "(", "p", ",", "1", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "<-", "time", ".", "After", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "}", "\n\n", "return", "f", ".", "Board", ".", "Pins", "(", ")", "[", "p", "]", ".", "Value", ",", "nil", "\n", "}" ]

[ "DigitalRead", "retrieves", "digital", "value", "from", "specified", "pin", ".", "Returns", "-", "1", "if", "the", "response", "from", "the", "board", "has", "timed", "out" ]

[ "func", "(", "f", "*", "Adaptor", ")", "AnalogRead", "(", "pin", "string", ")", "(", "val", "int", ",", "err", "error", ")", "{", "p", ",", "err", ":=", "strconv", ".", "Atoi", "(", "pin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "p", "=", "f", ".", "digitalPin", "(", "p", ")", "\n\n", "if", "f", ".", "Board", ".", "Pins", "(", ")", "[", "p", "]", ".", "Mode", "!=", "client", ".", "Analog", "{", "if", "err", "=", "f", ".", "Board", ".", "SetPinMode", "(", "p", ",", "client", ".", "Analog", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "if", "err", "=", "f", ".", "Board", ".", "ReportAnalog", "(", "p", ",", "1", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "<-", "time", ".", "After", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "}", "\n\n", "return", "f", ".", "Board", ".", "Pins", "(", ")", "[", "p", "]", ".", "Value", ",", "nil", "\n", "}" ]

[ "AnalogRead", "retrieves", "value", "from", "analog", "pin", ".", "Returns", "-", "1", "if", "the", "response", "from", "the", "board", "has", "timed", "out" ]

[ "func", "(", "m", "*", "Driver", ")", "Start", "(", ")", "error", "{", "go", "func", "(", ")", "{", "for", "{", "packet", ",", "err", ":=", "m", ".", "adaptor", "(", ")", ".", "ReadMAVLinkPacket", "(", ")", "\n", "if", "err", "!=", "nil", "{", "m", ".", "Publish", "(", "ErrorIOEvent", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "m", ".", "Publish", "(", "PacketEvent", ",", "packet", ")", "\n", "message", ",", "err", ":=", "packet", ".", "MAVLinkMessage", "(", ")", "\n", "if", "err", "!=", "nil", "{", "m", ".", "Publish", "(", "ErrorMAVLinkEvent", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "m", ".", "Publish", "(", "MessageEvent", ",", "message", ")", "\n", "time", ".", "Sleep", "(", "m", ".", "interval", ")", "\n", "}", "\n", "}", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Start", "begins", "process", "to", "read", "mavlink", "packets", "every", "m", ".", "Interval", "and", "process", "them" ]

[ "func", "(", "m", "*", "Driver", ")", "SendPacket", "(", "packet", "*", "common", ".", "MAVLinkPacket", ")", "(", "err", "error", ")", "{", "_", ",", "err", "=", "m", ".", "adaptor", "(", ")", ".", "Write", "(", "packet", ".", "Pack", "(", ")", ")", "\n", "return", "err", "\n", "}" ]

[ "SendPacket", "sends", "a", "packet", "to", "mavlink", "device" ]

[ "func", "NewDriver", "(", "a", "ble", ".", "BLEConnector", ")", "*", "Driver", "{", "n", ":=", "&", "Driver", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "connection", ":", "a", ",", "Eventer", ":", "gobot", ".", "NewEventer", "(", ")", ",", "packetChannel", ":", "make", "(", "chan", "*", "packet", ",", "1024", ")", ",", "}", "\n\n", "n", ".", "AddEvent", "(", "Collision", ")", "\n\n", "return", "n", "\n", "}" ]

[ "NewDriver", "creates", "a", "Driver", "for", "a", "Sphero", "Ollie" ]

[ "func", "(", "b", "*", "Driver", ")", "Init", "(", ")", "(", "err", "error", ")", "{", "b", ".", "AntiDOSOff", "(", ")", "\n", "b", ".", "SetTXPower", "(", "7", ")", "\n", "b", ".", "Wake", "(", ")", "\n\n", "// subscribe to Sphero response notifications", "b", ".", "adaptor", "(", ")", ".", "Subscribe", "(", "responseCharacteristic", ",", "b", ".", "HandleResponses", ")", "\n\n", "return", "\n", "}" ]

[ "Init", "is", "used", "to", "initialize", "the", "Ollie" ]

[ "func", "(", "b", "*", "Driver", ")", "AntiDOSOff", "(", ")", "(", "err", "error", ")", "{", "str", ":=", "\"", "\"", "\n", "buf", ":=", "&", "bytes", ".", "Buffer", "{", "}", "\n", "buf", ".", "WriteString", "(", "str", ")", "\n\n", "err", "=", "b", ".", "adaptor", "(", ")", ".", "WriteCharacteristic", "(", "antiDosCharacteristic", ",", "buf", ".", "Bytes", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Println", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "AntiDOSOff", "turns", "off", "Anti", "-", "DOS", "code", "so", "we", "can", "control", "Ollie" ]

[ "func", "(", "b", "*", "Driver", ")", "Wake", "(", ")", "(", "err", "error", ")", "{", "buf", ":=", "[", "]", "byte", "{", "0x01", "}", "\n\n", "err", "=", "b", ".", "adaptor", "(", ")", ".", "WriteCharacteristic", "(", "wakeCharacteristic", ",", "buf", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Println", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "Wake", "wakes", "Ollie", "up", "so", "we", "can", "play" ]

[ "func", "(", "b", "*", "Driver", ")", "SetTXPower", "(", "level", "int", ")", "(", "err", "error", ")", "{", "buf", ":=", "[", "]", "byte", "{", "byte", "(", "level", ")", "}", "\n\n", "err", "=", "b", ".", "adaptor", "(", ")", ".", "WriteCharacteristic", "(", "txPowerCharacteristic", ",", "buf", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Println", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "SetTXPower", "sets", "transmit", "level" ]

[ "func", "(", "b", "*", "Driver", ")", "HandleResponses", "(", "data", "[", "]", "byte", ",", "e", "error", ")", "{", "//fmt.Println(\"response data:\", data, e)", "b", ".", "handleCollisionDetected", "(", "data", ")", "\n", "}" ]

[ "HandleResponses", "handles", "responses", "returned", "from", "Ollie" ]

[ "func", "(", "b", "*", "Driver", ")", "SetRGB", "(", "r", "uint8", ",", "g", "uint8", ",", "bl", "uint8", ")", "{", "b", ".", "packetChannel", "<-", "b", ".", "craftPacket", "(", "[", "]", "uint8", "{", "r", ",", "g", ",", "bl", ",", "0x01", "}", ",", "0x02", ",", "0x20", ")", "\n", "}" ]

[ "SetRGB", "sets", "the", "Ollie", "to", "the", "given", "r", "g", "and", "b", "values" ]

[ "func", "(", "b", "*", "Driver", ")", "Roll", "(", "speed", "uint8", ",", "heading", "uint16", ")", "{", "b", ".", "packetChannel", "<-", "b", ".", "craftPacket", "(", "[", "]", "uint8", "{", "speed", ",", "uint8", "(", "heading", ">>", "8", ")", ",", "uint8", "(", "heading", "&", "0xFF", ")", ",", "0x01", "}", ",", "0x02", ",", "0x30", ")", "\n", "}" ]

[ "Roll", "tells", "the", "Ollie", "to", "roll" ]

[ "func", "(", "b", "*", "Driver", ")", "Boost", "(", "state", "bool", ")", "{", "s", ":=", "uint8", "(", "0x01", ")", "\n", "if", "!", "state", "{", "s", "=", "0x00", "\n", "}", "\n", "b", ".", "packetChannel", "<-", "b", ".", "craftPacket", "(", "[", "]", "uint8", "{", "s", "}", ",", "0x02", ",", "0x31", ")", "\n", "}" ]

[ "Boost", "executes", "the", "boost", "macro", "from", "within", "the", "SSB", "which", "takes", "a", "1", "byte", "parameter", "which", "is", "either", "01h", "to", "begin", "boosting", "or", "00h", "to", "stop", "." ]

[ "func", "GetSpiConnection", "(", "busNum", ",", "chipNum", ",", "mode", ",", "bits", "int", ",", "maxSpeed", "int64", ")", "(", "Connection", ",", "error", ")", "{", "p", ",", "err", ":=", "xsysfs", ".", "NewSPI", "(", "busNum", ",", "chipNum", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "c", ",", "err", ":=", "p", ".", "Connect", "(", "physic", ".", "Frequency", "(", "maxSpeed", ")", "*", "physic", ".", "Hertz", ",", "xspi", ".", "Mode", "(", "mode", ")", ",", "bits", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "NewConnection", "(", "p", ",", "c", ")", ",", "nil", "\n", "}" ]

[ "GetSpiConnection", "is", "a", "helper", "to", "return", "a", "SPI", "device", "." ]

[ "func", "NewPWMPin", "(", "pin", "int", ")", "*", "PWMPin", "{", "return", "&", "PWMPin", "{", "pin", ":", "strconv", ".", "Itoa", "(", "pin", ")", ",", "enabled", ":", "false", ",", "Path", ":", "\"", "\"", ",", "read", ":", "readPwmFile", ",", "write", ":", "writePwmFile", "}", "\n", "}" ]

[ "NewPwmPin", "returns", "a", "new", "pwmPin" ]

[ "func", "(", "p", "*", "PWMPin", ")", "Export", "(", ")", "error", "{", "_", ",", "err", ":=", "p", ".", "write", "(", "p", ".", "pwmExportPath", "(", ")", ",", "[", "]", "byte", "(", "p", ".", "pin", ")", ")", "\n", "if", "err", "!=", "nil", "{", "// If EBUSY then the pin has already been exported", "e", ",", "ok", ":=", "err", ".", "(", "*", "os", ".", "PathError", ")", "\n", "if", "!", "ok", "||", "e", ".", "Err", "!=", "syscall", ".", "EBUSY", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// Pause to avoid race condition in case there is any udev rule", "// that changes file permissions on newly exported PWMPin. This", "// is a common circumstance when running as a non-root user.", "time", ".", "Sleep", "(", "100", "*", "time", ".", "Millisecond", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Export", "writes", "pin", "to", "pwm", "export", "path" ]

[ "func", "(", "p", "*", "PWMPin", ")", "Unexport", "(", ")", "(", "err", "error", ")", "{", "_", ",", "err", "=", "p", ".", "write", "(", "p", ".", "pwmUnexportPath", "(", ")", ",", "[", "]", "byte", "(", "p", ".", "pin", ")", ")", "\n", "return", "\n", "}" ]

[ "Unexport", "writes", "pin", "to", "pwm", "unexport", "path" ]

[ "func", "(", "p", "*", "PWMPin", ")", "Enable", "(", "enable", "bool", ")", "(", "err", "error", ")", "{", "if", "p", ".", "enabled", "!=", "enable", "{", "p", ".", "enabled", "=", "enable", "\n", "enableVal", ":=", "0", "\n", "if", "enable", "{", "enableVal", "=", "1", "\n", "}", "\n", "_", ",", "err", "=", "p", ".", "write", "(", "p", ".", "pwmEnablePath", "(", ")", ",", "[", "]", "byte", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "enableVal", ")", ")", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Enable", "writes", "value", "to", "pwm", "enable", "path" ]