Browse Source

Vendoring updates

master
KemoNine 2 years ago
parent
commit
8b0c907c3d
  1. 7
      go.mod
  2. 2
      go.sum
  3. 25
      vendor/github.com/d2r2/go-bh1750/.travis.yml
  4. 91
      vendor/github.com/d2r2/go-bh1750/README.md
  5. 323
      vendor/github.com/d2r2/go-bh1750/bh1750.go
  6. 10
      vendor/github.com/d2r2/go-bh1750/logger.go
  7. 106
      vendor/github.com/d2r2/go-bh1750/utils.go
  8. 25
      vendor/github.com/d2r2/go-i2c/.travis.yml
  9. 22
      vendor/github.com/d2r2/go-i2c/LICENSE
  10. 97
      vendor/github.com/d2r2/go-i2c/README.md
  11. 12
      vendor/github.com/d2r2/go-i2c/cgo.go
  12. 241
      vendor/github.com/d2r2/go-i2c/i2c.go
  13. 11
      vendor/github.com/d2r2/go-i2c/logger.go
  14. 11
      vendor/github.com/d2r2/go-i2c/noncgo.go
  15. 2
      vendor/github.com/d2r2/go-logger/README.md
  16. 161
      vendor/github.com/d2r2/go-logger/file.go
  17. 31
      vendor/github.com/d2r2/go-logger/format.go
  18. 309
      vendor/github.com/d2r2/go-logger/logger.go
  19. 258
      vendor/github.com/d2r2/go-logger/package.go
  20. 133
      vendor/github.com/d2r2/go-logger/utils.go
  21. 15
      vendor/github.com/davecgh/go-spew/LICENSE
  22. 145
      vendor/github.com/davecgh/go-spew/spew/bypass.go
  23. 38
      vendor/github.com/davecgh/go-spew/spew/bypasssafe.go
  24. 341
      vendor/github.com/davecgh/go-spew/spew/common.go
  25. 306
      vendor/github.com/davecgh/go-spew/spew/config.go
  26. 211
      vendor/github.com/davecgh/go-spew/spew/doc.go
  27. 509
      vendor/github.com/davecgh/go-spew/spew/dump.go
  28. 419
      vendor/github.com/davecgh/go-spew/spew/format.go
  29. 148
      vendor/github.com/davecgh/go-spew/spew/spew.go
  30. 28
      vendor/github.com/eiannone/keyboard/.gitignore
  31. 5
      vendor/github.com/eiannone/keyboard/AUTHORS
  32. 6
      vendor/github.com/eiannone/keyboard/LICENSE
  33. 81
      vendor/github.com/eiannone/keyboard/README.md
  34. 207
      vendor/github.com/eiannone/keyboard/keyboard.go
  35. 231
      vendor/github.com/eiannone/keyboard/keyboard_common.go
  36. 285
      vendor/github.com/eiannone/keyboard/keyboard_windows.go
  37. 12
      vendor/github.com/eiannone/keyboard/syscalls.go
  38. 10
      vendor/github.com/eiannone/keyboard/syscalls_linux.go
  39. 257
      vendor/github.com/eiannone/keyboard/terminfo.go
  40. 13
      vendor/golang.org/x/sys/windows/aliases.go
  41. 415
      vendor/golang.org/x/sys/windows/dll_windows.go
  42. 8
      vendor/golang.org/x/sys/windows/empty.s
  43. 54
      vendor/golang.org/x/sys/windows/env_windows.go
  44. 20
      vendor/golang.org/x/sys/windows/eventlog.go
  45. 97
      vendor/golang.org/x/sys/windows/exec_windows.go
  46. 31
      vendor/golang.org/x/sys/windows/memory_windows.go
  47. 63
      vendor/golang.org/x/sys/windows/mkerrors.bash
  48. 27
      vendor/golang.org/x/sys/windows/mkknownfolderids.bash
  49. 9
      vendor/golang.org/x/sys/windows/mksyscall.go
  50. 30
      vendor/golang.org/x/sys/windows/race.go
  51. 25
      vendor/golang.org/x/sys/windows/race0.go
  52. 1406
      vendor/golang.org/x/sys/windows/security_windows.go
  53. 229
      vendor/golang.org/x/sys/windows/service.go
  54. 22
      vendor/golang.org/x/sys/windows/str.go
  55. 74
      vendor/golang.org/x/sys/windows/syscall.go
  56. 1489
      vendor/golang.org/x/sys/windows/syscall_windows.go
  57. 1786
      vendor/golang.org/x/sys/windows/types_windows.go
  58. 22
      vendor/golang.org/x/sys/windows/types_windows_386.go
  59. 22
      vendor/golang.org/x/sys/windows/types_windows_amd64.go
  60. 22
      vendor/golang.org/x/sys/windows/types_windows_arm.go
  61. 6853
      vendor/golang.org/x/sys/windows/zerrors_windows.go
  62. 149
      vendor/golang.org/x/sys/windows/zknownfolderids_windows.go
  63. 4070
      vendor/golang.org/x/sys/windows/zsyscall_windows.go
  64. 8
      vendor/modules.txt

7
go.mod

@ -3,11 +3,12 @@ module git.kemonine.info/PiFrame
go 1.15
require (
github.com/d2r2/go-bh1750 v0.0.0-20181222061755-1195122364ab
github.com/d2r2/go-i2c v0.0.0-20191123181816-73a8a799d6bc
github.com/d2r2/go-logger v0.0.0-20181221090742-9998a510495e
github.com/d2r2/go-bh1750 v0.0.0-20181222061755-1195122364ab // indirect
github.com/d2r2/go-i2c v0.0.0-20191123181816-73a8a799d6bc // indirect
github.com/d2r2/go-logger v0.0.0-20181221090742-9998a510495e // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/dietsche/rfsnotify v0.0.0-20200716145600-b37be6e4177f
github.com/eiannone/keyboard v0.0.0-20200508000154-caf4b762e807
github.com/fsnotify/fsnotify v1.4.9 // indirect
github.com/gdamore/tcell v1.4.0
github.com/rivo/tview v0.0.0-20200818120338-53d50e499bf9

2
go.sum

@ -9,6 +9,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dietsche/rfsnotify v0.0.0-20200716145600-b37be6e4177f h1:b3QvpXLSx1U13VM79rSkA+6Xv4lmT/urEMzA36Yma0U=
github.com/dietsche/rfsnotify v0.0.0-20200716145600-b37be6e4177f/go.mod h1:ztitxkMUaBsHRey1tS5xFCd4gm/zAQwA9yfCP5y4cAA=
github.com/eiannone/keyboard v0.0.0-20200508000154-caf4b762e807 h1:jdjd5e68T4R/j4PWxfZqcKY8KtT9oo8IPNVuV4bSXDQ=
github.com/eiannone/keyboard v0.0.0-20200508000154-caf4b762e807/go.mod h1:Xoiu5VdKMvbRgHuY7+z64lhu/7lvax/22nzASF6GrO8=
github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=

25
vendor/github.com/d2r2/go-bh1750/.travis.yml generated vendored

@ -1,25 +0,0 @@
language: go
go:
# - "1.10"
- "tip"
# first part of the GOARCH workaround
# setting the GOARCH directly doesn't work, since the value will be overwritten later
# so set it to a temporary environment variable first
env:
global:
TRAVIS_CGO_ENABLED=1
TRAVIS_GOOS=linux
matrix:
- TRAVIS_GOARCH=amd64
- TRAVIS_GOARCH=arm TRAVIS_CC=arm-linux-gnueabi-gcc TRAVIS_GOARM=6
# second part of the GOARCH workaround
# now actually set the GOARCH env variable to the value of the temporary variable set earlier
before_install:
- sudo apt-get install gcc-arm-linux-gnueabi # for CGO cross compile to ARM
- export CGO_ENABLED=$TRAVIS_CGO_ENABLED GOARCH=$TRAVIS_GOARCH GOARM=$TRAVIS_GOARM GOOS=$TRAVIS_GOOS CC=$TRAVIS_CC
- go env # for debugging
- go tool dist env # for debugging

91
vendor/github.com/d2r2/go-bh1750/README.md generated vendored

@ -1,91 +0,0 @@
BH1750 ambient light sensor
=====================
[![Build Status](https://travis-ci.org/d2r2/go-bh1750.svg?branch=master)](https://travis-ci.org/d2r2/go-bh1750)
[![Go Report Card](https://goreportcard.com/badge/github.com/d2r2/go-bh1750)](https://goreportcard.com/report/github.com/d2r2/go-bh1750)
[![GoDoc](https://godoc.org/github.com/d2r2/go-bh1750?status.svg)](https://godoc.org/github.com/d2r2/go-bh1750)
[![MIT License](http://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
BH1750 ([general specification](https://raw.github.com/d2r2/go-bh1750/master/docs/bh1750fvi-e-186247.pdf)) is a power effective ambient light sensor with spectral response close to human eye. Sensor returns measured ambient light value in lux units. Easily integrated with Arduino and Raspberry PI via i2c communication interface:
![image](https://raw.github.com/d2r2/go-bh1750/master/docs/bh1750.jpg)
Here is a library written in [Go programming language](https://golang.org/) for Raspberry PI and counterparts, which gives you in the output ambient light value (making all necessary i2c-bus interacting and values computing).
Golang usage
------------
```go
func main() {
// Create new connection to i2c-bus on 0 line with address 0x23.
// Use i2cdetect utility to find device address over the i2c-bus
i2c, err := i2c.NewI2C(0x23, 0)
if err != nil {
log.Fatal(err)
}
defer i2c.Close()
sensor := bh1750.NewBH1750()
resolution := bh1750.HighResolution
amb, err := sensor.MeasureAmbientLight(i2c, resolution)
if err != nil {
lg.Fatal(err)
}
log.Printf("Ambient light (%s) = %v lx", resolution, amb)
```
Getting help
------------
GoDoc [documentation](http://godoc.org/github.com/d2r2/go-bh1750)
Installation
------------
```bash
$ go get -u github.com/d2r2/go-bh1750
```
Troubleshooting
--------------
- *How to obtain fresh Golang installation to RPi device (either any RPi clone):*
If your RaspberryPI golang installation taken by default from repository is outdated, you may consider
to install actual golang manually from official Golang [site](https://golang.org/dl/). Download
tar.gz file containing armv6l in the name. Follow installation instructions.
- *How to enable I2C bus on RPi device:*
If you employ RaspberryPI, use raspi-config utility to activate i2c-bus on the OS level.
Go to "Interfacing Options" menu, to active I2C bus.
Probably you will need to reboot to load i2c kernel module.
Finally you should have device like /dev/i2c-1 present in the system.
- *How to find I2C bus allocation and device address:*
Use i2cdetect utility in format "i2cdetect -y X", where X may vary from 0 to 5 or more,
to discover address occupied by peripheral device. To install utility you should run
`apt install i2c-tools` on debian-kind system. `i2cdetect -y 1` sample output:
```
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- 76 --
```
Contact
-------
Please use [Github issue tracker](https://github.com/d2r2/go-bh1750/issues) for filing bugs or feature requests.
License
-------
Go-bh1750 is licensed under MIT License.

323
vendor/github.com/d2r2/go-bh1750/bh1750.go generated vendored

@ -1,323 +0,0 @@
//--------------------------------------------------------------------------------------------------
//
// Copyright (c) 2018 Denis Dyakov
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
// associated documentation files (the "Software"), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all copies or substantial
// portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
// BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//--------------------------------------------------------------------------------------------------
package bh1750
import (
"encoding/binary"
"errors"
"time"
i2c "github.com/d2r2/go-i2c"
"github.com/davecgh/go-spew/spew"
)
// Command bytes
const (
// No active state.
CMD_POWER_DOWN = 0x00
// Waiting for measurement command.
CMD_POWER_ON = 0x01
// Reset Data register value.
// Reset command is not acceptable in Power Down mode.
CMD_RESET = 0x07
// Start measurement at 1lx resolution.
// Measurement Time is typically 120ms.
CMD_CONTINUOUSLY_H_RES_MODE = 0x10
// Start measurement at 0.5lx resolution.
// Measurement Time is typically 120ms.
CMD_CONTINUOUSLY_H_RES_MODE2 = 0x11
// Start measurement at 4lx resolution.
// Measurement Time is typically 16ms.
CMD_CONTINUOUSLY_L_RES_MODE = 0x13
// Start measurement at 1lx resolution.
// Measurement Time is typically 120ms.
// It is automatically set to Power Down mode after measurement
CMD_ONE_TIME_H_RES_MODE = 0x20
// Start measurement at 0.5lx resolution.
// Measurement Time is typically 120ms.
// It is automatically set to Power Down mode after measurement.
CMD_ONE_TIME_H_RES_MODE2 = 0x21
// Start measurement at 4lx resolution.
// Measurement Time is typically 16ms.
// It is automatically set to Power Down mode after measurement.
CMD_ONE_TIME_L_RES_MODE = 0x23
// Change measurement time. 01000_MT[7,6,5]
CMD_CHANGE_MEAS_TIME_HIGH = 0x40
// Change measurement time. 011_MT[4,3,2,1,0]
CMD_CHANGE_MEAS_TIME_LOW = 0x60
)
// ResolutionMode define sensor sensitivity
// and measure time. Be aware, that improving
// sensitivity lead to increasing of measurement time.
type ResolutionMode int
const (
// LowResolution precision 4 lx, 16 ms measurement time
LowResolution ResolutionMode = iota + 1
// HighResolution precision 1 lx, 120 ms measurement time
HighResolution
// HighestResolution precision 0.5 lx, 120 ms measurement time
HighestResolution
)
// String define stringer interface.
func (v ResolutionMode) String() string {
switch v {
case LowResolution:
return "Low Resolution"
case HighResolution:
return "High Resolution"
case HighestResolution:
return "Highest Resolution"
default:
return "<unknown>"
}
}
// BH1750 it's a sensor itself.
type BH1750 struct {
// Since sensor have no register
// to report current state, we save
// last issued command to fill this gap.
lastCmd byte
lastResolution ResolutionMode
factor byte
}
// NewBH1750 return new sensor instance.
func NewBH1750() *BH1750 {
v := &BH1750{}
v.factor = v.GetDefaultSensivityFactor()
return v
}
// Reset clear ambient light register value.
func (v *BH1750) Reset(i2c *i2c.I2C) error {
lg.Debug("Reset sensor...")
_, err := i2c.WriteBytes([]byte{CMD_RESET})
if err != nil {
return err
}
v.lastCmd = CMD_RESET
time.Sleep(time.Microsecond * 3)
return nil
}
// PowerDown return register to idle state.
func (v *BH1750) PowerDown(i2c *i2c.I2C) error {
lg.Debug("Power down sensor...")
_, err := i2c.WriteBytes([]byte{CMD_POWER_DOWN})
if err != nil {
return err
}
v.lastCmd = CMD_POWER_DOWN
return nil
}
// PowerOn activate sensor.
func (v *BH1750) PowerOn(i2c *i2c.I2C) error {
lg.Debug("Power on sensor...")
_, err := i2c.WriteBytes([]byte{CMD_POWER_ON})
if err != nil {
return err
}
v.lastCmd = CMD_POWER_ON
return nil
}
// Get internal parameters used to program sensor.
func (v *BH1750) getResolutionData(resolution ResolutionMode) (cmd byte,
wait time.Duration, divider uint32) {
switch resolution {
case LowResolution:
cmd = CMD_ONE_TIME_L_RES_MODE
divider = 1
// typical measure time is 16 ms,
// but as it was found 24 ms max time
// gives better results
wait = time.Millisecond * 24
case HighResolution:
cmd = CMD_ONE_TIME_H_RES_MODE
divider = 1
// typical measure time
wait = time.Millisecond * 120
case HighestResolution:
cmd = CMD_ONE_TIME_H_RES_MODE2
divider = 2
// typical measure time
wait = time.Millisecond * 120
}
wait = wait * time.Duration(v.factor) /
time.Duration(v.GetDefaultSensivityFactor())
return cmd, wait, divider
}
// MeasureAmbientLight measure and return ambient light once in lux.
func (v *BH1750) MeasureAmbientLight(i2c *i2c.I2C,
resolution ResolutionMode) (uint16, error) {
lg.Debug("Run one time measure...")
cmd, wait, divider := v.getResolutionData(resolution)
v.lastCmd = cmd
v.lastResolution = resolution
_, err := i2c.WriteBytes([]byte{cmd})
if err != nil {
return 0, err
}
time.Sleep(wait)
var data struct {
Data [2]byte
}
err = readDataToStruct(i2c, 2, binary.BigEndian, &data)
if err != nil {
return 0, err
}
amb := uint16(uint32(uint16(data.Data[0])<<8|uint16(data.Data[1])) *
5 / 6 / divider)
return amb, nil
}
// StartMeasureAmbientLightContinuously start continuous
// measurement process. Use FetchMeasuredAmbientLight to get
// average ambient light amount collected and calculated over a time.
// Use PowerDown to stop measurements and return sensor to idle state.
func (v *BH1750) StartMeasureAmbientLightContinuously(i2c *i2c.I2C,
resolution ResolutionMode) (wait time.Duration, err error) {
lg.Debug("Start measures continuously...")
cmd, wait, _ := v.getResolutionData(resolution)
v.lastCmd = cmd
v.lastResolution = resolution
_, err = i2c.WriteBytes([]byte{cmd})
if err != nil {
return 0, err
}
// Wait first time to collect necessary
// amount of light for correct results.
// It's not necessary to wait next time
// same amount of time, because
// sensor accumulate average lux amount
// without any overwrite old value.
time.Sleep(wait)
// In any case we are returning same
// recommended amount of time to wait
// between measures.
return wait, nil
}
// FetchMeasuredAmbientLight return current average ambient light in lux.
// Previous command should be any continuous measurement initiation,
// otherwise error will be reported.
func (v *BH1750) FetchMeasuredAmbientLight(i2c *i2c.I2C) (uint16, error) {
lg.Debug("Fetch measured data...")
cmd, _, divider := v.getResolutionData(v.lastResolution)
if v.lastCmd != cmd {
return 0, errors.New(
"can't fetch measured ambient light, since last command doesn't match")
}
var data struct {
Data [2]byte
}
err := readDataToStruct(i2c, 2, binary.BigEndian, &data)
if err != nil {
return 0, err
}
amb := uint16(uint32(uint16(data.Data[0])<<8|uint16(data.Data[1])) *
5 / 6 / divider)
return amb, nil
}
// GetDefaultSensivityFactor return factor value
// used when your sensor have no any protection cover.
// This is default setting according to specification.
func (v *BH1750) GetDefaultSensivityFactor() byte {
return 69
}
// ChangeSensivityFactor used when you close sensor
// with protection cover, which change (ordinary decrease)
// expected amount of light falling on the sensor.
// In this case you should calibrate you sensor and find
// appropriate factor to get in output correct ambient light value.
// Be aware, that improving sensitivity will increase
// measurement time.
func (v *BH1750) ChangeSensivityFactor(i2c *i2c.I2C, factor byte) error {
lg.Debug("Change sensitivity factor...")
// minimum limit
const minValue = 31
// maximum limit
const maxValue = 254
if factor < minValue || factor > maxValue {
return errors.New(spew.Sprintf("sensitivity factor value exceed range [%d..%d]",
minValue, maxValue))
}
high := (factor & 0xE0) >> 5
_, err := i2c.WriteBytes([]byte{CMD_CHANGE_MEAS_TIME_HIGH | high})
if err != nil {
return err
}
low := (factor & 0x1F)
_, err = i2c.WriteBytes([]byte{CMD_CHANGE_MEAS_TIME_LOW | low})
if err != nil {
return err
}
v.factor = factor
return nil
}

10
vendor/github.com/d2r2/go-bh1750/logger.go generated vendored

@ -1,10 +0,0 @@
package bh1750
import logger "github.com/d2r2/go-logger"
// You can manage verbosity of log output
// in the package by changing last parameter value.
var lg = logger.NewPackageLogger("bh1750",
logger.DebugLevel,
// logger.InfoLevel,
)

106
vendor/github.com/d2r2/go-bh1750/utils.go generated vendored

@ -1,106 +0,0 @@
//--------------------------------------------------------------------------------------------------
//
// Copyright (c) 2018 Denis Dyakov
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
// associated documentation files (the "Software"), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all copies or substantial
// portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
// BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//--------------------------------------------------------------------------------------------------
package bh1750
import (
"bytes"
"encoding/binary"
"math"
i2c "github.com/d2r2/go-i2c"
)
// Utility functions
// getS16BE extract 2-byte integer as signed big-endian.
func getS16BE(buf []byte) int16 {
v := int16(buf[0])<<8 + int16(buf[1])
return v
}
// getS16LE extract 2-byte integer as signed little-endian.
func getS16LE(buf []byte) int16 {
w := getS16BE(buf)
// exchange bytes
v := (w&0xFF)<<8 + w>>8
return v
}
// getU16BE extract 2-byte integer as unsigned big-endian.
func getU16BE(buf []byte) uint16 {
v := uint16(buf[0])<<8 + uint16(buf[1])
return v
}
// getU16LE extract 2-byte integer as unsigned little-endian.
func getU16LE(buf []byte) uint16 {
w := getU16BE(buf)
// exchange bytes
v := (w&0xFF)<<8 + w>>8
return v
}
func calcCRC1(seed byte, buf []byte) byte {
for i := 0; i < len(buf); i++ {
b := buf[ /*len(buf)-1-*/ i]
for j := 0; j < 8; j++ {
if (seed^b)&0x01 != 0 {
seed ^= 0x18
seed >>= 1
seed |= 0x80
// crc = crc ^ 0x8c
} else {
seed >>= 1
}
b >>= 1
}
}
return seed
}
// Round float amount to certain precision.
func round64(value float64, precision int) float64 {
value2 := math.Round(value*math.Pow10(precision)) /
math.Pow10(precision)
return value2
}
// Round float amount to certain precision.
func round32(value float32, precision int) float32 {
return float32(round64(float64(value), precision))
}
// Read byte block from i2c device to struct object.
func readDataToStruct(i2c *i2c.I2C, byteCount int,
byteOrder binary.ByteOrder, obj interface{}) error {
buf1 := make([]byte, byteCount)
_, err := i2c.ReadBytes(buf1)
if err != nil {
return err
}
buf := bytes.NewBuffer(buf1)
err = binary.Read(buf, byteOrder, obj)
if err != nil {
return err
}
return nil
}

25
vendor/github.com/d2r2/go-i2c/.travis.yml generated vendored

@ -1,25 +0,0 @@
language: go
go:
- "1.10"
# - "tip"
# first part of the GOARCH workaround
# setting the GOARCH directly doesn't work, since the value will be overwritten later
# so set it to a temporary environment variable first
env:
global:
TRAVIS_CGO_ENABLED=1
TRAVIS_GOOS=linux
matrix:
- TRAVIS_GOARCH=amd64
- TRAVIS_GOARCH=arm TRAVIS_CC=arm-linux-gnueabi-gcc TRAVIS_GOARM=6
# second part of the GOARCH workaround
# now actually set the GOARCH env variable to the value of the temporary variable set earlier
before_install:
- sudo apt-get install gcc-arm-linux-gnueabi crossbuild-essential-armel # for CGO cross compile to ARM
- export CGO_ENABLED=$TRAVIS_CGO_ENABLED GOARCH=$TRAVIS_GOARCH GOARM=$TRAVIS_GOARM GOOS=$TRAVIS_GOOS CC=$TRAVIS_CC
- go env # for debugging
- go tool dist env # for debugging

22
vendor/github.com/d2r2/go-i2c/LICENSE generated vendored

@ -1,22 +0,0 @@
MIT License
Copyright (c) 2016 Denis Dyakov
Copyright (c) 2013 Dave Cheney
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

97
vendor/github.com/d2r2/go-i2c/README.md generated vendored

@ -1,97 +0,0 @@
I2C-bus interaction of peripheral sensors with Raspberry PI embedded linux or respective clones
==============================================================================================
[![Build Status](https://travis-ci.org/d2r2/go-i2c.svg?branch=master)](https://travis-ci.org/d2r2/go-i2c)
[![Go Report Card](https://goreportcard.com/badge/github.com/d2r2/go-i2c)](https://goreportcard.com/report/github.com/d2r2/go-i2c)
[![GoDoc](https://godoc.org/github.com/d2r2/go-i2c?status.svg)](https://godoc.org/github.com/d2r2/go-i2c)
[![MIT License](http://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
This library written in [Go programming language](https://golang.org/) intended to activate and interact with the I2C bus by reading and writing data.
Compatibility
-------------
Tested on Raspberry Pi 1 (model B), Raspberry Pi 3 B+, Banana Pi (model M1), Orange Pi Zero, Orange Pi One.
Golang usage
------------
```go
func main() {
// Create new connection to I2C bus on 2 line with address 0x27
i2c, err := i2c.NewI2C(0x27, 2)
if err != nil { log.Fatal(err) }
// Free I2C connection on exit
defer i2c.Close()
....
// Here goes code specific for sending and reading data
// to and from device connected via I2C bus, like:
_, err := i2c.Write([]byte{0x1, 0xF3})
if err != nil { log.Fatal(err) }
....
}
```
Tutorial
--------
My [repositories](https://github.com/d2r2?tab=repositories) contain quite a lot projects, which use i2c library as a starting point to interact with various peripheral devices and sensors for use on embedded Linux devices. All these libraries start with a standard call to open I2C-connection to specific bus line and address, than pass i2c instance to device.
In its turn, go-i2c use [go-logger](https://github.com/d2r2/go-logger) library to output debug and other notification's lines which produce all necessary levels of logging. You can manage what level of verbosity you would like to see, by adding call:
```go
// Uncomment/comment next line to suppress/increase verbosity of output
logger.ChangePackageLogLevel("i2c", logger.InfoLevel)
```
Once you put this call, it will decrease verbosity from default "Debug" up to next "Info" level, reducing the number of low-level console outputs that occur during interaction with the I2C bus. Please, find examples in corresponding I2C-driven sensors among my projects.
You will find here the list of all devices and sensors supported by me, that reference this library:
- [Liquid-crystal display driven by Hitachi HD44780 IC](https://github.com/d2r2/go-hd44780).
- [BMP180/BMP280/BME280 temperature and pressure sensors](https://github.com/d2r2/go-bsbmp).
- [DHT12/AM2320 humidity and temperature sensors](https://github.com/d2r2/go-aosong).
- [Si7021 relative humidity and temperature sensor](https://github.com/d2r2/go-si7021).
- [SHT3x humidity and temperature sensor](https://github.com/d2r2/go-sht3x).
- [VL53L0X time-of-flight ranging sensor](https://github.com/d2r2/go-vl53l0x).
- [BH1750 ambient light sensor](https://github.com/d2r2/go-bh1750).
- [MPL3115A2 pressure and temperature sensor](https://github.com/d2r2/go-mpl3115a2).
Getting help
------------
GoDoc [documentation](http://godoc.org/github.com/d2r2/go-i2c)
Troubleshooting
--------------
- *How to obtain fresh Golang installation to RPi device (either any RPi clone):*
If your RaspberryPI golang installation taken by default from repository is outdated, you may consider
to install actual golang manually from official Golang [site](https://golang.org/dl/). Download
tar.gz file containing armv6l in the name. Follow installation instructions.
- *How to enable I2C bus on RPi device:*
If you employ RaspberryPI, use raspi-config utility to activate i2c-bus on the OS level.
Go to "Interfacing Options" menu, to active I2C bus.
Probably you will need to reboot to load i2c kernel module.
Finally you should have device like /dev/i2c-1 present in the system.
- *How to find I2C bus allocation and device address:*
Use i2cdetect utility in format "i2cdetect -y X", where X may vary from 0 to 5 or more,
to discover address occupied by peripheral device. To install utility you should run
`apt install i2c-tools` on debian-kind system. `i2cdetect -y 1` sample output:
```
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- 76 --
```
License
-------
Go-i2c is licensed under MIT License.

12
vendor/github.com/d2r2/go-i2c/cgo.go generated vendored

@ -1,12 +0,0 @@
// +build linux,cgo
package i2c
// #include <linux/i2c-dev.h>
import "C"
// Get I2C_SLAVE constant value from
// Linux OS I2C declaration file.
const (
I2C_SLAVE = C.I2C_SLAVE
)

241
vendor/github.com/d2r2/go-i2c/i2c.go generated vendored

@ -1,241 +0,0 @@
// Package i2c provides low level control over the Linux i2c bus.
//
// Before usage you should load the i2c-dev kernel module
//
// sudo modprobe i2c-dev
//
// Each i2c bus can address 127 independent i2c devices, and most
// Linux systems contain several buses.
package i2c
import (
"encoding/hex"
"fmt"
"os"
"syscall"
)
// I2C represents a connection to I2C-device.
type I2C struct {
addr uint8
bus int
rc *os.File
}
// NewI2C opens a connection for I2C-device.
// SMBus (System Management Bus) protocol over I2C
// supported as well: you should preliminary specify
// register address to read from, either write register
// together with the data in case of write operations.
func NewI2C(addr uint8, bus int) (*I2C, error) {
f, err := os.OpenFile(fmt.Sprintf("/dev/i2c-%d", bus), os.O_RDWR, 0600)
if err != nil {
return nil, err
}
if err := ioctl(f.Fd(), I2C_SLAVE, uintptr(addr)); err != nil {
return nil, err
}
v := &I2C{rc: f, bus: bus, addr: addr}
return v, nil
}
// GetBus return bus line, where I2C-device is allocated.
func (v *I2C) GetBus() int {
return v.bus
}
// GetAddr return device occupied address in the bus.
func (v *I2C) GetAddr() uint8 {
return v.addr
}
func (v *I2C) write(buf []byte) (int, error) {
return v.rc.Write(buf)
}
// WriteBytes send bytes to the remote I2C-device. The interpretation of
// the message is implementation-dependent.
func (v *I2C) WriteBytes(buf []byte) (int, error) {
lg.Debugf("Write %d hex bytes: [%+v]", len(buf), hex.EncodeToString(buf))
return v.write(buf)
}
func (v *I2C) read(buf []byte) (int, error) {
return v.rc.Read(buf)
}
// ReadBytes read bytes from I2C-device.
// Number of bytes read correspond to buf parameter length.
func (v *I2C) ReadBytes(buf []byte) (int, error) {
n, err := v.read(buf)
if err != nil {
return n, err
}
lg.Debugf("Read %d hex bytes: [%+v]", len(buf), hex.EncodeToString(buf))
return n, nil
}
// Close I2C-connection.
func (v *I2C) Close() error {
return v.rc.Close()
}
// ReadRegBytes read count of n byte's sequence from I2C-device
// starting from reg address.
// SMBus (System Management Bus) protocol over I2C.
func (v *I2C) ReadRegBytes(reg byte, n int) ([]byte, int, error) {
lg.Debugf("Read %d bytes starting from reg 0x%0X...", n, reg)
_, err := v.WriteBytes([]byte{reg})
if err != nil {
return nil, 0, err
}
buf := make([]byte, n)
c, err := v.ReadBytes(buf)
if err != nil {
return nil, 0, err
}
return buf, c, nil
}
// ReadRegU8 reads byte from I2C-device register specified in reg.
// SMBus (System Management Bus) protocol over I2C.
func (v *I2C) ReadRegU8(reg byte) (byte, error) {
_, err := v.WriteBytes([]byte{reg})
if err != nil {
return 0, err
}
buf := make([]byte, 1)
_, err = v.ReadBytes(buf)
if err != nil {
return 0, err
}
lg.Debugf("Read U8 %d from reg 0x%0X", buf[0], reg)
return buf[0], nil
}
// WriteRegU8 writes byte to I2C-device register specified in reg.
// SMBus (System Management Bus) protocol over I2C.
func (v *I2C) WriteRegU8(reg byte, value byte) error {
buf := []byte{reg, value}
_, err := v.WriteBytes(buf)
if err != nil {
return err
}
lg.Debugf("Write U8 %d to reg 0x%0X", value, reg)
return nil
}
// ReadRegU16BE reads unsigned big endian word (16 bits)
// from I2C-device starting from address specified in reg.
// SMBus (System Management Bus) protocol over I2C.
func (v *I2C) ReadRegU16BE(reg byte) (uint16, error) {
_, err := v.WriteBytes([]byte{reg})
if err != nil {
return 0, err
}
buf := make([]byte, 2)
_, err = v.ReadBytes(buf)
if err != nil {
return 0, err
}
w := uint16(buf[0])<<8 + uint16(buf[1])
lg.Debugf("Read U16 %d from reg 0x%0X", w, reg)
return w, nil
}
// ReadRegU16LE reads unsigned little endian word (16 bits)
// from I2C-device starting from address specified in reg.
// SMBus (System Management Bus) protocol over I2C.
func (v *I2C) ReadRegU16LE(reg byte) (uint16, error) {
w, err := v.ReadRegU16BE(reg)
if err != nil {
return 0, err
}
// exchange bytes
w = (w&0xFF)<<8 + w>>8
return w, nil
}
// ReadRegS16BE reads signed big endian word (16 bits)
// from I2C-device starting from address specified in reg.
// SMBus (System Management Bus) protocol over I2C.
func (v *I2C) ReadRegS16BE(reg byte) (int16, error) {
_, err := v.WriteBytes([]byte{reg})
if err != nil {
return 0, err
}
buf := make([]byte, 2)
_, err = v.ReadBytes(buf)
if err != nil {
return 0, err
}
w := int16(buf[0])<<8 + int16(buf[1])
lg.Debugf("Read S16 %d from reg 0x%0X", w, reg)
return w, nil
}
// ReadRegS16LE reads signed little endian word (16 bits)
// from I2C-device starting from address specified in reg.
// SMBus (System Management Bus) protocol over I2C.
func (v *I2C) ReadRegS16LE(reg byte) (int16, error) {
w, err := v.ReadRegS16BE(reg)
if err != nil {
return 0, err
}
// exchange bytes
w = (w&0xFF)<<8 + w>>8
return w, nil
}
// WriteRegU16BE writes unsigned big endian word (16 bits)
// value to I2C-device starting from address specified in reg.
// SMBus (System Management Bus) protocol over I2C.
func (v *I2C) WriteRegU16BE(reg byte, value uint16) error {
buf := []byte{reg, byte((value & 0xFF00) >> 8), byte(value & 0xFF)}
_, err := v.WriteBytes(buf)
if err != nil {
return err
}
lg.Debugf("Write U16 %d to reg 0x%0X", value, reg)
return nil
}
// WriteRegU16LE writes unsigned little endian word (16 bits)
// value to I2C-device starting from address specified in reg.
// SMBus (System Management Bus) protocol over I2C.
func (v *I2C) WriteRegU16LE(reg byte, value uint16) error {
w := (value*0xFF00)>>8 + value<<8
return v.WriteRegU16BE(reg, w)
}
// WriteRegS16BE writes signed big endian word (16 bits)
// value to I2C-device starting from address specified in reg.
// SMBus (System Management Bus) protocol over I2C.
func (v *I2C) WriteRegS16BE(reg byte, value int16) error {
buf := []byte{reg, byte((uint16(value) & 0xFF00) >> 8), byte(value & 0xFF)}
_, err := v.WriteBytes(buf)
if err != nil {
return err
}
lg.Debugf("Write S16 %d to reg 0x%0X", value, reg)
return nil
}
// WriteRegS16LE writes signed little endian word (16 bits)
// value to I2C-device starting from address specified in reg.
// SMBus (System Management Bus) protocol over I2C.
func (v *I2C) WriteRegS16LE(reg byte, value int16) error {
w := int16((uint16(value)*0xFF00)>>8) + value<<8
return v.WriteRegS16BE(reg, w)
}
func ioctl(fd, cmd, arg uintptr) error {
_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, cmd, arg, 0, 0, 0)
if err != 0 {
return err
}
return nil
}

11
vendor/github.com/d2r2/go-i2c/logger.go generated vendored

@ -1,11 +0,0 @@
package i2c
import logger "github.com/d2r2/go-logger"
// You can manage verbosity of log output
// in the package by changing last parameter value
// (comment/uncomment corresponding lines).
var lg = logger.NewPackageLogger("i2c",
logger.DebugLevel,
// logger.InfoLevel,
)

11
vendor/github.com/d2r2/go-i2c/noncgo.go generated vendored

@ -1,11 +0,0 @@
// +build !cgo
package i2c
// Use hard-coded value for system I2C_SLAVE
// constant, if OS not Linux or CGO disabled.
// This is not a good approach, but
// can be used as a last resort.
const (
I2C_SLAVE = 0x0703
)

2
vendor/github.com/d2r2/go-logger/README.md generated vendored

@ -1,2 +0,0 @@
Golang logger functionality with logging separation by package to improve debug process

161
vendor/github.com/d2r2/go-logger/file.go generated vendored

@ -1,161 +0,0 @@
package logger
import (
"bytes"
"fmt"
"io"
"os"
"path"
"path/filepath"
"sort"
"sync"
)
type File struct {
sync.RWMutex
Path string
File *os.File
}
func (v *File) Flush() error {
v.Lock()
defer v.Unlock()
if v.File != nil {
err := v.File.Sync()
v.File = nil
return err
}
return nil
}
func (v *File) Close() error {
v.Lock()
defer v.Unlock()
if v.File != nil {
err := v.File.Close()
v.File = nil
return err
}
return nil
}
func (v *File) getRotatedFileList() ([]logFile, error) {
var list []logFile
err := filepath.Walk(path.Dir(v.Path), func(p string,
info os.FileInfo, err error) error {
pattern := "*" + path.Base(v.Path) + "*"
if ok, err := path.Match(pattern, path.Base(p)); ok && err == nil {
i := extractIndex(info)
list = append(list, logFile{FileInfo: info, Index: i})
} else if err != nil {
return err
}
return nil
})
if err != nil {
return nil, err
}
s := &sortLogFiles{Items: list}
sort.Sort(s)
return s.Items, nil
}
func (v *File) doRotate(items []logFile, rotateMaxCount int) error {
if len(items) > 0 {
// delete last files
deleteCount := len(items) - rotateMaxCount + 1
if deleteCount > 0 {
for i := 0; i < deleteCount; i++ {
err := os.Remove(items[i].FileInfo.Name())
if err != nil {
return err
}
}
items = items[deleteCount:]
}
// change names of rest files
baseFilePath := items[len(items)-1].FileInfo.Name()
movs := make([]int, len(items))
// 1st round to change names
for i, item := range items {
movs[i] = i + 100000
err := os.Rename(item.FileInfo.Name(),
fmt.Sprintf("%s.%d", baseFilePath, movs[i]))
if err != nil {
return err
}
}
// 2nd round to change names
for i, item := range movs {
err := os.Rename(fmt.Sprintf("%s.%d", baseFilePath, item),
fmt.Sprintf("%s.%d", baseFilePath, len(items)-i))
if err != nil {
return err
}
}
}
return nil
}
func (v *File) rotateFiles(rotateMaxSize int64, rotateMaxCount int) error {
fs, err := v.File.Stat()
if err != nil {
return err
}
if fs.Size() > rotateMaxSize {
if v.File != nil {
err := v.File.Close()
if err != nil {
return err
}
v.File = nil
}
list, err := v.getRotatedFileList()
if err != nil {
return err
}
if err = v.doRotate(list, rotateMaxCount); err != nil {
return err
}
}
return nil
}
func (v *File) getFile() (*os.File, error) {
v.Lock()
defer v.Unlock()
if v.File == nil {
file, err := os.OpenFile(v.Path, os.O_RDWR|os.O_APPEND, 0660)
if err != nil {
file, err = os.Create(v.Path)
if err != nil {
return nil, err
}
}
v.File = file
}
return v.File, nil
}
func (v *File) writeToFile(msg string, rotateMaxSize int64, rotateMaxCount int) error {
file, err := v.getFile()
if err != nil {
return err
}
v.Lock()
defer v.Unlock()
var buf bytes.Buffer
buf.WriteString(msg)
buf.WriteString(fmt.Sprintln())
if _, err := io.Copy(file, &buf); err != nil {
return err
}
// if err = file.Sync(); err != nil {
// return err
// }
if err := v.rotateFiles(rotateMaxSize, rotateMaxCount); err != nil {
return err
}
return nil
}

31
vendor/github.com/d2r2/go-logger/format.go generated vendored

@ -1,31 +0,0 @@
package logger
import "os"
type LevelLength int
const (
LevelShort LevelLength = iota
LevelLong
)
type FormatOptions struct {
TimeFormat string
PackageLength int
LevelLength LevelLength
}
func FormatMessage(options FormatOptions, level LogLevel, packageName, msg string, colored bool) string {
appName := os.Args[0]
out := metaFmtStr(colored, level, options, appName,
packageName, msg, "%[1]s [%[3]s] %[4]s %[5]s")
return out
}
func (options FormatOptions) GetLevelStr(level LogLevel) string {
if options.LevelLength == LevelLong {
return level.LongStr()
} else {
return level.ShortStr()
}
}

309
vendor/github.com/d2r2/go-logger/logger.go generated vendored

@ -1,309 +0,0 @@
package logger
import (
"fmt"
"io"
"log"
"os"
"path"
"path/filepath"
"sync"
)
type LogLevel int
const (
FatalLevel LogLevel = iota
PanicLevel
ErrorLevel
WarnLevel
NotifyLevel
InfoLevel
DebugLevel
)
func (v LogLevel) String() string {
switch v {
case FatalLevel:
return "Fatal"
case PanicLevel:
return "Panic"
case ErrorLevel:
return "Error"
case WarnLevel:
return "Warning"
case NotifyLevel:
return "Notice"
case InfoLevel:
return "Information"
case DebugLevel:
return "Debug"
default:
return "<undef>"
}
}
func (v LogLevel) LongStr() string {
return v.String()
}
func (v LogLevel) ShortStr() string {
switch v {
case FatalLevel:
return "Fatal"
case PanicLevel:
return "Panic"
case ErrorLevel:
return "Error"
case WarnLevel:
return "Warn"
case NotifyLevel:
return "Notice"
case InfoLevel:
return "Info"
case DebugLevel:
return "Debug"
default:
return "<undef>"
}
}
type Log struct {
log *log.Logger
colored bool
level LogLevel
}
func NewLog(log *log.Logger, colored bool, level LogLevel) *Log {
v := &Log{log: log, colored: colored, level: level}
return v
}
type Logger struct {
sync.RWMutex
logs []*Log
packages []*Package
options FormatOptions
logFile *File
rotateMaxSize int64
rotateMaxCount int
enableSyslog bool
}
func NewLogger() *Logger {
stdout := NewLog(log.New(os.Stdout, "", 0), true, DebugLevel)
logs := []*Log{stdout}
options := FormatOptions{TimeFormat: "2006-01-02T15:04:05.000", LevelLength: LevelShort, PackageLength: 8}
l := &Logger{
logs: logs,
options: options,
rotateMaxSize: 1024 * 1024 * 512,
rotateMaxCount: 3,
}
return l
}
func (v *Logger) Close() error {
v.Lock()
defer v.Unlock()
for _, pack := range v.packages {
pack.Close()
}
v.packages = nil
if v.logFile != nil {
v.logFile.Close()
}
return nil
}
func (v *Logger) SetRotateParams(rotateMaxSize int64, rotateMaxCount int) {
v.Lock()
defer v.Unlock()
v.rotateMaxSize = rotateMaxSize
v.rotateMaxCount = rotateMaxCount
}
func (v *Logger) GetRotateMaxSize() int64 {
v.Lock()
defer v.Unlock()
return v.rotateMaxSize
}
func (v *Logger) GetRotateMaxCount() int {
v.Lock()
defer v.Unlock()
return v.rotateMaxCount
}
/*
func (v *Logger) SetApplicationName(appName string) {
v.Lock()
defer v.Unlock()
v.appName = appName
}
func (v *Logger) GetApplicationName() string {
v.RLock()
defer v.RUnlock()
return v.appName
}
*/
func (v *Logger) EnableSyslog(enable bool) {
v.Lock()
defer v.Unlock()
v.enableSyslog = enable
}
func (v *Logger) GetSyslogEnabled() bool {
v.RLock()
defer v.RUnlock()
return v.enableSyslog
}
func (v *Logger) SetFormatOptions(options FormatOptions) {
v.Lock()
defer v.Unlock()
v.options = options
}
func (v *Logger) GetFormatOptions() FormatOptions {
v.RLock()
defer v.RUnlock()
return v.options
}
func (v *Logger) SetLogFileName(logFilePath string) error {
if path.Ext(logFilePath) == "" {
logFilePath += ".log"
}
fp, err := filepath.Abs(logFilePath)
if err != nil {
return err
}
v.Lock()
defer v.Unlock()
lf := &File{Path: fp}
v.logFile = lf
return nil
}
func (v *Logger) GetLogFileInfo() *File {
v.RLock()
defer v.RUnlock()
return v.logFile
}
func (v *Logger) NewPackageLogger(packageName string, level LogLevel) PackageLog {
v.Lock()
defer v.Unlock()
p := &Package{parent: v, packageName: packageName, level: level}
v.packages = append(v.packages, p)