Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "m", "*", "Debug", ")", "Decode", "(", "buf", "[", "]", "byte", ")", "{", "data", ":=", "bytes", ".", "NewBuffer", "(", "buf", ")", "\n", "binary", ".", "Read", "(", "data", ",", "binary", ".", "LittleEndian", ",", "&", "m", ".", "TIME_BOOT_MS", ")", "\n", "binary", ".", "Read", "(", "data", ",", "binary", ".", "LittleEndian", ",", "&", "m", ".", "VALUE", ")", "\n", "binary", ".", "Read", "(", "data", ",", "binary", ".", "LittleEndian", ",", "&", "m", ".", "IND", ")", "\n", "}" ]

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

[ "func", "NewDriver", "(", ")", "*", "Driver", "{", "k", ":=", "&", "Driver", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "connect", ":", "func", "(", "k", "*", "Driver", ")", "(", "err", "error", ")", "{", "if", "err", ":=", "configure", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "k", ".", "stdin", "=", "os", ".", "Stdin", "\n", "return", "\n", "}", ",", "listen", ":", "func", "(", "k", "*", "Driver", ")", "{", "ctrlc", ":=", "bytes", "{", "3", "}", "\n\n", "for", "{", "var", "keybuf", "bytes", "\n", "k", ".", "stdin", ".", "Read", "(", "keybuf", "[", "0", ":", "3", "]", ")", "\n\n", "if", "keybuf", "==", "ctrlc", "{", "proc", ",", "err", ":=", "os", ".", "FindProcess", "(", "os", ".", "Getpid", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "proc", ".", "Signal", "(", "os", ".", "Interrupt", ")", "\n", "break", "\n", "}", "\n\n", "k", ".", "Publish", "(", "Key", ",", "Parse", "(", "keybuf", ")", ")", "\n\n", "}", "\n", "}", ",", "Eventer", ":", "gobot", ".", "NewEventer", "(", ")", ",", "}", "\n\n", "k", ".", "AddEvent", "(", "Key", ")", "\n\n", "return", "k", "\n", "}" ]

[ "NewDriver", "returns", "a", "new", "keyboard", "Driver", "." ]

[ "func", "(", "k", "*", "Driver", ")", "Start", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "k", ".", "connect", "(", "k", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "go", "k", ".", "listen", "(", "k", ")", "\n\n", "return", "\n", "}" ]

[ "Start", "initializes", "keyboard", "by", "grabbing", "key", "events", "as", "they", "come", "in", "and", "publishing", "each", "as", "a", "key", "event" ]

[ "func", "(", "p", "*", "PWMPin", ")", "Unexport", "(", ")", "error", "{", "return", "p", ".", "piBlaster", "(", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "p", ".", "pin", ")", ")", "\n", "}" ]

[ "Unexport", "unexports", "the", "pin", "and", "releases", "the", "pin", "from", "the", "operating", "system" ]

[ "func", "(", "p", "*", "PWMPin", ")", "Period", "(", ")", "(", "period", "uint32", ",", "err", "error", ")", "{", "if", "p", ".", "period", "==", "0", "{", "return", "p", ".", "period", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "p", ".", "period", ",", "nil", "\n", "}" ]

[ "Period", "returns", "the", "current", "PWM", "period", "for", "pin" ]

[ "func", "(", "p", "*", "PWMPin", ")", "DutyCycle", "(", ")", "(", "duty", "uint32", ",", "err", "error", ")", "{", "return", "p", ".", "dc", ",", "nil", "\n", "}" ]

[ "DutyCycle", "returns", "the", "duty", "cycle", "for", "the", "pin" ]

[ "func", "(", "p", "*", "PWMPin", ")", "SetDutyCycle", "(", "duty", "uint32", ")", "(", "err", "error", ")", "{", "if", "p", ".", "period", "==", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "duty", ">", "p", ".", "period", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "p", ".", "dc", "=", "duty", "\n\n", "val", ":=", "gobot", ".", "FromScale", "(", "float64", "(", "p", ".", "dc", ")", ",", "0", ",", "float64", "(", "p", ".", "period", ")", ")", "\n\n", "// never go below minimum allowed duty for pi blaster", "if", "val", "<", "0.05", "{", "val", "=", "0.05", "\n", "}", "\n", "return", "p", ".", "piBlaster", "(", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "p", ".", "pin", ",", "val", ")", ")", "\n", "}" ]

[ "SetDutyCycle", "writes", "the", "duty", "cycle", "to", "the", "pin" ]

[ "func", "(", "l", "*", "littleWire", ")", "i2cStart", "(", "address7bit", "uint8", ",", "direction", "uint8", ")", "error", "{", "if", "C", ".", "i2c_start", "(", "l", ".", "lwHandle", ",", "C", ".", "uchar", "(", "address7bit", ")", ",", "C", ".", "uchar", "(", "direction", ")", ")", "==", "1", "{", "return", "nil", "\n", "}", "\n", "if", "err", ":=", "l", ".", "error", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "address7bit", ",", "direction", ")", "\n", "}" ]

[ "i2cStart", "starts", "the", "i2c", "communication", ";", "set", "direction", "to", "1", "for", "reading", "0", "for", "writing" ]

[ "func", "(", "l", "*", "littleWire", ")", "i2cUpdateDelay", "(", "duration", "uint", ")", "error", "{", "C", ".", "i2c_updateDelay", "(", "l", ".", "lwHandle", ",", "C", ".", "uint", "(", "duration", ")", ")", "\n", "return", "l", ".", "error", "(", ")", "\n", "}" ]

[ "i2cUpdateDelay", "updates", "i2c", "signal", "delay", "amount", ".", "Tune", "if", "neccessary", "to", "fit", "your", "requirements" ]

[ "func", "NewMotorDriver", "(", "a", "DigitalWriter", ",", "speedPin", "string", ")", "*", "MotorDriver", "{", "return", "&", "MotorDriver", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "connection", ":", "a", ",", "SpeedPin", ":", "speedPin", ",", "CurrentState", ":", "0", ",", "CurrentSpeed", ":", "0", ",", "CurrentMode", ":", "\"", "\"", ",", "CurrentDirection", ":", "\"", "\"", ",", "}", "\n", "}" ]

[ "NewMotorDriver", "return", "a", "new", "MotorDriver", "given", "a", "DigitalWriter", "and", "pin" ]

[ "func", "(", "m", "*", "MotorDriver", ")", "Off", "(", ")", "(", "err", "error", ")", "{", "if", "m", ".", "isDigital", "(", ")", "{", "err", "=", "m", ".", "changeState", "(", "0", ")", "\n", "}", "else", "{", "err", "=", "m", ".", "Speed", "(", "0", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Off", "turns", "the", "motor", "off", "or", "sets", "the", "motor", "to", "a", "0", "speed" ]

[ "func", "(", "m", "*", "MotorDriver", ")", "On", "(", ")", "(", "err", "error", ")", "{", "if", "m", ".", "isDigital", "(", ")", "{", "err", "=", "m", ".", "changeState", "(", "1", ")", "\n", "}", "else", "{", "if", "m", ".", "CurrentSpeed", "==", "0", "{", "m", ".", "CurrentSpeed", "=", "255", "\n", "}", "\n", "err", "=", "m", ".", "Speed", "(", "m", ".", "CurrentSpeed", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "On", "turns", "the", "motor", "on", "or", "sets", "the", "motor", "to", "a", "maximum", "speed" ]

[ "func", "(", "m", "*", "MotorDriver", ")", "IsOn", "(", ")", "bool", "{", "if", "m", ".", "isDigital", "(", ")", "{", "return", "m", ".", "CurrentState", "==", "1", "\n", "}", "\n", "return", "m", ".", "CurrentSpeed", ">", "0", "\n", "}" ]

[ "IsOn", "returns", "true", "if", "the", "motor", "is", "on" ]

[ "func", "(", "m", "*", "MotorDriver", ")", "Toggle", "(", ")", "(", "err", "error", ")", "{", "if", "m", ".", "IsOn", "(", ")", "{", "err", "=", "m", ".", "Off", "(", ")", "\n", "}", "else", "{", "err", "=", "m", ".", "On", "(", ")", "\n", "}", "\n", "return", "\n", "}" ]

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

[ "func", "(", "m", "*", "MotorDriver", ")", "Speed", "(", "value", "byte", ")", "(", "err", "error", ")", "{", "if", "writer", ",", "ok", ":=", "m", ".", "connection", ".", "(", "PwmWriter", ")", ";", "ok", "{", "m", ".", "CurrentMode", "=", "\"", "\"", "\n", "m", ".", "CurrentSpeed", "=", "value", "\n", "return", "writer", ".", "PwmWrite", "(", "m", ".", "SpeedPin", ",", "value", ")", "\n", "}", "\n", "return", "ErrPwmWriteUnsupported", "\n", "}" ]

[ "Speed", "sets", "the", "speed", "of", "the", "motor" ]

[ "func", "(", "m", "*", "MotorDriver", ")", "Forward", "(", "speed", "byte", ")", "(", "err", "error", ")", "{", "err", "=", "m", ".", "Direction", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "err", "=", "m", ".", "Speed", "(", "speed", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "return", "\n", "}" ]

[ "Forward", "sets", "the", "forward", "pin", "to", "the", "specified", "speed" ]

[ "func", "(", "m", "*", "MotorDriver", ")", "Direction", "(", "direction", "string", ")", "(", "err", "error", ")", "{", "m", ".", "CurrentDirection", "=", "direction", "\n", "if", "m", ".", "DirectionPin", "!=", "\"", "\"", "{", "var", "level", "byte", "\n", "if", "direction", "==", "\"", "\"", "{", "level", "=", "1", "\n", "}", "else", "{", "level", "=", "0", "\n", "}", "\n", "err", "=", "m", ".", "connection", ".", "DigitalWrite", "(", "m", ".", "DirectionPin", ",", "level", ")", "\n", "}", "else", "{", "var", "forwardLevel", ",", "backwardLevel", "byte", "\n", "switch", "direction", "{", "case", "\"", "\"", ":", "forwardLevel", "=", "1", "\n", "backwardLevel", "=", "0", "\n", "case", "\"", "\"", ":", "forwardLevel", "=", "0", "\n", "backwardLevel", "=", "1", "\n", "case", "\"", "\"", ":", "forwardLevel", "=", "0", "\n", "backwardLevel", "=", "0", "\n", "}", "\n", "err", "=", "m", ".", "connection", ".", "DigitalWrite", "(", "m", ".", "ForwardPin", ",", "forwardLevel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "err", "=", "m", ".", "connection", ".", "DigitalWrite", "(", "m", ".", "BackwardPin", ",", "backwardLevel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Direction", "sets", "the", "direction", "pin", "to", "the", "specified", "speed" ]

[ "func", "(", "h", "*", "BH1750Driver", ")", "Start", "(", ")", "(", "err", "error", ")", "{", "bus", ":=", "h", ".", "GetBusOrDefault", "(", "h", ".", "connector", ".", "GetDefaultBus", "(", ")", ")", "\n", "address", ":=", "h", ".", "GetAddressOrDefault", "(", "bh1750Address", ")", "\n\n", "h", ".", "connection", ",", "err", "=", "h", ".", "connector", ".", "GetConnection", "(", "address", ",", "bus", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "err", "=", "h", ".", "connection", ".", "WriteByte", "(", "h", ".", "mode", ")", "\n", "time", ".", "Sleep", "(", "10", "*", "time", ".", "Microsecond", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "Start", "initialized", "the", "bh1750" ]

[ "func", "(", "h", "*", "BH1750Driver", ")", "RawSensorData", "(", ")", "(", "level", "int", ",", "err", "error", ")", "{", "buf", ":=", "[", "]", "byte", "{", "0", ",", "0", "}", "\n", "bytesRead", ",", "err", ":=", "h", ".", "connection", ".", "Read", "(", "buf", ")", "\n", "if", "bytesRead", "!=", "2", "{", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "level", "=", "int", "(", "buf", "[", "0", "]", ")", "<<", "8", "|", "int", "(", "buf", "[", "1", "]", ")", "\n\n", "return", "\n", "}" ]

[ "RawSensorData", "returns", "the", "raw", "value", "from", "the", "bh1750" ]

[ "func", "(", "h", "*", "BH1750Driver", ")", "Lux", "(", ")", "(", "lux", "int", ",", "err", "error", ")", "{", "lux", ",", "err", "=", "h", ".", "RawSensorData", "(", ")", "\n", "lux", "=", "int", "(", "float64", "(", "lux", ")", "/", "1.2", ")", "\n\n", "return", "\n", "}" ]

[ "Lux", "returns", "the", "adjusted", "value", "from", "the", "bh1750" ]

[ "func", "NewAdaptor", "(", ")", "*", "Adaptor", "{", "return", "&", "Adaptor", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "pinmap", ":", "arduinoPinMap", ",", "writeFile", ":", "writeFile", ",", "readFile", ":", "readFile", ",", "mutex", ":", "&", "sync", ".", "Mutex", "{", "}", ",", "}", "\n", "}" ]

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

[ "func", "(", "e", "*", "Adaptor", ")", "Connect", "(", ")", "(", "err", "error", ")", "{", "e", ".", "digitalPins", "=", "make", "(", "map", "[", "int", "]", "*", "sysfs", ".", "DigitalPin", ")", "\n", "e", ".", "pwmPins", "=", "make", "(", "map", "[", "int", "]", "*", "sysfs", ".", "PWMPin", ")", "\n\n", "if", "e", ".", "Board", "(", ")", "==", "\"", "\"", "||", "e", ".", "Board", "(", ")", "==", "\"", "\"", "{", "aerr", ":=", "e", ".", "checkForArduino", "(", ")", "\n", "if", "aerr", "!=", "nil", "{", "return", "aerr", "\n", "}", "\n", "e", ".", "board", "=", "\"", "\"", "\n", "}", "\n\n", "switch", "e", ".", "Board", "(", ")", "{", "case", "\"", "\"", ":", "e", ".", "pinmap", "=", "sparkfunPinMap", "\n", "e", ".", "sparkfunSetup", "(", ")", "\n", "case", "\"", "\"", ":", "e", ".", "pinmap", "=", "arduinoPinMap", "\n", "if", "errs", ":=", "e", ".", "arduinoSetup", "(", ")", ";", "errs", "!=", "nil", "{", "err", "=", "multierror", ".", "Append", "(", "err", ",", "errs", ")", "\n", "}", "\n", "case", "\"", "\"", ":", "e", ".", "pinmap", "=", "miniboardPinMap", "\n", "e", ".", "miniboardSetup", "(", ")", "\n", "default", ":", "errs", ":=", "errors", ".", "New", "(", "\"", "\"", "+", "e", ".", "Board", "(", ")", ")", "\n", "err", "=", "multierror", ".", "Append", "(", "err", ",", "errs", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Connect", "initializes", "the", "Edison", "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", ":=", "e", ".", "pinmap", "[", "pin", "]", "\n", "if", "e", ".", "digitalPins", "[", "i", ".", "pin", "]", "==", "nil", "{", "e", ".", "digitalPins", "[", "i", ".", "pin", "]", ",", "err", "=", "e", ".", "newExportedPin", "(", "i", ".", "pin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "if", "i", ".", "resistor", ">", "0", "{", "e", ".", "digitalPins", "[", "i", ".", "resistor", "]", ",", "err", "=", "e", ".", "newExportedPin", "(", "i", ".", "resistor", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n\n", "if", "i", ".", "levelShifter", ">", "0", "{", "e", ".", "digitalPins", "[", "i", ".", "levelShifter", "]", ",", "err", "=", "e", ".", "newExportedPin", "(", "i", ".", "levelShifter", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "i", ".", "mux", ")", ">", "0", "{", "for", "_", ",", "mux", ":=", "range", "i", ".", "mux", "{", "e", ".", "digitalPins", "[", "mux", ".", "pin", "]", ",", "err", "=", "e", ".", "newExportedPin", "(", "mux", ".", "pin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "err", "=", "pinWrite", "(", "e", ".", "digitalPins", "[", "mux", ".", "pin", "]", ",", "sysfs", ".", "OUT", ",", "mux", ".", "value", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "dir", "==", "\"", "\"", "{", "if", "err", "=", "e", ".", "digitalPins", "[", "i", ".", "pin", "]", ".", "Direction", "(", "sysfs", ".", "IN", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "if", "i", ".", "resistor", ">", "0", "{", "err", "=", "pinWrite", "(", "e", ".", "digitalPins", "[", "i", ".", "resistor", "]", ",", "sysfs", ".", "OUT", ",", "sysfs", ".", "LOW", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n\n", "if", "i", ".", "levelShifter", ">", "0", "{", "err", "=", "pinWrite", "(", "e", ".", "digitalPins", "[", "i", ".", "levelShifter", "]", ",", "sysfs", ".", "OUT", ",", "sysfs", ".", "LOW", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "}", "else", "if", "dir", "==", "\"", "\"", "{", "if", "err", "=", "e", ".", "digitalPins", "[", "i", ".", "pin", "]", ".", "Direction", "(", "sysfs", ".", "OUT", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "if", "i", ".", "resistor", ">", "0", "{", "if", "err", "=", "e", ".", "digitalPins", "[", "i", ".", "resistor", "]", ".", "Direction", "(", "sysfs", ".", "IN", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n\n", "if", "i", ".", "levelShifter", ">", "0", "{", "err", "=", "pinWrite", "(", "e", ".", "digitalPins", "[", "i", ".", "levelShifter", "]", ",", "sysfs", ".", "OUT", ",", "sysfs", ".", "HIGH", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "e", ".", "digitalPins", "[", "i", ".", "pin", "]", ",", "nil", "\n", "}" ]

[ "DigitalPin", "returns", "matched", "sysfs", ".", "DigitalPin", "for", "specified", "values" ]

[ "func", "(", "e", "*", "Adaptor", ")", "arduinoSetup", "(", ")", "(", "err", "error", ")", "{", "if", "err", "=", "e", ".", "exportTristatePin", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "err", "=", "pinWrite", "(", "e", ".", "tristate", ",", "sysfs", ".", "OUT", ",", "sysfs", ".", "LOW", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "for", "_", ",", "i", ":=", "range", "[", "]", "int", "{", "263", ",", "262", "}", "{", "if", "err", "=", "e", ".", "newDigitalPin", "(", "i", ",", "sysfs", ".", "HIGH", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "i", ":=", "range", "[", "]", "int", "{", "240", ",", "241", ",", "242", ",", "243", "}", "{", "if", "err", "=", "e", ".", "newDigitalPin", "(", "i", ",", "sysfs", ".", "LOW", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "i", ":=", "range", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "{", "if", "err", "=", "changePinMode", "(", "e", ",", "i", ",", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "i", ":=", "range", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "{", "if", "err", "=", "changePinMode", "(", "e", ",", "i", ",", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "err", "=", "e", ".", "tristate", ".", "Write", "(", "sysfs", ".", "HIGH", ")", "\n", "return", "\n", "}" ]

[ "arduinoSetup", "does", "needed", "setup", "for", "the", "Arduino", "compatible", "breakout", "board" ]

[ "func", "changePinMode", "(", "a", "*", "Adaptor", ",", "pin", ",", "mode", "string", ")", "(", "err", "error", ")", "{", "_", ",", "err", "=", "a", ".", "writeFile", "(", "\"", "\"", "+", "pin", "+", "\"", "\"", ",", "[", "]", "byte", "(", "\"", "\"", "+", "mode", ")", ",", ")", "\n", "return", "\n", "}" ]

[ "changePinMode", "writes", "pin", "mode", "to", "current_pinmux", "file" ]

[ "func", "pinWrite", "(", "pin", "*", "sysfs", ".", "DigitalPin", ",", "dir", "string", ",", "level", "int", ")", "(", "err", "error", ")", "{", "if", "err", "=", "pin", ".", "Direction", "(", "dir", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "err", "=", "pin", ".", "Write", "(", "level", ")", "\n", "return", "\n", "}" ]

[ "pinWrite", "sets", "Direction", "and", "writes", "level", "for", "a", "specific", "pin" ]

[ "func", "(", "d", "*", "APA102Driver", ")", "SetRGBA", "(", "i", "int", ",", "v", "color", ".", "RGBA", ")", "{", "d", ".", "vals", "[", "i", "]", "=", "v", "\n", "}" ]

[ "SetRGBA", "sets", "the", "ith", "LED", "s", "color", "to", "the", "given", "RGBA", "value", ".", "A", "subsequent", "call", "to", "Draw", "is", "required", "to", "transmit", "values", "to", "the", "LED", "strip", "." ]

[ "func", "(", "d", "*", "APA102Driver", ")", "Draw", "(", ")", "error", "{", "// TODO(jbd): dotstar allows other RGBA alignments, support those layouts.", "n", ":=", "len", "(", "d", ".", "vals", ")", "\n\n", "tx", ":=", "make", "(", "[", "]", "byte", ",", "4", "*", "(", "n", "+", "1", ")", "+", "(", "n", "/", "2", "+", "1", ")", ")", "\n", "tx", "[", "0", "]", "=", "0x00", "\n", "tx", "[", "1", "]", "=", "0x00", "\n", "tx", "[", "2", "]", "=", "0x00", "\n", "tx", "[", "3", "]", "=", "0x00", "\n\n", "for", "i", ",", "c", ":=", "range", "d", ".", "vals", "{", "j", ":=", "(", "i", "+", "1", ")", "*", "4", "\n", "tx", "[", "j", "]", "=", "0xe0", "+", "byte", "(", "c", ".", "R", ")", "\n", "tx", "[", "j", "+", "1", "]", "=", "byte", "(", "c", ".", "B", ")", "\n", "tx", "[", "j", "+", "2", "]", "=", "byte", "(", "c", ".", "G", ")", "\n", "tx", "[", "j", "+", "3", "]", "=", "byte", "(", "c", ".", "R", ")", "\n", "}", "\n\n", "// end frame with at least n/2 0xff vals", "for", "i", ":=", "(", "n", "+", "1", ")", "*", "4", ";", "i", "<", "len", "(", "tx", ")", ";", "i", "++", "{", "tx", "[", "i", "]", "=", "0xff", "\n", "}", "\n\n", "return", "d", ".", "connection", ".", "Tx", "(", "tx", ",", "nil", ")", "\n", "}" ]

[ "Draw", "displays", "the", "RGBA", "values", "set", "on", "the", "actual", "LED", "strip", "." ]

[ "func", "(", "d", "*", "BMP280Driver", ")", "Start", "(", ")", "(", "err", "error", ")", "{", "bus", ":=", "d", ".", "GetBusOrDefault", "(", "d", ".", "connector", ".", "GetDefaultBus", "(", ")", ")", "\n", "address", ":=", "d", ".", "GetAddressOrDefault", "(", "bmp180Address", ")", "\n\n", "if", "d", ".", "connection", ",", "err", "=", "d", ".", "connector", ".", "GetConnection", "(", "address", ",", "bus", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "d", ".", "initialization", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Start", "initializes", "the", "BMP280", "and", "loads", "the", "calibration", "coefficients", "." ]

[ "func", "(", "d", "*", "BMP280Driver", ")", "Pressure", "(", ")", "(", "press", "float32", ",", "err", "error", ")", "{", "var", "rawT", ",", "rawP", "int32", "\n", "if", "rawT", ",", "err", "=", "d", ".", "rawTemp", "(", ")", ";", "err", "!=", "nil", "{", "return", "0.0", ",", "err", "\n", "}", "\n\n", "if", "rawP", ",", "err", "=", "d", ".", "rawPressure", "(", ")", ";", "err", "!=", "nil", "{", "return", "0.0", ",", "err", "\n", "}", "\n", "_", ",", "tFine", ":=", "d", ".", "calculateTemp", "(", "rawT", ")", "\n", "return", "d", ".", "calculatePress", "(", "rawP", ",", "tFine", ")", ",", "nil", "\n", "}" ]

[ "Pressure", "returns", "the", "current", "barometric", "pressure", "in", "Pa" ]

[ "func", "(", "d", "*", "BMP280Driver", ")", "initialization", "(", ")", "(", "err", "error", ")", "{", "var", "coefficients", "[", "]", "byte", "\n", "if", "coefficients", ",", "err", "=", "d", ".", "read", "(", "bmp280RegisterCalib00", ",", "24", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "buf", ":=", "bytes", ".", "NewBuffer", "(", "coefficients", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "d", ".", "tpc", ".", "t1", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "d", ".", "tpc", ".", "t2", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "d", ".", "tpc", ".", "t3", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "d", ".", "tpc", ".", "p1", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "d", ".", "tpc", ".", "p2", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "d", ".", "tpc", ".", "p3", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "d", ".", "tpc", ".", "p4", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "d", ".", "tpc", ".", "p5", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "d", ".", "tpc", ".", "p6", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "d", ".", "tpc", ".", "p7", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "d", ".", "tpc", ".", "p8", ")", "\n", "binary", ".", "Read", "(", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "d", ".", "tpc", ".", "p9", ")", "\n\n", "d", ".", "connection", ".", "WriteByteData", "(", "bmp280RegisterControl", ",", "0x3F", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "initialization", "reads", "the", "calibration", "coefficients", "." ]

[ "func", "(", "s", "*", "DisplayBuffer", ")", "Set", "(", "x", ",", "y", ",", "c", "int", ")", "{", "idx", ":=", "x", "+", "(", "y", "/", "ssd1306PageSize", ")", "*", "s", ".", "Width", "\n", "bit", ":=", "uint", "(", "y", ")", "%", "ssd1306PageSize", "\n\n", "if", "c", "==", "0", "{", "s", ".", "buffer", "[", "idx", "]", "&=", "^", "(", "1", "<<", "bit", ")", "\n", "}", "else", "{", "s", ".", "buffer", "[", "idx", "]", "|=", "(", "1", "<<", "bit", ")", "\n", "}", "\n", "}" ]

[ "Set", "sets", "the", "x", "y", "pixel", "with", "c", "color" ]

[ "func", "WithDisplayWidth", "(", "val", "int", ")", "func", "(", "Config", ")", "{", "return", "func", "(", "c", "Config", ")", "{", "d", ",", "ok", ":=", "c", ".", "(", "*", "SSD1306Driver", ")", "\n", "if", "ok", "{", "d", ".", "DisplayWidth", "=", "val", "\n", "}", "else", "{", "// TODO: return error for trying to set DisplayWidth for non-SSD1306Driver", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "WithDisplayWidth", "option", "sets", "the", "SSD1306Driver", "DisplayWidth", "option", "." ]

[ "func", "WithDisplayHeight", "(", "val", "int", ")", "func", "(", "Config", ")", "{", "return", "func", "(", "c", "Config", ")", "{", "d", ",", "ok", ":=", "c", ".", "(", "*", "SSD1306Driver", ")", "\n", "if", "ok", "{", "d", ".", "DisplayHeight", "=", "val", "\n", "}", "else", "{", "// TODO: return error for trying to set DisplayHeight for non-SSD1306Driver", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "WithDisplayHeight", "option", "sets", "the", "SSD1306Driver", "DisplayHeight", "option", "." ]

[ "func", "(", "s", "*", "SSD1306Driver", ")", "Init", "(", ")", "(", "err", "error", ")", "{", "s", ".", "Off", "(", ")", "\n", "s", ".", "commands", "(", "ssd1306InitSequence", ")", "\n\n", "s", ".", "commands", "(", "[", "]", "byte", "{", "ssd1306ColumnAddr", ",", "0", ",", "// Start at 0,", "byte", "(", "s", ".", "Buffer", ".", "Width", ")", "-", "1", ",", "// End at last column (127?)", "}", ")", "\n\n", "s", ".", "commands", "(", "[", "]", "byte", "{", "ssd1306PageAddr", ",", "0", ",", "// Start at 0,", "(", "byte", "(", "s", ".", "Buffer", ".", "Height", ")", "/", "ssd1306PageSize", ")", "-", "1", ",", "// End at page 7", "}", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Init", "turns", "display", "on" ]

[ "func", "(", "s", "*", "SSD1306Driver", ")", "Set", "(", "x", ",", "y", ",", "c", "int", ")", "{", "s", ".", "Buffer", ".", "Set", "(", "x", ",", "y", ",", "c", ")", "\n", "}" ]

[ "Set", "sets", "a", "pixel" ]

[ "func", "(", "s", "*", "SSD1306Driver", ")", "Reset", "(", ")", "(", "err", "error", ")", "{", "s", ".", "Off", "(", ")", "\n", "s", ".", "Clear", "(", ")", "\n", "s", ".", "On", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Reset", "sends", "the", "memory", "buffer", "to", "the", "display" ]

[ "func", "(", "s", "*", "SSD1306Driver", ")", "SetContrast", "(", "contrast", "byte", ")", "(", "err", "error", ")", "{", "err", "=", "s", ".", "commands", "(", "[", "]", "byte", "{", "ssd1306SetContrast", ",", "contrast", "}", ")", "\n", "return", "\n", "}" ]

[ "SetContrast", "sets", "the", "display", "contrast" ]

[ "func", "(", "s", "*", "SSD1306Driver", ")", "Display", "(", ")", "(", "err", "error", ")", "{", "// Write the buffer", "_", ",", "err", "=", "s", ".", "connection", ".", "Write", "(", "append", "(", "[", "]", "byte", "{", "0x40", "}", ",", "s", ".", "Buffer", ".", "buffer", "...", ")", ")", "\n", "return", "err", "\n", "}" ]

[ "Display", "sends", "the", "memory", "buffer", "to", "the", "display" ]

[ "func", "(", "s", "*", "SSD1306Driver", ")", "commands", "(", "commands", "[", "]", "byte", ")", "(", "err", "error", ")", "{", "var", "command", "[", "]", "byte", "\n", "for", "_", ",", "d", ":=", "range", "commands", "{", "command", "=", "append", "(", "command", ",", "[", "]", "byte", "{", "0x80", ",", "d", "}", "...", ")", "\n", "}", "\n", "_", ",", "err", "=", "s", ".", "connection", ".", "Write", "(", "command", ")", "\n", "return", "\n", "}" ]

[ "commands", "sends", "a", "command", "sequence" ]

[ "func", "NewBLEAdaptor", "(", "args", "...", "interface", "{", "}", ")", "*", "BLEAdaptor", "{", "address", ":=", "args", "[", "0", "]", ".", "(", "string", ")", "\n", "rid", ":=", "ReceiveID", "\n", "wid", ":=", "TransmitID", "\n\n", "if", "len", "(", "args", ")", ">=", "3", "{", "rid", "=", "args", "[", "1", "]", ".", "(", "string", ")", "\n", "wid", "=", "args", "[", "2", "]", ".", "(", "string", ")", "\n", "}", "\n\n", "a", ":=", "NewAdaptor", "(", "address", ")", "\n", "a", ".", "SetName", "(", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ")", "\n", "a", ".", "PortOpener", "=", "func", "(", "port", "string", ")", "(", "io", ".", "ReadWriteCloser", ",", "error", ")", "{", "sp", ":=", "ble", ".", "NewSerialPort", "(", "address", ",", "rid", ",", "wid", ")", "\n", "sp", ".", "Open", "(", ")", "\n", "return", "sp", ",", "nil", "\n", "}", "\n\n", "return", "&", "BLEAdaptor", "{", "Adaptor", ":", "a", ",", "}", "\n", "}" ]

[ "NewBLEAdaptor", "opens", "and", "uses", "a", "BLE", "connection", "to", "a", "microcontroller", "running", "FirmataBLE" ]

[ "func", "NewDriver", "(", "tcpaddress", "string", ",", "udpaddress", "string", ")", "*", "Driver", "{", "command", ":=", "[", "]", "byte", "{", "0xff", ",", "// 2 byte header", "0x04", ",", "// Left joystick", "0x7e", ",", "// throttle 0x00 - 0xff(?)", "0x3f", ",", "// rotate left/right", "// Right joystick", "0xc0", ",", "// forward / backward 0x80 - 0xfe(?)", "0x3f", ",", "// left / right 0x00 - 0x7e(?)", "// Trim", "0x90", ",", "// ? yaw (used as a setting to trim the yaw of the uav)", "0x10", ",", "// ? pitch (used as a setting to trim the pitch of the uav)", "0x10", ",", "// ? roll (used as a setting to trim the roll of the uav)", "0x00", ",", "// flags/buttons", "0x00", ",", "// checksum; 255 - ((sum of flight controls from index 1 to 9) % 256)", "}", "\n", "command", "[", "10", "]", "=", "checksum", "(", "command", ")", "\n\n", "return", "&", "Driver", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "stopc", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "tcpaddress", ":", "tcpaddress", ",", "udpaddress", ":", "udpaddress", ",", "cmd", ":", "command", ",", "mutex", ":", "&", "sync", ".", "RWMutex", "{", "}", "}", "\n", "}" ]

[ "NewDriver", "creates", "a", "driver", "for", "the", "HolyStone", "hs200" ]

[ "func", "(", "d", "Driver", ")", "Enable", "(", ")", "{", "d", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "d", ".", "mutex", ".", "Unlock", "(", ")", "\n", "if", "!", "d", ".", "enabled", "{", "go", "d", ".", "flightLoop", "(", "d", ".", "stopc", ")", "\n", "d", ".", "enabled", "=", "true", "\n", "}", "\n", "}" ]

[ "Enable", "enables", "the", "drone", "to", "start", "flying", "." ]

[ "func", "(", "d", "Driver", ")", "Disable", "(", ")", "{", "d", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "d", ".", "mutex", ".", "Unlock", "(", ")", "\n", "if", "d", ".", "enabled", "{", "d", ".", "stopc", "<-", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}" ]

[ "Disable", "disables", "the", "drone", "from", "flying", "." ]

[ "func", "floatToCmdByte", "(", "cmd", "float32", ",", "mid", "byte", ",", "maxv", "byte", ")", "byte", "{", "if", "cmd", ">", "1.0", "{", "cmd", "=", "1.0", "\n", "}", "\n", "if", "cmd", "<", "-", "1.0", "{", "cmd", "=", "-", "1.0", "\n", "}", "\n", "cmd", "=", "cmd", "*", "float32", "(", "maxv", ")", "\n", "bval", ":=", "byte", "(", "cmd", "+", "float32", "(", "mid", ")", "+", "0.5", ")", "\n", "return", "bval", "\n", "}" ]

[ "floatToCmdByte", "converts", "a", "float", "in", "the", "range", "of", "-", "1", "to", "+", "1", "to", "an", "integer", "command" ]

[ "func", "(", "b", "*", "Client", ")", "Disconnect", "(", ")", "(", "err", "error", ")", "{", "b", ".", "setConnected", "(", "false", ")", "\n", "return", "b", ".", "connection", ".", "Close", "(", ")", "\n", "}" ]

[ "Disconnect", "disconnects", "the", "Client" ]

[ "func", "(", "b", "*", "Client", ")", "Connect", "(", "conn", "io", ".", "ReadWriteCloser", ")", "(", "err", "error", ")", "{", "if", "b", ".", "Connected", "(", ")", "{", "return", "ErrConnected", "\n", "}", "\n\n", "b", ".", "connection", "=", "conn", "\n", "b", ".", "Reset", "(", ")", "\n", "connected", ":=", "make", "(", "chan", "bool", ",", "1", ")", "\n", "connectError", ":=", "make", "(", "chan", "error", ",", "1", ")", "\n\n", "b", ".", "Once", "(", "b", ".", "Event", "(", "\"", "\"", ")", ",", "func", "(", "data", "interface", "{", "}", ")", "{", "e", ":=", "b", ".", "FirmwareQuery", "(", ")", "\n", "if", "e", "!=", "nil", "{", "b", ".", "setConnecting", "(", "false", ")", "\n", "connectError", "<-", "e", "\n", "}", "\n", "}", ")", "\n\n", "b", ".", "Once", "(", "b", ".", "Event", "(", "\"", "\"", ")", ",", "func", "(", "data", "interface", "{", "}", ")", "{", "e", ":=", "b", ".", "CapabilitiesQuery", "(", ")", "\n", "if", "e", "!=", "nil", "{", "b", ".", "setConnecting", "(", "false", ")", "\n", "connectError", "<-", "e", "\n", "}", "\n", "}", ")", "\n\n", "b", ".", "Once", "(", "b", ".", "Event", "(", "\"", "\"", ")", ",", "func", "(", "data", "interface", "{", "}", ")", "{", "e", ":=", "b", ".", "AnalogMappingQuery", "(", ")", "\n", "if", "e", "!=", "nil", "{", "b", ".", "setConnecting", "(", "false", ")", "\n", "connectError", "<-", "e", "\n", "}", "\n", "}", ")", "\n\n", "b", ".", "Once", "(", "b", ".", "Event", "(", "\"", "\"", ")", ",", "func", "(", "data", "interface", "{", "}", ")", "{", "b", ".", "ReportDigital", "(", "0", ",", "1", ")", "\n", "b", ".", "ReportDigital", "(", "1", ",", "1", ")", "\n", "b", ".", "setConnecting", "(", "false", ")", "\n", "b", ".", "setConnected", "(", "true", ")", "\n", "connected", "<-", "true", "\n", "}", ")", "\n\n", "// start it off...", "b", ".", "setConnecting", "(", "true", ")", "\n", "b", ".", "ProtocolVersionQuery", "(", ")", "\n\n", "go", "func", "(", ")", "{", "for", "{", "if", "!", "b", ".", "Connecting", "(", ")", "{", "return", "\n", "}", "\n", "if", "e", ":=", "b", ".", "process", "(", ")", ";", "e", "!=", "nil", "{", "connectError", "<-", "e", "\n", "return", "\n", "}", "\n", "time", ".", "Sleep", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "select", "{", "case", "<-", "connected", ":", "case", "e", ":=", "<-", "connectError", ":", "return", "e", "\n", "case", "<-", "time", ".", "After", "(", "b", ".", "ConnectTimeout", ")", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "go", "func", "(", ")", "{", "for", "{", "if", "!", "b", ".", "Connected", "(", ")", "{", "break", "\n", "}", "\n\n", "if", "err", ":=", "b", ".", "process", "(", ")", ";", "err", "!=", "nil", "{", "b", ".", "Publish", "(", "b", ".", "Event", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "return", "\n", "}" ]

[ "Connect", "connects", "to", "the", "Client", "given", "conn", ".", "It", "first", "resets", "the", "firmata", "board", "then", "continuously", "polls", "the", "firmata", "board", "for", "new", "information", "when", "it", "s", "available", "." ]

[ "func", "(", "b", "*", "Client", ")", "SetPinMode", "(", "pin", "int", ",", "mode", "int", ")", "error", "{", "b", ".", "pins", "[", "byte", "(", "pin", ")", "]", ".", "Mode", "=", "mode", "\n", "return", "b", ".", "write", "(", "[", "]", "byte", "{", "PinMode", ",", "byte", "(", "pin", ")", ",", "byte", "(", "mode", ")", "}", ")", "\n", "}" ]

[ "SetPinMode", "sets", "the", "pin", "to", "mode", "." ]

[ "func", "(", "b", "*", "Client", ")", "DigitalWrite", "(", "pin", "int", ",", "value", "int", ")", "error", "{", "port", ":=", "byte", "(", "math", ".", "Floor", "(", "float64", "(", "pin", ")", "/", "8", ")", ")", "\n", "portValue", ":=", "byte", "(", "0", ")", "\n\n", "b", ".", "pins", "[", "pin", "]", ".", "Value", "=", "value", "\n\n", "for", "i", ":=", "byte", "(", "0", ")", ";", "i", "<", "8", ";", "i", "++", "{", "if", "b", ".", "pins", "[", "8", "*", "port", "+", "i", "]", ".", "Value", "!=", "0", "{", "portValue", "=", "portValue", "|", "(", "1", "<<", "i", ")", "\n", "}", "\n", "}", "\n", "return", "b", ".", "write", "(", "[", "]", "byte", "{", "DigitalMessage", "|", "port", ",", "portValue", "&", "0x7F", ",", "(", "portValue", ">>", "7", ")", "&", "0x7F", "}", ")", "\n", "}" ]

[ "DigitalWrite", "writes", "value", "to", "pin", "." ]

[ "func", "(", "b", "*", "Client", ")", "ServoConfig", "(", "pin", "int", ",", "max", "int", ",", "min", "int", ")", "error", "{", "ret", ":=", "[", "]", "byte", "{", "ServoConfig", ",", "byte", "(", "pin", ")", ",", "byte", "(", "min", "&", "0x7F", ")", ",", "byte", "(", "(", "min", ">>", "7", ")", "&", "0x7F", ")", ",", "byte", "(", "max", "&", "0x7F", ")", ",", "byte", "(", "(", "max", ">>", "7", ")", "&", "0x7F", ")", ",", "}", "\n", "return", "b", ".", "WriteSysex", "(", "ret", ")", "\n", "}" ]

[ "ServoConfig", "sets", "the", "min", "and", "max", "pulse", "width", "for", "servo", "PWM", "range" ]

[ "func", "(", "b", "*", "Client", ")", "AnalogWrite", "(", "pin", "int", ",", "value", "int", ")", "error", "{", "b", ".", "pins", "[", "pin", "]", ".", "Value", "=", "value", "\n", "return", "b", ".", "write", "(", "[", "]", "byte", "{", "AnalogMessage", "|", "byte", "(", "pin", ")", ",", "byte", "(", "value", "&", "0x7F", ")", ",", "byte", "(", "(", "value", ">>", "7", ")", "&", "0x7F", ")", "}", ")", "\n", "}" ]

[ "AnalogWrite", "writes", "value", "to", "pin", "." ]

[ "func", "(", "b", "*", "Client", ")", "PinStateQuery", "(", "pin", "int", ")", "error", "{", "return", "b", ".", "WriteSysex", "(", "[", "]", "byte", "{", "PinStateQuery", ",", "byte", "(", "pin", ")", "}", ")", "\n", "}" ]

[ "PinStateQuery", "sends", "a", "PinStateQuery", "for", "pin", "." ]

[ "func", "(", "b", "*", "Client", ")", "ReportDigital", "(", "pin", "int", ",", "state", "int", ")", "error", "{", "return", "b", ".", "togglePinReporting", "(", "pin", ",", "state", ",", "ReportDigital", ")", "\n", "}" ]

[ "ReportDigital", "enables", "or", "disables", "digital", "reporting", "for", "pin", "a", "non", "zero", "state", "enables", "reporting" ]

[ "func", "(", "b", "*", "Client", ")", "ReportAnalog", "(", "pin", "int", ",", "state", "int", ")", "error", "{", "return", "b", ".", "togglePinReporting", "(", "pin", ",", "state", ",", "ReportAnalog", ")", "\n", "}" ]

[ "ReportAnalog", "enables", "or", "disables", "analog", "reporting", "for", "pin", "a", "non", "zero", "state", "enables", "reporting" ]

[ "func", "(", "b", "*", "Client", ")", "I2cRead", "(", "address", "int", ",", "numBytes", "int", ")", "error", "{", "return", "b", ".", "WriteSysex", "(", "[", "]", "byte", "{", "I2CRequest", ",", "byte", "(", "address", ")", ",", "(", "I2CModeRead", "<<", "3", ")", ",", "byte", "(", "numBytes", ")", "&", "0x7F", ",", "(", "byte", "(", "numBytes", ")", ">>", "7", ")", "&", "0x7F", "}", ")", "\n", "}" ]

[ "I2cRead", "reads", "numBytes", "from", "address", "once", "." ]

[ "func", "(", "b", "*", "Client", ")", "I2cWrite", "(", "address", "int", ",", "data", "[", "]", "byte", ")", "error", "{", "ret", ":=", "[", "]", "byte", "{", "I2CRequest", ",", "byte", "(", "address", ")", ",", "(", "I2CModeWrite", "<<", "3", ")", "}", "\n", "for", "_", ",", "val", ":=", "range", "data", "{", "ret", "=", "append", "(", "ret", ",", "byte", "(", "val", "&", "0x7F", ")", ")", "\n", "ret", "=", "append", "(", "ret", ",", "byte", "(", "(", "val", ">>", "7", ")", "&", "0x7F", ")", ")", "\n", "}", "\n", "return", "b", ".", "WriteSysex", "(", "ret", ")", "\n", "}" ]

[ "I2cWrite", "writes", "data", "to", "address", "." ]

[ "func", "(", "b", "*", "Client", ")", "I2cConfig", "(", "delay", "int", ")", "error", "{", "return", "b", ".", "WriteSysex", "(", "[", "]", "byte", "{", "I2CConfig", ",", "byte", "(", "delay", "&", "0xFF", ")", ",", "byte", "(", "(", "delay", ">>", "8", ")", "&", "0xFF", ")", "}", ")", "\n", "}" ]

[ "I2cConfig", "configures", "the", "delay", "in", "which", "a", "register", "can", "be", "read", "from", "after", "it", "has", "been", "written", "to", "." ]

[ "func", "(", "b", "*", "Client", ")", "WriteSysex", "(", "data", "[", "]", "byte", ")", "(", "err", "error", ")", "{", "return", "b", ".", "write", "(", "append", "(", "[", "]", "byte", "{", "StartSysex", "}", ",", "append", "(", "data", ",", "EndSysex", ")", "...", ")", ")", "\n", "}" ]

[ "WriteSysex", "writes", "an", "arbitrary", "Sysex", "command", "to", "the", "microcontroller", "." ]

[ "func", "NewDriver", "(", "a", "ble", ".", "BLEConnector", ")", "*", "Driver", "{", "n", ":=", "&", "Driver", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "connection", ":", "a", ",", "Pcmd", ":", "Pcmd", "{", "Flag", ":", "0", ",", "Roll", ":", "0", ",", "Pitch", ":", "0", ",", "Yaw", ":", "0", ",", "Gaz", ":", "0", ",", "Psi", ":", "0", ",", "}", ",", "Eventer", ":", "gobot", ".", "NewEventer", "(", ")", ",", "}", "\n\n", "n", ".", "AddEvent", "(", "Battery", ")", "\n", "n", ".", "AddEvent", "(", "FlightStatus", ")", "\n\n", "n", ".", "AddEvent", "(", "Takeoff", ")", "\n", "n", ".", "AddEvent", "(", "Flying", ")", "\n", "n", ".", "AddEvent", "(", "Hovering", ")", "\n", "n", ".", "AddEvent", "(", "Landing", ")", "\n", "n", ".", "AddEvent", "(", "Landed", ")", "\n", "n", ".", "AddEvent", "(", "Emergency", ")", "\n", "n", ".", "AddEvent", "(", "Rolling", ")", "\n\n", "return", "n", "\n", "}" ]

[ "NewDriver", "creates", "a", "Parrot", "Minidrone", "Driver" ]

[ "func", "(", "b", "*", "Driver", ")", "Init", "(", ")", "(", "err", "error", ")", "{", "b", ".", "GenerateAllStates", "(", ")", "\n\n", "// subscribe to battery notifications", "b", ".", "adaptor", "(", ")", ".", "Subscribe", "(", "batteryCharacteristic", ",", "func", "(", "data", "[", "]", "byte", ",", "e", "error", ")", "{", "b", ".", "Publish", "(", "b", ".", "Event", "(", "Battery", ")", ",", "data", "[", "len", "(", "data", ")", "-", "1", "]", ")", "\n", "}", ")", "\n\n", "// subscribe to flying status notifications", "b", ".", "adaptor", "(", ")", ".", "Subscribe", "(", "flightStatusCharacteristic", ",", "func", "(", "data", "[", "]", "byte", ",", "e", "error", ")", "{", "b", ".", "processFlightStatus", "(", "data", ")", "\n", "}", ")", "\n\n", "return", "\n", "}" ]

[ "Init", "initializes", "the", "BLE", "insterfaces", "used", "by", "the", "Minidrone" ]

[ "func", "(", "b", "*", "Driver", ")", "GenerateAllStates", "(", ")", "(", "err", "error", ")", "{", "b", ".", "stepsfa0b", "++", "\n", "buf", ":=", "[", "]", "byte", "{", "0x04", ",", "byte", "(", "b", ".", "stepsfa0b", ")", ",", "0x00", ",", "0x04", ",", "0x01", ",", "0x00", ",", "0x32", ",", "0x30", ",", "0x31", ",", "0x34", ",", "0x2D", ",", "0x31", ",", "0x30", ",", "0x2D", ",", "0x32", ",", "0x38", ",", "0x00", "}", "\n", "err", "=", "b", ".", "adaptor", "(", ")", ".", "WriteCharacteristic", "(", "commandCharacteristic", ",", "buf", ")", "\n\n", "return", "\n", "}" ]

[ "GenerateAllStates", "sets", "up", "all", "the", "default", "states", "aka", "settings", "on", "the", "drone" ]

[ "func", "(", "b", "*", "Driver", ")", "Emergency", "(", ")", "(", "err", "error", ")", "{", "b", ".", "stepsfa0b", "++", "\n", "buf", ":=", "[", "]", "byte", "{", "0x02", ",", "byte", "(", "b", ".", "stepsfa0b", ")", "&", "0xff", ",", "0x02", ",", "0x00", ",", "0x04", ",", "0x00", "}", "\n", "err", "=", "b", ".", "adaptor", "(", ")", ".", "WriteCharacteristic", "(", "priorityCharacteristic", ",", "buf", ")", "\n\n", "return", "err", "\n", "}" ]

[ "Emergency", "sets", "the", "Minidrone", "into", "emergency", "mode" ]

[ "func", "(", "b", "*", "Driver", ")", "StartPcmd", "(", ")", "{", "go", "func", "(", ")", "{", "// wait a little bit so that there is enough time to get some ACKs", "time", ".", "Sleep", "(", "500", "*", "time", ".", "Millisecond", ")", "\n", "for", "{", "err", ":=", "b", ".", "adaptor", "(", ")", ".", "WriteCharacteristic", "(", "pcmdCharacteristic", ",", "b", ".", "generatePcmd", "(", ")", ".", "Bytes", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Println", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "time", ".", "Sleep", "(", "50", "*", "time", ".", "Millisecond", ")", "\n", "}", "\n", "}", "(", ")", "\n", "}" ]

[ "StartPcmd", "starts", "the", "continuous", "Pcmd", "communication", "with", "the", "Minidrone" ]

[ "func", "(", "b", "*", "Driver", ")", "Stop", "(", ")", "error", "{", "b", ".", "pcmdMutex", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "pcmdMutex", ".", "Unlock", "(", ")", "\n\n", "b", ".", "Pcmd", "=", "Pcmd", "{", "Flag", ":", "0", ",", "Roll", ":", "0", ",", "Pitch", ":", "0", ",", "Yaw", ":", "0", ",", "Gaz", ":", "0", ",", "Psi", ":", "0", ",", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Stop", "tells", "the", "drone", "to", "stop", "moving", "in", "any", "direction", "and", "simply", "hover", "in", "place" ]

[ "func", "(", "b", "*", "Driver", ")", "RightFlip", "(", ")", "(", "err", "error", ")", "{", "return", "b", ".", "adaptor", "(", ")", ".", "WriteCharacteristic", "(", "commandCharacteristic", ",", "b", ".", "generateAnimation", "(", "2", ")", ".", "Bytes", "(", ")", ")", "\n", "}" ]

[ "RightFlip", "tells", "the", "drone", "to", "perform", "a", "flip", "to", "the", "right" ]

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

[ "NewDeviceInformationDriver", "creates", "a", "DeviceInformationDriver" ]

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

[ "GetFirmwareRevision", "returns", "the", "firmware", "revision", "for", "the", "BLE", "Peripheral" ]

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

[ "GetManufacturerName", "returns", "the", "manufacturer", "name", "for", "the", "BLE", "Peripheral" ]

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

[ "GetPnPId", "returns", "the", "PnP", "ID", "for", "the", "BLE", "Peripheral" ]

[ "func", "NewMotorDriver", "(", "megaPi", "*", "Adaptor", ",", "port", "byte", ")", "*", "MotorDriver", "{", "return", "&", "MotorDriver", "{", "name", ":", "\"", "\"", ",", "megaPi", ":", "megaPi", ",", "port", ":", "port", ",", "halted", ":", "true", ",", "syncRoot", ":", "&", "sync", ".", "Mutex", "{", "}", ",", "}", "\n", "}" ]

[ "NewMotorDriver", "creates", "a", "new", "MotorDriver", "at", "the", "given", "port" ]

[ "func", "(", "m", "*", "MotorDriver", ")", "Start", "(", ")", "error", "{", "m", ".", "syncRoot", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "syncRoot", ".", "Unlock", "(", ")", "\n", "m", ".", "halted", "=", "false", "\n", "m", ".", "speedHelper", "(", "0", ")", "\n", "return", "nil", "\n", "}" ]

[ "Start", "implements", "the", "Driver", "interface" ]

[ "func", "(", "m", "*", "MotorDriver", ")", "Halt", "(", ")", "error", "{", "m", ".", "syncRoot", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "syncRoot", ".", "Unlock", "(", ")", "\n", "m", ".", "halted", "=", "true", "\n", "m", ".", "speedHelper", "(", "0", ")", "\n", "return", "nil", "\n", "}" ]

[ "Halt", "terminates", "the", "Driver", "interface" ]

[ "func", "(", "m", "*", "MotorDriver", ")", "Speed", "(", "speed", "int16", ")", "error", "{", "m", ".", "syncRoot", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "syncRoot", ".", "Unlock", "(", ")", "\n", "if", "m", ".", "halted", "{", "return", "nil", "\n", "}", "\n", "m", ".", "speedHelper", "(", "speed", ")", "\n", "return", "nil", "\n", "}" ]

[ "Speed", "sets", "the", "motors", "speed", "to", "the", "specified", "value" ]

[ "func", "(", "m", "*", "MotorDriver", ")", "speedHelper", "(", "speed", "int16", ")", "{", "m", ".", "sendSpeed", "(", "speed", "-", "1", ")", "\n", "m", ".", "sendSpeed", "(", "speed", ")", "\n", "}" ]

[ "there", "is", "some", "sort", "of", "bug", "on", "the", "hardware", "such", "that", "you", "cannot", "send", "the", "exact", "same", "speed", "to", "2", "different", "motors", "consecutively", "hence", "we", "ensure", "we", "always", "alternate", "speeds" ]

[ "func", "(", "m", "*", "MotorDriver", ")", "sendSpeed", "(", "speed", "int16", ")", "{", "bufOut", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n\n", "// byte sequence: 0xff, 0x55, id, action, device, port", "bufOut", ".", "Write", "(", "[", "]", "byte", "{", "0xff", ",", "0x55", ",", "0x6", ",", "0x0", ",", "0x2", ",", "0xa", ",", "m", ".", "port", "}", ")", "\n", "binary", ".", "Write", "(", "bufOut", ",", "binary", ".", "LittleEndian", ",", "speed", ")", "\n", "bufOut", ".", "Write", "(", "[", "]", "byte", "{", "0xa", "}", ")", "\n", "m", ".", "megaPi", ".", "writeBytesChannel", "<-", "bufOut", ".", "Bytes", "(", ")", "\n", "}" ]

[ "sendSpeed", "sets", "the", "motors", "speed", "to", "the", "specified", "value" ]

[ "func", "NewTCPAdaptor", "(", "args", "...", "interface", "{", "}", ")", "*", "TCPAdaptor", "{", "address", ":=", "args", "[", "0", "]", ".", "(", "string", ")", "\n\n", "a", ":=", "NewAdaptor", "(", "address", ")", "\n", "a", ".", "SetName", "(", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ")", "\n", "a", ".", "PortOpener", "=", "func", "(", "port", "string", ")", "(", "io", ".", "ReadWriteCloser", ",", "error", ")", "{", "return", "connect", "(", "port", ")", "\n", "}", "\n\n", "return", "&", "TCPAdaptor", "{", "Adaptor", ":", "a", ",", "}", "\n", "}" ]

[ "NewTCPAdaptor", "opens", "and", "uses", "a", "TCP", "connection", "to", "a", "microcontroller", "running", "WiFiFirmata" ]

[ "func", "NewAPI", "(", "m", "*", "gobot", ".", "Master", ")", "*", "API", "{", "return", "&", "API", "{", "master", ":", "m", ",", "router", ":", "pat", ".", "New", "(", ")", ",", "Port", ":", "\"", "\"", ",", "start", ":", "func", "(", "a", "*", "API", ")", "{", "log", ".", "Println", "(", "\"", "\"", "+", "a", ".", "Host", "+", "\"", "\"", "+", "a", ".", "Port", "+", "\"", "\"", ")", "\n", "http", ".", "Handle", "(", "\"", "\"", ",", "a", ")", "\n\n", "go", "func", "(", ")", "{", "if", "a", ".", "Cert", "!=", "\"", "\"", "&&", "a", ".", "Key", "!=", "\"", "\"", "{", "http", ".", "ListenAndServeTLS", "(", "a", ".", "Host", "+", "\"", "\"", "+", "a", ".", "Port", ",", "a", ".", "Cert", ",", "a", ".", "Key", ",", "nil", ")", "\n", "}", "else", "{", "log", ".", "Println", "(", "\"", "\"", "+", "\"", "\"", ")", "\n", "http", ".", "ListenAndServe", "(", "a", ".", "Host", "+", "\"", "\"", "+", "a", ".", "Port", ",", "nil", ")", "\n", "}", "\n", "}", "(", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "NewAPI", "returns", "a", "new", "api", "instance" ]

[ "func", "(", "a", "*", "API", ")", "ServeHTTP", "(", "res", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "for", "_", ",", "handler", ":=", "range", "a", ".", "handlers", "{", "rec", ":=", "httptest", ".", "NewRecorder", "(", ")", "\n", "handler", "(", "rec", ",", "req", ")", "\n", "for", "k", ",", "v", ":=", "range", "rec", ".", "Header", "(", ")", "{", "res", ".", "Header", "(", ")", "[", "k", "]", "=", "v", "\n", "}", "\n", "if", "rec", ".", "Code", "==", "http", ".", "StatusUnauthorized", "{", "http", ".", "Error", "(", "res", ",", "\"", "\"", ",", "http", ".", "StatusUnauthorized", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "a", ".", "router", ".", "ServeHTTP", "(", "res", ",", "req", ")", "\n", "}" ]

[ "ServeHTTP", "calls", "api", "handlers", "and", "then", "serves", "request", "using", "api", "router" ]

[ "func", "(", "a", "*", "API", ")", "Delete", "(", "path", "string", ",", "f", "func", "(", "http", ".", "ResponseWriter", ",", "*", "http", ".", "Request", ")", ")", "{", "a", ".", "router", ".", "Del", "(", "path", ",", "http", ".", "HandlerFunc", "(", "f", ")", ")", "\n", "}" ]

[ "Delete", "wraps", "api", "router", "Delete", "call" ]

[ "func", "(", "a", "*", "API", ")", "Options", "(", "path", "string", ",", "f", "func", "(", "http", ".", "ResponseWriter", ",", "*", "http", ".", "Request", ")", ")", "{", "a", ".", "router", ".", "Options", "(", "path", ",", "http", ".", "HandlerFunc", "(", "f", ")", ")", "\n", "}" ]

[ "Options", "wraps", "api", "router", "Options", "call" ]

[ "func", "(", "a", "*", "API", ")", "AddHandler", "(", "f", "func", "(", "http", ".", "ResponseWriter", ",", "*", "http", ".", "Request", ")", ")", "{", "a", ".", "handlers", "=", "append", "(", "a", ".", "handlers", ",", "f", ")", "\n", "}" ]

[ "AddHandler", "appends", "handler", "to", "api", "handlers" ]

[ "func", "(", "a", "*", "API", ")", "AddRobeauxRoutes", "(", ")", "{", "a", ".", "AddC3PIORoutes", "(", ")", "\n\n", "a", ".", "Get", "(", "\"", "\"", ",", "func", "(", "res", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "http", ".", "Redirect", "(", "res", ",", "req", ",", "\"", "\"", ",", "http", ".", "StatusMovedPermanently", ")", "\n", "}", ")", "\n", "a", ".", "Get", "(", "\"", "\"", ",", "a", ".", "robeaux", ")", "\n", "a", ".", "Get", "(", "\"", "\"", ",", "a", ".", "robeaux", ")", "\n", "a", ".", "Get", "(", "\"", "\"", ",", "a", ".", "robeaux", ")", "\n", "a", ".", "Get", "(", "\"", "\"", ",", "a", ".", "robeaux", ")", "\n", "a", ".", "Get", "(", "\"", "\"", ",", "a", ".", "robeaux", ")", "\n", "a", ".", "Get", "(", "\"", "\"", ",", "a", ".", "robeaux", ")", "\n", "a", ".", "Get", "(", "\"", "\"", ",", "a", ".", "robeaux", ")", "\n", "a", ".", "Get", "(", "\"", "\"", ",", "a", ".", "robeaux", ")", "\n", "a", ".", "Get", "(", "\"", "\"", ",", "a", ".", "robeaux", ")", "\n", "}" ]

[ "AddRobeauxRoutes", "adds", "all", "of", "the", "robeaux", "web", "interface", "routes", "to", "the", "API", ".", "The", "Robeaux", "web", "interface", "requires", "the", "C3PIO", "API", "so", "it", "is", "also", "activated", "when", "you", "call", "this", "method", "." ]

[ "func", "(", "a", "*", "API", ")", "robeaux", "(", "res", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "path", ":=", "req", ".", "URL", ".", "Path", "\n", "buf", ",", "err", ":=", "robeaux", ".", "Asset", "(", "path", "[", "1", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "http", ".", "Error", "(", "res", ",", "err", ".", "Error", "(", ")", ",", "http", ".", "StatusNotFound", ")", "\n", "return", "\n", "}", "\n", "t", ":=", "strings", ".", "Split", "(", "path", ",", "\"", "\"", ")", "\n", "if", "t", "[", "len", "(", "t", ")", "-", "1", "]", "==", "\"", "\"", "{", "res", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "else", "if", "t", "[", "len", "(", "t", ")", "-", "1", "]", "==", "\"", "\"", "{", "res", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "else", "if", "t", "[", "len", "(", "t", ")", "-", "1", "]", "==", "\"", "\"", "{", "res", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "res", ".", "Write", "(", "buf", ")", "\n", "}" ]

[ "robeaux", "returns", "handler", "for", "robeaux", "routes", ".", "Writes", "asset", "in", "response", "and", "sets", "correct", "header" ]

[ "func", "(", "a", "*", "API", ")", "mcp", "(", "res", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "gobot", ".", "NewJSONMaster", "(", "a", ".", "master", ")", "}", ",", "res", ")", "\n", "}" ]

[ "mcp", "returns", "MCP", "route", "handler", ".", "Writes", "JSON", "with", "gobot", "representation" ]

[ "func", "(", "a", "*", "API", ")", "robots", "(", "res", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "jsonRobots", ":=", "[", "]", "*", "gobot", ".", "JSONRobot", "{", "}", "\n", "a", ".", "master", ".", "Robots", "(", ")", ".", "Each", "(", "func", "(", "r", "*", "gobot", ".", "Robot", ")", "{", "jsonRobots", "=", "append", "(", "jsonRobots", ",", "gobot", ".", "NewJSONRobot", "(", "r", ")", ")", "\n", "}", ")", "\n", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "jsonRobots", "}", ",", "res", ")", "\n", "}" ]

[ "robots", "returns", "route", "handler", ".", "Writes", "JSON", "with", "robots", "representation" ]

[ "func", "(", "a", "*", "API", ")", "robot", "(", "res", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "if", "robot", ",", "err", ":=", "a", ".", "jsonRobotFor", "(", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ")", ";", "err", "!=", "nil", "{", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "err", ".", "Error", "(", ")", "}", ",", "res", ")", "\n", "}", "else", "{", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "robot", "}", ",", "res", ")", "\n", "}", "\n", "}" ]

[ "robot", "returns", "route", "handler", ".", "Writes", "JSON", "with", "robot", "representation" ]

[ "func", "(", "a", "*", "API", ")", "robotDevices", "(", "res", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "if", "robot", ":=", "a", ".", "master", ".", "Robot", "(", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ")", ";", "robot", "!=", "nil", "{", "jsonDevices", ":=", "[", "]", "*", "gobot", ".", "JSONDevice", "{", "}", "\n", "robot", ".", "Devices", "(", ")", ".", "Each", "(", "func", "(", "d", "gobot", ".", "Device", ")", "{", "jsonDevices", "=", "append", "(", "jsonDevices", ",", "gobot", ".", "NewJSONDevice", "(", "d", ")", ")", "\n", "}", ")", "\n", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "jsonDevices", "}", ",", "res", ")", "\n", "}", "else", "{", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "\"", "\"", "+", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", "}", ",", "res", ")", "\n", "}", "\n", "}" ]

[ "robotDevices", "returns", "devices", "route", "handler", ".", "Writes", "JSON", "with", "robot", "devices", "representation" ]

[ "func", "(", "a", "*", "API", ")", "robotDevice", "(", "res", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "if", "device", ",", "err", ":=", "a", ".", "jsonDeviceFor", "(", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ",", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ")", ";", "err", "!=", "nil", "{", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "err", ".", "Error", "(", ")", "}", ",", "res", ")", "\n", "}", "else", "{", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "device", "}", ",", "res", ")", "\n", "}", "\n", "}" ]

[ "robotDevice", "returns", "device", "route", "handler", ".", "Writes", "JSON", "with", "robot", "device", "representation" ]

[ "func", "(", "a", "*", "API", ")", "robotConnections", "(", "res", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "jsonConnections", ":=", "[", "]", "*", "gobot", ".", "JSONConnection", "{", "}", "\n", "if", "robot", ":=", "a", ".", "master", ".", "Robot", "(", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ")", ";", "robot", "!=", "nil", "{", "robot", ".", "Connections", "(", ")", ".", "Each", "(", "func", "(", "c", "gobot", ".", "Connection", ")", "{", "jsonConnections", "=", "append", "(", "jsonConnections", ",", "gobot", ".", "NewJSONConnection", "(", "c", ")", ")", "\n", "}", ")", "\n", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "jsonConnections", "}", ",", "res", ")", "\n", "}", "else", "{", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "\"", "\"", "+", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", "}", ",", "res", ")", "\n", "}", "\n\n", "}" ]

[ "robotConnections", "returns", "connections", "route", "handler", "writes", "JSON", "with", "robot", "connections", "representation" ]

[ "func", "(", "a", "*", "API", ")", "robotConnection", "(", "res", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "if", "conn", ",", "err", ":=", "a", ".", "jsonConnectionFor", "(", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ",", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ")", ";", "err", "!=", "nil", "{", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "err", ".", "Error", "(", ")", "}", ",", "res", ")", "\n", "}", "else", "{", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "conn", "}", ",", "res", ")", "\n", "}", "\n", "}" ]

[ "robotConnection", "returns", "connection", "route", "handler", "writes", "JSON", "with", "robot", "connection", "representation" ]

[ "func", "(", "a", "*", "API", ")", "executeMcpCommand", "(", "res", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "a", ".", "executeCommand", "(", "a", ".", "master", ".", "Command", "(", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ")", ",", "res", ",", "req", ",", ")", "\n", "}" ]

[ "executeMcpCommand", "calls", "a", "global", "command", "associated", "to", "requested", "route" ]

[ "func", "(", "a", "*", "API", ")", "executeRobotDeviceCommand", "(", "res", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "if", "_", ",", "err", ":=", "a", ".", "jsonDeviceFor", "(", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ",", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ")", ";", "err", "!=", "nil", "{", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "err", ".", "Error", "(", ")", "}", ",", "res", ")", "\n", "}", "else", "{", "a", ".", "executeCommand", "(", "a", ".", "master", ".", "Robot", "(", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ")", ".", "Device", "(", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ")", ".", "(", "gobot", ".", "Commander", ")", ".", "Command", "(", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ")", ",", "res", ",", "req", ",", ")", "\n", "}", "\n", "}" ]

[ "executeRobotDeviceCommand", "calls", "a", "device", "command", "associated", "to", "requested", "route" ]

[ "func", "(", "a", "*", "API", ")", "executeRobotCommand", "(", "res", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "if", "_", ",", "err", ":=", "a", ".", "jsonRobotFor", "(", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ")", ";", "err", "!=", "nil", "{", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "err", ".", "Error", "(", ")", "}", ",", "res", ")", "\n", "}", "else", "{", "a", ".", "executeCommand", "(", "a", ".", "master", ".", "Robot", "(", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ")", ".", "Command", "(", "req", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ")", ",", "res", ",", "req", ",", ")", "\n", "}", "\n", "}" ]

[ "executeRobotCommand", "calls", "a", "robot", "command", "associated", "to", "requested", "route" ]

[ "func", "(", "a", "*", "API", ")", "executeCommand", "(", "f", "func", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "interface", "{", "}", ",", "res", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ",", ")", "{", "body", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "json", ".", "NewDecoder", "(", "req", ".", "Body", ")", ".", "Decode", "(", "&", "body", ")", "\n\n", "if", "f", "!=", "nil", "{", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "f", "(", "body", ")", "}", ",", "res", ")", "\n", "}", "else", "{", "a", ".", "writeJSON", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "\"", "\"", "}", ",", "res", ")", "\n", "}", "\n", "}" ]

[ "executeCommand", "writes", "JSON", "response", "with", "f", "returned", "value", "." ]

[ "func", "(", "a", "*", "API", ")", "writeJSON", "(", "j", "interface", "{", "}", ",", "res", "http", ".", "ResponseWriter", ")", "{", "data", ",", "_", ":=", "json", ".", "Marshal", "(", "j", ")", "\n", "res", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "res", ".", "Write", "(", "data", ")", "\n", "}" ]

[ "writeJSON", "writes", "j", "as", "JSON", "in", "response" ]

[ "func", "(", "a", "*", "API", ")", "Debug", "(", ")", "{", "a", ".", "AddHandler", "(", "func", "(", "res", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "log", ".", "Println", "(", "req", ")", "\n", "}", ")", "\n", "}" ]

[ "Debug", "add", "handler", "to", "api", "that", "prints", "each", "request" ]

[ "func", "NewAdaptor", "(", "deviceID", "string", ",", "accessToken", "string", ")", "*", "Adaptor", "{", "return", "&", "Adaptor", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "DeviceID", ":", "deviceID", ",", "AccessToken", ":", "accessToken", ",", "servoPins", ":", "make", "(", "map", "[", "string", "]", "bool", ")", ",", "APIServer", ":", "\"", "\"", ",", "Eventer", ":", "gobot", ".", "NewEventer", "(", ")", ",", "}", "\n", "}" ]

[ "NewAdaptor", "creates", "new", "Photon", "adaptor", "with", "deviceId", "and", "accessToken", "using", "api", ".", "particle", ".", "io", "server", "as", "default" ]

[ "func", "(", "s", "*", "Adaptor", ")", "AnalogRead", "(", "pin", "string", ")", "(", "val", "int", ",", "err", "error", ")", "{", "params", ":=", "url", ".", "Values", "{", "\"", "\"", ":", "{", "pin", "}", ",", "\"", "\"", ":", "{", "s", ".", "AccessToken", "}", ",", "}", "\n\n", "url", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "s", ".", "deviceURL", "(", ")", ")", "\n\n", "resp", ",", "err", ":=", "s", ".", "request", "(", "\"", "\"", ",", "url", ",", "params", ")", "\n", "if", "err", "==", "nil", "{", "val", "=", "int", "(", "resp", "[", "\"", "\"", "]", ".", "(", "float64", ")", ")", "\n", "return", "\n", "}", "\n\n", "return", "0", ",", "err", "\n", "}" ]

[ "AnalogRead", "reads", "analog", "ping", "value", "using", "Particle", "cloud", "api" ]

[ "func", "(", "s", "*", "Adaptor", ")", "PwmWrite", "(", "pin", "string", ",", "level", "byte", ")", "(", "err", "error", ")", "{", "return", "s", ".", "AnalogWrite", "(", "pin", ",", "level", ")", "\n", "}" ]

[ "PwmWrite", "writes", "in", "pin", "using", "analog", "write", "api" ]

[ "func", "(", "s", "*", "Adaptor", ")", "AnalogWrite", "(", "pin", "string", ",", "level", "byte", ")", "(", "err", "error", ")", "{", "params", ":=", "url", ".", "Values", "{", "\"", "\"", ":", "{", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "pin", ",", "level", ")", "}", ",", "\"", "\"", ":", "{", "s", ".", "AccessToken", "}", ",", "}", "\n", "url", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "s", ".", "deviceURL", "(", ")", ")", "\n", "_", ",", "err", "=", "s", ".", "request", "(", "\"", "\"", ",", "url", ",", "params", ")", "\n", "return", "\n", "}" ]

[ "AnalogWrite", "writes", "analog", "pin", "with", "specified", "level", "using", "Particle", "cloud", "api" ]