id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
14,100 | ktrysmt/go-bitbucket | client.go | NewOAuthClientCredentials | func NewOAuthClientCredentials(i, s string) *Client {
a := &auth{appID: i, secret: s}
ctx := context.Background()
conf := &clientcredentials.Config{
ClientID: i,
ClientSecret: s,
TokenURL: bitbucket.Endpoint.TokenURL,
}
tok, err := conf.Token(ctx)
if err != nil {
log.Fatal(err)
}
a.token = *tok
return injectClient(a)
} | go | func NewOAuthClientCredentials(i, s string) *Client {
a := &auth{appID: i, secret: s}
ctx := context.Background()
conf := &clientcredentials.Config{
ClientID: i,
ClientSecret: s,
TokenURL: bitbucket.Endpoint.TokenURL,
}
tok, err := conf.Token(ctx)
if err != nil {
log.Fatal(err)
}
a.token = *tok
return injectClient(a)
} | [
"func",
"NewOAuthClientCredentials",
"(",
"i",
",",
"s",
"string",
")",
"*",
"Client",
"{",
"a",
":=",
"&",
"auth",
"{",
"appID",
":",
"i",
",",
"secret",
":",
"s",
"}",
"\n",
"ctx",
":=",
"context",
".",
"Background",
"(",
")",
"\n",
"conf",
":=",... | // Uses the Client Credentials Grant oauth2 flow to authenticate to Bitbucket | [
"Uses",
"the",
"Client",
"Credentials",
"Grant",
"oauth2",
"flow",
"to",
"authenticate",
"to",
"Bitbucket"
] | 1f1c5e77687102cc8f6baa9f79276178be6f0ea3 | https://github.com/ktrysmt/go-bitbucket/blob/1f1c5e77687102cc8f6baa9f79276178be6f0ea3/client.go#L46-L62 |
14,101 | lucasb-eyer/go-colorful | colors.go | RGBA | func (col Color) RGBA() (r, g, b, a uint32) {
r = uint32(col.R*65535.0 + 0.5)
g = uint32(col.G*65535.0 + 0.5)
b = uint32(col.B*65535.0 + 0.5)
a = 0xFFFF
return
} | go | func (col Color) RGBA() (r, g, b, a uint32) {
r = uint32(col.R*65535.0 + 0.5)
g = uint32(col.G*65535.0 + 0.5)
b = uint32(col.B*65535.0 + 0.5)
a = 0xFFFF
return
} | [
"func",
"(",
"col",
"Color",
")",
"RGBA",
"(",
")",
"(",
"r",
",",
"g",
",",
"b",
",",
"a",
"uint32",
")",
"{",
"r",
"=",
"uint32",
"(",
"col",
".",
"R",
"*",
"65535.0",
"+",
"0.5",
")",
"\n",
"g",
"=",
"uint32",
"(",
"col",
".",
"G",
"*"... | // Implement the Go color.Color interface. | [
"Implement",
"the",
"Go",
"color",
".",
"Color",
"interface",
"."
] | 30298f24079860c4dee452fdef6519b362a4a026 | https://github.com/lucasb-eyer/go-colorful/blob/30298f24079860c4dee452fdef6519b362a4a026/colors.go#L16-L22 |
14,102 | lucasb-eyer/go-colorful | colors.go | MakeColor | func MakeColor(col color.Color) (Color, bool) {
r, g, b, a := col.RGBA()
if a == 0 {
return Color{0, 0, 0}, false
}
// Since color.Color is alpha pre-multiplied, we need to divide the
// RGB values by alpha again in order to get back the original RGB.
r *= 0xffff
r /= a
g *= 0xffff
g /= a
b *= 0xffff
b /= a
return Color{float64(r) / 65535.0, float64(g) / 65535.0, float64(b) / 65535.0}, true
} | go | func MakeColor(col color.Color) (Color, bool) {
r, g, b, a := col.RGBA()
if a == 0 {
return Color{0, 0, 0}, false
}
// Since color.Color is alpha pre-multiplied, we need to divide the
// RGB values by alpha again in order to get back the original RGB.
r *= 0xffff
r /= a
g *= 0xffff
g /= a
b *= 0xffff
b /= a
return Color{float64(r) / 65535.0, float64(g) / 65535.0, float64(b) / 65535.0}, true
} | [
"func",
"MakeColor",
"(",
"col",
"color",
".",
"Color",
")",
"(",
"Color",
",",
"bool",
")",
"{",
"r",
",",
"g",
",",
"b",
",",
"a",
":=",
"col",
".",
"RGBA",
"(",
")",
"\n",
"if",
"a",
"==",
"0",
"{",
"return",
"Color",
"{",
"0",
",",
"0",... | // Constructs a colorful.Color from something implementing color.Color | [
"Constructs",
"a",
"colorful",
".",
"Color",
"from",
"something",
"implementing",
"color",
".",
"Color"
] | 30298f24079860c4dee452fdef6519b362a4a026 | https://github.com/lucasb-eyer/go-colorful/blob/30298f24079860c4dee452fdef6519b362a4a026/colors.go#L25-L41 |
14,103 | lucasb-eyer/go-colorful | colors.go | RGB255 | func (col Color) RGB255() (r, g, b uint8) {
r = uint8(col.R*255.0 + 0.5)
g = uint8(col.G*255.0 + 0.5)
b = uint8(col.B*255.0 + 0.5)
return
} | go | func (col Color) RGB255() (r, g, b uint8) {
r = uint8(col.R*255.0 + 0.5)
g = uint8(col.G*255.0 + 0.5)
b = uint8(col.B*255.0 + 0.5)
return
} | [
"func",
"(",
"col",
"Color",
")",
"RGB255",
"(",
")",
"(",
"r",
",",
"g",
",",
"b",
"uint8",
")",
"{",
"r",
"=",
"uint8",
"(",
"col",
".",
"R",
"*",
"255.0",
"+",
"0.5",
")",
"\n",
"g",
"=",
"uint8",
"(",
"col",
".",
"G",
"*",
"255.0",
"+... | // Might come in handy sometimes to reduce boilerplate code. | [
"Might",
"come",
"in",
"handy",
"sometimes",
"to",
"reduce",
"boilerplate",
"code",
"."
] | 30298f24079860c4dee452fdef6519b362a4a026 | https://github.com/lucasb-eyer/go-colorful/blob/30298f24079860c4dee452fdef6519b362a4a026/colors.go#L44-L49 |
14,104 | lucasb-eyer/go-colorful | colors.go | DistanceRgb | func (c1 Color) DistanceRgb(c2 Color) float64 {
return math.Sqrt(sq(c1.R-c2.R) + sq(c1.G-c2.G) + sq(c1.B-c2.B))
} | go | func (c1 Color) DistanceRgb(c2 Color) float64 {
return math.Sqrt(sq(c1.R-c2.R) + sq(c1.G-c2.G) + sq(c1.B-c2.B))
} | [
"func",
"(",
"c1",
"Color",
")",
"DistanceRgb",
"(",
"c2",
"Color",
")",
"float64",
"{",
"return",
"math",
".",
"Sqrt",
"(",
"sq",
"(",
"c1",
".",
"R",
"-",
"c2",
".",
"R",
")",
"+",
"sq",
"(",
"c1",
".",
"G",
"-",
"c2",
".",
"G",
")",
"+",... | // DistanceRgb computes the distance between two colors in RGB space.
// This is not a good measure! Rather do it in Lab space. | [
"DistanceRgb",
"computes",
"the",
"distance",
"between",
"two",
"colors",
"in",
"RGB",
"space",
".",
"This",
"is",
"not",
"a",
"good",
"measure!",
"Rather",
"do",
"it",
"in",
"Lab",
"space",
"."
] | 30298f24079860c4dee452fdef6519b362a4a026 | https://github.com/lucasb-eyer/go-colorful/blob/30298f24079860c4dee452fdef6519b362a4a026/colors.go#L87-L89 |
14,105 | lucasb-eyer/go-colorful | colors.go | linearize_fast | func linearize_fast(v float64) float64 {
v1 := v - 0.5
v2 := v1 * v1
v3 := v2 * v1
v4 := v2 * v2
//v5 := v3*v2
return -0.248750514614486 + 0.925583310193438*v + 1.16740237321695*v2 + 0.280457026598666*v3 - 0.0757991963780179*v4 //+ 0.0437040411548932*v5
} | go | func linearize_fast(v float64) float64 {
v1 := v - 0.5
v2 := v1 * v1
v3 := v2 * v1
v4 := v2 * v2
//v5 := v3*v2
return -0.248750514614486 + 0.925583310193438*v + 1.16740237321695*v2 + 0.280457026598666*v3 - 0.0757991963780179*v4 //+ 0.0437040411548932*v5
} | [
"func",
"linearize_fast",
"(",
"v",
"float64",
")",
"float64",
"{",
"v1",
":=",
"v",
"-",
"0.5",
"\n",
"v2",
":=",
"v1",
"*",
"v1",
"\n",
"v3",
":=",
"v2",
"*",
"v1",
"\n",
"v4",
":=",
"v2",
"*",
"v2",
"\n",
"//v5 := v3*v2",
"return",
"-",
"0.248... | // A much faster and still quite precise linearization using a 6th-order Taylor approximation.
// See the accompanying Jupyter notebook for derivation of the constants. | [
"A",
"much",
"faster",
"and",
"still",
"quite",
"precise",
"linearization",
"using",
"a",
"6th",
"-",
"order",
"Taylor",
"approximation",
".",
"See",
"the",
"accompanying",
"Jupyter",
"notebook",
"for",
"derivation",
"of",
"the",
"constants",
"."
] | 30298f24079860c4dee452fdef6519b362a4a026 | https://github.com/lucasb-eyer/go-colorful/blob/30298f24079860c4dee452fdef6519b362a4a026/colors.go#L360-L367 |
14,106 | lucasb-eyer/go-colorful | colors.go | XyzToLinearRgb | func XyzToLinearRgb(x, y, z float64) (r, g, b float64) {
r = 3.2404542*x - 1.5371385*y - 0.4985314*z
g = -0.9692660*x + 1.8760108*y + 0.0415560*z
b = 0.0556434*x - 0.2040259*y + 1.0572252*z
return
} | go | func XyzToLinearRgb(x, y, z float64) (r, g, b float64) {
r = 3.2404542*x - 1.5371385*y - 0.4985314*z
g = -0.9692660*x + 1.8760108*y + 0.0415560*z
b = 0.0556434*x - 0.2040259*y + 1.0572252*z
return
} | [
"func",
"XyzToLinearRgb",
"(",
"x",
",",
"y",
",",
"z",
"float64",
")",
"(",
"r",
",",
"g",
",",
"b",
"float64",
")",
"{",
"r",
"=",
"3.2404542",
"*",
"x",
"-",
"1.5371385",
"*",
"y",
"-",
"0.4985314",
"*",
"z",
"\n",
"g",
"=",
"-",
"0.9692660"... | // XyzToLinearRgb converts from CIE XYZ-space to Linear RGB space. | [
"XyzToLinearRgb",
"converts",
"from",
"CIE",
"XYZ",
"-",
"space",
"to",
"Linear",
"RGB",
"space",
"."
] | 30298f24079860c4dee452fdef6519b362a4a026 | https://github.com/lucasb-eyer/go-colorful/blob/30298f24079860c4dee452fdef6519b362a4a026/colors.go#L424-L429 |
14,107 | lucasb-eyer/go-colorful | colors.go | DistanceLab | func (c1 Color) DistanceLab(c2 Color) float64 {
l1, a1, b1 := c1.Lab()
l2, a2, b2 := c2.Lab()
return math.Sqrt(sq(l1-l2) + sq(a1-a2) + sq(b1-b2))
} | go | func (c1 Color) DistanceLab(c2 Color) float64 {
l1, a1, b1 := c1.Lab()
l2, a2, b2 := c2.Lab()
return math.Sqrt(sq(l1-l2) + sq(a1-a2) + sq(b1-b2))
} | [
"func",
"(",
"c1",
"Color",
")",
"DistanceLab",
"(",
"c2",
"Color",
")",
"float64",
"{",
"l1",
",",
"a1",
",",
"b1",
":=",
"c1",
".",
"Lab",
"(",
")",
"\n",
"l2",
",",
"a2",
",",
"b2",
":=",
"c2",
".",
"Lab",
"(",
")",
"\n",
"return",
"math",... | // DistanceLab is a good measure of visual similarity between two colors!
// A result of 0 would mean identical colors, while a result of 1 or higher
// means the colors differ a lot. | [
"DistanceLab",
"is",
"a",
"good",
"measure",
"of",
"visual",
"similarity",
"between",
"two",
"colors!",
"A",
"result",
"of",
"0",
"would",
"mean",
"identical",
"colors",
"while",
"a",
"result",
"of",
"1",
"or",
"higher",
"means",
"the",
"colors",
"differ",
... | 30298f24079860c4dee452fdef6519b362a4a026 | https://github.com/lucasb-eyer/go-colorful/blob/30298f24079860c4dee452fdef6519b362a4a026/colors.go#L586-L590 |
14,108 | lucasb-eyer/go-colorful | colors.go | DistanceCIE94 | func (cl Color) DistanceCIE94(cr Color) float64 {
l1, a1, b1 := cl.Lab()
l2, a2, b2 := cr.Lab()
// NOTE: Since all those formulas expect L,a,b values 100x larger than we
// have them in this library, we either need to adjust all constants
// in the formula, or convert the ranges of L,a,b before, and then
// scale the distances down again. The latter is less error-prone.
l1, a1, b1 = l1*100.0, a1*100.0, b1*100.0
l2, a2, b2 = l2*100.0, a2*100.0, b2*100.0
kl := 1.0 // 2.0 for textiles
kc := 1.0
kh := 1.0
k1 := 0.045 // 0.048 for textiles
k2 := 0.015 // 0.014 for textiles.
deltaL := l1 - l2
c1 := math.Sqrt(sq(a1) + sq(b1))
c2 := math.Sqrt(sq(a2) + sq(b2))
deltaCab := c1 - c2
// Not taking Sqrt here for stability, and it's unnecessary.
deltaHab2 := sq(a1-a2) + sq(b1-b2) - sq(deltaCab)
sl := 1.0
sc := 1.0 + k1*c1
sh := 1.0 + k2*c1
vL2 := sq(deltaL / (kl * sl))
vC2 := sq(deltaCab / (kc * sc))
vH2 := deltaHab2 / sq(kh*sh)
return math.Sqrt(vL2+vC2+vH2) * 0.01 // See above.
} | go | func (cl Color) DistanceCIE94(cr Color) float64 {
l1, a1, b1 := cl.Lab()
l2, a2, b2 := cr.Lab()
// NOTE: Since all those formulas expect L,a,b values 100x larger than we
// have them in this library, we either need to adjust all constants
// in the formula, or convert the ranges of L,a,b before, and then
// scale the distances down again. The latter is less error-prone.
l1, a1, b1 = l1*100.0, a1*100.0, b1*100.0
l2, a2, b2 = l2*100.0, a2*100.0, b2*100.0
kl := 1.0 // 2.0 for textiles
kc := 1.0
kh := 1.0
k1 := 0.045 // 0.048 for textiles
k2 := 0.015 // 0.014 for textiles.
deltaL := l1 - l2
c1 := math.Sqrt(sq(a1) + sq(b1))
c2 := math.Sqrt(sq(a2) + sq(b2))
deltaCab := c1 - c2
// Not taking Sqrt here for stability, and it's unnecessary.
deltaHab2 := sq(a1-a2) + sq(b1-b2) - sq(deltaCab)
sl := 1.0
sc := 1.0 + k1*c1
sh := 1.0 + k2*c1
vL2 := sq(deltaL / (kl * sl))
vC2 := sq(deltaCab / (kc * sc))
vH2 := deltaHab2 / sq(kh*sh)
return math.Sqrt(vL2+vC2+vH2) * 0.01 // See above.
} | [
"func",
"(",
"cl",
"Color",
")",
"DistanceCIE94",
"(",
"cr",
"Color",
")",
"float64",
"{",
"l1",
",",
"a1",
",",
"b1",
":=",
"cl",
".",
"Lab",
"(",
")",
"\n",
"l2",
",",
"a2",
",",
"b2",
":=",
"cr",
".",
"Lab",
"(",
")",
"\n\n",
"// NOTE: Since... | // Uses the CIE94 formula to calculate color distance. More accurate than
// DistanceLab, but also more work. | [
"Uses",
"the",
"CIE94",
"formula",
"to",
"calculate",
"color",
"distance",
".",
"More",
"accurate",
"than",
"DistanceLab",
"but",
"also",
"more",
"work",
"."
] | 30298f24079860c4dee452fdef6519b362a4a026 | https://github.com/lucasb-eyer/go-colorful/blob/30298f24079860c4dee452fdef6519b362a4a026/colors.go#L599-L632 |
14,109 | lucasb-eyer/go-colorful | colors.go | xyz_to_uv | func xyz_to_uv(x, y, z float64) (u, v float64) {
denom := x + 15.0*y + 3.0*z
if denom == 0.0 {
u, v = 0.0, 0.0
} else {
u = 4.0 * x / denom
v = 9.0 * y / denom
}
return
} | go | func xyz_to_uv(x, y, z float64) (u, v float64) {
denom := x + 15.0*y + 3.0*z
if denom == 0.0 {
u, v = 0.0, 0.0
} else {
u = 4.0 * x / denom
v = 9.0 * y / denom
}
return
} | [
"func",
"xyz_to_uv",
"(",
"x",
",",
"y",
",",
"z",
"float64",
")",
"(",
"u",
",",
"v",
"float64",
")",
"{",
"denom",
":=",
"x",
"+",
"15.0",
"*",
"y",
"+",
"3.0",
"*",
"z",
"\n",
"if",
"denom",
"==",
"0.0",
"{",
"u",
",",
"v",
"=",
"0.0",
... | // For this part, we do as R's graphics.hcl does, not as wikipedia does.
// Or is it the same? | [
"For",
"this",
"part",
"we",
"do",
"as",
"R",
"s",
"graphics",
".",
"hcl",
"does",
"not",
"as",
"wikipedia",
"does",
".",
"Or",
"is",
"it",
"the",
"same?"
] | 30298f24079860c4dee452fdef6519b362a4a026 | https://github.com/lucasb-eyer/go-colorful/blob/30298f24079860c4dee452fdef6519b362a4a026/colors.go#L755-L764 |
14,110 | lucasb-eyer/go-colorful | colors.go | DistanceLuv | func (c1 Color) DistanceLuv(c2 Color) float64 {
l1, u1, v1 := c1.Luv()
l2, u2, v2 := c2.Luv()
return math.Sqrt(sq(l1-l2) + sq(u1-u2) + sq(v1-v2))
} | go | func (c1 Color) DistanceLuv(c2 Color) float64 {
l1, u1, v1 := c1.Luv()
l2, u2, v2 := c2.Luv()
return math.Sqrt(sq(l1-l2) + sq(u1-u2) + sq(v1-v2))
} | [
"func",
"(",
"c1",
"Color",
")",
"DistanceLuv",
"(",
"c2",
"Color",
")",
"float64",
"{",
"l1",
",",
"u1",
",",
"v1",
":=",
"c1",
".",
"Luv",
"(",
")",
"\n",
"l2",
",",
"u2",
",",
"v2",
":=",
"c2",
".",
"Luv",
"(",
")",
"\n",
"return",
"math",... | // DistanceLuv is a good measure of visual similarity between two colors!
// A result of 0 would mean identical colors, while a result of 1 or higher
// means the colors differ a lot. | [
"DistanceLuv",
"is",
"a",
"good",
"measure",
"of",
"visual",
"similarity",
"between",
"two",
"colors!",
"A",
"result",
"of",
"0",
"would",
"mean",
"identical",
"colors",
"while",
"a",
"result",
"of",
"1",
"or",
"higher",
"means",
"the",
"colors",
"differ",
... | 30298f24079860c4dee452fdef6519b362a4a026 | https://github.com/lucasb-eyer/go-colorful/blob/30298f24079860c4dee452fdef6519b362a4a026/colors.go#L822-L826 |
14,111 | lucasb-eyer/go-colorful | doc/gradientgen/gradientgen.go | MustParseHex | func MustParseHex(s string) colorful.Color {
c, err := colorful.Hex(s)
if err != nil {
panic("MustParseHex: " + err.Error())
}
return c
} | go | func MustParseHex(s string) colorful.Color {
c, err := colorful.Hex(s)
if err != nil {
panic("MustParseHex: " + err.Error())
}
return c
} | [
"func",
"MustParseHex",
"(",
"s",
"string",
")",
"colorful",
".",
"Color",
"{",
"c",
",",
"err",
":=",
"colorful",
".",
"Hex",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
"+",
"err",
".",
"Error",
"(",
")",
")"... | // This is a very nice thing Golang forces you to do!
// It is necessary so that we can write out the literal of the colortable below. | [
"This",
"is",
"a",
"very",
"nice",
"thing",
"Golang",
"forces",
"you",
"to",
"do!",
"It",
"is",
"necessary",
"so",
"that",
"we",
"can",
"write",
"out",
"the",
"literal",
"of",
"the",
"colortable",
"below",
"."
] | 30298f24079860c4dee452fdef6519b362a4a026 | https://github.com/lucasb-eyer/go-colorful/blob/30298f24079860c4dee452fdef6519b362a4a026/doc/gradientgen/gradientgen.go#L37-L43 |
14,112 | lucasb-eyer/go-colorful | soft_palettegen.go | SoftPalette | func SoftPalette(colorsCount int) ([]Color, error) {
return SoftPaletteEx(colorsCount, SoftPaletteSettings{nil, 50, false})
} | go | func SoftPalette(colorsCount int) ([]Color, error) {
return SoftPaletteEx(colorsCount, SoftPaletteSettings{nil, 50, false})
} | [
"func",
"SoftPalette",
"(",
"colorsCount",
"int",
")",
"(",
"[",
"]",
"Color",
",",
"error",
")",
"{",
"return",
"SoftPaletteEx",
"(",
"colorsCount",
",",
"SoftPaletteSettings",
"{",
"nil",
",",
"50",
",",
"false",
"}",
")",
"\n",
"}"
] | // A wrapper which uses common parameters. | [
"A",
"wrapper",
"which",
"uses",
"common",
"parameters",
"."
] | 30298f24079860c4dee452fdef6519b362a4a026 | https://github.com/lucasb-eyer/go-colorful/blob/30298f24079860c4dee452fdef6519b362a4a026/soft_palettegen.go#L152-L154 |
14,113 | lucasb-eyer/go-colorful | soft_palettegen.go | lab_dist | func lab_dist(lab1, lab2 lab_t) float64 {
return math.Sqrt(sq(lab1.L-lab2.L) + sq(lab1.A-lab2.A) + sq(lab1.B-lab2.B))
} | go | func lab_dist(lab1, lab2 lab_t) float64 {
return math.Sqrt(sq(lab1.L-lab2.L) + sq(lab1.A-lab2.A) + sq(lab1.B-lab2.B))
} | [
"func",
"lab_dist",
"(",
"lab1",
",",
"lab2",
"lab_t",
")",
"float64",
"{",
"return",
"math",
".",
"Sqrt",
"(",
"sq",
"(",
"lab1",
".",
"L",
"-",
"lab2",
".",
"L",
")",
"+",
"sq",
"(",
"lab1",
".",
"A",
"-",
"lab2",
".",
"A",
")",
"+",
"sq",
... | // That's faster than using colorful's DistanceLab since we would have to
// convert back and forth for that. Here is no conversion. | [
"That",
"s",
"faster",
"than",
"using",
"colorful",
"s",
"DistanceLab",
"since",
"we",
"would",
"have",
"to",
"convert",
"back",
"and",
"forth",
"for",
"that",
".",
"Here",
"is",
"no",
"conversion",
"."
] | 30298f24079860c4dee452fdef6519b362a4a026 | https://github.com/lucasb-eyer/go-colorful/blob/30298f24079860c4dee452fdef6519b362a4a026/soft_palettegen.go#L175-L177 |
14,114 | rifflock/lfshook | lfshook.go | NewHook | func NewHook(output interface{}, formatter logrus.Formatter) *LfsHook {
hook := &LfsHook{
lock: new(sync.Mutex),
}
hook.SetFormatter(formatter)
switch output.(type) {
case string:
hook.SetDefaultPath(output.(string))
break
case io.Writer:
hook.SetDefaultWriter(output.(io.Writer))
break
case PathMap:
hook.paths = output.(PathMap)
for level := range output.(PathMap) {
hook.levels = append(hook.levels, level)
}
break
case WriterMap:
hook.writers = output.(WriterMap)
for level := range output.(WriterMap) {
hook.levels = append(hook.levels, level)
}
break
default:
panic(fmt.Sprintf("unsupported level map type: %v", reflect.TypeOf(output)))
}
return hook
} | go | func NewHook(output interface{}, formatter logrus.Formatter) *LfsHook {
hook := &LfsHook{
lock: new(sync.Mutex),
}
hook.SetFormatter(formatter)
switch output.(type) {
case string:
hook.SetDefaultPath(output.(string))
break
case io.Writer:
hook.SetDefaultWriter(output.(io.Writer))
break
case PathMap:
hook.paths = output.(PathMap)
for level := range output.(PathMap) {
hook.levels = append(hook.levels, level)
}
break
case WriterMap:
hook.writers = output.(WriterMap)
for level := range output.(WriterMap) {
hook.levels = append(hook.levels, level)
}
break
default:
panic(fmt.Sprintf("unsupported level map type: %v", reflect.TypeOf(output)))
}
return hook
} | [
"func",
"NewHook",
"(",
"output",
"interface",
"{",
"}",
",",
"formatter",
"logrus",
".",
"Formatter",
")",
"*",
"LfsHook",
"{",
"hook",
":=",
"&",
"LfsHook",
"{",
"lock",
":",
"new",
"(",
"sync",
".",
"Mutex",
")",
",",
"}",
"\n\n",
"hook",
".",
"... | // NewHook returns new LFS hook.
// Output can be a string, io.Writer, WriterMap or PathMap.
// If using io.Writer or WriterMap, user is responsible for closing the used io.Writer. | [
"NewHook",
"returns",
"new",
"LFS",
"hook",
".",
"Output",
"can",
"be",
"a",
"string",
"io",
".",
"Writer",
"WriterMap",
"or",
"PathMap",
".",
"If",
"using",
"io",
".",
"Writer",
"or",
"WriterMap",
"user",
"is",
"responsible",
"for",
"closing",
"the",
"u... | b9218ef580f59a2e72dad1aa33d660150445d05a | https://github.com/rifflock/lfshook/blob/b9218ef580f59a2e72dad1aa33d660150445d05a/lfshook.go#L43-L74 |
14,115 | rifflock/lfshook | lfshook.go | SetFormatter | func (hook *LfsHook) SetFormatter(formatter logrus.Formatter) {
hook.lock.Lock()
defer hook.lock.Unlock()
if formatter == nil {
formatter = defaultFormatter
} else {
switch formatter.(type) {
case *logrus.TextFormatter:
textFormatter := formatter.(*logrus.TextFormatter)
textFormatter.DisableColors = true
}
}
hook.formatter = formatter
} | go | func (hook *LfsHook) SetFormatter(formatter logrus.Formatter) {
hook.lock.Lock()
defer hook.lock.Unlock()
if formatter == nil {
formatter = defaultFormatter
} else {
switch formatter.(type) {
case *logrus.TextFormatter:
textFormatter := formatter.(*logrus.TextFormatter)
textFormatter.DisableColors = true
}
}
hook.formatter = formatter
} | [
"func",
"(",
"hook",
"*",
"LfsHook",
")",
"SetFormatter",
"(",
"formatter",
"logrus",
".",
"Formatter",
")",
"{",
"hook",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"hook",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"formatter",
"==",
... | // SetFormatter sets the format that will be used by hook.
// If using text formatter, this method will disable color output to make the log file more readable. | [
"SetFormatter",
"sets",
"the",
"format",
"that",
"will",
"be",
"used",
"by",
"hook",
".",
"If",
"using",
"text",
"formatter",
"this",
"method",
"will",
"disable",
"color",
"output",
"to",
"make",
"the",
"log",
"file",
"more",
"readable",
"."
] | b9218ef580f59a2e72dad1aa33d660150445d05a | https://github.com/rifflock/lfshook/blob/b9218ef580f59a2e72dad1aa33d660150445d05a/lfshook.go#L78-L92 |
14,116 | rifflock/lfshook | lfshook.go | SetDefaultPath | func (hook *LfsHook) SetDefaultPath(defaultPath string) {
hook.lock.Lock()
defer hook.lock.Unlock()
hook.defaultPath = defaultPath
hook.hasDefaultPath = true
} | go | func (hook *LfsHook) SetDefaultPath(defaultPath string) {
hook.lock.Lock()
defer hook.lock.Unlock()
hook.defaultPath = defaultPath
hook.hasDefaultPath = true
} | [
"func",
"(",
"hook",
"*",
"LfsHook",
")",
"SetDefaultPath",
"(",
"defaultPath",
"string",
")",
"{",
"hook",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"hook",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"hook",
".",
"defaultPath",
"=",
"defau... | // SetDefaultPath sets default path for levels that don't have any defined output path. | [
"SetDefaultPath",
"sets",
"default",
"path",
"for",
"levels",
"that",
"don",
"t",
"have",
"any",
"defined",
"output",
"path",
"."
] | b9218ef580f59a2e72dad1aa33d660150445d05a | https://github.com/rifflock/lfshook/blob/b9218ef580f59a2e72dad1aa33d660150445d05a/lfshook.go#L95-L100 |
14,117 | rifflock/lfshook | lfshook.go | SetDefaultWriter | func (hook *LfsHook) SetDefaultWriter(defaultWriter io.Writer) {
hook.lock.Lock()
defer hook.lock.Unlock()
hook.defaultWriter = defaultWriter
hook.hasDefaultWriter = true
} | go | func (hook *LfsHook) SetDefaultWriter(defaultWriter io.Writer) {
hook.lock.Lock()
defer hook.lock.Unlock()
hook.defaultWriter = defaultWriter
hook.hasDefaultWriter = true
} | [
"func",
"(",
"hook",
"*",
"LfsHook",
")",
"SetDefaultWriter",
"(",
"defaultWriter",
"io",
".",
"Writer",
")",
"{",
"hook",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"hook",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"hook",
".",
"defaultWri... | // SetDefaultWriter sets default writer for levels that don't have any defined writer. | [
"SetDefaultWriter",
"sets",
"default",
"writer",
"for",
"levels",
"that",
"don",
"t",
"have",
"any",
"defined",
"writer",
"."
] | b9218ef580f59a2e72dad1aa33d660150445d05a | https://github.com/rifflock/lfshook/blob/b9218ef580f59a2e72dad1aa33d660150445d05a/lfshook.go#L103-L108 |
14,118 | rifflock/lfshook | lfshook.go | Fire | func (hook *LfsHook) Fire(entry *logrus.Entry) error {
hook.lock.Lock()
defer hook.lock.Unlock()
if hook.writers != nil || hook.hasDefaultWriter {
return hook.ioWrite(entry)
} else if hook.paths != nil || hook.hasDefaultPath {
return hook.fileWrite(entry)
}
return nil
} | go | func (hook *LfsHook) Fire(entry *logrus.Entry) error {
hook.lock.Lock()
defer hook.lock.Unlock()
if hook.writers != nil || hook.hasDefaultWriter {
return hook.ioWrite(entry)
} else if hook.paths != nil || hook.hasDefaultPath {
return hook.fileWrite(entry)
}
return nil
} | [
"func",
"(",
"hook",
"*",
"LfsHook",
")",
"Fire",
"(",
"entry",
"*",
"logrus",
".",
"Entry",
")",
"error",
"{",
"hook",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"hook",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"hook",
".",
"w... | // Fire writes the log file to defined path or using the defined writer.
// User who run this function needs write permissions to the file or directory if the file does not yet exist. | [
"Fire",
"writes",
"the",
"log",
"file",
"to",
"defined",
"path",
"or",
"using",
"the",
"defined",
"writer",
".",
"User",
"who",
"run",
"this",
"function",
"needs",
"write",
"permissions",
"to",
"the",
"file",
"or",
"directory",
"if",
"the",
"file",
"does",... | b9218ef580f59a2e72dad1aa33d660150445d05a | https://github.com/rifflock/lfshook/blob/b9218ef580f59a2e72dad1aa33d660150445d05a/lfshook.go#L112-L122 |
14,119 | rifflock/lfshook | lfshook.go | ioWrite | func (hook *LfsHook) ioWrite(entry *logrus.Entry) error {
var (
writer io.Writer
msg []byte
err error
ok bool
)
if writer, ok = hook.writers[entry.Level]; !ok {
if hook.hasDefaultWriter {
writer = hook.defaultWriter
} else {
return nil
}
}
// use our formatter instead of entry.String()
msg, err = hook.formatter.Format(entry)
if err != nil {
log.Println("failed to generate string for entry:", err)
return err
}
_, err = writer.Write(msg)
return err
} | go | func (hook *LfsHook) ioWrite(entry *logrus.Entry) error {
var (
writer io.Writer
msg []byte
err error
ok bool
)
if writer, ok = hook.writers[entry.Level]; !ok {
if hook.hasDefaultWriter {
writer = hook.defaultWriter
} else {
return nil
}
}
// use our formatter instead of entry.String()
msg, err = hook.formatter.Format(entry)
if err != nil {
log.Println("failed to generate string for entry:", err)
return err
}
_, err = writer.Write(msg)
return err
} | [
"func",
"(",
"hook",
"*",
"LfsHook",
")",
"ioWrite",
"(",
"entry",
"*",
"logrus",
".",
"Entry",
")",
"error",
"{",
"var",
"(",
"writer",
"io",
".",
"Writer",
"\n",
"msg",
"[",
"]",
"byte",
"\n",
"err",
"error",
"\n",
"ok",
"bool",
"\n",
")",
"\n\... | // Write a log line to an io.Writer. | [
"Write",
"a",
"log",
"line",
"to",
"an",
"io",
".",
"Writer",
"."
] | b9218ef580f59a2e72dad1aa33d660150445d05a | https://github.com/rifflock/lfshook/blob/b9218ef580f59a2e72dad1aa33d660150445d05a/lfshook.go#L125-L150 |
14,120 | rifflock/lfshook | lfshook.go | fileWrite | func (hook *LfsHook) fileWrite(entry *logrus.Entry) error {
var (
fd *os.File
path string
msg []byte
err error
ok bool
)
if path, ok = hook.paths[entry.Level]; !ok {
if hook.hasDefaultPath {
path = hook.defaultPath
} else {
return nil
}
}
dir := filepath.Dir(path)
os.MkdirAll(dir, os.ModePerm)
fd, err = os.OpenFile(path, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
if err != nil {
log.Println("failed to open logfile:", path, err)
return err
}
defer fd.Close()
// use our formatter instead of entry.String()
msg, err = hook.formatter.Format(entry)
if err != nil {
log.Println("failed to generate string for entry:", err)
return err
}
fd.Write(msg)
return nil
} | go | func (hook *LfsHook) fileWrite(entry *logrus.Entry) error {
var (
fd *os.File
path string
msg []byte
err error
ok bool
)
if path, ok = hook.paths[entry.Level]; !ok {
if hook.hasDefaultPath {
path = hook.defaultPath
} else {
return nil
}
}
dir := filepath.Dir(path)
os.MkdirAll(dir, os.ModePerm)
fd, err = os.OpenFile(path, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
if err != nil {
log.Println("failed to open logfile:", path, err)
return err
}
defer fd.Close()
// use our formatter instead of entry.String()
msg, err = hook.formatter.Format(entry)
if err != nil {
log.Println("failed to generate string for entry:", err)
return err
}
fd.Write(msg)
return nil
} | [
"func",
"(",
"hook",
"*",
"LfsHook",
")",
"fileWrite",
"(",
"entry",
"*",
"logrus",
".",
"Entry",
")",
"error",
"{",
"var",
"(",
"fd",
"*",
"os",
".",
"File",
"\n",
"path",
"string",
"\n",
"msg",
"[",
"]",
"byte",
"\n",
"err",
"error",
"\n",
"ok"... | // Write a log line directly to a file. | [
"Write",
"a",
"log",
"line",
"directly",
"to",
"a",
"file",
"."
] | b9218ef580f59a2e72dad1aa33d660150445d05a | https://github.com/rifflock/lfshook/blob/b9218ef580f59a2e72dad1aa33d660150445d05a/lfshook.go#L153-L189 |
14,121 | kidoman/embd | motion/servo/servo.go | New | func New(pwm PWM) *Servo {
return &Servo{
PWM: pwm,
Minus: minus,
Maxus: maxus,
}
} | go | func New(pwm PWM) *Servo {
return &Servo{
PWM: pwm,
Minus: minus,
Maxus: maxus,
}
} | [
"func",
"New",
"(",
"pwm",
"PWM",
")",
"*",
"Servo",
"{",
"return",
"&",
"Servo",
"{",
"PWM",
":",
"pwm",
",",
"Minus",
":",
"minus",
",",
"Maxus",
":",
"maxus",
",",
"}",
"\n",
"}"
] | // New creates a new Servo interface. | [
"New",
"creates",
"a",
"new",
"Servo",
"interface",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/motion/servo/servo.go#L31-L37 |
14,122 | kidoman/embd | motion/servo/servo.go | SetAngle | func (s *Servo) SetAngle(angle int) error {
us := util.Map(int64(angle), 0, 180, int64(s.Minus), int64(s.Maxus))
glog.V(1).Infof("servo: given angle %v calculated %v us", angle, us)
return s.PWM.SetMicroseconds(int(us))
} | go | func (s *Servo) SetAngle(angle int) error {
us := util.Map(int64(angle), 0, 180, int64(s.Minus), int64(s.Maxus))
glog.V(1).Infof("servo: given angle %v calculated %v us", angle, us)
return s.PWM.SetMicroseconds(int(us))
} | [
"func",
"(",
"s",
"*",
"Servo",
")",
"SetAngle",
"(",
"angle",
"int",
")",
"error",
"{",
"us",
":=",
"util",
".",
"Map",
"(",
"int64",
"(",
"angle",
")",
",",
"0",
",",
"180",
",",
"int64",
"(",
"s",
".",
"Minus",
")",
",",
"int64",
"(",
"s",... | // SetAngle sets the servo angle. | [
"SetAngle",
"sets",
"the",
"servo",
"angle",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/motion/servo/servo.go#L40-L46 |
14,123 | kidoman/embd | controller/servoblaster/servoblaster.go | setMicroseconds | func (d *ServoBlaster) setMicroseconds(channel, us int) error {
if err := d.setup(); err != nil {
return err
}
cmd := fmt.Sprintf("%v=%vus\n", channel, us)
glog.V(1).Infof("servoblaster: sending command %q", cmd)
_, err := d.fd.WriteString(cmd)
return err
} | go | func (d *ServoBlaster) setMicroseconds(channel, us int) error {
if err := d.setup(); err != nil {
return err
}
cmd := fmt.Sprintf("%v=%vus\n", channel, us)
glog.V(1).Infof("servoblaster: sending command %q", cmd)
_, err := d.fd.WriteString(cmd)
return err
} | [
"func",
"(",
"d",
"*",
"ServoBlaster",
")",
"setMicroseconds",
"(",
"channel",
",",
"us",
"int",
")",
"error",
"{",
"if",
"err",
":=",
"d",
".",
"setup",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"cmd",
":=",
"fmt"... | // SetMicroseconds sends a command to the PWM driver to generate a us wide pulse. | [
"SetMicroseconds",
"sends",
"a",
"command",
"to",
"the",
"PWM",
"driver",
"to",
"generate",
"a",
"us",
"wide",
"pulse",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/servoblaster/servoblaster.go#L51-L59 |
14,124 | kidoman/embd | controller/servoblaster/servoblaster.go | Close | func (d *ServoBlaster) Close() error {
if d.fd != nil {
return d.fd.Close()
}
return nil
} | go | func (d *ServoBlaster) Close() error {
if d.fd != nil {
return d.fd.Close()
}
return nil
} | [
"func",
"(",
"d",
"*",
"ServoBlaster",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"d",
".",
"fd",
"!=",
"nil",
"{",
"return",
"d",
".",
"fd",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close closes the open driver handle. | [
"Close",
"closes",
"the",
"open",
"driver",
"handle",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/servoblaster/servoblaster.go#L62-L67 |
14,125 | kidoman/embd | interface/keypad/matrix4x3/matrix4x3.go | New | func New(rowPins, colPins []int) (*Matrix4x3, error) {
m := &Matrix4x3{
rowPins: make([]embd.DigitalPin, rows),
colPins: make([]embd.DigitalPin, cols),
poll: pollDelay,
}
var err error
for i := 0; i < rows; i++ {
m.rowPins[i], err = embd.NewDigitalPin(rowPins[i])
if err != nil {
return nil, err
}
}
for i := 0; i < cols; i++ {
m.colPins[i], err = embd.NewDigitalPin(colPins[i])
if err != nil {
return nil, err
}
}
return m, nil
} | go | func New(rowPins, colPins []int) (*Matrix4x3, error) {
m := &Matrix4x3{
rowPins: make([]embd.DigitalPin, rows),
colPins: make([]embd.DigitalPin, cols),
poll: pollDelay,
}
var err error
for i := 0; i < rows; i++ {
m.rowPins[i], err = embd.NewDigitalPin(rowPins[i])
if err != nil {
return nil, err
}
}
for i := 0; i < cols; i++ {
m.colPins[i], err = embd.NewDigitalPin(colPins[i])
if err != nil {
return nil, err
}
}
return m, nil
} | [
"func",
"New",
"(",
"rowPins",
",",
"colPins",
"[",
"]",
"int",
")",
"(",
"*",
"Matrix4x3",
",",
"error",
")",
"{",
"m",
":=",
"&",
"Matrix4x3",
"{",
"rowPins",
":",
"make",
"(",
"[",
"]",
"embd",
".",
"DigitalPin",
",",
"rows",
")",
",",
"colPin... | // New creates a new interface for matrix4x3. | [
"New",
"creates",
"a",
"new",
"interface",
"for",
"matrix4x3",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/interface/keypad/matrix4x3/matrix4x3.go#L83-L105 |
14,126 | kidoman/embd | interface/keypad/matrix4x3/matrix4x3.go | PressedKey | func (d *Matrix4x3) PressedKey() (key Key, err error) {
select {
case key = <-d.keyPressed:
return
default:
return d.findPressedKey()
}
} | go | func (d *Matrix4x3) PressedKey() (key Key, err error) {
select {
case key = <-d.keyPressed:
return
default:
return d.findPressedKey()
}
} | [
"func",
"(",
"d",
"*",
"Matrix4x3",
")",
"PressedKey",
"(",
")",
"(",
"key",
"Key",
",",
"err",
"error",
")",
"{",
"select",
"{",
"case",
"key",
"=",
"<-",
"d",
".",
"keyPressed",
":",
"return",
"\n",
"default",
":",
"return",
"d",
".",
"findPresse... | // Pressed key returns the current key pressed on the keypad. | [
"Pressed",
"key",
"returns",
"the",
"current",
"key",
"pressed",
"on",
"the",
"keypad",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/interface/keypad/matrix4x3/matrix4x3.go#L184-L191 |
14,127 | kidoman/embd | interface/keypad/matrix4x3/matrix4x3.go | Run | func (d *Matrix4x3) Run() {
d.quit = make(chan bool)
go func() {
timer := time.Tick(time.Duration(d.poll) * time.Millisecond)
var key Key
for {
var keyUpdates chan Key
select {
case <-timer:
var err error
if key, err = d.findPressedKey(); err == nil {
keyUpdates = d.keyPressed
}
case keyUpdates <- key:
keyUpdates = nil
case <-d.quit:
d.keyPressed = nil
return
}
}
}()
} | go | func (d *Matrix4x3) Run() {
d.quit = make(chan bool)
go func() {
timer := time.Tick(time.Duration(d.poll) * time.Millisecond)
var key Key
for {
var keyUpdates chan Key
select {
case <-timer:
var err error
if key, err = d.findPressedKey(); err == nil {
keyUpdates = d.keyPressed
}
case keyUpdates <- key:
keyUpdates = nil
case <-d.quit:
d.keyPressed = nil
return
}
}
}()
} | [
"func",
"(",
"d",
"*",
"Matrix4x3",
")",
"Run",
"(",
")",
"{",
"d",
".",
"quit",
"=",
"make",
"(",
"chan",
"bool",
")",
"\n\n",
"go",
"func",
"(",
")",
"{",
"timer",
":=",
"time",
".",
"Tick",
"(",
"time",
".",
"Duration",
"(",
"d",
".",
"pol... | // Run starts the continuous key scan loop. | [
"Run",
"starts",
"the",
"continuous",
"key",
"scan",
"loop",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/interface/keypad/matrix4x3/matrix4x3.go#L194-L219 |
14,128 | kidoman/embd | gpiodriver.go | NewGPIODriver | func NewGPIODriver(pinMap PinMap, dpf digitalPinFactory, apf analogPinFactory, ppf pwmPinFactory) GPIODriver {
return &gpioDriver{
pinMap: pinMap,
dpf: dpf,
apf: apf,
ppf: ppf,
initializedPins: map[string]pin{},
}
} | go | func NewGPIODriver(pinMap PinMap, dpf digitalPinFactory, apf analogPinFactory, ppf pwmPinFactory) GPIODriver {
return &gpioDriver{
pinMap: pinMap,
dpf: dpf,
apf: apf,
ppf: ppf,
initializedPins: map[string]pin{},
}
} | [
"func",
"NewGPIODriver",
"(",
"pinMap",
"PinMap",
",",
"dpf",
"digitalPinFactory",
",",
"apf",
"analogPinFactory",
",",
"ppf",
"pwmPinFactory",
")",
"GPIODriver",
"{",
"return",
"&",
"gpioDriver",
"{",
"pinMap",
":",
"pinMap",
",",
"dpf",
":",
"dpf",
",",
"a... | // NewGPIODriver returns a GPIODriver interface which allows control
// over the GPIO subsystem. | [
"NewGPIODriver",
"returns",
"a",
"GPIODriver",
"interface",
"which",
"allows",
"control",
"over",
"the",
"GPIO",
"subsystem",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/gpiodriver.go#L30-L39 |
14,129 | kidoman/embd | i2c.go | InitI2C | func InitI2C() error {
if i2cDriverInitialized {
return nil
}
desc, err := DescribeHost()
if err != nil {
return err
}
if desc.I2CDriver == nil {
return ErrFeatureNotSupported
}
i2cDriverInstance = desc.I2CDriver()
i2cDriverInitialized = true
return nil
} | go | func InitI2C() error {
if i2cDriverInitialized {
return nil
}
desc, err := DescribeHost()
if err != nil {
return err
}
if desc.I2CDriver == nil {
return ErrFeatureNotSupported
}
i2cDriverInstance = desc.I2CDriver()
i2cDriverInitialized = true
return nil
} | [
"func",
"InitI2C",
"(",
")",
"error",
"{",
"if",
"i2cDriverInitialized",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"desc",
",",
"err",
":=",
"DescribeHost",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"desc... | // InitI2C initializes the I2C driver. | [
"InitI2C",
"initializes",
"the",
"I2C",
"driver",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/i2c.go#L47-L65 |
14,130 | kidoman/embd | i2c.go | NewI2CBus | func NewI2CBus(l byte) I2CBus {
if err := InitI2C(); err != nil {
panic(err)
}
return i2cDriverInstance.Bus(l)
} | go | func NewI2CBus(l byte) I2CBus {
if err := InitI2C(); err != nil {
panic(err)
}
return i2cDriverInstance.Bus(l)
} | [
"func",
"NewI2CBus",
"(",
"l",
"byte",
")",
"I2CBus",
"{",
"if",
"err",
":=",
"InitI2C",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"i2cDriverInstance",
".",
"Bus",
"(",
"l",
")",
"\n",
"}"
] | // NewI2CBus returns a I2CBus. | [
"NewI2CBus",
"returns",
"a",
"I2CBus",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/i2c.go#L73-L79 |
14,131 | kidoman/embd | spidriver.go | NewSPIDriver | func NewSPIDriver(spiDevMinor int, sbf spiBusFactory, i func() error) SPIDriver {
return &spiDriver{
spiDevMinor: spiDevMinor,
sbf: sbf,
initializer: i,
}
} | go | func NewSPIDriver(spiDevMinor int, sbf spiBusFactory, i func() error) SPIDriver {
return &spiDriver{
spiDevMinor: spiDevMinor,
sbf: sbf,
initializer: i,
}
} | [
"func",
"NewSPIDriver",
"(",
"spiDevMinor",
"int",
",",
"sbf",
"spiBusFactory",
",",
"i",
"func",
"(",
")",
"error",
")",
"SPIDriver",
"{",
"return",
"&",
"spiDriver",
"{",
"spiDevMinor",
":",
"spiDevMinor",
",",
"sbf",
":",
"sbf",
",",
"initializer",
":",... | // NewSPIDriver returns a SPIDriver interface which allows control
// over the SPI bus. | [
"NewSPIDriver",
"returns",
"a",
"SPIDriver",
"interface",
"which",
"allows",
"control",
"over",
"the",
"SPI",
"bus",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/spidriver.go#L19-L25 |
14,132 | kidoman/embd | spidriver.go | Bus | func (s *spiDriver) Bus(mode, channel byte, speed, bpw, delay int) SPIBus {
s.busMapLock.Lock()
defer s.busMapLock.Unlock()
b := s.sbf(s.spiDevMinor, mode, channel, speed, bpw, delay, s.initializer)
s.busMap = make(map[byte]SPIBus)
s.busMap[channel] = b
return b
} | go | func (s *spiDriver) Bus(mode, channel byte, speed, bpw, delay int) SPIBus {
s.busMapLock.Lock()
defer s.busMapLock.Unlock()
b := s.sbf(s.spiDevMinor, mode, channel, speed, bpw, delay, s.initializer)
s.busMap = make(map[byte]SPIBus)
s.busMap[channel] = b
return b
} | [
"func",
"(",
"s",
"*",
"spiDriver",
")",
"Bus",
"(",
"mode",
",",
"channel",
"byte",
",",
"speed",
",",
"bpw",
",",
"delay",
"int",
")",
"SPIBus",
"{",
"s",
".",
"busMapLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"busMapLock",
".",
"Un... | // Bus returns a SPIBus interface which allows us to use spi functionalities | [
"Bus",
"returns",
"a",
"SPIBus",
"interface",
"which",
"allows",
"us",
"to",
"use",
"spi",
"functionalities"
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/spidriver.go#L28-L36 |
14,133 | kidoman/embd | spidriver.go | Close | func (s *spiDriver) Close() error {
for _, b := range s.busMap {
b.Close()
}
return nil
} | go | func (s *spiDriver) Close() error {
for _, b := range s.busMap {
b.Close()
}
return nil
} | [
"func",
"(",
"s",
"*",
"spiDriver",
")",
"Close",
"(",
")",
"error",
"{",
"for",
"_",
",",
"b",
":=",
"range",
"s",
".",
"busMap",
"{",
"b",
".",
"Close",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Close cleans up all the initialized SPIbus | [
"Close",
"cleans",
"up",
"all",
"the",
"initialized",
"SPIbus"
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/spidriver.go#L39-L45 |
14,134 | kidoman/embd | descriptor.go | Register | func Register(host Host, describer Describer) {
if describer == nil {
panic("embd: describer is nil")
}
if _, dup := describers[host]; dup {
panic("embd: describer already registered")
}
describers[host] = describer
glog.V(1).Infof("embd: host %v is registered", host)
} | go | func Register(host Host, describer Describer) {
if describer == nil {
panic("embd: describer is nil")
}
if _, dup := describers[host]; dup {
panic("embd: describer already registered")
}
describers[host] = describer
glog.V(1).Infof("embd: host %v is registered", host)
} | [
"func",
"Register",
"(",
"host",
"Host",
",",
"describer",
"Describer",
")",
"{",
"if",
"describer",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"dup",
":=",
"describers",
"[",
"host",
"]",
";",
"dup",
"{",
"... | // Register makes a host describer available by the provided host key.
// If Register is called twice with the same host or if describer is nil,
// it panics. | [
"Register",
"makes",
"a",
"host",
"describer",
"available",
"by",
"the",
"provided",
"host",
"key",
".",
"If",
"Register",
"is",
"called",
"twice",
"with",
"the",
"same",
"host",
"or",
"if",
"describer",
"is",
"nil",
"it",
"panics",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/descriptor.go#L29-L39 |
14,135 | kidoman/embd | descriptor.go | SetHost | func SetHost(host Host, rev int) {
hostOverride = host
hostRevOverride = rev
hostOverriden = true
} | go | func SetHost(host Host, rev int) {
hostOverride = host
hostRevOverride = rev
hostOverriden = true
} | [
"func",
"SetHost",
"(",
"host",
"Host",
",",
"rev",
"int",
")",
"{",
"hostOverride",
"=",
"host",
"\n",
"hostRevOverride",
"=",
"rev",
"\n\n",
"hostOverriden",
"=",
"true",
"\n",
"}"
] | // SetHost overrides the host and revision no. | [
"SetHost",
"overrides",
"the",
"host",
"and",
"revision",
"no",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/descriptor.go#L46-L51 |
14,136 | kidoman/embd | descriptor.go | DescribeHost | func DescribeHost() (*Descriptor, error) {
var host Host
var rev int
if hostOverriden {
host, rev = hostOverride, hostRevOverride
} else {
var err error
host, rev, err = DetectHost()
if err != nil {
return nil, err
}
}
describer, ok := describers[host]
if !ok {
return nil, fmt.Errorf("host: invalid host %q", host)
}
return describer(rev), nil
} | go | func DescribeHost() (*Descriptor, error) {
var host Host
var rev int
if hostOverriden {
host, rev = hostOverride, hostRevOverride
} else {
var err error
host, rev, err = DetectHost()
if err != nil {
return nil, err
}
}
describer, ok := describers[host]
if !ok {
return nil, fmt.Errorf("host: invalid host %q", host)
}
return describer(rev), nil
} | [
"func",
"DescribeHost",
"(",
")",
"(",
"*",
"Descriptor",
",",
"error",
")",
"{",
"var",
"host",
"Host",
"\n",
"var",
"rev",
"int",
"\n\n",
"if",
"hostOverriden",
"{",
"host",
",",
"rev",
"=",
"hostOverride",
",",
"hostRevOverride",
"\n",
"}",
"else",
... | // DescribeHost returns the detected host descriptor.
// Can be overriden by calling SetHost though. | [
"DescribeHost",
"returns",
"the",
"detected",
"host",
"descriptor",
".",
"Can",
"be",
"overriden",
"by",
"calling",
"SetHost",
"though",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/descriptor.go#L55-L75 |
14,137 | kidoman/embd | sensor/lsm303/lsm303.go | New | func New(bus embd.I2CBus) *LSM303 {
return &LSM303{Bus: bus, Poll: pollDelay}
} | go | func New(bus embd.I2CBus) *LSM303 {
return &LSM303{Bus: bus, Poll: pollDelay}
} | [
"func",
"New",
"(",
"bus",
"embd",
".",
"I2CBus",
")",
"*",
"LSM303",
"{",
"return",
"&",
"LSM303",
"{",
"Bus",
":",
"bus",
",",
"Poll",
":",
"pollDelay",
"}",
"\n",
"}"
] | // New creates a new LSM303 interface. The bus variable controls
// the I2C bus used to communicate with the device. | [
"New",
"creates",
"a",
"new",
"LSM303",
"interface",
".",
"The",
"bus",
"variable",
"controls",
"the",
"I2C",
"bus",
"used",
"to",
"communicate",
"with",
"the",
"device",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/lsm303/lsm303.go#L60-L62 |
14,138 | kidoman/embd | sensor/lsm303/lsm303.go | setup | func (d *LSM303) setup() error {
d.mu.RLock()
if d.initialized {
d.mu.RUnlock()
return nil
}
d.mu.RUnlock()
d.mu.Lock()
defer d.mu.Unlock()
if err := d.Bus.WriteByteToReg(magAddress, magConfigRegA, MagCRADefault); err != nil {
return err
}
if err := d.Bus.WriteByteToReg(magAddress, magModeReg, MagMRDefault); err != nil {
return err
}
d.initialized = true
return nil
} | go | func (d *LSM303) setup() error {
d.mu.RLock()
if d.initialized {
d.mu.RUnlock()
return nil
}
d.mu.RUnlock()
d.mu.Lock()
defer d.mu.Unlock()
if err := d.Bus.WriteByteToReg(magAddress, magConfigRegA, MagCRADefault); err != nil {
return err
}
if err := d.Bus.WriteByteToReg(magAddress, magModeReg, MagMRDefault); err != nil {
return err
}
d.initialized = true
return nil
} | [
"func",
"(",
"d",
"*",
"LSM303",
")",
"setup",
"(",
")",
"error",
"{",
"d",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"if",
"d",
".",
"initialized",
"{",
"d",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"d",
... | // Initialize the device | [
"Initialize",
"the",
"device"
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/lsm303/lsm303.go#L65-L86 |
14,139 | kidoman/embd | sensor/lsm303/lsm303.go | Heading | func (d *LSM303) Heading() (float64, error) {
select {
case heading := <-d.headings:
return heading, nil
default:
glog.V(2).Infof("lsm303: no headings available... measuring")
return d.measureHeading()
}
} | go | func (d *LSM303) Heading() (float64, error) {
select {
case heading := <-d.headings:
return heading, nil
default:
glog.V(2).Infof("lsm303: no headings available... measuring")
return d.measureHeading()
}
} | [
"func",
"(",
"d",
"*",
"LSM303",
")",
"Heading",
"(",
")",
"(",
"float64",
",",
"error",
")",
"{",
"select",
"{",
"case",
"heading",
":=",
"<-",
"d",
".",
"headings",
":",
"return",
"heading",
",",
"nil",
"\n",
"default",
":",
"glog",
".",
"V",
"... | // Heading returns the current heading [0, 360). | [
"Heading",
"returns",
"the",
"current",
"heading",
"[",
"0",
"360",
")",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/lsm303/lsm303.go#L114-L122 |
14,140 | kidoman/embd | sensor/lsm303/lsm303.go | Close | func (d *LSM303) Close() error {
if d.quit != nil {
d.quit <- struct{}{}
}
return d.Bus.WriteByteToReg(magAddress, magModeReg, MagSleep)
} | go | func (d *LSM303) Close() error {
if d.quit != nil {
d.quit <- struct{}{}
}
return d.Bus.WriteByteToReg(magAddress, magModeReg, MagSleep)
} | [
"func",
"(",
"d",
"*",
"LSM303",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"d",
".",
"quit",
"!=",
"nil",
"{",
"d",
".",
"quit",
"<-",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"return",
"d",
".",
"Bus",
".",
"WriteByteToReg",
"(",
"ma... | // Close the sensor data acquisition loop and put the LSM303 into sleep mode. | [
"Close",
"the",
"sensor",
"data",
"acquisition",
"loop",
"and",
"put",
"the",
"LSM303",
"into",
"sleep",
"mode",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/lsm303/lsm303.go#L156-L161 |
14,141 | kidoman/embd | sensor/watersensor/watersensor.go | IsWet | func (d *WaterSensor) IsWet() (bool, error) {
if err := d.setup(); err != nil {
return false, err
}
glog.V(1).Infof("watersensor: reading")
value, err := d.Pin.Read()
if err != nil {
return false, err
}
if value == embd.High {
return true, nil
} else {
return false, nil
}
} | go | func (d *WaterSensor) IsWet() (bool, error) {
if err := d.setup(); err != nil {
return false, err
}
glog.V(1).Infof("watersensor: reading")
value, err := d.Pin.Read()
if err != nil {
return false, err
}
if value == embd.High {
return true, nil
} else {
return false, nil
}
} | [
"func",
"(",
"d",
"*",
"WaterSensor",
")",
"IsWet",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"err",
":=",
"d",
".",
"setup",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"glog",
".",
"V... | // IsWet determines if there is water present on the sensor | [
"IsWet",
"determines",
"if",
"there",
"is",
"water",
"present",
"on",
"the",
"sensor"
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/watersensor/watersensor.go#L44-L60 |
14,142 | kidoman/embd | sensor/bmp085/bmp085.go | New | func New(bus embd.I2CBus) *BMP085 {
return &BMP085{Bus: bus, Poll: pollDelay}
} | go | func New(bus embd.I2CBus) *BMP085 {
return &BMP085{Bus: bus, Poll: pollDelay}
} | [
"func",
"New",
"(",
"bus",
"embd",
".",
"I2CBus",
")",
"*",
"BMP085",
"{",
"return",
"&",
"BMP085",
"{",
"Bus",
":",
"bus",
",",
"Poll",
":",
"pollDelay",
"}",
"\n",
"}"
] | // New returns a handle to a BMP085 sensor. | [
"New",
"returns",
"a",
"handle",
"to",
"a",
"BMP085",
"sensor",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/bmp085/bmp085.go#L62-L64 |
14,143 | kidoman/embd | sensor/bmp085/bmp085.go | Pressure | func (d *BMP085) Pressure() (int, error) {
if err := d.calibrate(); err != nil {
return 0, err
}
select {
case p := <-d.pressures:
return int(p), nil
default:
glog.V(1).Infof("bcm085: no pressures available... measuring")
p, _, err := d.measurePressureAndAltitude()
if err != nil {
return 0, err
}
return int(p), nil
}
} | go | func (d *BMP085) Pressure() (int, error) {
if err := d.calibrate(); err != nil {
return 0, err
}
select {
case p := <-d.pressures:
return int(p), nil
default:
glog.V(1).Infof("bcm085: no pressures available... measuring")
p, _, err := d.measurePressureAndAltitude()
if err != nil {
return 0, err
}
return int(p), nil
}
} | [
"func",
"(",
"d",
"*",
"BMP085",
")",
"Pressure",
"(",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"err",
":=",
"d",
".",
"calibrate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"select",
"{",
"ca... | // Pressure returns the current pressure reading. | [
"Pressure",
"returns",
"the",
"current",
"pressure",
"reading",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/bmp085/bmp085.go#L307-L323 |
14,144 | kidoman/embd | sensor/bmp085/bmp085.go | Altitude | func (d *BMP085) Altitude() (float64, error) {
if err := d.calibrate(); err != nil {
return 0, err
}
select {
case altitude := <-d.altitudes:
return altitude, nil
default:
glog.V(1).Info("bcm085: no altitudes available... measuring")
_, altitude, err := d.measurePressureAndAltitude()
if err != nil {
return 0, err
}
return altitude, nil
}
} | go | func (d *BMP085) Altitude() (float64, error) {
if err := d.calibrate(); err != nil {
return 0, err
}
select {
case altitude := <-d.altitudes:
return altitude, nil
default:
glog.V(1).Info("bcm085: no altitudes available... measuring")
_, altitude, err := d.measurePressureAndAltitude()
if err != nil {
return 0, err
}
return altitude, nil
}
} | [
"func",
"(",
"d",
"*",
"BMP085",
")",
"Altitude",
"(",
")",
"(",
"float64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"d",
".",
"calibrate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"select",
"{",
... | // Altitude returns the current altitude reading. | [
"Altitude",
"returns",
"the",
"current",
"altitude",
"reading",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/bmp085/bmp085.go#L326-L342 |
14,145 | kidoman/embd | controller/hd44780/hd44780.go | NewGPIO | func NewGPIO(
rs, en, d4, d5, d6, d7, backlight interface{},
blPolarity BacklightPolarity,
rowAddr RowAddress,
modes ...ModeSetter,
) (*HD44780, error) {
pinKeys := []interface{}{rs, en, d4, d5, d6, d7, backlight}
pins := [7]embd.DigitalPin{}
for idx, key := range pinKeys {
if key == nil {
continue
}
var digitalPin embd.DigitalPin
if pin, ok := key.(embd.DigitalPin); ok {
digitalPin = pin
} else {
var err error
digitalPin, err = embd.NewDigitalPin(key)
if err != nil {
glog.V(1).Infof("hd44780: error creating digital pin %+v: %s", key, err)
return nil, err
}
}
pins[idx] = digitalPin
}
for _, pin := range pins {
if pin == nil {
continue
}
err := pin.SetDirection(embd.Out)
if err != nil {
glog.Errorf("hd44780: error setting pin %+v to out direction: %s", pin, err)
return nil, err
}
}
return New(
NewGPIOConnection(
pins[0],
pins[1],
pins[2],
pins[3],
pins[4],
pins[5],
pins[6],
blPolarity),
rowAddr,
modes...,
)
} | go | func NewGPIO(
rs, en, d4, d5, d6, d7, backlight interface{},
blPolarity BacklightPolarity,
rowAddr RowAddress,
modes ...ModeSetter,
) (*HD44780, error) {
pinKeys := []interface{}{rs, en, d4, d5, d6, d7, backlight}
pins := [7]embd.DigitalPin{}
for idx, key := range pinKeys {
if key == nil {
continue
}
var digitalPin embd.DigitalPin
if pin, ok := key.(embd.DigitalPin); ok {
digitalPin = pin
} else {
var err error
digitalPin, err = embd.NewDigitalPin(key)
if err != nil {
glog.V(1).Infof("hd44780: error creating digital pin %+v: %s", key, err)
return nil, err
}
}
pins[idx] = digitalPin
}
for _, pin := range pins {
if pin == nil {
continue
}
err := pin.SetDirection(embd.Out)
if err != nil {
glog.Errorf("hd44780: error setting pin %+v to out direction: %s", pin, err)
return nil, err
}
}
return New(
NewGPIOConnection(
pins[0],
pins[1],
pins[2],
pins[3],
pins[4],
pins[5],
pins[6],
blPolarity),
rowAddr,
modes...,
)
} | [
"func",
"NewGPIO",
"(",
"rs",
",",
"en",
",",
"d4",
",",
"d5",
",",
"d6",
",",
"d7",
",",
"backlight",
"interface",
"{",
"}",
",",
"blPolarity",
"BacklightPolarity",
",",
"rowAddr",
"RowAddress",
",",
"modes",
"...",
"ModeSetter",
",",
")",
"(",
"*",
... | // NewGPIO creates a new HD44780 connected by a 4-bit GPIO bus. | [
"NewGPIO",
"creates",
"a",
"new",
"HD44780",
"connected",
"by",
"a",
"4",
"-",
"bit",
"GPIO",
"bus",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/hd44780/hd44780.go#L104-L152 |
14,146 | kidoman/embd | controller/hd44780/hd44780.go | New | func New(bus Connection, rowAddr RowAddress, modes ...ModeSetter) (*HD44780, error) {
controller := &HD44780{
Connection: bus,
eMode: 0x00,
dMode: 0x00,
fMode: 0x00,
rowAddr: rowAddr,
}
err := controller.lcdInit()
if err != nil {
return nil, err
}
err = controller.SetMode(append(DefaultModes, modes...)...)
if err != nil {
return nil, err
}
return controller, nil
} | go | func New(bus Connection, rowAddr RowAddress, modes ...ModeSetter) (*HD44780, error) {
controller := &HD44780{
Connection: bus,
eMode: 0x00,
dMode: 0x00,
fMode: 0x00,
rowAddr: rowAddr,
}
err := controller.lcdInit()
if err != nil {
return nil, err
}
err = controller.SetMode(append(DefaultModes, modes...)...)
if err != nil {
return nil, err
}
return controller, nil
} | [
"func",
"New",
"(",
"bus",
"Connection",
",",
"rowAddr",
"RowAddress",
",",
"modes",
"...",
"ModeSetter",
")",
"(",
"*",
"HD44780",
",",
"error",
")",
"{",
"controller",
":=",
"&",
"HD44780",
"{",
"Connection",
":",
"bus",
",",
"eMode",
":",
"0x00",
",... | // New creates a new HD44780 connected by a Connection bus. | [
"New",
"creates",
"a",
"new",
"HD44780",
"connected",
"by",
"a",
"Connection",
"bus",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/hd44780/hd44780.go#L166-L183 |
14,147 | kidoman/embd | controller/hd44780/hd44780.go | SetMode | func (hd *HD44780) SetMode(modes ...ModeSetter) error {
for _, m := range modes {
m(hd)
}
functions := []func() error{
func() error { return hd.setEntryMode() },
func() error { return hd.setDisplayMode() },
func() error { return hd.setFunctionMode() },
}
for _, f := range functions {
err := f()
if err != nil {
return err
}
}
return nil
} | go | func (hd *HD44780) SetMode(modes ...ModeSetter) error {
for _, m := range modes {
m(hd)
}
functions := []func() error{
func() error { return hd.setEntryMode() },
func() error { return hd.setDisplayMode() },
func() error { return hd.setFunctionMode() },
}
for _, f := range functions {
err := f()
if err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"hd",
"*",
"HD44780",
")",
"SetMode",
"(",
"modes",
"...",
"ModeSetter",
")",
"error",
"{",
"for",
"_",
",",
"m",
":=",
"range",
"modes",
"{",
"m",
"(",
"hd",
")",
"\n",
"}",
"\n",
"functions",
":=",
"[",
"]",
"func",
"(",
")",
"er... | // SetModes modifies the entry mode, display mode, and function mode with the
// given mode setter functions. | [
"SetModes",
"modifies",
"the",
"entry",
"mode",
"display",
"mode",
"and",
"function",
"mode",
"with",
"the",
"given",
"mode",
"setter",
"functions",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/hd44780/hd44780.go#L288-L304 |
14,148 | kidoman/embd | controller/hd44780/hd44780.go | Home | func (hd *HD44780) Home() error {
err := hd.WriteInstruction(lcdReturnHome)
time.Sleep(clearDelay)
return err
} | go | func (hd *HD44780) Home() error {
err := hd.WriteInstruction(lcdReturnHome)
time.Sleep(clearDelay)
return err
} | [
"func",
"(",
"hd",
"*",
"HD44780",
")",
"Home",
"(",
")",
"error",
"{",
"err",
":=",
"hd",
".",
"WriteInstruction",
"(",
"lcdReturnHome",
")",
"\n",
"time",
".",
"Sleep",
"(",
"clearDelay",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Home moves the cursor and all characters to the home position. | [
"Home",
"moves",
"the",
"cursor",
"and",
"all",
"characters",
"to",
"the",
"home",
"position",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/hd44780/hd44780.go#L365-L369 |
14,149 | kidoman/embd | controller/hd44780/hd44780.go | Clear | func (hd *HD44780) Clear() error {
err := hd.WriteInstruction(lcdClearDisplay)
if err != nil {
return err
}
time.Sleep(clearDelay)
// have to set mode here because clear also clears some mode settings
return hd.SetMode()
} | go | func (hd *HD44780) Clear() error {
err := hd.WriteInstruction(lcdClearDisplay)
if err != nil {
return err
}
time.Sleep(clearDelay)
// have to set mode here because clear also clears some mode settings
return hd.SetMode()
} | [
"func",
"(",
"hd",
"*",
"HD44780",
")",
"Clear",
"(",
")",
"error",
"{",
"err",
":=",
"hd",
".",
"WriteInstruction",
"(",
"lcdClearDisplay",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"time",
".",
"Sleep",
"(",
"cle... | // Clear clears the display and mode settings sets the cursor to the home position. | [
"Clear",
"clears",
"the",
"display",
"and",
"mode",
"settings",
"sets",
"the",
"cursor",
"to",
"the",
"home",
"position",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/hd44780/hd44780.go#L372-L380 |
14,150 | kidoman/embd | controller/hd44780/hd44780.go | SetDDRamAddr | func (hd *HD44780) SetDDRamAddr(value byte) error {
return hd.WriteInstruction(lcdSetDDRamAddr | value)
} | go | func (hd *HD44780) SetDDRamAddr(value byte) error {
return hd.WriteInstruction(lcdSetDDRamAddr | value)
} | [
"func",
"(",
"hd",
"*",
"HD44780",
")",
"SetDDRamAddr",
"(",
"value",
"byte",
")",
"error",
"{",
"return",
"hd",
".",
"WriteInstruction",
"(",
"lcdSetDDRamAddr",
"|",
"value",
")",
"\n",
"}"
] | // SetDDRamAddr sets the input cursor to the given address. | [
"SetDDRamAddr",
"sets",
"the",
"input",
"cursor",
"to",
"the",
"given",
"address",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/hd44780/hd44780.go#L396-L398 |
14,151 | kidoman/embd | controller/hd44780/hd44780.go | WriteChar | func (hd *HD44780) WriteChar(value byte) error {
return hd.Write(true, value)
} | go | func (hd *HD44780) WriteChar(value byte) error {
return hd.Write(true, value)
} | [
"func",
"(",
"hd",
"*",
"HD44780",
")",
"WriteChar",
"(",
"value",
"byte",
")",
"error",
"{",
"return",
"hd",
".",
"Write",
"(",
"true",
",",
"value",
")",
"\n",
"}"
] | // WriteInstruction writes a byte to the bus with register select in data mode. | [
"WriteInstruction",
"writes",
"a",
"byte",
"to",
"the",
"bus",
"with",
"register",
"select",
"in",
"data",
"mode",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/hd44780/hd44780.go#L401-L403 |
14,152 | kidoman/embd | controller/hd44780/hd44780.go | WriteInstruction | func (hd *HD44780) WriteInstruction(value byte) error {
return hd.Write(false, value)
} | go | func (hd *HD44780) WriteInstruction(value byte) error {
return hd.Write(false, value)
} | [
"func",
"(",
"hd",
"*",
"HD44780",
")",
"WriteInstruction",
"(",
"value",
"byte",
")",
"error",
"{",
"return",
"hd",
".",
"Write",
"(",
"false",
",",
"value",
")",
"\n",
"}"
] | // WriteInstruction writes a byte to the bus with register select in command mode. | [
"WriteInstruction",
"writes",
"a",
"byte",
"to",
"the",
"bus",
"with",
"register",
"select",
"in",
"command",
"mode",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/hd44780/hd44780.go#L406-L408 |
14,153 | kidoman/embd | controller/hd44780/hd44780.go | NewGPIOConnection | func NewGPIOConnection(
rs, en, d4, d5, d6, d7, backlight embd.DigitalPin,
blPolarity BacklightPolarity,
) *GPIOConnection {
return &GPIOConnection{
RS: rs,
EN: en,
D4: d4,
D5: d5,
D6: d6,
D7: d7,
Backlight: backlight,
BLPolarity: blPolarity,
}
} | go | func NewGPIOConnection(
rs, en, d4, d5, d6, d7, backlight embd.DigitalPin,
blPolarity BacklightPolarity,
) *GPIOConnection {
return &GPIOConnection{
RS: rs,
EN: en,
D4: d4,
D5: d5,
D6: d6,
D7: d7,
Backlight: backlight,
BLPolarity: blPolarity,
}
} | [
"func",
"NewGPIOConnection",
"(",
"rs",
",",
"en",
",",
"d4",
",",
"d5",
",",
"d6",
",",
"d7",
",",
"backlight",
"embd",
".",
"DigitalPin",
",",
"blPolarity",
"BacklightPolarity",
",",
")",
"*",
"GPIOConnection",
"{",
"return",
"&",
"GPIOConnection",
"{",
... | // NewGPIOConnection returns a new Connection based on a 4-bit GPIO bus. | [
"NewGPIOConnection",
"returns",
"a",
"new",
"Connection",
"based",
"on",
"a",
"4",
"-",
"bit",
"GPIO",
"bus",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/hd44780/hd44780.go#L440-L454 |
14,154 | kidoman/embd | controller/hd44780/hd44780.go | Write | func (conn *GPIOConnection) Write(rs bool, data byte) error {
glog.V(3).Infof("hd44780: writing to GPIO RS: %t, data: %#x", rs, data)
rsInt := embd.Low
if rs {
rsInt = embd.High
}
functions := []func() error{
func() error { return conn.RS.Write(rsInt) },
func() error { return conn.D4.Write(int((data >> 4) & 0x01)) },
func() error { return conn.D5.Write(int((data >> 5) & 0x01)) },
func() error { return conn.D6.Write(int((data >> 6) & 0x01)) },
func() error { return conn.D7.Write(int((data >> 7) & 0x01)) },
func() error { return conn.pulseEnable() },
func() error { return conn.D4.Write(int(data & 0x01)) },
func() error { return conn.D5.Write(int((data >> 1) & 0x01)) },
func() error { return conn.D6.Write(int((data >> 2) & 0x01)) },
func() error { return conn.D7.Write(int((data >> 3) & 0x01)) },
func() error { return conn.pulseEnable() },
}
for _, f := range functions {
err := f()
if err != nil {
return err
}
}
time.Sleep(writeDelay)
return nil
} | go | func (conn *GPIOConnection) Write(rs bool, data byte) error {
glog.V(3).Infof("hd44780: writing to GPIO RS: %t, data: %#x", rs, data)
rsInt := embd.Low
if rs {
rsInt = embd.High
}
functions := []func() error{
func() error { return conn.RS.Write(rsInt) },
func() error { return conn.D4.Write(int((data >> 4) & 0x01)) },
func() error { return conn.D5.Write(int((data >> 5) & 0x01)) },
func() error { return conn.D6.Write(int((data >> 6) & 0x01)) },
func() error { return conn.D7.Write(int((data >> 7) & 0x01)) },
func() error { return conn.pulseEnable() },
func() error { return conn.D4.Write(int(data & 0x01)) },
func() error { return conn.D5.Write(int((data >> 1) & 0x01)) },
func() error { return conn.D6.Write(int((data >> 2) & 0x01)) },
func() error { return conn.D7.Write(int((data >> 3) & 0x01)) },
func() error { return conn.pulseEnable() },
}
for _, f := range functions {
err := f()
if err != nil {
return err
}
}
time.Sleep(writeDelay)
return nil
} | [
"func",
"(",
"conn",
"*",
"GPIOConnection",
")",
"Write",
"(",
"rs",
"bool",
",",
"data",
"byte",
")",
"error",
"{",
"glog",
".",
"V",
"(",
"3",
")",
".",
"Infof",
"(",
"\"",
"\"",
",",
"rs",
",",
"data",
")",
"\n",
"rsInt",
":=",
"embd",
".",
... | // Write writes a register select flag and byte to the 4-bit GPIO connection. | [
"Write",
"writes",
"a",
"register",
"select",
"flag",
"and",
"byte",
"to",
"the",
"4",
"-",
"bit",
"GPIO",
"connection",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/hd44780/hd44780.go#L481-L508 |
14,155 | kidoman/embd | controller/hd44780/hd44780.go | Close | func (conn *GPIOConnection) Close() error {
glog.V(2).Info("hd44780: closing all GPIO pins")
pins := []embd.DigitalPin{
conn.RS,
conn.EN,
conn.D4,
conn.D5,
conn.D6,
conn.D7,
conn.Backlight,
}
for _, pin := range pins {
err := pin.Close()
if err != nil {
glog.Errorf("hd44780: error closing pin %+v: %s", pin, err)
return err
}
}
return nil
} | go | func (conn *GPIOConnection) Close() error {
glog.V(2).Info("hd44780: closing all GPIO pins")
pins := []embd.DigitalPin{
conn.RS,
conn.EN,
conn.D4,
conn.D5,
conn.D6,
conn.D7,
conn.Backlight,
}
for _, pin := range pins {
err := pin.Close()
if err != nil {
glog.Errorf("hd44780: error closing pin %+v: %s", pin, err)
return err
}
}
return nil
} | [
"func",
"(",
"conn",
"*",
"GPIOConnection",
")",
"Close",
"(",
")",
"error",
"{",
"glog",
".",
"V",
"(",
"2",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"pins",
":=",
"[",
"]",
"embd",
".",
"DigitalPin",
"{",
"conn",
".",
"RS",
",",
"conn",
... | // Close closes all open DigitalPins. | [
"Close",
"closes",
"all",
"open",
"DigitalPins",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/hd44780/hd44780.go#L523-L543 |
14,156 | kidoman/embd | sensor/us020/us020.go | New | func New(echoPin, triggerPin embd.DigitalPin, thermometer Thermometer) *US020 {
return &US020{EchoPin: echoPin, TriggerPin: triggerPin, Thermometer: thermometer}
} | go | func New(echoPin, triggerPin embd.DigitalPin, thermometer Thermometer) *US020 {
return &US020{EchoPin: echoPin, TriggerPin: triggerPin, Thermometer: thermometer}
} | [
"func",
"New",
"(",
"echoPin",
",",
"triggerPin",
"embd",
".",
"DigitalPin",
",",
"thermometer",
"Thermometer",
")",
"*",
"US020",
"{",
"return",
"&",
"US020",
"{",
"EchoPin",
":",
"echoPin",
",",
"TriggerPin",
":",
"triggerPin",
",",
"Thermometer",
":",
"... | // New creates a new US020 interface. The bus variable controls
// the I2C bus used to communicate with the device. | [
"New",
"creates",
"a",
"new",
"US020",
"interface",
".",
"The",
"bus",
"variable",
"controls",
"the",
"I2C",
"bus",
"used",
"to",
"communicate",
"with",
"the",
"device",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/us020/us020.go#L44-L46 |
14,157 | kidoman/embd | sensor/us020/us020.go | Distance | func (d *US020) Distance() (float64, error) {
if err := d.setup(); err != nil {
return 0, err
}
glog.V(2).Infof("us020: trigerring pulse")
// Generate a TRIGGER pulse
d.TriggerPin.Write(embd.High)
time.Sleep(pulseDelay)
d.TriggerPin.Write(embd.Low)
glog.V(2).Infof("us020: waiting for echo to go high")
duration, err := d.EchoPin.TimePulse(embd.High)
if err != nil {
return 0, err
}
// Calculate the distance based on the time computed
distance := float64(duration.Nanoseconds()) / 10000000 * (d.speedSound / 2)
return distance, nil
} | go | func (d *US020) Distance() (float64, error) {
if err := d.setup(); err != nil {
return 0, err
}
glog.V(2).Infof("us020: trigerring pulse")
// Generate a TRIGGER pulse
d.TriggerPin.Write(embd.High)
time.Sleep(pulseDelay)
d.TriggerPin.Write(embd.Low)
glog.V(2).Infof("us020: waiting for echo to go high")
duration, err := d.EchoPin.TimePulse(embd.High)
if err != nil {
return 0, err
}
// Calculate the distance based on the time computed
distance := float64(duration.Nanoseconds()) / 10000000 * (d.speedSound / 2)
return distance, nil
} | [
"func",
"(",
"d",
"*",
"US020",
")",
"Distance",
"(",
")",
"(",
"float64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"d",
".",
"setup",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"glog",
".",
"V",
... | // Distance computes the distance of the bot from the closest obstruction. | [
"Distance",
"computes",
"the",
"distance",
"of",
"the",
"bot",
"from",
"the",
"closest",
"obstruction",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/us020/us020.go#L80-L103 |
14,158 | kidoman/embd | gpio.go | InitGPIO | func InitGPIO() error {
if gpioDriverInitialized {
return nil
}
desc, err := DescribeHost()
if err != nil {
return err
}
if desc.GPIODriver == nil {
return ErrFeatureNotSupported
}
gpioDriverInstance = desc.GPIODriver()
gpioDriverInitialized = true
return nil
} | go | func InitGPIO() error {
if gpioDriverInitialized {
return nil
}
desc, err := DescribeHost()
if err != nil {
return err
}
if desc.GPIODriver == nil {
return ErrFeatureNotSupported
}
gpioDriverInstance = desc.GPIODriver()
gpioDriverInitialized = true
return nil
} | [
"func",
"InitGPIO",
"(",
")",
"error",
"{",
"if",
"gpioDriverInitialized",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"desc",
",",
"err",
":=",
"DescribeHost",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"de... | // InitGPIO initializes the GPIO driver. | [
"InitGPIO",
"initializes",
"the",
"GPIO",
"driver",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/gpio.go#L155-L173 |
14,159 | kidoman/embd | gpio.go | NewDigitalPin | func NewDigitalPin(key interface{}) (DigitalPin, error) {
if err := InitGPIO(); err != nil {
return nil, err
}
return gpioDriverInstance.DigitalPin(key)
} | go | func NewDigitalPin(key interface{}) (DigitalPin, error) {
if err := InitGPIO(); err != nil {
return nil, err
}
return gpioDriverInstance.DigitalPin(key)
} | [
"func",
"NewDigitalPin",
"(",
"key",
"interface",
"{",
"}",
")",
"(",
"DigitalPin",
",",
"error",
")",
"{",
"if",
"err",
":=",
"InitGPIO",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"gpioDriverIn... | // NewDigitalPin returns a DigitalPin interface which allows control over
// the digital GPIO pin. | [
"NewDigitalPin",
"returns",
"a",
"DigitalPin",
"interface",
"which",
"allows",
"control",
"over",
"the",
"digital",
"GPIO",
"pin",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/gpio.go#L182-L188 |
14,160 | kidoman/embd | gpio.go | DigitalWrite | func DigitalWrite(key interface{}, val int) error {
pin, err := NewDigitalPin(key)
if err != nil {
return err
}
return pin.Write(val)
} | go | func DigitalWrite(key interface{}, val int) error {
pin, err := NewDigitalPin(key)
if err != nil {
return err
}
return pin.Write(val)
} | [
"func",
"DigitalWrite",
"(",
"key",
"interface",
"{",
"}",
",",
"val",
"int",
")",
"error",
"{",
"pin",
",",
"err",
":=",
"NewDigitalPin",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"pin",
".... | // DigitalWrite writes val to the pin. | [
"DigitalWrite",
"writes",
"val",
"to",
"the",
"pin",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/gpio.go#L191-L198 |
14,161 | kidoman/embd | gpio.go | DigitalRead | func DigitalRead(key interface{}) (int, error) {
pin, err := NewDigitalPin(key)
if err != nil {
return 0, err
}
return pin.Read()
} | go | func DigitalRead(key interface{}) (int, error) {
pin, err := NewDigitalPin(key)
if err != nil {
return 0, err
}
return pin.Read()
} | [
"func",
"DigitalRead",
"(",
"key",
"interface",
"{",
"}",
")",
"(",
"int",
",",
"error",
")",
"{",
"pin",
",",
"err",
":=",
"NewDigitalPin",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"retu... | // DigitalRead reads a value from the pin. | [
"DigitalRead",
"reads",
"a",
"value",
"from",
"the",
"pin",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/gpio.go#L201-L208 |
14,162 | kidoman/embd | gpio.go | ActiveLow | func ActiveLow(key interface{}, b bool) error {
pin, err := NewDigitalPin(key)
if err != nil {
return err
}
return pin.ActiveLow(b)
} | go | func ActiveLow(key interface{}, b bool) error {
pin, err := NewDigitalPin(key)
if err != nil {
return err
}
return pin.ActiveLow(b)
} | [
"func",
"ActiveLow",
"(",
"key",
"interface",
"{",
"}",
",",
"b",
"bool",
")",
"error",
"{",
"pin",
",",
"err",
":=",
"NewDigitalPin",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"pin",
".",
... | // ActiveLow makes the pin active low. A low logical state is represented by
// a high state on the physical pin, and vice-versa. | [
"ActiveLow",
"makes",
"the",
"pin",
"active",
"low",
".",
"A",
"low",
"logical",
"state",
"is",
"represented",
"by",
"a",
"high",
"state",
"on",
"the",
"physical",
"pin",
"and",
"vice",
"-",
"versa",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/gpio.go#L222-L229 |
14,163 | kidoman/embd | gpio.go | PullUp | func PullUp(key interface{}) error {
pin, err := NewDigitalPin(key)
if err != nil {
return err
}
return pin.PullUp()
} | go | func PullUp(key interface{}) error {
pin, err := NewDigitalPin(key)
if err != nil {
return err
}
return pin.PullUp()
} | [
"func",
"PullUp",
"(",
"key",
"interface",
"{",
"}",
")",
"error",
"{",
"pin",
",",
"err",
":=",
"NewDigitalPin",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"pin",
".",
"PullUp",
"(",
")",
... | // PullUp pulls the pin up. | [
"PullUp",
"pulls",
"the",
"pin",
"up",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/gpio.go#L232-L239 |
14,164 | kidoman/embd | gpio.go | PullDown | func PullDown(key interface{}) error {
pin, err := NewDigitalPin(key)
if err != nil {
return err
}
return pin.PullDown()
} | go | func PullDown(key interface{}) error {
pin, err := NewDigitalPin(key)
if err != nil {
return err
}
return pin.PullDown()
} | [
"func",
"PullDown",
"(",
"key",
"interface",
"{",
"}",
")",
"error",
"{",
"pin",
",",
"err",
":=",
"NewDigitalPin",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"pin",
".",
"PullDown",
"(",
")"... | // PullDown pulls the pin down. | [
"PullDown",
"pulls",
"the",
"pin",
"down",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/gpio.go#L242-L249 |
14,165 | kidoman/embd | gpio.go | NewAnalogPin | func NewAnalogPin(key interface{}) (AnalogPin, error) {
if err := InitGPIO(); err != nil {
return nil, err
}
return gpioDriverInstance.AnalogPin(key)
} | go | func NewAnalogPin(key interface{}) (AnalogPin, error) {
if err := InitGPIO(); err != nil {
return nil, err
}
return gpioDriverInstance.AnalogPin(key)
} | [
"func",
"NewAnalogPin",
"(",
"key",
"interface",
"{",
"}",
")",
"(",
"AnalogPin",
",",
"error",
")",
"{",
"if",
"err",
":=",
"InitGPIO",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"gpioDriverInst... | // NewAnalogPin returns a AnalogPin interface which allows control over
// the analog GPIO pin. | [
"NewAnalogPin",
"returns",
"a",
"AnalogPin",
"interface",
"which",
"allows",
"control",
"over",
"the",
"analog",
"GPIO",
"pin",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/gpio.go#L253-L259 |
14,166 | kidoman/embd | gpio.go | AnalogRead | func AnalogRead(key interface{}) (int, error) {
pin, err := NewAnalogPin(key)
if err != nil {
return 0, err
}
return pin.Read()
} | go | func AnalogRead(key interface{}) (int, error) {
pin, err := NewAnalogPin(key)
if err != nil {
return 0, err
}
return pin.Read()
} | [
"func",
"AnalogRead",
"(",
"key",
"interface",
"{",
"}",
")",
"(",
"int",
",",
"error",
")",
"{",
"pin",
",",
"err",
":=",
"NewAnalogPin",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"return... | // AnalogWrite reads a value from the pin. | [
"AnalogWrite",
"reads",
"a",
"value",
"from",
"the",
"pin",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/gpio.go#L262-L269 |
14,167 | kidoman/embd | gpio.go | NewPWMPin | func NewPWMPin(key interface{}) (PWMPin, error) {
if err := InitGPIO(); err != nil {
return nil, err
}
return gpioDriverInstance.PWMPin(key)
} | go | func NewPWMPin(key interface{}) (PWMPin, error) {
if err := InitGPIO(); err != nil {
return nil, err
}
return gpioDriverInstance.PWMPin(key)
} | [
"func",
"NewPWMPin",
"(",
"key",
"interface",
"{",
"}",
")",
"(",
"PWMPin",
",",
"error",
")",
"{",
"if",
"err",
":=",
"InitGPIO",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"gpioDriverInstance",... | // NewPWMPin returns a PWMPin interface which allows PWM signal
// generation over a the PWM pin. | [
"NewPWMPin",
"returns",
"a",
"PWMPin",
"interface",
"which",
"allows",
"PWM",
"signal",
"generation",
"over",
"a",
"the",
"PWM",
"pin",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/gpio.go#L273-L279 |
14,168 | kidoman/embd | detect.go | DetectHost | func DetectHost() (host Host, rev int, err error) {
major, minor, patch, err := kernelVersion()
if err != nil {
return HostNull, 0, err
}
if major < 3 || (major == 3 && minor < 8) {
return HostNull, 0, fmt.Errorf(
"embd: linux kernel versions lower than 3.8 are not supported, "+
"you have %v.%v.%v", major, minor, patch)
}
model, hardware, rev, err := cpuInfo()
if err != nil {
return HostNull, 0, err
}
switch {
case strings.Contains(model, "ARMv7") && (strings.Contains(hardware, "AM33XX") || strings.Contains(hardware, "AM335X")):
return HostBBB, rev, nil
case strings.Contains(hardware, "BCM2708") || strings.Contains(hardware, "BCM2709") || strings.Contains(hardware, "BCM2835"):
return HostRPi, rev, nil
case hardware == "Allwinner sun4i/sun5i Families":
if major < 4 || (major == 4 && minor < 4) {
return HostNull, 0, fmt.Errorf(
"embd: linux kernel version 4.4+ required, you have %v.%v",
major, minor)
}
return HostCHIP, rev, nil
default:
return HostNull, 0, fmt.Errorf(`embd: your host "%v:%v" is not supported at this moment. request support at https://github.com/kidoman/embd/issues`, host, model)
}
} | go | func DetectHost() (host Host, rev int, err error) {
major, minor, patch, err := kernelVersion()
if err != nil {
return HostNull, 0, err
}
if major < 3 || (major == 3 && minor < 8) {
return HostNull, 0, fmt.Errorf(
"embd: linux kernel versions lower than 3.8 are not supported, "+
"you have %v.%v.%v", major, minor, patch)
}
model, hardware, rev, err := cpuInfo()
if err != nil {
return HostNull, 0, err
}
switch {
case strings.Contains(model, "ARMv7") && (strings.Contains(hardware, "AM33XX") || strings.Contains(hardware, "AM335X")):
return HostBBB, rev, nil
case strings.Contains(hardware, "BCM2708") || strings.Contains(hardware, "BCM2709") || strings.Contains(hardware, "BCM2835"):
return HostRPi, rev, nil
case hardware == "Allwinner sun4i/sun5i Families":
if major < 4 || (major == 4 && minor < 4) {
return HostNull, 0, fmt.Errorf(
"embd: linux kernel version 4.4+ required, you have %v.%v",
major, minor)
}
return HostCHIP, rev, nil
default:
return HostNull, 0, fmt.Errorf(`embd: your host "%v:%v" is not supported at this moment. request support at https://github.com/kidoman/embd/issues`, host, model)
}
} | [
"func",
"DetectHost",
"(",
")",
"(",
"host",
"Host",
",",
"rev",
"int",
",",
"err",
"error",
")",
"{",
"major",
",",
"minor",
",",
"patch",
",",
"err",
":=",
"kernelVersion",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"HostNull",
",",... | // DetectHost returns the detected host and its revision number. | [
"DetectHost",
"returns",
"the",
"detected",
"host",
"and",
"its",
"revision",
"number",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/detect.go#L107-L139 |
14,169 | kidoman/embd | sensor/l3gd20/l3gd20.go | New | func New(bus embd.I2CBus, Range *Range) *L3GD20 {
return &L3GD20{
Bus: bus,
Range: Range,
}
} | go | func New(bus embd.I2CBus, Range *Range) *L3GD20 {
return &L3GD20{
Bus: bus,
Range: Range,
}
} | [
"func",
"New",
"(",
"bus",
"embd",
".",
"I2CBus",
",",
"Range",
"*",
"Range",
")",
"*",
"L3GD20",
"{",
"return",
"&",
"L3GD20",
"{",
"Bus",
":",
"bus",
",",
"Range",
":",
"Range",
",",
"}",
"\n",
"}"
] | // New creates a new L3GD20 interface. The bus variable controls
// the I2C bus used to communicate with the device. | [
"New",
"creates",
"a",
"new",
"L3GD20",
"interface",
".",
"The",
"bus",
"variable",
"controls",
"the",
"I2C",
"bus",
"used",
"to",
"communicate",
"with",
"the",
"device",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/l3gd20/l3gd20.go#L129-L134 |
14,170 | kidoman/embd | sensor/l3gd20/l3gd20.go | Orientations | func (d *L3GD20) Orientations() (<-chan Orientation, error) {
if err := d.setup(); err != nil {
return nil, err
}
return d.orientations, nil
} | go | func (d *L3GD20) Orientations() (<-chan Orientation, error) {
if err := d.setup(); err != nil {
return nil, err
}
return d.orientations, nil
} | [
"func",
"(",
"d",
"*",
"L3GD20",
")",
"Orientations",
"(",
")",
"(",
"<-",
"chan",
"Orientation",
",",
"error",
")",
"{",
"if",
"err",
":=",
"d",
".",
"setup",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\... | // Orientations returns a channel which will have the current temperature reading. | [
"Orientations",
"returns",
"a",
"channel",
"which",
"will",
"have",
"the",
"current",
"temperature",
"reading",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/l3gd20/l3gd20.go#L319-L325 |
14,171 | kidoman/embd | sensor/l3gd20/l3gd20.go | Stop | func (d *L3GD20) Stop() error {
if d.closing != nil {
waitc := make(chan struct{})
d.closing <- waitc
<-waitc
d.closing = nil
}
if err := d.Bus.WriteByteToReg(address, ctrlReg1, ctrlReg1Finished); err != nil {
return err
}
d.initialized = false
return nil
} | go | func (d *L3GD20) Stop() error {
if d.closing != nil {
waitc := make(chan struct{})
d.closing <- waitc
<-waitc
d.closing = nil
}
if err := d.Bus.WriteByteToReg(address, ctrlReg1, ctrlReg1Finished); err != nil {
return err
}
d.initialized = false
return nil
} | [
"func",
"(",
"d",
"*",
"L3GD20",
")",
"Stop",
"(",
")",
"error",
"{",
"if",
"d",
".",
"closing",
"!=",
"nil",
"{",
"waitc",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"d",
".",
"closing",
"<-",
"waitc",
"\n",
"<-",
"waitc",
"\n",... | // Stop the data acquisition loop. | [
"Stop",
"the",
"data",
"acquisition",
"loop",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/l3gd20/l3gd20.go#L368-L380 |
14,172 | kidoman/embd | controller/mcp4725/mcp4725.go | SetVoltage | func (d *MCP4725) SetVoltage(voltage int) error {
return d.setVoltage(voltage, dacReg)
} | go | func (d *MCP4725) SetVoltage(voltage int) error {
return d.setVoltage(voltage, dacReg)
} | [
"func",
"(",
"d",
"*",
"MCP4725",
")",
"SetVoltage",
"(",
"voltage",
"int",
")",
"error",
"{",
"return",
"d",
".",
"setVoltage",
"(",
"voltage",
",",
"dacReg",
")",
"\n",
"}"
] | // SetVoltage sets the output voltage. | [
"SetVoltage",
"sets",
"the",
"output",
"voltage",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/mcp4725/mcp4725.go#L82-L84 |
14,173 | kidoman/embd | controller/mcp4725/mcp4725.go | SetPersistedVoltage | func (d *MCP4725) SetPersistedVoltage(voltage int) error {
return d.setVoltage(voltage, programReg)
} | go | func (d *MCP4725) SetPersistedVoltage(voltage int) error {
return d.setVoltage(voltage, programReg)
} | [
"func",
"(",
"d",
"*",
"MCP4725",
")",
"SetPersistedVoltage",
"(",
"voltage",
"int",
")",
"error",
"{",
"return",
"d",
".",
"setVoltage",
"(",
"voltage",
",",
"programReg",
")",
"\n",
"}"
] | // SetPersistedVoltage sets the voltage and programs the EEPROM so
// that the voltage is restored on reboot. | [
"SetPersistedVoltage",
"sets",
"the",
"voltage",
"and",
"programs",
"the",
"EEPROM",
"so",
"that",
"the",
"voltage",
"is",
"restored",
"on",
"reboot",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/mcp4725/mcp4725.go#L88-L90 |
14,174 | kidoman/embd | controller/mcp4725/mcp4725.go | Close | func (d *MCP4725) Close() error {
glog.V(1).Infof("mcp4725: powering down")
if err := d.Bus.WriteWordToReg(d.Addr, powerDown, 0); err != nil {
return err
}
return nil
} | go | func (d *MCP4725) Close() error {
glog.V(1).Infof("mcp4725: powering down")
if err := d.Bus.WriteWordToReg(d.Addr, powerDown, 0); err != nil {
return err
}
return nil
} | [
"func",
"(",
"d",
"*",
"MCP4725",
")",
"Close",
"(",
")",
"error",
"{",
"glog",
".",
"V",
"(",
"1",
")",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"err",
":=",
"d",
".",
"Bus",
".",
"WriteWordToReg",
"(",
"d",
".",
"Addr",
",",
"power... | // Close puts the DAC into power down mode. | [
"Close",
"puts",
"the",
"DAC",
"into",
"power",
"down",
"mode",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/mcp4725/mcp4725.go#L93-L100 |
14,175 | kidoman/embd | spi.go | InitSPI | func InitSPI() error {
if spiDriverInitialized {
return nil
}
desc, err := DescribeHost()
if err != nil {
return err
}
if desc.SPIDriver == nil {
return ErrFeatureNotSupported
}
spiDriverInstance = desc.SPIDriver()
spiDriverInitialized = true
return nil
} | go | func InitSPI() error {
if spiDriverInitialized {
return nil
}
desc, err := DescribeHost()
if err != nil {
return err
}
if desc.SPIDriver == nil {
return ErrFeatureNotSupported
}
spiDriverInstance = desc.SPIDriver()
spiDriverInitialized = true
return nil
} | [
"func",
"InitSPI",
"(",
")",
"error",
"{",
"if",
"spiDriverInitialized",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"desc",
",",
"err",
":=",
"DescribeHost",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"desc... | // InitSPI initializes the SPI driver. | [
"InitSPI",
"initializes",
"the",
"SPI",
"driver",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/spi.go#L60-L78 |
14,176 | kidoman/embd | spi.go | NewSPIBus | func NewSPIBus(mode, channel byte, speed, bpw, delay int) SPIBus {
if err := InitSPI(); err != nil {
panic(err)
}
return spiDriverInstance.Bus(mode, channel, speed, bpw, delay)
} | go | func NewSPIBus(mode, channel byte, speed, bpw, delay int) SPIBus {
if err := InitSPI(); err != nil {
panic(err)
}
return spiDriverInstance.Bus(mode, channel, speed, bpw, delay)
} | [
"func",
"NewSPIBus",
"(",
"mode",
",",
"channel",
"byte",
",",
"speed",
",",
"bpw",
",",
"delay",
"int",
")",
"SPIBus",
"{",
"if",
"err",
":=",
"InitSPI",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"retur... | // NewSPIBus returns a SPIBus. | [
"NewSPIBus",
"returns",
"a",
"SPIBus",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/spi.go#L86-L92 |
14,177 | kidoman/embd | sensor/bmp180/bmp180.go | New | func New(bus embd.I2CBus) *BMP180 {
return &BMP180{Bus: bus, Poll: pollDelay}
} | go | func New(bus embd.I2CBus) *BMP180 {
return &BMP180{Bus: bus, Poll: pollDelay}
} | [
"func",
"New",
"(",
"bus",
"embd",
".",
"I2CBus",
")",
"*",
"BMP180",
"{",
"return",
"&",
"BMP180",
"{",
"Bus",
":",
"bus",
",",
"Poll",
":",
"pollDelay",
"}",
"\n",
"}"
] | // New returns a handle to a BMP180 sensor. | [
"New",
"returns",
"a",
"handle",
"to",
"a",
"BMP180",
"sensor",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/bmp180/bmp180.go#L62-L64 |
14,178 | kidoman/embd | host/bbb/bbb.go | ensureFeatureDisabled | func ensureFeatureDisabled(id string) error {
pattern := "/sys/devices/bone_capemgr.*/slots"
file, err := embd.FindFirstMatchingFile(pattern)
if err != nil {
return err
}
slots, err := os.OpenFile(file, os.O_RDWR, os.ModeExclusive)
if err != nil {
return err
}
defer slots.Close()
scanner := bufio.NewScanner(slots)
for scanner.Scan() {
text := scanner.Text()
if !strings.Contains(text, id) {
continue
}
// Extract the id from the line
idx := strings.Index(text, ":")
if idx < 0 {
// Something is off, bail
continue
}
dis := strings.TrimSpace(text[:idx])
slots.Seek(0, 0)
_, err = slots.WriteString("-" + dis)
return err
}
// Could not disable the feature
return fmt.Errorf("embd: could not disable feature %q", id)
} | go | func ensureFeatureDisabled(id string) error {
pattern := "/sys/devices/bone_capemgr.*/slots"
file, err := embd.FindFirstMatchingFile(pattern)
if err != nil {
return err
}
slots, err := os.OpenFile(file, os.O_RDWR, os.ModeExclusive)
if err != nil {
return err
}
defer slots.Close()
scanner := bufio.NewScanner(slots)
for scanner.Scan() {
text := scanner.Text()
if !strings.Contains(text, id) {
continue
}
// Extract the id from the line
idx := strings.Index(text, ":")
if idx < 0 {
// Something is off, bail
continue
}
dis := strings.TrimSpace(text[:idx])
slots.Seek(0, 0)
_, err = slots.WriteString("-" + dis)
return err
}
// Could not disable the feature
return fmt.Errorf("embd: could not disable feature %q", id)
} | [
"func",
"ensureFeatureDisabled",
"(",
"id",
"string",
")",
"error",
"{",
"pattern",
":=",
"\"",
"\"",
"\n",
"file",
",",
"err",
":=",
"embd",
".",
"FindFirstMatchingFile",
"(",
"pattern",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
... | // This cannot be currently used to disable things like the
// analog and pwm modules. Removing them from slots file can
// potentially cause a kernel panic and unsettle things. So the
// recommended thing to do is to simply reboot. | [
"This",
"cannot",
"be",
"currently",
"used",
"to",
"disable",
"things",
"like",
"the",
"analog",
"and",
"pwm",
"modules",
".",
"Removing",
"them",
"from",
"slots",
"file",
"can",
"potentially",
"cause",
"a",
"kernel",
"panic",
"and",
"unsettle",
"things",
".... | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/host/bbb/bbb.go#L130-L160 |
14,179 | kidoman/embd | controller/pca9685/pca9685.go | New | func New(bus embd.I2CBus, addr byte) *PCA9685 {
return &PCA9685{
Bus: bus,
Addr: addr,
}
} | go | func New(bus embd.I2CBus, addr byte) *PCA9685 {
return &PCA9685{
Bus: bus,
Addr: addr,
}
} | [
"func",
"New",
"(",
"bus",
"embd",
".",
"I2CBus",
",",
"addr",
"byte",
")",
"*",
"PCA9685",
"{",
"return",
"&",
"PCA9685",
"{",
"Bus",
":",
"bus",
",",
"Addr",
":",
"addr",
",",
"}",
"\n",
"}"
] | // New creates a new PCA9685 interface. | [
"New",
"creates",
"a",
"new",
"PCA9685",
"interface",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/pca9685/pca9685.go#L38-L43 |
14,180 | kidoman/embd | controller/pca9685/pca9685.go | setMicroseconds | func (d *PCA9685) setMicroseconds(channel, us int) error {
offTime := us * d.Freq * pwmControlPoints / 1000000
return d.SetPwm(channel, 0, offTime)
} | go | func (d *PCA9685) setMicroseconds(channel, us int) error {
offTime := us * d.Freq * pwmControlPoints / 1000000
return d.SetPwm(channel, 0, offTime)
} | [
"func",
"(",
"d",
"*",
"PCA9685",
")",
"setMicroseconds",
"(",
"channel",
",",
"us",
"int",
")",
"error",
"{",
"offTime",
":=",
"us",
"*",
"d",
".",
"Freq",
"*",
"pwmControlPoints",
"/",
"1000000",
"\n",
"return",
"d",
".",
"SetPwm",
"(",
"channel",
... | // SetMicroseconds is a convinience method which allows easy servo control. | [
"SetMicroseconds",
"is",
"a",
"convinience",
"method",
"which",
"allows",
"easy",
"servo",
"control",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/pca9685/pca9685.go#L167-L170 |
14,181 | kidoman/embd | controller/pca9685/pca9685.go | Close | func (d *PCA9685) Close() error {
if err := d.setup(); err != nil {
return err
}
if err := d.sleep(); err != nil {
return err
}
glog.V(1).Infof("pca9685: reset request received")
if err := d.Bus.WriteByteToReg(d.Addr, mode1RegAddr, 0x00); err != nil {
return err
}
glog.V(1).Infof("pca9685: cleaning up all PWM control registers")
for regAddr := 0x06; regAddr <= 0x45; regAddr++ {
if err := d.Bus.WriteByteToReg(d.Addr, byte(regAddr), 0x00); err != nil {
return err
}
}
if glog.V(1) {
glog.Infof("pca9685: done Cleaning up all PWM control registers")
glog.Infof("pca9685: controller reset")
}
return nil
} | go | func (d *PCA9685) Close() error {
if err := d.setup(); err != nil {
return err
}
if err := d.sleep(); err != nil {
return err
}
glog.V(1).Infof("pca9685: reset request received")
if err := d.Bus.WriteByteToReg(d.Addr, mode1RegAddr, 0x00); err != nil {
return err
}
glog.V(1).Infof("pca9685: cleaning up all PWM control registers")
for regAddr := 0x06; regAddr <= 0x45; regAddr++ {
if err := d.Bus.WriteByteToReg(d.Addr, byte(regAddr), 0x00); err != nil {
return err
}
}
if glog.V(1) {
glog.Infof("pca9685: done Cleaning up all PWM control registers")
glog.Infof("pca9685: controller reset")
}
return nil
} | [
"func",
"(",
"d",
"*",
"PCA9685",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"d",
".",
"setup",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"d",
".",
"sleep",
"(",
")",
";",
"... | // Close stops the controller and resets mode and pwm controller registers. | [
"Close",
"stops",
"the",
"controller",
"and",
"resets",
"mode",
"and",
"pwm",
"controller",
"registers",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/pca9685/pca9685.go#L173-L202 |
14,182 | kidoman/embd | controller/pca9685/pca9685.go | Sleep | func (d *PCA9685) Sleep() error {
if err := d.setup(); err != nil {
return err
}
return d.sleep()
} | go | func (d *PCA9685) Sleep() error {
if err := d.setup(); err != nil {
return err
}
return d.sleep()
} | [
"func",
"(",
"d",
"*",
"PCA9685",
")",
"Sleep",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"d",
".",
"setup",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"d",
".",
"sleep",
"(",
")",
"\n",
"}"
] | // Sleep puts the controller in sleep mode. Does not change the pwm control registers. | [
"Sleep",
"puts",
"the",
"controller",
"in",
"sleep",
"mode",
".",
"Does",
"not",
"change",
"the",
"pwm",
"control",
"registers",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/pca9685/pca9685.go#L224-L230 |
14,183 | kidoman/embd | controller/pca9685/pca9685.go | Wake | func (d *PCA9685) Wake() error {
if err := d.setup(); err != nil {
return err
}
return d.wake()
} | go | func (d *PCA9685) Wake() error {
if err := d.setup(); err != nil {
return err
}
return d.wake()
} | [
"func",
"(",
"d",
"*",
"PCA9685",
")",
"Wake",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"d",
".",
"setup",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"d",
".",
"wake",
"(",
")",
"\n",
"}"
] | // Wake allows the controller to exit sleep mode and resume with PWM generation. | [
"Wake",
"allows",
"the",
"controller",
"to",
"exit",
"sleep",
"mode",
"and",
"resume",
"with",
"PWM",
"generation",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/controller/pca9685/pca9685.go#L259-L265 |
14,184 | kidoman/embd | interface/display/characterdisplay/characterdisplay.go | New | func New(controller Controller, cols, rows int) *Display {
return &Display{
Controller: controller,
cols: cols,
rows: rows,
p: &position{0, 0},
}
} | go | func New(controller Controller, cols, rows int) *Display {
return &Display{
Controller: controller,
cols: cols,
rows: rows,
p: &position{0, 0},
}
} | [
"func",
"New",
"(",
"controller",
"Controller",
",",
"cols",
",",
"rows",
"int",
")",
"*",
"Display",
"{",
"return",
"&",
"Display",
"{",
"Controller",
":",
"controller",
",",
"cols",
":",
"cols",
",",
"rows",
":",
"rows",
",",
"p",
":",
"&",
"positi... | // New creates a new Display | [
"New",
"creates",
"a",
"new",
"Display"
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/interface/display/characterdisplay/characterdisplay.go#L41-L48 |
14,185 | kidoman/embd | interface/display/characterdisplay/characterdisplay.go | Message | func (disp *Display) Message(message string) error {
bytes := []byte(message)
for _, b := range bytes {
if b == byte('\n') {
err := disp.Newline()
if err != nil {
return err
}
continue
}
err := disp.WriteChar(b)
if err != nil {
return err
}
disp.p.col++
if disp.p.col >= disp.cols || disp.p.col < 0 {
err := disp.Newline()
if err != nil {
return err
}
}
}
return nil
} | go | func (disp *Display) Message(message string) error {
bytes := []byte(message)
for _, b := range bytes {
if b == byte('\n') {
err := disp.Newline()
if err != nil {
return err
}
continue
}
err := disp.WriteChar(b)
if err != nil {
return err
}
disp.p.col++
if disp.p.col >= disp.cols || disp.p.col < 0 {
err := disp.Newline()
if err != nil {
return err
}
}
}
return nil
} | [
"func",
"(",
"disp",
"*",
"Display",
")",
"Message",
"(",
"message",
"string",
")",
"error",
"{",
"bytes",
":=",
"[",
"]",
"byte",
"(",
"message",
")",
"\n",
"for",
"_",
",",
"b",
":=",
"range",
"bytes",
"{",
"if",
"b",
"==",
"byte",
"(",
"'\\n'"... | // Message prints the given string on the display, including interpreting newline
// characters and wrapping at the end of lines. | [
"Message",
"prints",
"the",
"given",
"string",
"on",
"the",
"display",
"including",
"interpreting",
"newline",
"characters",
"and",
"wrapping",
"at",
"the",
"end",
"of",
"lines",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/interface/display/characterdisplay/characterdisplay.go#L64-L87 |
14,186 | kidoman/embd | sensor/tmp006/tmp006.go | Close | func (d *TMP006) Close() error {
if err := d.setup(); err != nil {
return err
}
if d.closing != nil {
waitc := make(chan struct{})
d.closing <- waitc
<-waitc
}
glog.V(1).Infof("tmp006: resetting")
if err := d.Bus.WriteWordToReg(d.Addr, configReg, reset); err != nil {
return err
}
return nil
} | go | func (d *TMP006) Close() error {
if err := d.setup(); err != nil {
return err
}
if d.closing != nil {
waitc := make(chan struct{})
d.closing <- waitc
<-waitc
}
glog.V(1).Infof("tmp006: resetting")
if err := d.Bus.WriteWordToReg(d.Addr, configReg, reset); err != nil {
return err
}
return nil
} | [
"func",
"(",
"d",
"*",
"TMP006",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"d",
".",
"setup",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"d",
".",
"closing",
"!=",
"nil",
"{",
"waitc",
":=",... | // Close puts the device into low power mode. | [
"Close",
"puts",
"the",
"device",
"into",
"low",
"power",
"mode",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/tmp006/tmp006.go#L90-L104 |
14,187 | kidoman/embd | sensor/tmp006/tmp006.go | Present | func (d *TMP006) Present() (bool, error) {
if err := d.validate(); err != nil {
return false, err
}
mid, err := d.Bus.ReadWordFromReg(d.Addr, manIdReg)
if err != nil {
return false, err
}
glog.V(1).Infof("tmp006: got manufacturer id %#04x", mid)
if mid != manId {
return false, fmt.Errorf("tmp006: not found at %#02x, manufacturer id mismatch", d.Addr)
}
did, err := d.Bus.ReadWordFromReg(d.Addr, devIdReg)
if err != nil {
return false, err
}
glog.V(1).Infof("tmp006: got device id %#04x", did)
if did != devId {
return false, fmt.Errorf("tmp006: not found at %#02x, device id mismatch", d.Addr)
}
return true, nil
} | go | func (d *TMP006) Present() (bool, error) {
if err := d.validate(); err != nil {
return false, err
}
mid, err := d.Bus.ReadWordFromReg(d.Addr, manIdReg)
if err != nil {
return false, err
}
glog.V(1).Infof("tmp006: got manufacturer id %#04x", mid)
if mid != manId {
return false, fmt.Errorf("tmp006: not found at %#02x, manufacturer id mismatch", d.Addr)
}
did, err := d.Bus.ReadWordFromReg(d.Addr, devIdReg)
if err != nil {
return false, err
}
glog.V(1).Infof("tmp006: got device id %#04x", did)
if did != devId {
return false, fmt.Errorf("tmp006: not found at %#02x, device id mismatch", d.Addr)
}
return true, nil
} | [
"func",
"(",
"d",
"*",
"TMP006",
")",
"Present",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"err",
":=",
"d",
".",
"validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"mid",
",",
"err"... | // Present checks if the device is present at the given address. | [
"Present",
"checks",
"if",
"the",
"device",
"is",
"present",
"at",
"the",
"given",
"address",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/tmp006/tmp006.go#L107-L129 |
14,188 | kidoman/embd | sensor/tmp006/tmp006.go | RawDieTemp | func (d *TMP006) RawDieTemp() (float64, error) {
select {
case temp := <-d.rawDieTemps:
return temp, nil
default:
return d.measureRawDieTemp()
}
} | go | func (d *TMP006) RawDieTemp() (float64, error) {
select {
case temp := <-d.rawDieTemps:
return temp, nil
default:
return d.measureRawDieTemp()
}
} | [
"func",
"(",
"d",
"*",
"TMP006",
")",
"RawDieTemp",
"(",
")",
"(",
"float64",
",",
"error",
")",
"{",
"select",
"{",
"case",
"temp",
":=",
"<-",
"d",
".",
"rawDieTemps",
":",
"return",
"temp",
",",
"nil",
"\n",
"default",
":",
"return",
"d",
".",
... | // RawDieTemp returns the current raw die temp reading. | [
"RawDieTemp",
"returns",
"the",
"current",
"raw",
"die",
"temp",
"reading",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/tmp006/tmp006.go#L225-L232 |
14,189 | kidoman/embd | sensor/tmp006/tmp006.go | ObjTemp | func (d *TMP006) ObjTemp() (float64, error) {
select {
case temp := <-d.objTemps:
return temp, nil
default:
return d.measureObjTemp()
}
} | go | func (d *TMP006) ObjTemp() (float64, error) {
select {
case temp := <-d.objTemps:
return temp, nil
default:
return d.measureObjTemp()
}
} | [
"func",
"(",
"d",
"*",
"TMP006",
")",
"ObjTemp",
"(",
")",
"(",
"float64",
",",
"error",
")",
"{",
"select",
"{",
"case",
"temp",
":=",
"<-",
"d",
".",
"objTemps",
":",
"return",
"temp",
",",
"nil",
"\n",
"default",
":",
"return",
"d",
".",
"meas... | // ObjTemp returns the current obj temp reading. | [
"ObjTemp",
"returns",
"the",
"current",
"obj",
"temp",
"reading",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/tmp006/tmp006.go#L240-L247 |
14,190 | kidoman/embd | led.go | InitLED | func InitLED() error {
if ledDriverInitialized {
return nil
}
desc, err := DescribeHost()
if err != nil {
return err
}
if desc.LEDDriver == nil {
return ErrFeatureNotSupported
}
ledDriverInstance = desc.LEDDriver()
ledDriverInitialized = true
return nil
} | go | func InitLED() error {
if ledDriverInitialized {
return nil
}
desc, err := DescribeHost()
if err != nil {
return err
}
if desc.LEDDriver == nil {
return ErrFeatureNotSupported
}
ledDriverInstance = desc.LEDDriver()
ledDriverInitialized = true
return nil
} | [
"func",
"InitLED",
"(",
")",
"error",
"{",
"if",
"ledDriverInitialized",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"desc",
",",
"err",
":=",
"DescribeHost",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"desc... | // InitLED initializes the LED driver. | [
"InitLED",
"initializes",
"the",
"LED",
"driver",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/led.go#L32-L50 |
14,191 | kidoman/embd | led.go | NewLED | func NewLED(key interface{}) (LED, error) {
if err := InitLED(); err != nil {
return nil, err
}
return ledDriverInstance.LED(key)
} | go | func NewLED(key interface{}) (LED, error) {
if err := InitLED(); err != nil {
return nil, err
}
return ledDriverInstance.LED(key)
} | [
"func",
"NewLED",
"(",
"key",
"interface",
"{",
"}",
")",
"(",
"LED",
",",
"error",
")",
"{",
"if",
"err",
":=",
"InitLED",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"ledDriverInstance",
".",
... | // NewLED returns a LED interface which allows control over the LED. | [
"NewLED",
"returns",
"a",
"LED",
"interface",
"which",
"allows",
"control",
"over",
"the",
"LED",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/led.go#L58-L64 |
14,192 | kidoman/embd | led.go | LEDOn | func LEDOn(key interface{}) error {
led, err := NewLED(key)
if err != nil {
return err
}
return led.On()
} | go | func LEDOn(key interface{}) error {
led, err := NewLED(key)
if err != nil {
return err
}
return led.On()
} | [
"func",
"LEDOn",
"(",
"key",
"interface",
"{",
"}",
")",
"error",
"{",
"led",
",",
"err",
":=",
"NewLED",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"led",
".",
"On",
"(",
")",
"\n",
"}"
... | // LEDOn switches the LED on. | [
"LEDOn",
"switches",
"the",
"LED",
"on",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/led.go#L67-L74 |
14,193 | kidoman/embd | led.go | LEDOff | func LEDOff(key interface{}) error {
led, err := NewLED(key)
if err != nil {
return err
}
return led.Off()
} | go | func LEDOff(key interface{}) error {
led, err := NewLED(key)
if err != nil {
return err
}
return led.Off()
} | [
"func",
"LEDOff",
"(",
"key",
"interface",
"{",
"}",
")",
"error",
"{",
"led",
",",
"err",
":=",
"NewLED",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"led",
".",
"Off",
"(",
")",
"\n",
"}... | // LEDOff switches the LED off. | [
"LEDOff",
"switches",
"the",
"LED",
"off",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/led.go#L77-L84 |
14,194 | kidoman/embd | led.go | LEDToggle | func LEDToggle(key interface{}) error {
led, err := NewLED(key)
if err != nil {
return err
}
return led.Toggle()
} | go | func LEDToggle(key interface{}) error {
led, err := NewLED(key)
if err != nil {
return err
}
return led.Toggle()
} | [
"func",
"LEDToggle",
"(",
"key",
"interface",
"{",
"}",
")",
"error",
"{",
"led",
",",
"err",
":=",
"NewLED",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"led",
".",
"Toggle",
"(",
")",
"\n"... | // LEDToggle toggles the LED. | [
"LEDToggle",
"toggles",
"the",
"LED",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/led.go#L87-L94 |
14,195 | kidoman/embd | sensor/bh1750fvi/bh1750fvi.go | New | func New(mode string, bus embd.I2CBus) *BH1750FVI {
switch mode {
case High:
return &BH1750FVI{Bus: bus, i2cAddr: sensorI2cAddr, operationCode: highResOpCode, Poll: pollDelay}
case High2:
return &BH1750FVI{Bus: bus, i2cAddr: sensorI2cAddr, operationCode: highResMode2OpCode, Poll: pollDelay}
default:
return &BH1750FVI{Bus: bus, i2cAddr: sensorI2cAddr, operationCode: highResOpCode, Poll: pollDelay}
}
} | go | func New(mode string, bus embd.I2CBus) *BH1750FVI {
switch mode {
case High:
return &BH1750FVI{Bus: bus, i2cAddr: sensorI2cAddr, operationCode: highResOpCode, Poll: pollDelay}
case High2:
return &BH1750FVI{Bus: bus, i2cAddr: sensorI2cAddr, operationCode: highResMode2OpCode, Poll: pollDelay}
default:
return &BH1750FVI{Bus: bus, i2cAddr: sensorI2cAddr, operationCode: highResOpCode, Poll: pollDelay}
}
} | [
"func",
"New",
"(",
"mode",
"string",
",",
"bus",
"embd",
".",
"I2CBus",
")",
"*",
"BH1750FVI",
"{",
"switch",
"mode",
"{",
"case",
"High",
":",
"return",
"&",
"BH1750FVI",
"{",
"Bus",
":",
"bus",
",",
"i2cAddr",
":",
"sensorI2cAddr",
",",
"operationCo... | // New returns a BH1750FVI sensor at the specific resolution mode. | [
"New",
"returns",
"a",
"BH1750FVI",
"sensor",
"at",
"the",
"specific",
"resolution",
"mode",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/bh1750fvi/bh1750fvi.go#L42-L51 |
14,196 | kidoman/embd | sensor/bh1750fvi/bh1750fvi.go | Lighting | func (d *BH1750FVI) Lighting() (float64, error) {
select {
case lighting := <-d.lightingReadings:
return lighting, nil
default:
return d.measureLighting()
}
} | go | func (d *BH1750FVI) Lighting() (float64, error) {
select {
case lighting := <-d.lightingReadings:
return lighting, nil
default:
return d.measureLighting()
}
} | [
"func",
"(",
"d",
"*",
"BH1750FVI",
")",
"Lighting",
"(",
")",
"(",
"float64",
",",
"error",
")",
"{",
"select",
"{",
"case",
"lighting",
":=",
"<-",
"d",
".",
"lightingReadings",
":",
"return",
"lighting",
",",
"nil",
"\n",
"default",
":",
"return",
... | // Lighting returns the ambient lighting in lx. | [
"Lighting",
"returns",
"the",
"ambient",
"lighting",
"in",
"lx",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/bh1750fvi/bh1750fvi.go#L78-L85 |
14,197 | kidoman/embd | sensor/bh1750fvi/bh1750fvi.go | Run | func (d *BH1750FVI) Run() {
go func() {
d.quit = make(chan bool)
timer := time.Tick(time.Duration(d.Poll) * time.Millisecond)
var lighting float64
for {
select {
case d.lightingReadings <- lighting:
case <-timer:
l, err := d.measureLighting()
if err == nil {
lighting = l
}
if err == nil && d.lightingReadings == nil {
d.lightingReadings = make(chan float64)
}
case <-d.quit:
d.lightingReadings = nil
return
}
}
}()
return
} | go | func (d *BH1750FVI) Run() {
go func() {
d.quit = make(chan bool)
timer := time.Tick(time.Duration(d.Poll) * time.Millisecond)
var lighting float64
for {
select {
case d.lightingReadings <- lighting:
case <-timer:
l, err := d.measureLighting()
if err == nil {
lighting = l
}
if err == nil && d.lightingReadings == nil {
d.lightingReadings = make(chan float64)
}
case <-d.quit:
d.lightingReadings = nil
return
}
}
}()
return
} | [
"func",
"(",
"d",
"*",
"BH1750FVI",
")",
"Run",
"(",
")",
"{",
"go",
"func",
"(",
")",
"{",
"d",
".",
"quit",
"=",
"make",
"(",
"chan",
"bool",
")",
"\n\n",
"timer",
":=",
"time",
".",
"Tick",
"(",
"time",
".",
"Duration",
"(",
"d",
".",
"Pol... | // Run starts continuous sensor data acquisition loop. | [
"Run",
"starts",
"continuous",
"sensor",
"data",
"acquisition",
"loop",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/sensor/bh1750fvi/bh1750fvi.go#L88-L114 |
14,198 | kidoman/embd | convertors/mcp3008/mcp3008.go | New | func New(mode byte, bus embd.SPIBus) *MCP3008 {
return &MCP3008{mode, bus}
} | go | func New(mode byte, bus embd.SPIBus) *MCP3008 {
return &MCP3008{mode, bus}
} | [
"func",
"New",
"(",
"mode",
"byte",
",",
"bus",
"embd",
".",
"SPIBus",
")",
"*",
"MCP3008",
"{",
"return",
"&",
"MCP3008",
"{",
"mode",
",",
"bus",
"}",
"\n",
"}"
] | // New creates a representation of the mcp3008 convertor | [
"New",
"creates",
"a",
"representation",
"of",
"the",
"mcp3008",
"convertor"
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/convertors/mcp3008/mcp3008.go#L25-L27 |
14,199 | kidoman/embd | convertors/mcp3008/mcp3008.go | AnalogValueAt | func (m *MCP3008) AnalogValueAt(chanNum int) (int, error) {
var data [3]uint8
data[0] = startBit
data[1] = uint8(m.Mode)<<7 | uint8(chanNum)<<4
data[2] = 0
glog.V(2).Infof("mcp3008: sendingdata buffer %v", data)
if err := m.Bus.TransferAndReceiveData(data[:]); err != nil {
return 0, err
}
return int(uint16(data[1]&0x03)<<8 | uint16(data[2])), nil
} | go | func (m *MCP3008) AnalogValueAt(chanNum int) (int, error) {
var data [3]uint8
data[0] = startBit
data[1] = uint8(m.Mode)<<7 | uint8(chanNum)<<4
data[2] = 0
glog.V(2).Infof("mcp3008: sendingdata buffer %v", data)
if err := m.Bus.TransferAndReceiveData(data[:]); err != nil {
return 0, err
}
return int(uint16(data[1]&0x03)<<8 | uint16(data[2])), nil
} | [
"func",
"(",
"m",
"*",
"MCP3008",
")",
"AnalogValueAt",
"(",
"chanNum",
"int",
")",
"(",
"int",
",",
"error",
")",
"{",
"var",
"data",
"[",
"3",
"]",
"uint8",
"\n",
"data",
"[",
"0",
"]",
"=",
"startBit",
"\n",
"data",
"[",
"1",
"]",
"=",
"uint... | // AnalogValueAt returns the analog value at the given channel of the convertor. | [
"AnalogValueAt",
"returns",
"the",
"analog",
"value",
"at",
"the",
"given",
"channel",
"of",
"the",
"convertor",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/convertors/mcp3008/mcp3008.go#L34-L46 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.