id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c14100 | bitbucket.Endpoint.TokenURL,
}
tok, err := conf.Token(ctx)
if err != nil {
log.Fatal(err)
}
a.token = *tok
return injectClient(a)
} | |
c14101 | b = uint32(col.B*65535.0 + 0.5)
a = 0xFFFF
return
} | |
c14102 | 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
} | |
c14103 | + 0.5)
g = uint8(col.G*255.0 + 0.5)
b = uint8(col.B*255.0 + 0.5)
return
} | |
c14104 | + sq(c1.G-c2.G) + sq(c1.B-c2.B))
} | |
c14105 | := v3*v2
return -0.248750514614486 + 0.925583310193438*v + 1.16740237321695*v2 + 0.280457026598666*v3 - 0.0757991963780179*v4 //+ 0.0437040411548932*v5
} | |
c14106 | 0.0415560*z
b = 0.0556434*x - 0.2040259*y + 1.0572252*z
return
} | |
c14107 | math.Sqrt(sq(l1-l2) + sq(a1-a2) + sq(b1-b2))
} | |
c14108 | 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... | |
c14109 | u = 4.0 * x / denom
v = 9.0 * y / denom
}
return
} | |
c14110 | math.Sqrt(sq(l1-l2) + sq(u1-u2) + sq(v1-v2))
} | |
c14111 |
if err != nil {
panic("MustParseHex: " + err.Error())
}
return c
} | |
c14112 | SoftPaletteSettings{nil, 50, false})
} | |
c14113 | sq(lab1.A-lab2.A) + sq(lab1.B-lab2.B))
} | |
c14114 | 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
} | |
c14115 | := formatter.(*logrus.TextFormatter)
textFormatter.DisableColors = true
}
}
hook.formatter = formatter
} | |
c14116 | hook.defaultPath = defaultPath
hook.hasDefaultPath = true
} | |
c14117 | hook.defaultWriter = defaultWriter
hook.hasDefaultWriter = true
} | |
c14118 |
} else if hook.paths != nil || hook.hasDefaultPath {
return hook.fileWrite(entry)
}
return nil
} | |
c14119 | 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
} | |
c14120 | 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 ... | |
c14121 | minus,
Maxus: maxus,
}
} | |
c14122 | int64(s.Maxus))
glog.V(1).Infof("servo: given angle %v calculated %v us", angle, us)
return s.PWM.SetMicroseconds(int(us))
} | |
c14123 |
glog.V(1).Infof("servoblaster: sending command %q", cmd)
_, err := d.fd.WriteString(cmd)
return err
} | |
c14124 | d.fd.Close()
}
return nil
} | |
c14125 |
for i := 0; i < cols; i++ {
m.colPins[i], err = embd.NewDigitalPin(colPins[i])
if err != nil {
return nil, err
}
}
return m, nil
} | |
c14126 | {
case key = <-d.keyPressed:
return
default:
return d.findPressedKey()
}
} | |
c14127 | keyUpdates = d.keyPressed
}
case keyUpdates <- key:
keyUpdates = nil
case <-d.quit:
d.keyPressed = nil
return
}
}
}()
} | |
c14128 | {
return &gpioDriver{
pinMap: pinMap,
dpf: dpf,
apf: apf,
ppf: ppf,
initializedPins: map[string]pin{},
}
} | |
c14129 |
}
i2cDriverInstance = desc.I2CDriver()
i2cDriverInitialized = true
return nil
} | |
c14130 |
return i2cDriverInstance.Bus(l)
} | |
c14131 | SPIDriver {
return &spiDriver{
spiDevMinor: spiDevMinor,
sbf: sbf,
initializer: i,
}
} | |
c14132 | delay, s.initializer)
s.busMap = make(map[byte]SPIBus)
s.busMap[channel] = b
return b
} | |
c14133 | _, b := range s.busMap {
b.Close()
}
return nil
} | |
c14134 | already registered")
}
describers[host] = describer
glog.V(1).Infof("embd: host %v is registered", host)
} | |
c14135 | = rev
hostOverriden = true
} | |
c14136 |
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
} | |
c14137 | bus, Poll: pollDelay}
} | |
c14138 | d.Bus.WriteByteToReg(magAddress, magModeReg, MagMRDefault); err != nil {
return err
}
d.initialized = true
return nil
} | |
c14139 | glog.V(2).Infof("lsm303: no headings available... measuring")
return d.measureHeading()
}
} | |
c14140 |
return d.Bus.WriteByteToReg(magAddress, magModeReg, MagSleep)
} | |
c14141 |
value, err := d.Pin.Read()
if err != nil {
return false, err
}
if value == embd.High {
return true, nil
} else {
return false, nil
}
} | |
c14142 | bus, Poll: pollDelay}
} | |
c14143 | 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
}
} | |
c14144 | 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
}
} | |
c14145 | == 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),
... | |
c14146 | }
err = controller.SetMode(append(DefaultModes, modes...)...)
if err != nil {
return nil, err
}
return controller, nil
} | |
c14147 | },
func() error { return hd.setDisplayMode() },
func() error { return hd.setFunctionMode() },
}
for _, f := range functions {
err := f()
if err != nil {
return err
}
}
return nil
} | |
c14148 |
time.Sleep(clearDelay)
return err
} | |
c14149 |
return err
}
time.Sleep(clearDelay)
// have to set mode here because clear also clears some mode settings
return hd.SetMode()
} | |
c14150 | hd.WriteInstruction(lcdSetDDRamAddr | value)
} | |
c14151 | return hd.Write(true, value)
} | |
c14152 | return hd.Write(false, value)
} | |
c14153 | d4,
D5: d5,
D6: d6,
D7: d7,
Backlight: backlight,
BLPolarity: blPolarity,
}
} | |
c14154 | & 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 ... | |
c14155 | pin := range pins {
err := pin.Close()
if err != nil {
glog.Errorf("hd44780: error closing pin %+v: %s", pin, err)
return err
}
}
return nil
} | |
c14156 | &US020{EchoPin: echoPin, TriggerPin: triggerPin, Thermometer: thermometer}
} | |
c14157 | 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
} | |
c14158 |
}
gpioDriverInstance = desc.GPIODriver()
gpioDriverInitialized = true
return nil
} | |
c14159 | nil, err
}
return gpioDriverInstance.DigitalPin(key)
} | |
c14160 | err := NewDigitalPin(key)
if err != nil {
return err
}
return pin.Write(val)
} | |
c14161 | := NewDigitalPin(key)
if err != nil {
return 0, err
}
return pin.Read()
} | |
c14162 | return err
}
return pin.ActiveLow(b)
} | |
c14163 |
if err != nil {
return err
}
return pin.PullUp()
} | |
c14164 | return err
}
return pin.PullDown()
} | |
c14165 | nil, err
}
return gpioDriverInstance.AnalogPin(key)
} | |
c14166 | := NewAnalogPin(key)
if err != nil {
return 0, err
}
return pin.Read()
} | |
c14167 | err
}
return gpioDriverInstance.PWMPin(key)
} | |
c14168 |
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 http... | |
c14169 |
Bus: bus,
Range: Range,
}
} | |
c14170 | {
return nil, err
}
return d.orientations, nil
} | |
c14171 | err := d.Bus.WriteByteToReg(address, ctrlReg1, ctrlReg1Finished); err != nil {
return err
}
d.initialized = false
return nil
} | |
c14172 | return d.setVoltage(voltage, dacReg)
} | |
c14173 | return d.setVoltage(voltage, programReg)
} | |
c14174 | := d.Bus.WriteWordToReg(d.Addr, powerDown, 0); err != nil {
return err
}
return nil
} | |
c14175 |
}
spiDriverInstance = desc.SPIDriver()
spiDriverInitialized = true
return nil
} | |
c14176 |
}
return spiDriverInstance.Bus(mode, channel, speed, bpw, delay)
} | |
c14177 | bus, Poll: pollDelay}
} | |
c14178 | ":")
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)
} | |
c14179 |
Bus: bus,
Addr: addr,
}
} | |
c14180 | := us * d.Freq * pwmControlPoints / 1000000
return d.SetPwm(channel, 0, offTime)
} | |
c14181 |
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")
... | |
c14182 | d.setup(); err != nil {
return err
}
return d.sleep()
} | |
c14183 | d.setup(); err != nil {
return err
}
return d.wake()
} | |
c14184 | Controller: controller,
cols: cols,
rows: rows,
p: &position{0, 0},
}
} | |
c14185 | }
disp.p.col++
if disp.p.col >= disp.cols || disp.p.col < 0 {
err := disp.Newline()
if err != nil {
return err
}
}
}
return nil
} | |
c14186 |
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
} | |
c14187 | != 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 ... | |
c14188 | temp := <-d.rawDieTemps:
return temp, nil
default:
return d.measureRawDieTemp()
}
} | |
c14189 | temp := <-d.objTemps:
return temp, nil
default:
return d.measureObjTemp()
}
} | |
c14190 |
}
ledDriverInstance = desc.LEDDriver()
ledDriverInitialized = true
return nil
} | |
c14191 | err
}
return ledDriverInstance.LED(key)
} | |
c14192 | return err
}
return led.On()
} | |
c14193 | return err
}
return led.Off()
} | |
c14194 | return err
}
return led.Toggle()
} | |
c14195 | i2cAddr: sensorI2cAddr, operationCode: highResMode2OpCode, Poll: pollDelay}
default:
return &BH1750FVI{Bus: bus, i2cAddr: sensorI2cAddr, operationCode: highResOpCode, Poll: pollDelay}
}
} | |
c14196 | return lighting, nil
default:
return d.measureLighting()
}
} | |
c14197 | }
if err == nil && d.lightingReadings == nil {
d.lightingReadings = make(chan float64)
}
case <-d.quit:
d.lightingReadings = nil
return
}
}
}()
return
} | |
c14198 | *MCP3008 {
return &MCP3008{mode, bus}
} | |
c14199 | 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
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.