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",
":=",
"&",
"clientcredentials",
".",
"Config",
"{",
"ClientID",
":",
"i",
",",
"ClientSecret",
":",
"s",
",",
"TokenURL",
":",
"bitbucket",
".",
"Endpoint",
".",
"TokenURL",
",",
"}",
"\n\n",
"tok",
",",
"err",
":=",
"conf",
".",
"Token",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"a",
".",
"token",
"=",
"*",
"tok",
"\n",
"return",
"injectClient",
"(",
"a",
")",
"\n\n",
"}"
] |
// 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",
"*",
"65535.0",
"+",
"0.5",
")",
"\n",
"b",
"=",
"uint32",
"(",
"col",
".",
"B",
"*",
"65535.0",
"+",
"0.5",
")",
"\n",
"a",
"=",
"0xFFFF",
"\n",
"return",
"\n",
"}"
] |
// 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",
",",
"0",
"}",
",",
"false",
"\n",
"}",
"\n\n",
"// 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",
"\n",
"r",
"/=",
"a",
"\n",
"g",
"*=",
"0xffff",
"\n",
"g",
"/=",
"a",
"\n",
"b",
"*=",
"0xffff",
"\n",
"b",
"/=",
"a",
"\n\n",
"return",
"Color",
"{",
"float64",
"(",
"r",
")",
"/",
"65535.0",
",",
"float64",
"(",
"g",
")",
"/",
"65535.0",
",",
"float64",
"(",
"b",
")",
"/",
"65535.0",
"}",
",",
"true",
"\n",
"}"
] |
// 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",
"+",
"0.5",
")",
"\n",
"b",
"=",
"uint8",
"(",
"col",
".",
"B",
"*",
"255.0",
"+",
"0.5",
")",
"\n",
"return",
"\n",
"}"
] |
// 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",
")",
"+",
"sq",
"(",
"c1",
".",
"B",
"-",
"c2",
".",
"B",
")",
")",
"\n",
"}"
] |
// 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.248750514614486",
"+",
"0.925583310193438",
"*",
"v",
"+",
"1.16740237321695",
"*",
"v2",
"+",
"0.280457026598666",
"*",
"v3",
"-",
"0.0757991963780179",
"*",
"v4",
"//+ 0.0437040411548932*v5",
"\n",
"}"
] |
// 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",
"*",
"x",
"+",
"1.8760108",
"*",
"y",
"+",
"0.0415560",
"*",
"z",
"\n",
"b",
"=",
"0.0556434",
"*",
"x",
"-",
"0.2040259",
"*",
"y",
"+",
"1.0572252",
"*",
"z",
"\n",
"return",
"\n",
"}"
] |
// 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",
".",
"Sqrt",
"(",
"sq",
"(",
"l1",
"-",
"l2",
")",
"+",
"sq",
"(",
"a1",
"-",
"a2",
")",
"+",
"sq",
"(",
"b1",
"-",
"b2",
")",
")",
"\n",
"}"
] |
// 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",
"a",
"lot",
"."
] |
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 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",
"\n",
"l2",
",",
"a2",
",",
"b2",
"=",
"l2",
"*",
"100.0",
",",
"a2",
"*",
"100.0",
",",
"b2",
"*",
"100.0",
"\n\n",
"kl",
":=",
"1.0",
"// 2.0 for textiles",
"\n",
"kc",
":=",
"1.0",
"\n",
"kh",
":=",
"1.0",
"\n",
"k1",
":=",
"0.045",
"// 0.048 for textiles",
"\n",
"k2",
":=",
"0.015",
"// 0.014 for textiles.",
"\n\n",
"deltaL",
":=",
"l1",
"-",
"l2",
"\n",
"c1",
":=",
"math",
".",
"Sqrt",
"(",
"sq",
"(",
"a1",
")",
"+",
"sq",
"(",
"b1",
")",
")",
"\n",
"c2",
":=",
"math",
".",
"Sqrt",
"(",
"sq",
"(",
"a2",
")",
"+",
"sq",
"(",
"b2",
")",
")",
"\n",
"deltaCab",
":=",
"c1",
"-",
"c2",
"\n\n",
"// Not taking Sqrt here for stability, and it's unnecessary.",
"deltaHab2",
":=",
"sq",
"(",
"a1",
"-",
"a2",
")",
"+",
"sq",
"(",
"b1",
"-",
"b2",
")",
"-",
"sq",
"(",
"deltaCab",
")",
"\n",
"sl",
":=",
"1.0",
"\n",
"sc",
":=",
"1.0",
"+",
"k1",
"*",
"c1",
"\n",
"sh",
":=",
"1.0",
"+",
"k2",
"*",
"c1",
"\n\n",
"vL2",
":=",
"sq",
"(",
"deltaL",
"/",
"(",
"kl",
"*",
"sl",
")",
")",
"\n",
"vC2",
":=",
"sq",
"(",
"deltaCab",
"/",
"(",
"kc",
"*",
"sc",
")",
")",
"\n",
"vH2",
":=",
"deltaHab2",
"/",
"sq",
"(",
"kh",
"*",
"sh",
")",
"\n\n",
"return",
"math",
".",
"Sqrt",
"(",
"vL2",
"+",
"vC2",
"+",
"vH2",
")",
"*",
"0.01",
"// See above.",
"\n",
"}"
] |
// 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",
",",
"0.0",
"\n",
"}",
"else",
"{",
"u",
"=",
"4.0",
"*",
"x",
"/",
"denom",
"\n",
"v",
"=",
"9.0",
"*",
"y",
"/",
"denom",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// 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",
".",
"Sqrt",
"(",
"sq",
"(",
"l1",
"-",
"l2",
")",
"+",
"sq",
"(",
"u1",
"-",
"u2",
")",
"+",
"sq",
"(",
"v1",
"-",
"v2",
")",
")",
"\n",
"}"
] |
// 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",
"a",
"lot",
"."
] |
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",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"c",
"\n",
"}"
] |
// 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",
"(",
"lab1",
".",
"B",
"-",
"lab2",
".",
"B",
")",
")",
"\n",
"}"
] |
// 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",
".",
"SetFormatter",
"(",
"formatter",
")",
"\n\n",
"switch",
"output",
".",
"(",
"type",
")",
"{",
"case",
"string",
":",
"hook",
".",
"SetDefaultPath",
"(",
"output",
".",
"(",
"string",
")",
")",
"\n",
"break",
"\n",
"case",
"io",
".",
"Writer",
":",
"hook",
".",
"SetDefaultWriter",
"(",
"output",
".",
"(",
"io",
".",
"Writer",
")",
")",
"\n",
"break",
"\n",
"case",
"PathMap",
":",
"hook",
".",
"paths",
"=",
"output",
".",
"(",
"PathMap",
")",
"\n",
"for",
"level",
":=",
"range",
"output",
".",
"(",
"PathMap",
")",
"{",
"hook",
".",
"levels",
"=",
"append",
"(",
"hook",
".",
"levels",
",",
"level",
")",
"\n",
"}",
"\n",
"break",
"\n",
"case",
"WriterMap",
":",
"hook",
".",
"writers",
"=",
"output",
".",
"(",
"WriterMap",
")",
"\n",
"for",
"level",
":=",
"range",
"output",
".",
"(",
"WriterMap",
")",
"{",
"hook",
".",
"levels",
"=",
"append",
"(",
"hook",
".",
"levels",
",",
"level",
")",
"\n",
"}",
"\n",
"break",
"\n",
"default",
":",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"output",
")",
")",
")",
"\n",
"}",
"\n\n",
"return",
"hook",
"\n",
"}"
] |
// 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",
"used",
"io",
".",
"Writer",
"."
] |
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",
"==",
"nil",
"{",
"formatter",
"=",
"defaultFormatter",
"\n",
"}",
"else",
"{",
"switch",
"formatter",
".",
"(",
"type",
")",
"{",
"case",
"*",
"logrus",
".",
"TextFormatter",
":",
"textFormatter",
":=",
"formatter",
".",
"(",
"*",
"logrus",
".",
"TextFormatter",
")",
"\n",
"textFormatter",
".",
"DisableColors",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"hook",
".",
"formatter",
"=",
"formatter",
"\n",
"}"
] |
// 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",
"=",
"defaultPath",
"\n",
"hook",
".",
"hasDefaultPath",
"=",
"true",
"\n",
"}"
] |
// 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",
".",
"defaultWriter",
"=",
"defaultWriter",
"\n",
"hook",
".",
"hasDefaultWriter",
"=",
"true",
"\n",
"}"
] |
// 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",
".",
"writers",
"!=",
"nil",
"||",
"hook",
".",
"hasDefaultWriter",
"{",
"return",
"hook",
".",
"ioWrite",
"(",
"entry",
")",
"\n",
"}",
"else",
"if",
"hook",
".",
"paths",
"!=",
"nil",
"||",
"hook",
".",
"hasDefaultPath",
"{",
"return",
"hook",
".",
"fileWrite",
"(",
"entry",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// 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",
"not",
"yet",
"exist",
"."
] |
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\n",
"if",
"writer",
",",
"ok",
"=",
"hook",
".",
"writers",
"[",
"entry",
".",
"Level",
"]",
";",
"!",
"ok",
"{",
"if",
"hook",
".",
"hasDefaultWriter",
"{",
"writer",
"=",
"hook",
".",
"defaultWriter",
"\n",
"}",
"else",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"// use our formatter instead of entry.String()",
"msg",
",",
"err",
"=",
"hook",
".",
"formatter",
".",
"Format",
"(",
"entry",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"writer",
".",
"Write",
"(",
"msg",
")",
"\n",
"return",
"err",
"\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",
"bool",
"\n",
")",
"\n\n",
"if",
"path",
",",
"ok",
"=",
"hook",
".",
"paths",
"[",
"entry",
".",
"Level",
"]",
";",
"!",
"ok",
"{",
"if",
"hook",
".",
"hasDefaultPath",
"{",
"path",
"=",
"hook",
".",
"defaultPath",
"\n",
"}",
"else",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"dir",
":=",
"filepath",
".",
"Dir",
"(",
"path",
")",
"\n",
"os",
".",
"MkdirAll",
"(",
"dir",
",",
"os",
".",
"ModePerm",
")",
"\n\n",
"fd",
",",
"err",
"=",
"os",
".",
"OpenFile",
"(",
"path",
",",
"os",
".",
"O_WRONLY",
"|",
"os",
".",
"O_APPEND",
"|",
"os",
".",
"O_CREATE",
",",
"0666",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
",",
"path",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"fd",
".",
"Close",
"(",
")",
"\n\n",
"// use our formatter instead of entry.String()",
"msg",
",",
"err",
"=",
"hook",
".",
"formatter",
".",
"Format",
"(",
"entry",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"fd",
".",
"Write",
"(",
"msg",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// 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",
".",
"Maxus",
")",
")",
"\n\n",
"glog",
".",
"V",
"(",
"1",
")",
".",
"Infof",
"(",
"\"",
"\"",
",",
"angle",
",",
"us",
")",
"\n\n",
"return",
"s",
".",
"PWM",
".",
"SetMicroseconds",
"(",
"int",
"(",
"us",
")",
")",
"\n",
"}"
] |
// 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",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"channel",
",",
"us",
")",
"\n",
"glog",
".",
"V",
"(",
"1",
")",
".",
"Infof",
"(",
"\"",
"\"",
",",
"cmd",
")",
"\n",
"_",
",",
"err",
":=",
"d",
".",
"fd",
".",
"WriteString",
"(",
"cmd",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// 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",
")",
",",
"colPins",
":",
"make",
"(",
"[",
"]",
"embd",
".",
"DigitalPin",
",",
"cols",
")",
",",
"poll",
":",
"pollDelay",
",",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"rows",
";",
"i",
"++",
"{",
"m",
".",
"rowPins",
"[",
"i",
"]",
",",
"err",
"=",
"embd",
".",
"NewDigitalPin",
"(",
"rowPins",
"[",
"i",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"cols",
";",
"i",
"++",
"{",
"m",
".",
"colPins",
"[",
"i",
"]",
",",
"err",
"=",
"embd",
".",
"NewDigitalPin",
"(",
"colPins",
"[",
"i",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] |
// 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",
".",
"findPressedKey",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// 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",
".",
"poll",
")",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"var",
"key",
"Key",
"\n\n",
"for",
"{",
"var",
"keyUpdates",
"chan",
"Key",
"\n\n",
"select",
"{",
"case",
"<-",
"timer",
":",
"var",
"err",
"error",
"\n",
"if",
"key",
",",
"err",
"=",
"d",
".",
"findPressedKey",
"(",
")",
";",
"err",
"==",
"nil",
"{",
"keyUpdates",
"=",
"d",
".",
"keyPressed",
"\n",
"}",
"\n",
"case",
"keyUpdates",
"<-",
"key",
":",
"keyUpdates",
"=",
"nil",
"\n",
"case",
"<-",
"d",
".",
"quit",
":",
"d",
".",
"keyPressed",
"=",
"nil",
"\n\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}"
] |
// 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",
",",
"apf",
":",
"apf",
",",
"ppf",
":",
"ppf",
",",
"initializedPins",
":",
"map",
"[",
"string",
"]",
"pin",
"{",
"}",
",",
"}",
"\n",
"}"
] |
// 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",
".",
"I2CDriver",
"==",
"nil",
"{",
"return",
"ErrFeatureNotSupported",
"\n",
"}",
"\n\n",
"i2cDriverInstance",
"=",
"desc",
".",
"I2CDriver",
"(",
")",
"\n",
"i2cDriverInitialized",
"=",
"true",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// 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",
":",
"i",
",",
"}",
"\n",
"}"
] |
// 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",
".",
"Unlock",
"(",
")",
"\n\n",
"b",
":=",
"s",
".",
"sbf",
"(",
"s",
".",
"spiDevMinor",
",",
"mode",
",",
"channel",
",",
"speed",
",",
"bpw",
",",
"delay",
",",
"s",
".",
"initializer",
")",
"\n",
"s",
".",
"busMap",
"=",
"make",
"(",
"map",
"[",
"byte",
"]",
"SPIBus",
")",
"\n",
"s",
".",
"busMap",
"[",
"channel",
"]",
"=",
"b",
"\n",
"return",
"b",
"\n",
"}"
] |
// 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",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"describers",
"[",
"host",
"]",
"=",
"describer",
"\n\n",
"glog",
".",
"V",
"(",
"1",
")",
".",
"Infof",
"(",
"\"",
"\"",
",",
"host",
")",
"\n",
"}"
] |
// 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",
"{",
"var",
"err",
"error",
"\n",
"host",
",",
"rev",
",",
"err",
"=",
"DetectHost",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"describer",
",",
"ok",
":=",
"describers",
"[",
"host",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"host",
")",
"\n",
"}",
"\n\n",
"return",
"describer",
"(",
"rev",
")",
",",
"nil",
"\n",
"}"
] |
// 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",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"d",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"d",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"err",
":=",
"d",
".",
"Bus",
".",
"WriteByteToReg",
"(",
"magAddress",
",",
"magConfigRegA",
",",
"MagCRADefault",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"d",
".",
"Bus",
".",
"WriteByteToReg",
"(",
"magAddress",
",",
"magModeReg",
",",
"MagMRDefault",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"d",
".",
"initialized",
"=",
"true",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// 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",
"(",
"2",
")",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"return",
"d",
".",
"measureHeading",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// 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",
"(",
"magAddress",
",",
"magModeReg",
",",
"MagSleep",
")",
"\n",
"}"
] |
// 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",
"(",
"1",
")",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n\n",
"value",
",",
"err",
":=",
"d",
".",
"Pin",
".",
"Read",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"if",
"value",
"==",
"embd",
".",
"High",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"else",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"}"
] |
// 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",
"{",
"case",
"p",
":=",
"<-",
"d",
".",
"pressures",
":",
"return",
"int",
"(",
"p",
")",
",",
"nil",
"\n",
"default",
":",
"glog",
".",
"V",
"(",
"1",
")",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"p",
",",
"_",
",",
"err",
":=",
"d",
".",
"measurePressureAndAltitude",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"int",
"(",
"p",
")",
",",
"nil",
"\n",
"}",
"\n",
"}"
] |
// 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",
"{",
"case",
"altitude",
":=",
"<-",
"d",
".",
"altitudes",
":",
"return",
"altitude",
",",
"nil",
"\n",
"default",
":",
"glog",
".",
"V",
"(",
"1",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"altitude",
",",
"err",
":=",
"d",
".",
"measurePressureAndAltitude",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"altitude",
",",
"nil",
"\n",
"}",
"\n",
"}"
] |
// 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",
",",
")",
"(",
"*",
"HD44780",
",",
"error",
")",
"{",
"pinKeys",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"rs",
",",
"en",
",",
"d4",
",",
"d5",
",",
"d6",
",",
"d7",
",",
"backlight",
"}",
"\n",
"pins",
":=",
"[",
"7",
"]",
"embd",
".",
"DigitalPin",
"{",
"}",
"\n",
"for",
"idx",
",",
"key",
":=",
"range",
"pinKeys",
"{",
"if",
"key",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"var",
"digitalPin",
"embd",
".",
"DigitalPin",
"\n",
"if",
"pin",
",",
"ok",
":=",
"key",
".",
"(",
"embd",
".",
"DigitalPin",
")",
";",
"ok",
"{",
"digitalPin",
"=",
"pin",
"\n",
"}",
"else",
"{",
"var",
"err",
"error",
"\n",
"digitalPin",
",",
"err",
"=",
"embd",
".",
"NewDigitalPin",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"glog",
".",
"V",
"(",
"1",
")",
".",
"Infof",
"(",
"\"",
"\"",
",",
"key",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"pins",
"[",
"idx",
"]",
"=",
"digitalPin",
"\n",
"}",
"\n",
"for",
"_",
",",
"pin",
":=",
"range",
"pins",
"{",
"if",
"pin",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"err",
":=",
"pin",
".",
"SetDirection",
"(",
"embd",
".",
"Out",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"pin",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"New",
"(",
"NewGPIOConnection",
"(",
"pins",
"[",
"0",
"]",
",",
"pins",
"[",
"1",
"]",
",",
"pins",
"[",
"2",
"]",
",",
"pins",
"[",
"3",
"]",
",",
"pins",
"[",
"4",
"]",
",",
"pins",
"[",
"5",
"]",
",",
"pins",
"[",
"6",
"]",
",",
"blPolarity",
")",
",",
"rowAddr",
",",
"modes",
"...",
",",
")",
"\n",
"}"
] |
// 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",
",",
"dMode",
":",
"0x00",
",",
"fMode",
":",
"0x00",
",",
"rowAddr",
":",
"rowAddr",
",",
"}",
"\n",
"err",
":=",
"controller",
".",
"lcdInit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"err",
"=",
"controller",
".",
"SetMode",
"(",
"append",
"(",
"DefaultModes",
",",
"modes",
"...",
")",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"controller",
",",
"nil",
"\n",
"}"
] |
// 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",
"(",
")",
"error",
"{",
"func",
"(",
")",
"error",
"{",
"return",
"hd",
".",
"setEntryMode",
"(",
")",
"}",
",",
"func",
"(",
")",
"error",
"{",
"return",
"hd",
".",
"setDisplayMode",
"(",
")",
"}",
",",
"func",
"(",
")",
"error",
"{",
"return",
"hd",
".",
"setFunctionMode",
"(",
")",
"}",
",",
"}",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"functions",
"{",
"err",
":=",
"f",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// 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",
"(",
"clearDelay",
")",
"\n",
"// have to set mode here because clear also clears some mode settings",
"return",
"hd",
".",
"SetMode",
"(",
")",
"\n",
"}"
] |
// 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",
"{",
"RS",
":",
"rs",
",",
"EN",
":",
"en",
",",
"D4",
":",
"d4",
",",
"D5",
":",
"d5",
",",
"D6",
":",
"d6",
",",
"D7",
":",
"d7",
",",
"Backlight",
":",
"backlight",
",",
"BLPolarity",
":",
"blPolarity",
",",
"}",
"\n",
"}"
] |
// 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",
".",
"Low",
"\n",
"if",
"rs",
"{",
"rsInt",
"=",
"embd",
".",
"High",
"\n",
"}",
"\n",
"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",
"(",
")",
"}",
",",
"}",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"functions",
"{",
"err",
":=",
"f",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"time",
".",
"Sleep",
"(",
"writeDelay",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// 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",
".",
"EN",
",",
"conn",
".",
"D4",
",",
"conn",
".",
"D5",
",",
"conn",
".",
"D6",
",",
"conn",
".",
"D7",
",",
"conn",
".",
"Backlight",
",",
"}",
"\n\n",
"for",
"_",
",",
"pin",
":=",
"range",
"pins",
"{",
"err",
":=",
"pin",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"pin",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// 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",
":",
"thermometer",
"}",
"\n",
"}"
] |
// 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",
"(",
"2",
")",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n\n",
"// Generate a TRIGGER pulse",
"d",
".",
"TriggerPin",
".",
"Write",
"(",
"embd",
".",
"High",
")",
"\n",
"time",
".",
"Sleep",
"(",
"pulseDelay",
")",
"\n",
"d",
".",
"TriggerPin",
".",
"Write",
"(",
"embd",
".",
"Low",
")",
"\n\n",
"glog",
".",
"V",
"(",
"2",
")",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n\n",
"duration",
",",
"err",
":=",
"d",
".",
"EchoPin",
".",
"TimePulse",
"(",
"embd",
".",
"High",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"// Calculate the distance based on the time computed",
"distance",
":=",
"float64",
"(",
"duration",
".",
"Nanoseconds",
"(",
")",
")",
"/",
"10000000",
"*",
"(",
"d",
".",
"speedSound",
"/",
"2",
")",
"\n\n",
"return",
"distance",
",",
"nil",
"\n",
"}"
] |
// 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",
"desc",
".",
"GPIODriver",
"==",
"nil",
"{",
"return",
"ErrFeatureNotSupported",
"\n",
"}",
"\n\n",
"gpioDriverInstance",
"=",
"desc",
".",
"GPIODriver",
"(",
")",
"\n",
"gpioDriverInitialized",
"=",
"true",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// 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",
"gpioDriverInstance",
".",
"DigitalPin",
"(",
"key",
")",
"\n",
"}"
] |
// 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",
".",
"Write",
"(",
"val",
")",
"\n",
"}"
] |
// 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",
"return",
"pin",
".",
"Read",
"(",
")",
"\n",
"}"
] |
// 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",
"(",
"b",
")",
"\n",
"}"
] |
// 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",
"(",
")",
"\n",
"}"
] |
// 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",
"(",
")",
"\n",
"}"
] |
// 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",
"gpioDriverInstance",
".",
"AnalogPin",
"(",
"key",
")",
"\n",
"}"
] |
// 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",
"pin",
".",
"Read",
"(",
")",
"\n",
"}"
] |
// 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",
".",
"PWMPin",
"(",
"key",
")",
"\n",
"}"
] |
// 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",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"major",
"<",
"3",
"||",
"(",
"major",
"==",
"3",
"&&",
"minor",
"<",
"8",
")",
"{",
"return",
"HostNull",
",",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"major",
",",
"minor",
",",
"patch",
")",
"\n",
"}",
"\n\n",
"model",
",",
"hardware",
",",
"rev",
",",
"err",
":=",
"cpuInfo",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"HostNull",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"switch",
"{",
"case",
"strings",
".",
"Contains",
"(",
"model",
",",
"\"",
"\"",
")",
"&&",
"(",
"strings",
".",
"Contains",
"(",
"hardware",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"Contains",
"(",
"hardware",
",",
"\"",
"\"",
")",
")",
":",
"return",
"HostBBB",
",",
"rev",
",",
"nil",
"\n",
"case",
"strings",
".",
"Contains",
"(",
"hardware",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"Contains",
"(",
"hardware",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"Contains",
"(",
"hardware",
",",
"\"",
"\"",
")",
":",
"return",
"HostRPi",
",",
"rev",
",",
"nil",
"\n",
"case",
"hardware",
"==",
"\"",
"\"",
":",
"if",
"major",
"<",
"4",
"||",
"(",
"major",
"==",
"4",
"&&",
"minor",
"<",
"4",
")",
"{",
"return",
"HostNull",
",",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"major",
",",
"minor",
")",
"\n",
"}",
"\n",
"return",
"HostCHIP",
",",
"rev",
",",
"nil",
"\n",
"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",
")",
"\n",
"}",
"\n",
"}"
] |
// 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\n",
"return",
"d",
".",
"orientations",
",",
"nil",
"\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",
"d",
".",
"closing",
"=",
"nil",
"\n",
"}",
"\n",
"if",
"err",
":=",
"d",
".",
"Bus",
".",
"WriteByteToReg",
"(",
"address",
",",
"ctrlReg1",
",",
"ctrlReg1Finished",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"d",
".",
"initialized",
"=",
"false",
"\n",
"return",
"nil",
"\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",
",",
"powerDown",
",",
"0",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// 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",
".",
"SPIDriver",
"==",
"nil",
"{",
"return",
"ErrFeatureNotSupported",
"\n",
"}",
"\n\n",
"spiDriverInstance",
"=",
"desc",
".",
"SPIDriver",
"(",
")",
"\n",
"spiDriverInitialized",
"=",
"true",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// 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",
"return",
"spiDriverInstance",
".",
"Bus",
"(",
"mode",
",",
"channel",
",",
"speed",
",",
"bpw",
",",
"delay",
")",
"\n",
"}"
] |
// 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",
"}",
"\n",
"slots",
",",
"err",
":=",
"os",
".",
"OpenFile",
"(",
"file",
",",
"os",
".",
"O_RDWR",
",",
"os",
".",
"ModeExclusive",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"slots",
".",
"Close",
"(",
")",
"\n",
"scanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"slots",
")",
"\n",
"for",
"scanner",
".",
"Scan",
"(",
")",
"{",
"text",
":=",
"scanner",
".",
"Text",
"(",
")",
"\n",
"if",
"!",
"strings",
".",
"Contains",
"(",
"text",
",",
"id",
")",
"{",
"continue",
"\n",
"}",
"\n",
"// Extract the id from the line",
"idx",
":=",
"strings",
".",
"Index",
"(",
"text",
",",
"\"",
"\"",
")",
"\n",
"if",
"idx",
"<",
"0",
"{",
"// Something is off, bail",
"continue",
"\n",
"}",
"\n",
"dis",
":=",
"strings",
".",
"TrimSpace",
"(",
"text",
"[",
":",
"idx",
"]",
")",
"\n",
"slots",
".",
"Seek",
"(",
"0",
",",
"0",
")",
"\n",
"_",
",",
"err",
"=",
"slots",
".",
"WriteString",
"(",
"\"",
"\"",
"+",
"dis",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"// Could not disable the feature",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"id",
")",
"\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",
".",
"So",
"the",
"recommended",
"thing",
"to",
"do",
"is",
"to",
"simply",
"reboot",
"."
] |
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",
",",
"0",
",",
"offTime",
")",
"\n",
"}"
] |
// 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",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"glog",
".",
"V",
"(",
"1",
")",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"err",
":=",
"d",
".",
"Bus",
".",
"WriteByteToReg",
"(",
"d",
".",
"Addr",
",",
"mode1RegAddr",
",",
"0x00",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"glog",
".",
"V",
"(",
"1",
")",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n\n",
"for",
"regAddr",
":=",
"0x06",
";",
"regAddr",
"<=",
"0x45",
";",
"regAddr",
"++",
"{",
"if",
"err",
":=",
"d",
".",
"Bus",
".",
"WriteByteToReg",
"(",
"d",
".",
"Addr",
",",
"byte",
"(",
"regAddr",
")",
",",
"0x00",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"glog",
".",
"V",
"(",
"1",
")",
"{",
"glog",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"glog",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// 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",
":",
"&",
"position",
"{",
"0",
",",
"0",
"}",
",",
"}",
"\n",
"}"
] |
// 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'",
")",
"{",
"err",
":=",
"disp",
".",
"Newline",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
":=",
"disp",
".",
"WriteChar",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"disp",
".",
"p",
".",
"col",
"++",
"\n",
"if",
"disp",
".",
"p",
".",
"col",
">=",
"disp",
".",
"cols",
"||",
"disp",
".",
"p",
".",
"col",
"<",
"0",
"{",
"err",
":=",
"disp",
".",
"Newline",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\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",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"d",
".",
"closing",
"<-",
"waitc",
"\n",
"<-",
"waitc",
"\n",
"}",
"\n",
"glog",
".",
"V",
"(",
"1",
")",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"d",
".",
"Bus",
".",
"WriteWordToReg",
"(",
"d",
".",
"Addr",
",",
"configReg",
",",
"reset",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// 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",
":=",
"d",
".",
"Bus",
".",
"ReadWordFromReg",
"(",
"d",
".",
"Addr",
",",
"manIdReg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"glog",
".",
"V",
"(",
"1",
")",
".",
"Infof",
"(",
"\"",
"\"",
",",
"mid",
")",
"\n",
"if",
"mid",
"!=",
"manId",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"d",
".",
"Addr",
")",
"\n",
"}",
"\n",
"did",
",",
"err",
":=",
"d",
".",
"Bus",
".",
"ReadWordFromReg",
"(",
"d",
".",
"Addr",
",",
"devIdReg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"glog",
".",
"V",
"(",
"1",
")",
".",
"Infof",
"(",
"\"",
"\"",
",",
"did",
")",
"\n",
"if",
"did",
"!=",
"devId",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"d",
".",
"Addr",
")",
"\n",
"}",
"\n\n",
"return",
"true",
",",
"nil",
"\n",
"}"
] |
// 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",
".",
"measureRawDieTemp",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// 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",
".",
"measureObjTemp",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// 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",
".",
"LEDDriver",
"==",
"nil",
"{",
"return",
"ErrFeatureNotSupported",
"\n",
"}",
"\n\n",
"ledDriverInstance",
"=",
"desc",
".",
"LEDDriver",
"(",
")",
"\n",
"ledDriverInitialized",
"=",
"true",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// 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",
".",
"LED",
"(",
"key",
")",
"\n",
"}"
] |
// 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",
",",
"operationCode",
":",
"highResOpCode",
",",
"Poll",
":",
"pollDelay",
"}",
"\n",
"case",
"High2",
":",
"return",
"&",
"BH1750FVI",
"{",
"Bus",
":",
"bus",
",",
"i2cAddr",
":",
"sensorI2cAddr",
",",
"operationCode",
":",
"highResMode2OpCode",
",",
"Poll",
":",
"pollDelay",
"}",
"\n",
"default",
":",
"return",
"&",
"BH1750FVI",
"{",
"Bus",
":",
"bus",
",",
"i2cAddr",
":",
"sensorI2cAddr",
",",
"operationCode",
":",
"highResOpCode",
",",
"Poll",
":",
"pollDelay",
"}",
"\n",
"}",
"\n",
"}"
] |
// 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",
"d",
".",
"measureLighting",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// 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",
".",
"Poll",
")",
"*",
"time",
".",
"Millisecond",
")",
"\n\n",
"var",
"lighting",
"float64",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"d",
".",
"lightingReadings",
"<-",
"lighting",
":",
"case",
"<-",
"timer",
":",
"l",
",",
"err",
":=",
"d",
".",
"measureLighting",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"lighting",
"=",
"l",
"\n",
"}",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"d",
".",
"lightingReadings",
"==",
"nil",
"{",
"d",
".",
"lightingReadings",
"=",
"make",
"(",
"chan",
"float64",
")",
"\n",
"}",
"\n",
"case",
"<-",
"d",
".",
"quit",
":",
"d",
".",
"lightingReadings",
"=",
"nil",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"\n",
"}"
] |
// 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",
"]",
"=",
"uint8",
"(",
"m",
".",
"Mode",
")",
"<<",
"7",
"|",
"uint8",
"(",
"chanNum",
")",
"<<",
"4",
"\n",
"data",
"[",
"2",
"]",
"=",
"0",
"\n\n",
"glog",
".",
"V",
"(",
"2",
")",
".",
"Infof",
"(",
"\"",
"\"",
",",
"data",
")",
"\n",
"if",
"err",
":=",
"m",
".",
"Bus",
".",
"TransferAndReceiveData",
"(",
"data",
"[",
":",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"int",
"(",
"uint16",
"(",
"data",
"[",
"1",
"]",
"&",
"0x03",
")",
"<<",
"8",
"|",
"uint16",
"(",
"data",
"[",
"2",
"]",
")",
")",
",",
"nil",
"\n",
"}"
] |
// 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.