_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q14100 | NewOAuthClientCredentials | train | 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 | {
"resource": ""
} |
q14101 | RGBA | train | 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 | {
"resource": ""
} |
q14102 | MakeColor | train | 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 | {
"resource": ""
} |
q14103 | RGB255 | train | 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 | {
"resource": ""
} |
q14104 | DistanceRgb | train | 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 | {
"resource": ""
} |
q14105 | linearize_fast | train | 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 | {
"resource": ""
} |
q14106 | XyzToLinearRgb | train | 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 | {
"resource": ""
} |
q14107 | DistanceLab | train | 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 | {
"resource": ""
} |
q14108 | DistanceCIE94 | train | 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 | {
"resource": ""
} |
q14109 | xyz_to_uv | train | 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 | {
"resource": ""
} |
q14110 | DistanceLuv | train | 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 | {
"resource": ""
} |
q14111 | MustParseHex | train | func MustParseHex(s string) colorful.Color {
c, err := colorful.Hex(s)
if err != nil {
panic("MustParseHex: " + err.Error())
}
return c
} | go | {
"resource": ""
} |
q14112 | SoftPalette | train | func SoftPalette(colorsCount int) ([]Color, error) {
return SoftPaletteEx(colorsCount, SoftPaletteSettings{nil, 50, false})
} | go | {
"resource": ""
} |
q14113 | lab_dist | train | 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 | {
"resource": ""
} |
q14114 | NewHook | train | 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 | {
"resource": ""
} |
q14115 | SetFormatter | train | 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 | {
"resource": ""
} |
q14116 | SetDefaultPath | train | func (hook *LfsHook) SetDefaultPath(defaultPath string) {
hook.lock.Lock()
defer hook.lock.Unlock()
hook.defaultPath = defaultPath
hook.hasDefaultPath = true
} | go | {
"resource": ""
} |
q14117 | SetDefaultWriter | train | func (hook *LfsHook) SetDefaultWriter(defaultWriter io.Writer) {
hook.lock.Lock()
defer hook.lock.Unlock()
hook.defaultWriter = defaultWriter
hook.hasDefaultWriter = true
} | go | {
"resource": ""
} |
q14118 | Fire | train | 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 | {
"resource": ""
} |
q14119 | ioWrite | train | 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 | {
"resource": ""
} |
q14120 | fileWrite | train | 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 | {
"resource": ""
} |
q14121 | New | train | func New(pwm PWM) *Servo {
return &Servo{
PWM: pwm,
Minus: minus,
Maxus: maxus,
}
} | go | {
"resource": ""
} |
q14122 | SetAngle | train | 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 | {
"resource": ""
} |
q14123 | setMicroseconds | train | 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 | {
"resource": ""
} |
q14124 | Close | train | func (d *ServoBlaster) Close() error {
if d.fd != nil {
return d.fd.Close()
}
return nil
} | go | {
"resource": ""
} |
q14125 | New | train | 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 | {
"resource": ""
} |
q14126 | PressedKey | train | func (d *Matrix4x3) PressedKey() (key Key, err error) {
select {
case key = <-d.keyPressed:
return
default:
return d.findPressedKey()
}
} | go | {
"resource": ""
} |
q14127 | Run | train | 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 | {
"resource": ""
} |
q14128 | NewGPIODriver | train | 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 | {
"resource": ""
} |
q14129 | InitI2C | train | 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 | {
"resource": ""
} |
q14130 | NewI2CBus | train | func NewI2CBus(l byte) I2CBus {
if err := InitI2C(); err != nil {
panic(err)
}
return i2cDriverInstance.Bus(l)
} | go | {
"resource": ""
} |
q14131 | NewSPIDriver | train | func NewSPIDriver(spiDevMinor int, sbf spiBusFactory, i func() error) SPIDriver {
return &spiDriver{
spiDevMinor: spiDevMinor,
sbf: sbf,
initializer: i,
}
} | go | {
"resource": ""
} |
q14132 | Bus | train | 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 | {
"resource": ""
} |
q14133 | Close | train | func (s *spiDriver) Close() error {
for _, b := range s.busMap {
b.Close()
}
return nil
} | go | {
"resource": ""
} |
q14134 | Register | train | 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 | {
"resource": ""
} |
q14135 | SetHost | train | func SetHost(host Host, rev int) {
hostOverride = host
hostRevOverride = rev
hostOverriden = true
} | go | {
"resource": ""
} |
q14136 | DescribeHost | train | 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 | {
"resource": ""
} |
q14137 | New | train | func New(bus embd.I2CBus) *LSM303 {
return &LSM303{Bus: bus, Poll: pollDelay}
} | go | {
"resource": ""
} |
q14138 | setup | train | 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 | {
"resource": ""
} |
q14139 | Heading | train | 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 | {
"resource": ""
} |
q14140 | Close | train | func (d *LSM303) Close() error {
if d.quit != nil {
d.quit <- struct{}{}
}
return d.Bus.WriteByteToReg(magAddress, magModeReg, MagSleep)
} | go | {
"resource": ""
} |
q14141 | IsWet | train | 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 | {
"resource": ""
} |
q14142 | New | train | func New(bus embd.I2CBus) *BMP085 {
return &BMP085{Bus: bus, Poll: pollDelay}
} | go | {
"resource": ""
} |
q14143 | Pressure | train | 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 | {
"resource": ""
} |
q14144 | Altitude | train | 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 | {
"resource": ""
} |
q14145 | NewGPIO | train | 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 | {
"resource": ""
} |
q14146 | New | train | 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 | {
"resource": ""
} |
q14147 | SetMode | train | 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 | {
"resource": ""
} |
q14148 | Home | train | func (hd *HD44780) Home() error {
err := hd.WriteInstruction(lcdReturnHome)
time.Sleep(clearDelay)
return err
} | go | {
"resource": ""
} |
q14149 | Clear | train | 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 | {
"resource": ""
} |
q14150 | SetDDRamAddr | train | func (hd *HD44780) SetDDRamAddr(value byte) error {
return hd.WriteInstruction(lcdSetDDRamAddr | value)
} | go | {
"resource": ""
} |
q14151 | WriteChar | train | func (hd *HD44780) WriteChar(value byte) error {
return hd.Write(true, value)
} | go | {
"resource": ""
} |
q14152 | WriteInstruction | train | func (hd *HD44780) WriteInstruction(value byte) error {
return hd.Write(false, value)
} | go | {
"resource": ""
} |
q14153 | NewGPIOConnection | train | 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 | {
"resource": ""
} |
q14154 | Write | train | 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 | {
"resource": ""
} |
q14155 | Close | train | 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 | {
"resource": ""
} |
q14156 | New | train | func New(echoPin, triggerPin embd.DigitalPin, thermometer Thermometer) *US020 {
return &US020{EchoPin: echoPin, TriggerPin: triggerPin, Thermometer: thermometer}
} | go | {
"resource": ""
} |
q14157 | Distance | train | 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 | {
"resource": ""
} |
q14158 | InitGPIO | train | 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 | {
"resource": ""
} |
q14159 | NewDigitalPin | train | func NewDigitalPin(key interface{}) (DigitalPin, error) {
if err := InitGPIO(); err != nil {
return nil, err
}
return gpioDriverInstance.DigitalPin(key)
} | go | {
"resource": ""
} |
q14160 | DigitalWrite | train | func DigitalWrite(key interface{}, val int) error {
pin, err := NewDigitalPin(key)
if err != nil {
return err
}
return pin.Write(val)
} | go | {
"resource": ""
} |
q14161 | DigitalRead | train | func DigitalRead(key interface{}) (int, error) {
pin, err := NewDigitalPin(key)
if err != nil {
return 0, err
}
return pin.Read()
} | go | {
"resource": ""
} |
q14162 | ActiveLow | train | func ActiveLow(key interface{}, b bool) error {
pin, err := NewDigitalPin(key)
if err != nil {
return err
}
return pin.ActiveLow(b)
} | go | {
"resource": ""
} |
q14163 | PullUp | train | func PullUp(key interface{}) error {
pin, err := NewDigitalPin(key)
if err != nil {
return err
}
return pin.PullUp()
} | go | {
"resource": ""
} |
q14164 | PullDown | train | func PullDown(key interface{}) error {
pin, err := NewDigitalPin(key)
if err != nil {
return err
}
return pin.PullDown()
} | go | {
"resource": ""
} |
q14165 | NewAnalogPin | train | func NewAnalogPin(key interface{}) (AnalogPin, error) {
if err := InitGPIO(); err != nil {
return nil, err
}
return gpioDriverInstance.AnalogPin(key)
} | go | {
"resource": ""
} |
q14166 | AnalogRead | train | func AnalogRead(key interface{}) (int, error) {
pin, err := NewAnalogPin(key)
if err != nil {
return 0, err
}
return pin.Read()
} | go | {
"resource": ""
} |
q14167 | NewPWMPin | train | func NewPWMPin(key interface{}) (PWMPin, error) {
if err := InitGPIO(); err != nil {
return nil, err
}
return gpioDriverInstance.PWMPin(key)
} | go | {
"resource": ""
} |
q14168 | DetectHost | train | 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 | {
"resource": ""
} |
q14169 | New | train | func New(bus embd.I2CBus, Range *Range) *L3GD20 {
return &L3GD20{
Bus: bus,
Range: Range,
}
} | go | {
"resource": ""
} |
q14170 | Orientations | train | func (d *L3GD20) Orientations() (<-chan Orientation, error) {
if err := d.setup(); err != nil {
return nil, err
}
return d.orientations, nil
} | go | {
"resource": ""
} |
q14171 | Stop | train | 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 | {
"resource": ""
} |
q14172 | SetVoltage | train | func (d *MCP4725) SetVoltage(voltage int) error {
return d.setVoltage(voltage, dacReg)
} | go | {
"resource": ""
} |
q14173 | SetPersistedVoltage | train | func (d *MCP4725) SetPersistedVoltage(voltage int) error {
return d.setVoltage(voltage, programReg)
} | go | {
"resource": ""
} |
q14174 | Close | train | 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 | {
"resource": ""
} |
q14175 | InitSPI | train | 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 | {
"resource": ""
} |
q14176 | NewSPIBus | train | 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 | {
"resource": ""
} |
q14177 | New | train | func New(bus embd.I2CBus) *BMP180 {
return &BMP180{Bus: bus, Poll: pollDelay}
} | go | {
"resource": ""
} |
q14178 | ensureFeatureDisabled | train | 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 | {
"resource": ""
} |
q14179 | New | train | func New(bus embd.I2CBus, addr byte) *PCA9685 {
return &PCA9685{
Bus: bus,
Addr: addr,
}
} | go | {
"resource": ""
} |
q14180 | setMicroseconds | train | func (d *PCA9685) setMicroseconds(channel, us int) error {
offTime := us * d.Freq * pwmControlPoints / 1000000
return d.SetPwm(channel, 0, offTime)
} | go | {
"resource": ""
} |
q14181 | Close | train | 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 | {
"resource": ""
} |
q14182 | Sleep | train | func (d *PCA9685) Sleep() error {
if err := d.setup(); err != nil {
return err
}
return d.sleep()
} | go | {
"resource": ""
} |
q14183 | Wake | train | func (d *PCA9685) Wake() error {
if err := d.setup(); err != nil {
return err
}
return d.wake()
} | go | {
"resource": ""
} |
q14184 | New | train | func New(controller Controller, cols, rows int) *Display {
return &Display{
Controller: controller,
cols: cols,
rows: rows,
p: &position{0, 0},
}
} | go | {
"resource": ""
} |
q14185 | Message | train | 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 | {
"resource": ""
} |
q14186 | Close | train | 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 | {
"resource": ""
} |
q14187 | Present | train | 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 | {
"resource": ""
} |
q14188 | RawDieTemp | train | func (d *TMP006) RawDieTemp() (float64, error) {
select {
case temp := <-d.rawDieTemps:
return temp, nil
default:
return d.measureRawDieTemp()
}
} | go | {
"resource": ""
} |
q14189 | ObjTemp | train | func (d *TMP006) ObjTemp() (float64, error) {
select {
case temp := <-d.objTemps:
return temp, nil
default:
return d.measureObjTemp()
}
} | go | {
"resource": ""
} |
q14190 | InitLED | train | 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 | {
"resource": ""
} |
q14191 | NewLED | train | func NewLED(key interface{}) (LED, error) {
if err := InitLED(); err != nil {
return nil, err
}
return ledDriverInstance.LED(key)
} | go | {
"resource": ""
} |
q14192 | LEDOn | train | func LEDOn(key interface{}) error {
led, err := NewLED(key)
if err != nil {
return err
}
return led.On()
} | go | {
"resource": ""
} |
q14193 | LEDOff | train | func LEDOff(key interface{}) error {
led, err := NewLED(key)
if err != nil {
return err
}
return led.Off()
} | go | {
"resource": ""
} |
q14194 | LEDToggle | train | func LEDToggle(key interface{}) error {
led, err := NewLED(key)
if err != nil {
return err
}
return led.Toggle()
} | go | {
"resource": ""
} |
q14195 | New | train | 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 | {
"resource": ""
} |
q14196 | Lighting | train | func (d *BH1750FVI) Lighting() (float64, error) {
select {
case lighting := <-d.lightingReadings:
return lighting, nil
default:
return d.measureLighting()
}
} | go | {
"resource": ""
} |
q14197 | Run | train | 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 | {
"resource": ""
} |
q14198 | New | train | func New(mode byte, bus embd.SPIBus) *MCP3008 {
return &MCP3008{mode, bus}
} | go | {
"resource": ""
} |
q14199 | AnalogValueAt | train | 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 | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.