Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "p", "*", "PWMPin", ")", "Polarity", "(", ")", "(", "polarity", "string", ",", "err", "error", ")", "{", "buf", ",", "err", ":=", "p", ".", "read", "(", "p", ".", "pwmPolarityPath", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "len", "(", "buf", ")", "==", "0", "{", "return", "\"", "\"", ",", "nil", "\n", "}", "\n\n", "return", "string", "(", "buf", ")", ",", "nil", "\n", "}" ]

[ "Polarity", "returns", "current", "polarity", "value" ]

[ "func", "(", "p", "*", "PWMPin", ")", "InvertPolarity", "(", "invert", "bool", ")", "(", "err", "error", ")", "{", "if", "!", "p", ".", "enabled", "{", "polarity", ":=", "\"", "\"", "\n", "if", "invert", "{", "polarity", "=", "\"", "\"", "\n", "}", "\n", "_", ",", "err", "=", "p", ".", "write", "(", "p", ".", "pwmPolarityPath", "(", ")", ",", "[", "]", "byte", "(", "polarity", ")", ")", "\n", "}", "else", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "InvertPolarity", "writes", "value", "to", "pwm", "polarity", "path" ]

[ "func", "(", "p", "*", "PWMPin", ")", "Period", "(", ")", "(", "period", "uint32", ",", "err", "error", ")", "{", "buf", ",", "err", ":=", "p", ".", "read", "(", "p", ".", "pwmPeriodPath", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "len", "(", "buf", ")", "==", "0", "{", "return", "0", ",", "nil", "\n", "}", "\n\n", "v", ":=", "bytes", ".", "TrimRight", "(", "buf", ",", "\"", "\\n", "\"", ")", "\n", "val", ",", "e", ":=", "strconv", ".", "Atoi", "(", "string", "(", "v", ")", ")", "\n", "return", "uint32", "(", "val", ")", ",", "e", "\n", "}" ]

[ "Period", "reads", "from", "pwm", "period", "path", "and", "returns", "value", "in", "nanoseconds" ]

[ "func", "(", "p", "*", "PWMPin", ")", "SetPeriod", "(", "period", "uint32", ")", "(", "err", "error", ")", "{", "_", ",", "err", "=", "p", ".", "write", "(", "p", ".", "pwmPeriodPath", "(", ")", ",", "[", "]", "byte", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "period", ")", ")", ")", "\n", "return", "\n", "}" ]

[ "SetPeriod", "sets", "pwm", "period", "in", "nanoseconds" ]

[ "func", "(", "p", "*", "PWMPin", ")", "DutyCycle", "(", ")", "(", "duty", "uint32", ",", "err", "error", ")", "{", "buf", ",", "err", ":=", "p", ".", "read", "(", "p", ".", "pwmDutyCyclePath", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "val", ",", "e", ":=", "strconv", ".", "Atoi", "(", "string", "(", "buf", ")", ")", "\n", "return", "uint32", "(", "val", ")", ",", "e", "\n", "}" ]

[ "DutyCycle", "reads", "from", "pwm", "duty", "cycle", "path", "and", "returns", "value", "in", "nanoseconds" ]

[ "func", "(", "p", "*", "PWMPin", ")", "SetDutyCycle", "(", "duty", "uint32", ")", "(", "err", "error", ")", "{", "_", ",", "err", "=", "p", ".", "write", "(", "p", ".", "pwmDutyCyclePath", "(", ")", ",", "[", "]", "byte", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "duty", ")", ")", ")", "\n", "return", "\n", "}" ]

[ "SetDutyCycle", "writes", "value", "to", "pwm", "duty", "cycle", "path", "duty", "is", "in", "nanoseconds" ]

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

[ "NewLEDDriver", "creates", "a", "Microbit", "LEDDriver" ]

[ "func", "(", "b", "*", "LEDDriver", ")", "ReadMatrix", "(", ")", "(", "data", "[", "]", "byte", ",", "err", "error", ")", "{", "data", ",", "err", "=", "b", ".", "adaptor", "(", ")", ".", "ReadCharacteristic", "(", "ledMatrixStateCharacteristic", ")", "\n", "return", "\n", "}" ]

[ "ReadMatrix", "read", "the", "current", "LED", "matrix", "state" ]

[ "func", "(", "b", "*", "LEDDriver", ")", "WriteMatrix", "(", "data", "[", "]", "byte", ")", "(", "err", "error", ")", "{", "err", "=", "b", ".", "adaptor", "(", ")", ".", "WriteCharacteristic", "(", "ledMatrixStateCharacteristic", ",", "data", ")", "\n", "return", "\n", "}" ]

[ "WriteMatrix", "writes", "an", "array", "of", "5", "bytes", "to", "set", "the", "LED", "matrix" ]

[ "func", "(", "b", "*", "LEDDriver", ")", "WriteText", "(", "msg", "string", ")", "(", "err", "error", ")", "{", "err", "=", "b", ".", "adaptor", "(", ")", ".", "WriteCharacteristic", "(", "ledTextCharacteristic", ",", "[", "]", "byte", "(", "msg", ")", ")", "\n", "return", "err", "\n", "}" ]

[ "WriteText", "writes", "a", "text", "message", "to", "the", "Microbit", "LED", "matrix" ]

[ "func", "(", "b", "*", "LEDDriver", ")", "Blank", "(", ")", "(", "err", "error", ")", "{", "buf", ":=", "[", "]", "byte", "{", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", "\n", "err", "=", "b", ".", "WriteMatrix", "(", "buf", ")", "\n", "return", "\n", "}" ]

[ "Blank", "clears", "the", "LEDs", "on", "the", "Microbit" ]

[ "func", "(", "b", "*", "LEDDriver", ")", "Solid", "(", ")", "(", "err", "error", ")", "{", "buf", ":=", "[", "]", "byte", "{", "0x1F", ",", "0x1F", ",", "0x1F", ",", "0x1F", ",", "0x1F", "}", "\n", "err", "=", "b", ".", "WriteMatrix", "(", "buf", ")", "\n", "return", "\n", "}" ]

[ "Solid", "turns", "on", "all", "of", "the", "Microbit", "LEDs" ]

[ "func", "(", "b", "*", "LEDDriver", ")", "UpRightArrow", "(", ")", "(", "err", "error", ")", "{", "buf", ":=", "[", "]", "byte", "{", "0x0F", ",", "0x03", ",", "0x05", ",", "0x09", ",", "0x10", "}", "\n", "err", "=", "b", ".", "WriteMatrix", "(", "buf", ")", "\n", "return", "\n", "}" ]

[ "UpRightArrow", "displays", "an", "arrow", "pointing", "upwards", "and", "to", "the", "right", "on", "the", "Microbit", "LEDs" ]

[ "func", "(", "b", "*", "LEDDriver", ")", "UpLeftArrow", "(", ")", "(", "err", "error", ")", "{", "buf", ":=", "[", "]", "byte", "{", "0x1E", ",", "0x18", ",", "0x14", ",", "0x12", ",", "0x01", "}", "\n", "err", "=", "b", ".", "WriteMatrix", "(", "buf", ")", "\n", "return", "\n", "}" ]

[ "UpLeftArrow", "displays", "an", "arrow", "pointing", "upwards", "and", "to", "the", "left", "on", "the", "Microbit", "LEDs" ]

[ "func", "(", "b", "*", "LEDDriver", ")", "DownRightArrow", "(", ")", "(", "err", "error", ")", "{", "buf", ":=", "[", "]", "byte", "{", "0x10", ",", "0x09", ",", "0x05", ",", "0x03", ",", "0x0F", "}", "\n", "err", "=", "b", ".", "WriteMatrix", "(", "buf", ")", "\n", "return", "\n", "}" ]

[ "DownRightArrow", "displays", "an", "arrow", "pointing", "down", "and", "to", "the", "right", "on", "the", "Microbit", "LEDs" ]

[ "func", "(", "b", "*", "LEDDriver", ")", "DownLeftArrow", "(", ")", "(", "err", "error", ")", "{", "buf", ":=", "[", "]", "byte", "{", "0x01", ",", "0x12", ",", "0x14", ",", "0x18", ",", "0x1E", "}", "\n", "err", "=", "b", ".", "WriteMatrix", "(", "buf", ")", "\n", "return", "\n", "}" ]

[ "DownLeftArrow", "displays", "an", "arrow", "pointing", "down", "and", "to", "the", "left", "on", "the", "Microbit", "LEDs" ]

[ "func", "(", "b", "*", "LEDDriver", ")", "Dimond", "(", ")", "(", "err", "error", ")", "{", "buf", ":=", "[", "]", "byte", "{", "0x04", ",", "0x0A", ",", "0x11", ",", "0x0A", ",", "0x04", "}", "\n", "err", "=", "b", ".", "WriteMatrix", "(", "buf", ")", "\n", "return", "\n", "}" ]

[ "Dimond", "displays", "a", "dimond", "on", "the", "Microbit", "LEDs" ]

[ "func", "(", "b", "*", "LEDDriver", ")", "Smile", "(", ")", "(", "err", "error", ")", "{", "buf", ":=", "[", "]", "byte", "{", "0x0A", ",", "0x0A", ",", "0x00", ",", "0x11", ",", "0x0E", "}", "\n", "err", "=", "b", ".", "WriteMatrix", "(", "buf", ")", "\n", "return", "\n", "}" ]

[ "Smile", "displays", "a", "smile", "on", "the", "Microbit", "LEDs" ]

[ "func", "(", "b", "*", "LEDDriver", ")", "Wink", "(", ")", "(", "err", "error", ")", "{", "buf", ":=", "[", "]", "byte", "{", "0x08", ",", "0x0B", ",", "0x00", ",", "0x11", ",", "0x0E", "}", "\n", "err", "=", "b", ".", "WriteMatrix", "(", "buf", ")", "\n", "return", "\n", "}" ]

[ "Wink", "displays", "a", "wink", "on", "the", "Microbit", "LEDs" ]

[ "func", "(", "s", "*", "ServoDriver", ")", "Move", "(", "angle", "uint8", ")", "(", "err", "error", ")", "{", "if", "!", "(", "angle", ">=", "0", "&&", "angle", "<=", "180", ")", "{", "return", "ErrServoOutOfRange", "\n", "}", "\n", "s", ".", "CurrentAngle", "=", "angle", "\n", "return", "s", ".", "connection", ".", "ServoWrite", "(", "s", ".", "Pin", "(", ")", ",", "angle", ")", "\n", "}" ]

[ "Move", "sets", "the", "servo", "to", "the", "specified", "angle", ".", "Acceptable", "angles", "are", "0", "-", "180" ]

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

[ "NewAccelerometerDriver", "creates", "a", "Microbit", "AccelerometerDriver" ]

[ "func", "NewWindowDriver", "(", ")", "*", "WindowDriver", "{", "return", "&", "WindowDriver", "{", "name", ":", "\"", "\"", ",", "start", ":", "func", "(", "w", "*", "WindowDriver", ")", "{", "w", ".", "window", "=", "gocv", ".", "NewWindow", "(", "w", ".", "Name", "(", ")", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "NewWindowDriver", "creates", "a", "new", "window", "driver", ".", "It", "adds", "an", "start", "function", "to", "initialize", "window" ]

[ "func", "(", "w", "*", "WindowDriver", ")", "ShowImage", "(", "img", "gocv", ".", "Mat", ")", "{", "w", ".", "window", ".", "IMShow", "(", "img", ")", "\n", "}" ]

[ "ShowImage", "displays", "image", "in", "window" ]

[ "func", "(", "c", "*", "commander", ")", "Command", "(", "name", "string", ")", "(", "command", "func", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "interface", "{", "}", ")", "{", "command", ",", "_", "=", "c", ".", "commands", "[", "name", "]", "\n", "return", "\n", "}" ]

[ "Command", "returns", "the", "command", "interface", "whene", "passed", "a", "valid", "command", "name" ]

[ "func", "(", "c", "*", "commander", ")", "AddCommand", "(", "name", "string", ",", "command", "func", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "interface", "{", "}", ")", "{", "c", ".", "commands", "[", "name", "]", "=", "command", "\n", "}" ]

[ "AddCommand", "adds", "a", "new", "command", "when", "passed", "a", "command", "name", "and", "the", "command", "interface", "." ]

[ "func", "NewSerialPort", "(", "address", "string", ",", "rid", "string", ",", "tid", "string", ")", "*", "SerialPort", "{", "return", "&", "SerialPort", "{", "address", ":", "address", ",", "rid", ":", "rid", ",", "tid", ":", "tid", "}", "\n", "}" ]

[ "NewSerialPort", "returns", "a", "new", "serial", "over", "Bluetooth", "LE", "connection" ]

[ "func", "(", "p", "*", "SerialPort", ")", "Open", "(", ")", "(", "err", "error", ")", "{", "p", ".", "client", "=", "NewClientAdaptor", "(", "p", ".", "address", ")", "\n\n", "err", "=", "p", ".", "client", ".", "Connect", "(", ")", "\n\n", "// subscribe to response notifications", "p", ".", "client", ".", "Subscribe", "(", "p", ".", "rid", ",", "func", "(", "data", "[", "]", "byte", ",", "e", "error", ")", "{", "p", ".", "responseMutex", ".", "Lock", "(", ")", "\n", "p", ".", "responseData", "=", "append", "(", "p", ".", "responseData", ",", "data", "...", ")", "\n", "p", ".", "responseMutex", ".", "Unlock", "(", ")", "\n", "}", ")", "\n", "return", "\n", "}" ]

[ "Open", "opens", "a", "connection", "to", "a", "BLE", "serial", "device" ]

[ "func", "(", "p", "*", "SerialPort", ")", "Read", "(", "b", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "if", "len", "(", "p", ".", "responseData", ")", "==", "0", "{", "return", "\n", "}", "\n\n", "p", ".", "responseMutex", ".", "Lock", "(", ")", "\n", "n", "=", "len", "(", "b", ")", "\n", "if", "len", "(", "p", ".", "responseData", ")", "<", "n", "{", "n", "=", "len", "(", "p", ".", "responseData", ")", "\n", "}", "\n", "copy", "(", "b", ",", "p", ".", "responseData", "[", ":", "n", "]", ")", "\n\n", "if", "len", "(", "p", ".", "responseData", ")", ">", "n", "{", "p", ".", "responseData", "=", "p", ".", "responseData", "[", "n", ":", "]", "\n", "}", "else", "{", "p", ".", "responseData", "=", "nil", "\n", "}", "\n", "p", ".", "responseMutex", ".", "Unlock", "(", ")", "\n\n", "return", "\n", "}" ]

[ "Read", "reads", "bytes", "from", "BLE", "serial", "port", "connection" ]

[ "func", "(", "p", "*", "SerialPort", ")", "Write", "(", "b", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "err", "=", "p", ".", "client", ".", "WriteCharacteristic", "(", "p", ".", "tid", ",", "b", ")", "\n", "n", "=", "len", "(", "b", ")", "\n", "return", "\n", "}" ]

[ "Write", "writes", "to", "the", "BLE", "serial", "port", "connection" ]

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

[ "Start", "initializes", "the", "driver", "." ]

[ "func", "(", "d", "*", "MCP3004Driver", ")", "Read", "(", "channel", "int", ")", "(", "result", "int", ",", "err", "error", ")", "{", "if", "channel", "<", "0", "||", "channel", ">", "MCP3004DriverMaxChannel", "-", "1", "{", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "tx", ":=", "make", "(", "[", "]", "byte", ",", "3", ")", "\n", "tx", "[", "0", "]", "=", "0x01", "\n", "tx", "[", "1", "]", "=", "byte", "(", "8", "+", "channel", ")", "<<", "4", "\n", "tx", "[", "2", "]", "=", "0x00", "\n\n", "rx", ":=", "make", "(", "[", "]", "byte", ",", "3", ")", "\n\n", "err", "=", "d", ".", "connection", ".", "Tx", "(", "tx", ",", "rx", ")", "\n", "if", "err", "==", "nil", "&&", "len", "(", "rx", ")", "==", "3", "{", "result", "=", "int", "(", "(", "rx", "[", "1", "]", "&", "0x3", ")", ")", "<<", "8", "+", "int", "(", "rx", "[", "2", "]", ")", "\n", "}", "\n\n", "return", "result", ",", "err", "\n", "}" ]

[ "Read", "reads", "the", "current", "analog", "data", "for", "the", "desired", "channel", "." ]

[ "func", "NewI2cDevice", "(", "location", "string", ")", "(", "d", "*", "i2cDevice", ",", "err", "error", ")", "{", "d", "=", "&", "i2cDevice", "{", "}", "\n\n", "if", "d", ".", "file", ",", "err", "=", "OpenFile", "(", "location", ",", "os", ".", "O_RDWR", ",", "os", ".", "ModeExclusive", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "err", "=", "d", ".", "queryFunctionality", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "NewI2cDevice", "returns", "an", "io", ".", "ReadWriteCloser", "with", "the", "proper", "ioctrl", "given", "an", "i2c", "bus", "location", "." ]

[ "func", "(", "d", "*", "i2cDevice", ")", "Write", "(", "b", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "return", "d", ".", "file", ".", "Write", "(", "b", ")", "\n", "}" ]

[ "Write", "implements", "the", "io", ".", "ReadWriteCloser", "method", "by", "direct", "I2C", "write", "operations", "." ]

[ "func", "NewAdaptor", "(", ")", "*", "Adaptor", "{", "return", "&", "Adaptor", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "drone", ":", "client", ".", "New", "(", ")", ",", "connect", ":", "func", "(", "a", "*", "Adaptor", ")", "error", "{", "return", "a", ".", "drone", ".", "Connect", "(", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "NewAdaptor", "returns", "a", "new", "BebopAdaptor" ]

[ "func", "NewFirmataI2cConnection", "(", "adaptor", "*", "Adaptor", ",", "address", "int", ")", "(", "connection", "*", "firmataI2cConnection", ")", "{", "return", "&", "firmataI2cConnection", "{", "adaptor", ":", "adaptor", ",", "address", ":", "address", "}", "\n", "}" ]

[ "NewFirmataI2cConnection", "creates", "an", "I2C", "connection", "to", "an", "I2C", "device", "at", "the", "specified", "address" ]

[ "func", "(", "h", "*", "LIDARLiteDriver", ")", "Start", "(", ")", "(", "err", "error", ")", "{", "bus", ":=", "h", ".", "GetBusOrDefault", "(", "h", ".", "connector", ".", "GetDefaultBus", "(", ")", ")", "\n", "address", ":=", "h", ".", "GetAddressOrDefault", "(", "lidarliteAddress", ")", "\n\n", "h", ".", "connection", ",", "err", "=", "h", ".", "connector", ".", "GetConnection", "(", "address", ",", "bus", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "\n", "}" ]

[ "Start", "initialized", "the", "LIDAR" ]

[ "func", "(", "h", "*", "LIDARLiteDriver", ")", "Distance", "(", ")", "(", "distance", "int", ",", "err", "error", ")", "{", "if", "_", ",", "err", "=", "h", ".", "connection", ".", "Write", "(", "[", "]", "byte", "{", "0x00", ",", "0x04", "}", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "time", ".", "Sleep", "(", "20", "*", "time", ".", "Millisecond", ")", "\n\n", "if", "_", ",", "err", "=", "h", ".", "connection", ".", "Write", "(", "[", "]", "byte", "{", "0x0F", "}", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "upper", ":=", "[", "]", "byte", "{", "0", "}", "\n", "bytesRead", ",", "err", ":=", "h", ".", "connection", ".", "Read", "(", "upper", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "if", "bytesRead", "!=", "1", "{", "err", "=", "ErrNotEnoughBytes", "\n", "return", "\n", "}", "\n\n", "if", "_", ",", "err", "=", "h", ".", "connection", ".", "Write", "(", "[", "]", "byte", "{", "0x10", "}", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "lower", ":=", "[", "]", "byte", "{", "0", "}", "\n", "bytesRead", ",", "err", "=", "h", ".", "connection", ".", "Read", "(", "lower", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "if", "bytesRead", "!=", "1", "{", "err", "=", "ErrNotEnoughBytes", "\n", "return", "\n", "}", "\n\n", "distance", "=", "(", "(", "int", "(", "upper", "[", "0", "]", ")", "&", "0xff", ")", "<<", "8", ")", "|", "(", "int", "(", "lower", "[", "0", "]", ")", "&", "0xff", ")", "\n\n", "return", "\n", "}" ]

[ "Distance", "returns", "the", "current", "distance", "in", "cm" ]

[ "func", "NewAdaptor", "(", "host", "string", ",", "clientID", "string", ")", "*", "Adaptor", "{", "return", "&", "Adaptor", "{", "name", ":", "gobot", ".", "DefaultName", "(", "\"", "\"", ")", ",", "Host", ":", "host", ",", "autoReconnect", ":", "false", ",", "cleanSession", ":", "true", ",", "useSSL", ":", "false", ",", "clientID", ":", "clientID", ",", "}", "\n", "}" ]

[ "NewAdaptor", "creates", "a", "new", "mqtt", "adaptor", "with", "specified", "host", "and", "client", "id" ]

[ "func", "NewAdaptorWithAuth", "(", "host", ",", "clientID", ",", "username", ",", "password", "string", ")", "*", "Adaptor", "{", "return", "&", "Adaptor", "{", "name", ":", "\"", "\"", ",", "Host", ":", "host", ",", "autoReconnect", ":", "false", ",", "cleanSession", ":", "true", ",", "useSSL", ":", "false", ",", "clientID", ":", "clientID", ",", "username", ":", "username", ",", "password", ":", "password", ",", "}", "\n", "}" ]

[ "NewAdaptorWithAuth", "creates", "a", "new", "mqtt", "adaptor", "with", "specified", "host", "client", "id", "username", "and", "password", "." ]

[ "func", "(", "a", "*", "Adaptor", ")", "Connect", "(", ")", "(", "err", "error", ")", "{", "a", ".", "client", "=", "paho", ".", "NewClient", "(", "a", ".", "createClientOptions", "(", ")", ")", "\n", "if", "token", ":=", "a", ".", "client", ".", "Connect", "(", ")", ";", "token", ".", "Wait", "(", ")", "&&", "token", ".", "Error", "(", ")", "!=", "nil", "{", "err", "=", "multierror", ".", "Append", "(", "err", ",", "token", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "Connect", "returns", "true", "if", "connection", "to", "mqtt", "is", "established" ]

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

[ "Disconnect", "returns", "true", "if", "connection", "to", "mqtt", "is", "closed" ]

[ "func", "(", "a", "*", "Adaptor", ")", "On", "(", "event", "string", ",", "f", "func", "(", "msg", "Message", ")", ")", "bool", "{", "if", "a", ".", "client", "==", "nil", "{", "return", "false", "\n", "}", "\n", "a", ".", "client", ".", "Subscribe", "(", "event", ",", "0", ",", "func", "(", "client", "paho", ".", "Client", ",", "msg", "paho", ".", "Message", ")", "{", "f", "(", "msg", ")", "\n", "}", ")", "\n", "return", "true", "\n", "}" ]

[ "On", "subscribes", "to", "a", "topic", "and", "then", "calls", "the", "message", "handler", "function", "when", "data", "is", "received" ]

[ "func", "(", "a", "*", "Adaptor", ")", "newTLSConfig", "(", ")", "*", "tls", ".", "Config", "{", "// Import server certificate", "var", "certpool", "*", "x509", ".", "CertPool", "\n", "if", "len", "(", "a", ".", "ServerCert", "(", ")", ")", ">", "0", "{", "certpool", "=", "x509", ".", "NewCertPool", "(", ")", "\n", "pemCerts", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "a", ".", "ServerCert", "(", ")", ")", "\n", "if", "err", "==", "nil", "{", "certpool", ".", "AppendCertsFromPEM", "(", "pemCerts", ")", "\n", "}", "\n", "}", "\n\n", "// Import client certificate/key pair", "var", "certs", "[", "]", "tls", ".", "Certificate", "\n", "if", "len", "(", "a", ".", "ClientCert", "(", ")", ")", ">", "0", "&&", "len", "(", "a", ".", "ClientKey", "(", ")", ")", ">", "0", "{", "cert", ",", "err", ":=", "tls", ".", "LoadX509KeyPair", "(", "a", ".", "ClientCert", "(", ")", ",", "a", ".", "ClientKey", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "// TODO: proper error handling", "panic", "(", "err", ")", "\n", "}", "\n", "certs", "=", "append", "(", "certs", ",", "cert", ")", "\n", "}", "\n\n", "// Create tls.Config with desired tls properties", "return", "&", "tls", ".", "Config", "{", "// RootCAs = certs used to verify server cert.", "RootCAs", ":", "certpool", ",", "// ClientAuth = whether to request cert from server.", "// Since the server is set up for SSL, this happens", "// anyways.", "ClientAuth", ":", "tls", ".", "NoClientCert", ",", "// ClientCAs = certs used to validate client cert.", "ClientCAs", ":", "nil", ",", "// InsecureSkipVerify = verify that cert contents", "// match server. IP matches what is in cert etc.", "InsecureSkipVerify", ":", "true", ",", "// Certificates = list of certs client sends to server.", "Certificates", ":", "certs", ",", "}", "\n", "}" ]

[ "newTLSConfig", "sets", "the", "TLS", "config", "in", "the", "case", "that", "we", "are", "using", "an", "MQTT", "broker", "with", "TLS" ]

[ "func", "(", "h", "*", "JHD1313M1Driver", ")", "Start", "(", ")", "(", "err", "error", ")", "{", "bus", ":=", "h", ".", "GetBusOrDefault", "(", "h", ".", "connector", ".", "GetDefaultBus", "(", ")", ")", "\n\n", "if", "h", ".", "lcdConnection", ",", "err", "=", "h", ".", "connector", ".", "GetConnection", "(", "h", ".", "lcdAddress", ",", "bus", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "h", ".", "rgbConnection", ",", "err", "=", "h", ".", "connector", ".", "GetConnection", "(", "h", ".", "rgbAddress", ",", "bus", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!", "// according to datasheet, we need at least 40ms after power rises above 2.7V", "// before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50", "time", ".", "Sleep", "(", "50", "*", "time", ".", "Millisecond", ")", "\n\n", "// this is according to the hitachi HD44780 datasheet", "// page 45 figure 23", "// Send function set command sequence", "init_payload", ":=", "[", "]", "byte", "{", "LCD_CMD", ",", "LCD_FUNCTIONSET", "|", "LCD_2LINE", "}", "\n", "if", "_", ",", "err", ":=", "h", ".", "lcdConnection", ".", "Write", "(", "init_payload", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// wait more than 4.1ms", "time", ".", "Sleep", "(", "4500", "*", "time", ".", "Microsecond", ")", "\n", "// second try", "if", "_", ",", "err", ":=", "h", ".", "lcdConnection", ".", "Write", "(", "init_payload", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "time", ".", "Sleep", "(", "150", "*", "time", ".", "Microsecond", ")", "\n", "// third go", "if", "_", ",", "err", ":=", "h", ".", "lcdConnection", ".", "Write", "(", "init_payload", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "h", ".", "lcdConnection", ".", "Write", "(", "[", "]", "byte", "{", "LCD_CMD", ",", "LCD_DISPLAYCONTROL", "|", "LCD_DISPLAYON", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "time", ".", "Sleep", "(", "100", "*", "time", ".", "Microsecond", ")", "\n", "if", "err", ":=", "h", ".", "Clear", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "h", ".", "lcdConnection", ".", "Write", "(", "[", "]", "byte", "{", "LCD_CMD", ",", "LCD_ENTRYMODESET", "|", "LCD_ENTRYLEFT", "|", "LCD_ENTRYSHIFTDECREMENT", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "h", ".", "setReg", "(", "0", ",", "0", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "h", ".", "setReg", "(", "1", ",", "0", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "h", ".", "setReg", "(", "0x08", ",", "0xAA", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "h", ".", "SetRGB", "(", "255", ",", "255", ",", "255", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Start", "starts", "the", "backlit", "and", "the", "screen", "and", "initializes", "the", "states", "." ]

[ "func", "(", "h", "*", "JHD1313M1Driver", ")", "SetRGB", "(", "r", ",", "g", ",", "b", "int", ")", "error", "{", "if", "err", ":=", "h", ".", "setReg", "(", "REG_RED", ",", "r", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "h", ".", "setReg", "(", "REG_GREEN", ",", "g", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "h", ".", "setReg", "(", "REG_BLUE", ",", "b", ")", "\n", "}" ]

[ "SetRGB", "sets", "the", "Red", "Green", "Blue", "value", "of", "backlit", "." ]

[ "func", "(", "h", "*", "JHD1313M1Driver", ")", "Clear", "(", ")", "error", "{", "err", ":=", "h", ".", "command", "(", "[", "]", "byte", "{", "LCD_CLEARDISPLAY", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "Clear", "clears", "the", "text", "on", "the", "lCD", "display", "." ]

[ "func", "(", "h", "*", "JHD1313M1Driver", ")", "Home", "(", ")", "error", "{", "err", ":=", "h", ".", "command", "(", "[", "]", "byte", "{", "LCD_RETURNHOME", "}", ")", "\n", "// This wait fixes a race condition when calling home and clear back to back.", "time", ".", "Sleep", "(", "2", "*", "time", ".", "Millisecond", ")", "\n", "return", "err", "\n", "}" ]

[ "Home", "sets", "the", "cursor", "to", "the", "origin", "position", "on", "the", "display", "." ]

[ "func", "(", "h", "*", "JHD1313M1Driver", ")", "Write", "(", "message", "string", ")", "error", "{", "// This wait fixes an odd bug where the clear function doesn't always work properly.", "time", ".", "Sleep", "(", "1", "*", "time", ".", "Millisecond", ")", "\n", "for", "_", ",", "val", ":=", "range", "message", "{", "if", "val", "==", "'\\n'", "{", "if", "err", ":=", "h", ".", "SetPosition", "(", "16", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "continue", "\n", "}", "\n", "if", "_", ",", "err", ":=", "h", ".", "lcdConnection", ".", "Write", "(", "[", "]", "byte", "{", "LCD_DATA", ",", "byte", "(", "val", ")", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Write", "displays", "the", "passed", "message", "on", "the", "screen", "." ]

[ "func", "(", "h", "*", "JHD1313M1Driver", ")", "SetPosition", "(", "pos", "int", ")", "(", "err", "error", ")", "{", "if", "pos", "<", "0", "||", "pos", ">", "31", "{", "err", "=", "ErrInvalidPosition", "\n", "return", "\n", "}", "\n", "offset", ":=", "byte", "(", "pos", ")", "\n", "if", "pos", ">=", "16", "{", "offset", "-=", "16", "\n", "offset", "|=", "LCD_2NDLINEOFFSET", "\n", "}", "\n", "err", "=", "h", ".", "command", "(", "[", "]", "byte", "{", "LCD_SETDDRAMADDR", "|", "offset", "}", ")", "\n", "return", "\n", "}" ]

[ "SetPosition", "sets", "the", "cursor", "and", "the", "data", "display", "to", "pos", ".", "0", "..", "15", "are", "the", "positions", "in", "the", "first", "display", "line", ".", "16", "..", "32", "are", "the", "positions", "in", "the", "second", "display", "line", "." ]

[ "func", "(", "h", "*", "JHD1313M1Driver", ")", "Scroll", "(", "lr", "bool", ")", "error", "{", "if", "lr", "{", "_", ",", "err", ":=", "h", ".", "lcdConnection", ".", "Write", "(", "[", "]", "byte", "{", "LCD_CMD", ",", "LCD_CURSORSHIFT", "|", "LCD_DISPLAYMOVE", "|", "LCD_MOVELEFT", "}", ")", "\n", "return", "err", "\n", "}", "\n\n", "_", ",", "err", ":=", "h", ".", "lcdConnection", ".", "Write", "(", "[", "]", "byte", "{", "LCD_CMD", ",", "LCD_CURSORSHIFT", "|", "LCD_DISPLAYMOVE", "|", "LCD_MOVERIGHT", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "Scroll", "sets", "the", "scrolling", "direction", "for", "the", "display", "either", "left", "to", "right", "or", "right", "to", "left", "." ]

[ "func", "(", "n", "*", "Driver", ")", "Start", "(", ")", "(", "err", "error", ")", "{", "go", "func", "(", ")", "{", "for", "{", "buff", ":=", "make", "(", "[", "]", "byte", ",", "1024", ")", "\n", "_", ",", "err", ":=", "n", ".", "adaptor", "(", ")", ".", "sp", ".", "Read", "(", "buff", "[", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "n", ".", "Publish", "(", "n", ".", "Event", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "else", "{", "n", ".", "parse", "(", "bytes", ".", "NewBuffer", "(", "buff", ")", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "return", "\n", "}" ]

[ "Start", "creates", "a", "go", "routine", "to", "listen", "from", "serial", "port", "and", "parse", "buffer", "readings" ]

[ "func", "(", "n", "*", "Driver", ")", "parse", "(", "buf", "*", "bytes", ".", "Buffer", ")", "{", "for", "buf", ".", "Len", "(", ")", ">", "2", "{", "b1", ",", "_", ":=", "buf", ".", "ReadByte", "(", ")", "\n", "b2", ",", "_", ":=", "buf", ".", "ReadByte", "(", ")", "\n", "if", "b1", "==", "BTSync", "&&", "b2", "==", "BTSync", "{", "length", ",", "_", ":=", "buf", ".", "ReadByte", "(", ")", "\n", "payload", ":=", "make", "(", "[", "]", "byte", ",", "length", ")", "\n", "buf", ".", "Read", "(", "payload", ")", "\n", "//checksum, _ := buf.ReadByte()", "buf", ".", "Next", "(", "1", ")", "\n", "n", ".", "parsePacket", "(", "bytes", ".", "NewBuffer", "(", "payload", ")", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "parse", "converts", "bytes", "buffer", "into", "packets", "until", "no", "more", "data", "is", "present" ]

[ "func", "(", "n", "*", "Driver", ")", "parsePacket", "(", "buf", "*", "bytes", ".", "Buffer", ")", "{", "for", "buf", ".", "Len", "(", ")", ">", "0", "{", "b", ",", "_", ":=", "buf", ".", "ReadByte", "(", ")", "\n", "switch", "b", "{", "case", "CodeEx", ":", "n", ".", "Publish", "(", "n", ".", "Event", "(", "\"", "\"", ")", ",", "nil", ")", "\n", "case", "CodeSignalQuality", ":", "ret", ",", "_", ":=", "buf", ".", "ReadByte", "(", ")", "\n", "n", ".", "Publish", "(", "n", ".", "Event", "(", "\"", "\"", ")", ",", "ret", ")", "\n", "case", "CodeAttention", ":", "ret", ",", "_", ":=", "buf", ".", "ReadByte", "(", ")", "\n", "n", ".", "Publish", "(", "n", ".", "Event", "(", "\"", "\"", ")", ",", "ret", ")", "\n", "case", "CodeMeditation", ":", "ret", ",", "_", ":=", "buf", ".", "ReadByte", "(", ")", "\n", "n", ".", "Publish", "(", "n", ".", "Event", "(", "\"", "\"", ")", ",", "ret", ")", "\n", "case", "CodeBlink", ":", "ret", ",", "_", ":=", "buf", ".", "ReadByte", "(", ")", "\n", "n", ".", "Publish", "(", "n", ".", "Event", "(", "\"", "\"", ")", ",", "ret", ")", "\n", "case", "CodeWave", ":", "buf", ".", "Next", "(", "1", ")", "\n", "var", "ret", "=", "make", "(", "[", "]", "byte", ",", "2", ")", "\n", "buf", ".", "Read", "(", "ret", ")", "\n", "n", ".", "Publish", "(", "n", ".", "Event", "(", "\"", "\"", ")", ",", "int16", "(", "ret", "[", "0", "]", ")", "<<", "8", "|", "int16", "(", "ret", "[", "1", "]", ")", ")", "\n", "case", "CodeAsicEEG", ":", "ret", ":=", "make", "(", "[", "]", "byte", ",", "25", ")", "\n", "i", ",", "_", ":=", "buf", ".", "Read", "(", "ret", ")", "\n", "if", "i", "==", "25", "{", "n", ".", "Publish", "(", "n", ".", "Event", "(", "\"", "\"", ")", ",", "n", ".", "parseEEG", "(", "ret", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "parsePacket", "publishes", "event", "according", "to", "data", "parsed" ]

[ "func", "(", "n", "*", "Driver", ")", "parseEEG", "(", "data", "[", "]", "byte", ")", "EEGData", "{", "return", "EEGData", "{", "Delta", ":", "n", ".", "parse3ByteInteger", "(", "data", "[", "0", ":", "3", "]", ")", ",", "Theta", ":", "n", ".", "parse3ByteInteger", "(", "data", "[", "3", ":", "6", "]", ")", ",", "LoAlpha", ":", "n", ".", "parse3ByteInteger", "(", "data", "[", "6", ":", "9", "]", ")", ",", "HiAlpha", ":", "n", ".", "parse3ByteInteger", "(", "data", "[", "9", ":", "12", "]", ")", ",", "LoBeta", ":", "n", ".", "parse3ByteInteger", "(", "data", "[", "12", ":", "15", "]", ")", ",", "HiBeta", ":", "n", ".", "parse3ByteInteger", "(", "data", "[", "15", ":", "18", "]", ")", ",", "LoGamma", ":", "n", ".", "parse3ByteInteger", "(", "data", "[", "18", ":", "21", "]", ")", ",", "MidGamma", ":", "n", ".", "parse3ByteInteger", "(", "data", "[", "21", ":", "25", "]", ")", ",", "}", "\n", "}" ]

[ "parseEEG", "returns", "data", "converted", "into", "EEG", "map" ]

[ "func", "(", "b", "*", "BlinkMDriver", ")", "Rgb", "(", "red", "byte", ",", "green", "byte", ",", "blue", "byte", ")", "(", "err", "error", ")", "{", "if", "_", ",", "err", "=", "b", ".", "connection", ".", "Write", "(", "[", "]", "byte", "(", "\"", "\"", ")", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "b", ".", "connection", ".", "Write", "(", "[", "]", "byte", "{", "red", ",", "green", ",", "blue", "}", ")", "\n", "return", "\n", "}" ]

[ "Rgb", "sets", "color", "using", "r", "g", "b", "params" ]

[ "func", "(", "b", "*", "BlinkMDriver", ")", "FirmwareVersion", "(", ")", "(", "version", "string", ",", "err", "error", ")", "{", "if", "_", ",", "err", "=", "b", ".", "connection", ".", "Write", "(", "[", "]", "byte", "(", "\"", "\"", ")", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "data", ":=", "[", "]", "byte", "{", "0", ",", "0", "}", "\n", "read", ",", "err", ":=", "b", ".", "connection", ".", "Read", "(", "data", ")", "\n", "if", "read", "!=", "2", "||", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "data", "[", "0", "]", ",", "data", "[", "1", "]", ")", ",", "nil", "\n", "}" ]

[ "FirmwareVersion", "returns", "version", "with", "MAYOR", ".", "minor", "format" ]

[ "func", "(", "b", "*", "BlinkMDriver", ")", "Color", "(", ")", "(", "color", "[", "]", "byte", ",", "err", "error", ")", "{", "if", "_", ",", "err", "=", "b", ".", "connection", ".", "Write", "(", "[", "]", "byte", "(", "\"", "\"", ")", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "data", ":=", "[", "]", "byte", "{", "0", ",", "0", ",", "0", "}", "\n", "read", ",", "err", ":=", "b", ".", "connection", ".", "Read", "(", "data", ")", "\n", "if", "read", "!=", "3", "||", "err", "!=", "nil", "{", "return", "[", "]", "byte", "{", "}", ",", "err", "\n", "}", "\n", "return", "[", "]", "byte", "{", "data", "[", "0", "]", ",", "data", "[", "1", "]", ",", "data", "[", "2", "]", "}", ",", "nil", "\n", "}" ]

[ "Color", "returns", "an", "array", "with", "current", "rgb", "color" ]

[ "func", "(", "s", "*", "SSD1306Driver", ")", "ssd1306Init", "(", ")", "{", "s", ".", "command", "(", "ssd1306SetDisplayOff", ")", "\n", "s", ".", "command", "(", "ssd1306SetDisplayClock", ")", "\n", "if", "s", ".", "DisplayHeight", "==", "16", "{", "s", ".", "command", "(", "0x60", ")", "\n", "}", "else", "{", "s", ".", "command", "(", "0x80", ")", "\n", "}", "\n", "s", ".", "command", "(", "ssd1306SetMultiplexRatio", ")", "\n", "s", ".", "command", "(", "uint8", "(", "s", ".", "DisplayHeight", ")", "-", "1", ")", "\n", "s", ".", "command", "(", "ssd1306SetDisplayOffset", ")", "\n", "s", ".", "command", "(", "0x0", ")", "\n", "s", ".", "command", "(", "ssd1306SetStartLine", ")", "\n", "s", ".", "command", "(", "0x0", ")", "\n", "s", ".", "command", "(", "ssd1306ChargePumpSetting", ")", "\n", "if", "s", ".", "ExternalVcc", "{", "s", ".", "command", "(", "0x10", ")", "\n", "}", "else", "{", "s", ".", "command", "(", "0x14", ")", "\n", "}", "\n", "s", ".", "command", "(", "ssd1306SetMemoryAddressingMode", ")", "\n", "s", ".", "command", "(", "0x00", ")", "\n", "s", ".", "command", "(", "ssd1306SetSegmentRemap0", ")", "\n", "s", ".", "command", "(", "0x01", ")", "\n", "s", ".", "command", "(", "ssd1306ComScanInc", ")", "\n", "s", ".", "command", "(", "ssd1306SetComPins", ")", "\n", "if", "s", ".", "DisplayHeight", "==", "64", "{", "s", ".", "command", "(", "0x12", ")", "\n", "}", "else", "{", "s", ".", "command", "(", "0x02", ")", "\n", "}", "\n", "s", ".", "command", "(", "ssd1306SetContrast", ")", "\n", "if", "s", ".", "DisplayHeight", "==", "64", "{", "if", "s", ".", "ExternalVcc", "{", "s", ".", "command", "(", "0x9F", ")", "\n", "}", "else", "{", "s", ".", "command", "(", "0xCF", ")", "\n", "}", "\n", "}", "else", "{", "s", ".", "command", "(", "0x8F", ")", "\n", "}", "\n", "s", ".", "command", "(", "ssd1306SetPrechargePeriod", ")", "\n", "if", "s", ".", "ExternalVcc", "{", "s", ".", "command", "(", "0x22", ")", "\n", "}", "else", "{", "s", ".", "command", "(", "0xF1", ")", "\n", "}", "\n", "s", ".", "command", "(", "ssd1306SetVComDeselectLevel", ")", "\n", "s", ".", "command", "(", "0x40", ")", "\n", "s", ".", "command", "(", "ssd1306DisplayOnResumeToRAM", ")", "\n", "s", ".", "command", "(", "ssd1306SetDisplayNormal", ")", "\n", "s", ".", "command", "(", "ssd1306DeactivateScroll", ")", "\n", "s", ".", "command", "(", "ssd1306SetDisplayOn", ")", "\n", "}" ]

[ "ssd1306Init", "configures", "the", "ssd1306", "based", "on", "the", "options", "passed", "in", "when", "the", "driver", "was", "created" ]

[ "func", "(", "d", "*", "DisplayBuffer", ")", "Size", "(", ")", "int", "{", "return", "(", "d", ".", "width", "*", "d", ".", "height", ")", "/", "d", ".", "pageSize", "\n", "}" ]

[ "Size", "returns", "the", "memory", "size", "of", "the", "display", "buffer" ]

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

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

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

[ "Start", "sets", "up", "the", "needed", "connection", "and", "initialized", "the", "device", "." ]

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

[ "Halt", "returns", "true", "if", "device", "is", "halted", "successfully", "." ]

[ "func", "WithDCPin", "(", "val", "string", ")", "func", "(", "Config", ")", "{", "return", "func", "(", "c", "Config", ")", "{", "d", ",", "ok", ":=", "c", ".", "(", "*", "SSD1306Driver", ")", "\n", "if", "ok", "{", "d", ".", "DCPin", "=", "val", "\n", "}", "else", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "WithDCPin", "option", "sets", "the", "SSD1306Driver", "DC", "Pin", "option", "." ]

[ "func", "WithRstPin", "(", "val", "string", ")", "func", "(", "Config", ")", "{", "return", "func", "(", "c", "Config", ")", "{", "d", ",", "ok", ":=", "c", ".", "(", "*", "SSD1306Driver", ")", "\n", "if", "ok", "{", "d", ".", "RSTPin", "=", "val", "\n", "}", "else", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "WithRstPin", "option", "sets", "the", "SSD1306Driver", "RST", "pin", "option", "." ]

[ "func", "WithExternalVCC", "(", "val", "bool", ")", "func", "(", "Config", ")", "{", "return", "func", "(", "c", "Config", ")", "{", "d", ",", "ok", ":=", "c", ".", "(", "*", "SSD1306Driver", ")", "\n", "if", "ok", "{", "d", ".", "ExternalVcc", "=", "val", "\n", "}", "else", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "WithExternalVCC", "option", "sets", "the", "SSD1306Driver", "external", "vcc", "option", "." ]

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

[ "Set", "sets", "a", "pixel", "in", "the", "display", "buffer", "." ]

[ "func", "(", "s", "*", "SSD1306Driver", ")", "Reset", "(", ")", "(", "err", "error", ")", "{", "s", ".", "rstDriver", ".", "DigitalWrite", "(", "1", ")", "\n", "time", ".", "Sleep", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "s", ".", "rstDriver", ".", "DigitalWrite", "(", "0", ")", "\n", "time", ".", "Sleep", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "s", ".", "rstDriver", ".", "DigitalWrite", "(", "1", ")", "\n", "return", "nil", "\n", "}" ]

[ "Reset", "re", "-", "initializes", "the", "device", "to", "a", "clean", "state", "." ]

[ "func", "(", "s", "*", "SSD1306Driver", ")", "SetBufferAndDisplay", "(", "buf", "[", "]", "byte", ")", "(", "err", "error", ")", "{", "s", ".", "buffer", ".", "Set", "(", "buf", ")", "\n", "return", "s", ".", "Display", "(", ")", "\n", "}" ]

[ "SetBufferAndDisplay", "sets", "the", "display", "buffer", "with", "the", "given", "buffer", "and", "displays", "the", "image", "." ]

[ "func", "(", "s", "*", "SSD1306Driver", ")", "Display", "(", ")", "(", "err", "error", ")", "{", "s", ".", "command", "(", "ssd1306ColumnAddr", ")", "\n", "s", ".", "command", "(", "0", ")", "\n", "s", ".", "command", "(", "uint8", "(", "s", ".", "DisplayWidth", ")", "-", "1", ")", "\n", "s", ".", "command", "(", "ssd1306PageAddr", ")", "\n", "s", ".", "command", "(", "0", ")", "\n", "s", ".", "command", "(", "uint8", "(", "s", ".", "pageSize", ")", "-", "1", ")", "\n", "if", "err", "=", "s", ".", "dcDriver", ".", "DigitalWrite", "(", "1", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "s", ".", "connection", ".", "Tx", "(", "append", "(", "[", "]", "byte", "{", "0x40", "}", ",", "s", ".", "buffer", ".", "buffer", "...", ")", ",", "nil", ")", "\n", "}" ]

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

[ "func", "(", "s", "*", "SSD1306Driver", ")", "ShowImage", "(", "img", "image", ".", "Image", ")", "(", "err", "error", ")", "{", "if", "img", ".", "Bounds", "(", ")", ".", "Dx", "(", ")", "!=", "s", ".", "DisplayWidth", "||", "img", ".", "Bounds", "(", ")", ".", "Dy", "(", ")", "!=", "s", ".", "DisplayHeight", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "s", ".", "Clear", "(", ")", "\n", "for", "y", ",", "w", ",", "h", ":=", "0", ",", "img", ".", "Bounds", "(", ")", ".", "Dx", "(", ")", ",", "img", ".", "Bounds", "(", ")", ".", "Dy", "(", ")", ";", "y", "<", "h", ";", "y", "++", "{", "for", "x", ":=", "0", ";", "x", "<", "w", ";", "x", "++", "{", "c", ":=", "img", ".", "At", "(", "x", ",", "y", ")", "\n", "if", "r", ",", "g", ",", "b", ",", "_", ":=", "c", ".", "RGBA", "(", ")", ";", "r", ">", "0", "||", "g", ">", "0", "||", "b", ">", "0", "{", "s", ".", "Set", "(", "x", ",", "y", ",", "1", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "s", ".", "Display", "(", ")", "\n", "}" ]

[ "ShowImage", "takes", "a", "standard", "Go", "image", "and", "shows", "it", "on", "the", "display", "in", "monochrome", "." ]

[ "func", "(", "h", "*", "HMC6352Driver", ")", "Start", "(", ")", "(", "err", "error", ")", "{", "bus", ":=", "h", ".", "GetBusOrDefault", "(", "h", ".", "connector", ".", "GetDefaultBus", "(", ")", ")", "\n", "address", ":=", "h", ".", "GetAddressOrDefault", "(", "hmc6352Address", ")", "\n\n", "h", ".", "connection", ",", "err", "=", "h", ".", "connector", ".", "GetConnection", "(", "address", ",", "bus", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "h", ".", "connection", ".", "Write", "(", "[", "]", "byte", "(", "\"", "\"", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "\n", "}" ]

[ "Start", "initializes", "the", "hmc6352" ]

[ "func", "(", "h", "*", "HMC6352Driver", ")", "Heading", "(", ")", "(", "heading", "uint16", ",", "err", "error", ")", "{", "if", "_", ",", "err", "=", "h", ".", "connection", ".", "Write", "(", "[", "]", "byte", "(", "\"", "\"", ")", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "buf", ":=", "[", "]", "byte", "{", "0", ",", "0", "}", "\n", "bytesRead", ",", "err", ":=", "h", ".", "connection", ".", "Read", "(", "buf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "bytesRead", "==", "2", "{", "heading", "=", "(", "uint16", "(", "buf", "[", "1", "]", ")", "+", "uint16", "(", "buf", "[", "0", "]", ")", "*", "256", ")", "/", "10", "\n", "return", "\n", "}", "\n\n", "err", "=", "ErrNotEnoughBytes", "\n", "return", "\n", "}" ]

[ "Heading", "returns", "the", "current", "heading" ]

[ "func", "NewConfig", "(", ")", "Config", "{", "return", "&", "spiConfig", "{", "bus", ":", "NotInitialized", ",", "chip", ":", "NotInitialized", ",", "mode", ":", "NotInitialized", ",", "bits", ":", "NotInitialized", ",", "speed", ":", "NotInitialized", "}", "\n", "}" ]

[ "NewConfig", "returns", "a", "new", "SPI", "Config", "." ]

[ "func", "(", "s", "*", "StepperDriver", ")", "Run", "(", ")", "(", "err", "error", ")", "{", "//halt if already moving", "if", "s", ".", "moving", "==", "true", "{", "s", ".", "Halt", "(", ")", "\n", "}", "\n\n", "s", ".", "mutex", ".", "Lock", "(", ")", "\n", "s", ".", "moving", "=", "true", "\n", "s", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "go", "func", "(", ")", "{", "for", "{", "if", "s", ".", "moving", "==", "false", "{", "break", "\n", "}", "\n", "s", ".", "step", "(", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "return", "\n", "}" ]

[ "Run", "continuously", "runs", "the", "stepper" ]

[ "func", "(", "s", "*", "StepperDriver", ")", "Halt", "(", ")", "(", "err", "error", ")", "{", "s", ".", "mutex", ".", "Lock", "(", ")", "\n", "s", ".", "moving", "=", "false", "\n", "s", ".", "mutex", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Halt", "implements", "the", "Driver", "interface", "and", "halts", "the", "motion", "of", "the", "Stepper" ]

[ "func", "(", "s", "*", "StepperDriver", ")", "SetDirection", "(", "direction", "string", ")", "error", "{", "direction", "=", "strings", ".", "ToLower", "(", "direction", ")", "\n", "if", "direction", "!=", "\"", "\"", "&&", "direction", "!=", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "s", ".", "mutex", ".", "Lock", "(", ")", "\n", "s", ".", "direction", "=", "direction", "\n", "s", ".", "mutex", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "SetDirection", "sets", "the", "direction", "in", "which", "motor", "should", "be", "moving", "Default", "is", "forward" ]

[ "func", "(", "s", "*", "StepperDriver", ")", "step", "(", ")", "error", "{", "if", "s", ".", "direction", "==", "\"", "\"", "{", "s", ".", "stepNum", "++", "\n", "}", "else", "{", "s", ".", "stepNum", "--", "\n", "}", "\n\n", "if", "s", ".", "stepNum", ">=", "int", "(", "s", ".", "stepsPerRev", ")", "{", "s", ".", "stepNum", "=", "0", "\n", "}", "else", "if", "s", ".", "stepNum", "<", "0", "{", "s", ".", "stepNum", "=", "int", "(", "s", ".", "stepsPerRev", ")", "-", "1", "\n", "}", "\n\n", "r", ":=", "int", "(", "math", ".", "Abs", "(", "float64", "(", "s", ".", "stepNum", ")", ")", ")", "%", "len", "(", "s", ".", "phase", ")", "\n\n", "for", "i", ",", "v", ":=", "range", "s", ".", "phase", "[", "r", "]", "{", "if", "err", ":=", "s", ".", "connection", ".", "DigitalWrite", "(", "s", ".", "pins", "[", "i", "]", ",", "v", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Step", "moves", "motor", "one", "step", "in", "giving", "direction" ]

[ "func", "(", "s", "*", "StepperDriver", ")", "Move", "(", "stepsToMove", "int", ")", "error", "{", "if", "stepsToMove", "==", "0", "{", "return", "s", ".", "Halt", "(", ")", "\n", "}", "\n\n", "if", "s", ".", "moving", "==", "true", "{", "//stop previous motion", "s", ".", "Halt", "(", ")", "\n", "}", "\n\n", "s", ".", "mutex", ".", "Lock", "(", ")", "\n", "s", ".", "moving", "=", "true", "\n", "s", ".", "direction", "=", "\"", "\"", "\n\n", "if", "stepsToMove", "<", "0", "{", "s", ".", "direction", "=", "\"", "\"", "\n", "}", "\n", "s", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "stepsLeft", ":=", "int64", "(", "math", ".", "Abs", "(", "float64", "(", "stepsToMove", ")", ")", ")", "\n", "//Do not remove *1000 and change duration to time.Millisecond. It has been done for a reason", "delay", ":=", "time", ".", "Duration", "(", "60000", "*", "1000", "/", "(", "s", ".", "stepsPerRev", "*", "s", ".", "speed", ")", ")", "*", "time", ".", "Microsecond", "\n\n", "for", "stepsLeft", ">", "0", "{", "if", "err", ":=", "s", ".", "step", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "stepsLeft", "--", "\n", "time", ".", "Sleep", "(", "delay", ")", "\n", "}", "\n\n", "s", ".", "moving", "=", "false", "\n", "return", "nil", "\n", "}" ]

[ "Move", "moves", "the", "motor", "for", "given", "number", "of", "steps" ]

[ "func", "(", "s", "*", "StepperDriver", ")", "SetSpeed", "(", "rpm", "uint", ")", "error", "{", "if", "rpm", "<=", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "m", ":=", "s", ".", "GetMaxSpeed", "(", ")", "\n", "if", "rpm", ">", "m", "{", "rpm", "=", "m", "\n", "}", "\n\n", "s", ".", "speed", "=", "rpm", "\n", "return", "nil", "\n", "}" ]

[ "SetSpeed", "sets", "the", "rpm" ]

[ "func", "NewEvent", "(", "name", "string", ",", "data", "interface", "{", "}", ")", "*", "Event", "{", "return", "&", "Event", "{", "Name", ":", "name", ",", "Data", ":", "data", "}", "\n", "}" ]

[ "NewEvent", "returns", "a", "new", "Event", "and", "its", "associated", "data", "." ]

[ "func", "(", "a", "*", "Driver", ")", "Up", "(", "speed", "float64", ")", "{", "a", ".", "adaptor", "(", ")", ".", "drone", ".", "Up", "(", "speed", ")", "\n", "}" ]

[ "Up", "makes", "the", "drone", "gain", "altitude", ".", "speed", "can", "be", "a", "value", "from", "0", ".", "0", "to", "1", ".", "0", "." ]

[ "func", "(", "a", "*", "Driver", ")", "Down", "(", "speed", "float64", ")", "{", "a", ".", "adaptor", "(", ")", ".", "drone", ".", "Down", "(", "speed", ")", "\n", "}" ]

[ "Down", "makes", "the", "drone", "reduce", "altitude", ".", "speed", "can", "be", "a", "value", "from", "0", ".", "0", "to", "1", ".", "0", "." ]

[ "func", "(", "a", "*", "Driver", ")", "Left", "(", "speed", "float64", ")", "{", "a", ".", "adaptor", "(", ")", ".", "drone", ".", "Left", "(", "speed", ")", "\n", "}" ]

[ "Left", "causes", "the", "drone", "to", "bank", "to", "the", "left", "controls", "the", "roll", "which", "is", "a", "horizontal", "movement", "using", "the", "camera", "as", "a", "reference", "point", ".", "speed", "can", "be", "a", "value", "from", "0", ".", "0", "to", "1", ".", "0", "." ]

[ "func", "(", "a", "*", "Driver", ")", "Right", "(", "speed", "float64", ")", "{", "a", ".", "adaptor", "(", ")", ".", "drone", ".", "Right", "(", "speed", ")", "\n", "}" ]

[ "Right", "causes", "the", "drone", "to", "bank", "to", "the", "right", "controls", "the", "roll", "which", "is", "a", "horizontal", "movement", "using", "the", "camera", "as", "a", "reference", "point", ".", "speed", "can", "be", "a", "value", "from", "0", ".", "0", "to", "1", ".", "0", "." ]

[ "func", "(", "a", "*", "Driver", ")", "Forward", "(", "speed", "float64", ")", "{", "a", ".", "adaptor", "(", ")", ".", "drone", ".", "Forward", "(", "speed", ")", "\n", "}" ]

[ "Forward", "causes", "the", "drone", "go", "forward", "controls", "the", "pitch", ".", "speed", "can", "be", "a", "value", "from", "0", ".", "0", "to", "1", ".", "0", "." ]

[ "func", "(", "a", "*", "Driver", ")", "Backward", "(", "speed", "float64", ")", "{", "a", ".", "adaptor", "(", ")", ".", "drone", ".", "Backward", "(", "speed", ")", "\n", "}" ]

[ "Backward", "causes", "the", "drone", "go", "backward", "controls", "the", "pitch", ".", "speed", "can", "be", "a", "value", "from", "0", ".", "0", "to", "1", ".", "0", "." ]

[ "func", "(", "a", "*", "Driver", ")", "Clockwise", "(", "speed", "float64", ")", "{", "a", ".", "adaptor", "(", ")", ".", "drone", ".", "Clockwise", "(", "speed", ")", "\n", "}" ]

[ "Clockwise", "causes", "the", "drone", "to", "spin", "in", "clockwise", "direction", "speed", "can", "be", "a", "value", "from", "0", ".", "0", "to", "1", ".", "0", "." ]

[ "func", "(", "a", "*", "Driver", ")", "CounterClockwise", "(", "speed", "float64", ")", "{", "a", ".", "adaptor", "(", ")", ".", "drone", ".", "Counterclockwise", "(", "speed", ")", "\n", "}" ]

[ "CounterClockwise", "the", "drone", "to", "spin", "in", "counter", "clockwise", "direction", "speed", "can", "be", "a", "value", "from", "0", ".", "0", "to", "1", ".", "0", "." ]

[ "func", "(", "w", "*", "WiichuckDriver", ")", "Start", "(", ")", "(", "err", "error", ")", "{", "bus", ":=", "w", ".", "GetBusOrDefault", "(", "w", ".", "connector", ".", "GetDefaultBus", "(", ")", ")", "\n", "address", ":=", "w", ".", "GetAddressOrDefault", "(", "wiichuckAddress", ")", "\n\n", "w", ".", "connection", ",", "err", "=", "w", ".", "connector", ".", "GetConnection", "(", "address", ",", "bus", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "go", "func", "(", ")", "{", "for", "{", "if", "_", ",", "err", ":=", "w", ".", "connection", ".", "Write", "(", "[", "]", "byte", "{", "0x40", ",", "0x00", "}", ")", ";", "err", "!=", "nil", "{", "w", ".", "Publish", "(", "w", ".", "Event", "(", "Error", ")", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "time", ".", "Sleep", "(", "w", ".", "pauseTime", ")", "\n", "if", "_", ",", "err", ":=", "w", ".", "connection", ".", "Write", "(", "[", "]", "byte", "{", "0x00", "}", ")", ";", "err", "!=", "nil", "{", "w", ".", "Publish", "(", "w", ".", "Event", "(", "Error", ")", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "time", ".", "Sleep", "(", "w", ".", "pauseTime", ")", "\n", "newValue", ":=", "make", "(", "[", "]", "byte", ",", "6", ")", "\n", "bytesRead", ",", "err", ":=", "w", ".", "connection", ".", "Read", "(", "newValue", ")", "\n", "if", "err", "!=", "nil", "{", "w", ".", "Publish", "(", "w", ".", "Event", "(", "Error", ")", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "bytesRead", "==", "6", "{", "if", "err", "=", "w", ".", "update", "(", "newValue", ")", ";", "err", "!=", "nil", "{", "w", ".", "Publish", "(", "w", ".", "Event", "(", "Error", ")", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "}", "\n", "time", ".", "Sleep", "(", "w", ".", "interval", ")", "\n", "}", "\n", "}", "(", ")", "\n", "return", "\n", "}" ]

[ "Start", "initilizes", "i2c", "and", "reads", "from", "adaptor", "using", "specified", "interval", "to", "update", "with", "new", "value" ]

[ "func", "(", "w", "*", "WiichuckDriver", ")", "Joystick", "(", ")", "map", "[", "string", "]", "float64", "{", "val", ":=", "make", "(", "map", "[", "string", "]", "float64", ")", "\n", "w", ".", "mtx", ".", "Lock", "(", ")", "\n", "defer", "w", ".", "mtx", ".", "Unlock", "(", ")", "\n", "val", "[", "\"", "\"", "]", "=", "w", ".", "joystick", "[", "\"", "\"", "]", "\n", "val", "[", "\"", "\"", "]", "=", "w", ".", "joystick", "[", "\"", "\"", "]", "\n", "return", "val", "\n", "}" ]

[ "Joystick", "returns", "the", "current", "value", "for", "the", "joystick" ]

[ "func", "(", "w", "*", "WiichuckDriver", ")", "update", "(", "value", "[", "]", "byte", ")", "(", "err", "error", ")", "{", "if", "w", ".", "isEncrypted", "(", "value", ")", "{", "return", "ErrEncryptedBytes", "\n", "}", "else", "{", "w", ".", "parse", "(", "value", ")", "\n", "w", ".", "adjustOrigins", "(", ")", "\n", "w", ".", "updateButtons", "(", ")", "\n", "w", ".", "updateJoystick", "(", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "update", "parses", "value", "to", "update", "buttons", "and", "joystick", ".", "If", "value", "is", "encrypted", "warning", "message", "is", "printed" ]

[ "func", "(", "w", "*", "WiichuckDriver", ")", "setJoystickDefaultValue", "(", "joystickAxis", "string", ",", "defaultValue", "float64", ")", "{", "w", ".", "mtx", ".", "Lock", "(", ")", "\n", "defer", "w", ".", "mtx", ".", "Unlock", "(", ")", "\n", "if", "w", ".", "joystick", "[", "joystickAxis", "]", "==", "-", "1", "{", "w", ".", "joystick", "[", "joystickAxis", "]", "=", "defaultValue", "\n", "}", "\n", "}" ]

[ "setJoystickDefaultValue", "sets", "default", "value", "if", "value", "is", "-", "1" ]

[ "func", "(", "w", "*", "WiichuckDriver", ")", "calculateJoystickValue", "(", "axis", "float64", ",", "origin", "float64", ")", "float64", "{", "return", "float64", "(", "axis", "-", "origin", ")", "\n", "}" ]

[ "calculateJoystickValue", "returns", "distance", "between", "axis", "and", "origin" ]

[ "func", "(", "w", "*", "WiichuckDriver", ")", "isEncrypted", "(", "value", "[", "]", "byte", ")", "bool", "{", "if", "value", "[", "0", "]", "==", "value", "[", "1", "]", "&&", "value", "[", "2", "]", "==", "value", "[", "3", "]", "&&", "value", "[", "4", "]", "==", "value", "[", "5", "]", "{", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "isEncrypted", "returns", "true", "if", "value", "is", "encrypted" ]

[ "func", "(", "w", "*", "WiichuckDriver", ")", "adjustOrigins", "(", ")", "{", "w", ".", "setJoystickDefaultValue", "(", "\"", "\"", ",", "w", ".", "data", "[", "\"", "\"", "]", ")", "\n", "w", ".", "setJoystickDefaultValue", "(", "\"", "\"", ",", "w", ".", "data", "[", "\"", "\"", "]", ")", "\n", "}" ]

[ "adjustOrigins", "sets", "sy_origin", "and", "sx_origin", "with", "values", "from", "data" ]

[ "func", "(", "w", "*", "WiichuckDriver", ")", "updateButtons", "(", ")", "{", "if", "w", ".", "data", "[", "\"", "\"", "]", "==", "0", "{", "w", ".", "Publish", "(", "w", ".", "Event", "(", "C", ")", ",", "true", ")", "\n", "}", "\n", "if", "w", ".", "data", "[", "\"", "\"", "]", "==", "0", "{", "w", ".", "Publish", "(", "w", ".", "Event", "(", "Z", ")", ",", "true", ")", "\n", "}", "\n", "}" ]

[ "updateButtons", "publishes", "c", "and", "x", "events", "if", "present", "in", "data" ]

[ "func", "(", "w", "*", "WiichuckDriver", ")", "updateJoystick", "(", ")", "{", "joy", ":=", "w", ".", "Joystick", "(", ")", "\n", "w", ".", "Publish", "(", "w", ".", "Event", "(", "Joystick", ")", ",", "map", "[", "string", "]", "float64", "{", "\"", "\"", ":", "w", ".", "calculateJoystickValue", "(", "w", ".", "data", "[", "\"", "\"", "]", ",", "joy", "[", "\"", "\"", "]", ")", ",", "\"", "\"", ":", "w", ".", "calculateJoystickValue", "(", "w", ".", "data", "[", "\"", "\"", "]", ",", "joy", "[", "\"", "\"", "]", ")", ",", "}", ")", "\n", "}" ]

[ "updateJoystick", "publishes", "event", "with", "current", "x", "and", "y", "values", "for", "joystick" ]

[ "func", "(", "w", "*", "WiichuckDriver", ")", "parse", "(", "value", "[", "]", "byte", ")", "{", "w", ".", "data", "[", "\"", "\"", "]", "=", "w", ".", "decode", "(", "value", "[", "0", "]", ")", "\n", "w", ".", "data", "[", "\"", "\"", "]", "=", "w", ".", "decode", "(", "value", "[", "1", "]", ")", "\n", "w", ".", "data", "[", "\"", "\"", "]", "=", "float64", "(", "uint8", "(", "w", ".", "decode", "(", "value", "[", "5", "]", ")", ")", "&", "0x01", ")", "\n", "w", ".", "data", "[", "\"", "\"", "]", "=", "float64", "(", "uint8", "(", "w", ".", "decode", "(", "value", "[", "5", "]", ")", ")", "&", "0x02", ")", "\n", "}" ]

[ "parse", "sets", "driver", "values", "based", "on", "parsed", "value" ]

[ "func", "NewCameraDriver", "(", "source", "interface", "{", "}", ")", "*", "CameraDriver", "{", "c", ":=", "&", "CameraDriver", "{", "name", ":", "\"", "\"", ",", "Eventer", ":", "gobot", ".", "NewEventer", "(", ")", ",", "Source", ":", "source", ",", "start", ":", "func", "(", "c", "*", "CameraDriver", ")", "(", "err", "error", ")", "{", "switch", "v", ":=", "c", ".", "Source", ".", "(", "type", ")", "{", "case", "string", ":", "c", ".", "camera", ",", "_", "=", "gocv", ".", "VideoCaptureFile", "(", "v", ")", "\n", "case", "int", ":", "c", ".", "camera", ",", "_", "=", "gocv", ".", "VideoCaptureDevice", "(", "v", ")", "\n", "default", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "\n", "}", ",", "}", "\n\n", "c", ".", "AddEvent", "(", "Frame", ")", "\n\n", "return", "c", "\n", "}" ]

[ "NewCameraDriver", "creates", "a", "new", "driver", "with", "specified", "source", ".", "It", "also", "creates", "a", "start", "function", "to", "either", "set", "camera", "as", "a", "File", "or", "Camera", "capture", "." ]

[ "func", "(", "c", "*", "CameraDriver", ")", "Start", "(", ")", "(", "err", "error", ")", "{", "if", "err", ":=", "c", ".", "start", "(", "c", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "img", ":=", "gocv", ".", "NewMat", "(", ")", "\n", "go", "func", "(", ")", "{", "for", "{", "if", "ok", ":=", "c", ".", "camera", ".", "Read", "(", "&", "img", ")", ";", "ok", "{", "c", ".", "Publish", "(", "Frame", ",", "img", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "return", "\n", "}" ]

[ "Start", "initializes", "camera", "by", "grabbing", "frames" ]