code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
try:
extra_coverage
except NameError:
print("SKIP")
raise SystemExit
import uerrno
import uio
data = extra_coverage()
# test hashing of str/bytes that have an invalid hash
print(data[0], data[1])
print(hash(data[0]))
print(hash(data[1]))
print(hash(bytes(data[0], "utf8")))
print(hash(str(data[1], "utf8")))
# test streams
stream = data[2] # has set_error and set_buf. Write always returns error
stream.set_error(uerrno.EAGAIN) # non-blocking error
print(stream.read()) # read all encounters non-blocking error
print(stream.read(1)) # read 1 byte encounters non-blocking error
print(stream.readline()) # readline encounters non-blocking error
print(stream.readinto(bytearray(10))) # readinto encounters non-blocking error
print(stream.write(b"1")) # write encounters non-blocking error
print(stream.write1(b"1")) # write1 encounters non-blocking error
stream.set_buf(b"123")
print(stream.read(4)) # read encounters non-blocking error after successful reads
stream.set_buf(b"123")
print(stream.read1(4)) # read1 encounters non-blocking error after successful reads
stream.set_buf(b"123")
print(stream.readline(4)) # readline encounters non-blocking error after successful reads
try:
print(stream.ioctl(0, 0)) # ioctl encounters non-blocking error; raises OSError
except OSError:
print("OSError")
stream.set_error(0)
print(stream.ioctl(0, bytearray(10))) # successful ioctl call
stream2 = data[3] # is textio
print(stream2.read(1)) # read 1 byte encounters non-blocking error with textio stream
# test BufferedWriter with stream errors
stream.set_error(uerrno.EAGAIN)
buf = uio.BufferedWriter(stream, 8)
print(buf.write(bytearray(16)))
# function defined in C++ code
print("cpp", extra_cpp_coverage())
# test user C module
import cexample
print(cexample.add_ints(3, 2))
# test user C module mixed with C++ code
import cppexample
print(cppexample.cppfunc(1, 2))
# test basic import of frozen scripts
import frzstr1
print(frzstr1.__file__)
import frzmpy1
print(frzmpy1.__file__)
# test import of frozen packages with __init__.py
import frzstr_pkg1
print(frzstr_pkg1.__file__, frzstr_pkg1.x)
import frzmpy_pkg1
print(frzmpy_pkg1.__file__, frzmpy_pkg1.x)
# test import of frozen packages without __init__.py
from frzstr_pkg2.mod import Foo
print(Foo.x)
from frzmpy_pkg2.mod import Foo
print(Foo.x)
# test raising exception in frozen script
try:
import frzmpy2
except ZeroDivisionError:
print("ZeroDivisionError")
# test loading a resource from a frozen string
import uio
buf = uio.resource_stream("frzstr_pkg2", "mod.py")
print(buf.read(21))
# test for MP_QSTR_NULL regression
from frzqstr import returns_NULL
print(returns_NULL())
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/unix/extra_coverage.py
|
Python
|
apache-2.0
| 2,694
|
try:
import ffi
except ImportError:
print("SKIP")
raise SystemExit
def ffi_open(names):
err = None
for n in names:
try:
mod = ffi.open(n)
return mod
except OSError as e:
err = e
raise err
libc = ffi_open(("libc.so", "libc.so.0", "libc.so.6", "libc.dylib"))
qsort = libc.func("v", "qsort", "piip")
def cmp(pa, pb):
a = ffi.as_bytearray(pa, 1)
b = ffi.as_bytearray(pb, 1)
# print("cmp:", a, b)
return a[0] - b[0]
cmp_c = ffi.callback("i", cmp, "pp")
s = bytearray(b"foobar")
print("org string:", s)
qsort(s, len(s), 1, cmp_c)
print("qsort'ed:", s)
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/unix/ffi_callback.py
|
Python
|
apache-2.0
| 648
|
# test ffi float support
try:
import ffi
except ImportError:
print("SKIP")
raise SystemExit
def ffi_open(names):
err = None
for n in names:
try:
mod = ffi.open(n)
return mod
except OSError as e:
err = e
raise err
libc = ffi_open(("libc.so", "libc.so.0", "libc.so.6", "libc.dylib"))
try:
strtof = libc.func("f", "strtof", "sp")
except OSError:
# Some libc's (e.g. Android's Bionic) define strtof as macro/inline func
# in terms of strtod().
print("SKIP")
raise SystemExit
print("%.6f" % strtof("1.23", None))
strtod = libc.func("d", "strtod", "sp")
print("%.6f" % strtod("1.23", None))
# test passing double and float args
libm = ffi_open(("libm.so", "libm.so.6", "libc.so.0", "libc.so.6", "libc.dylib"))
tgamma = libm.func("d", "tgamma", "d")
for fun_name in ("tgamma",):
fun = globals()[fun_name]
for val in (0.5, 1, 1.0, 1.5, 4, 4.0):
print(fun_name, "%.5f" % fun(val))
# test passing 2x float/double args
powf = libm.func("f", "powf", "ff")
pow = libm.func("d", "pow", "dd")
for fun_name in ("powf", "pow"):
fun = globals()[fun_name]
for args in ((0, 1), (1, 0), (2, 0.5), (3, 4)):
print(fun_name, "%.5f" % fun(*args))
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/unix/ffi_float.py
|
Python
|
apache-2.0
| 1,259
|
# test ffi float support
try:
import ffi
except ImportError:
print("SKIP")
raise SystemExit
def ffi_open(names):
err = None
for n in names:
try:
mod = ffi.open(n)
return mod
except OSError as e:
err = e
raise err
libm = ffi_open(("libm.so", "libm.so.6", "libc.so.0", "libc.so.6", "libc.dylib"))
# Some libc's implement tgammaf as header macro with tgamma(), so don't assume
# it'll be in library.
try:
tgammaf = libm.func("f", "tgammaf", "f")
except OSError:
print("SKIP")
raise SystemExit
for fun in (tgammaf,):
for val in (0.5, 1, 1.0, 1.5, 4, 4.0):
print("%.6f" % fun(val))
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/unix/ffi_float2.py
|
Python
|
apache-2.0
| 683
|
#include <stdint.h>
int8_t f8i(int8_t x) {
return x ^ 1;
}
uint8_t f8u(uint8_t x) {
return x ^ 1;
}
int16_t f16i(int16_t x) {
return x ^ 1;
}
uint16_t f16u(uint16_t x) {
return x ^ 1;
}
int32_t f32i(int32_t x) {
return x ^ 1;
}
uint32_t f32u(uint32_t x) {
return x ^ 1;
}
int64_t f64i(int64_t x) {
return x ^ 1;
}
uint64_t f64u(uint64_t x) {
return x ^ 1;
}
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/unix/ffi_lib.c
|
C
|
apache-2.0
| 398
|
# test 8/16/32/64 bit signed/unsigned integer arguments and return types for ffi functions
# requires ffi_lib.c to be compiled as: $(CC) -shared -o ffi_lib.so ffi_lib.c
import uos, usys
try:
import ffi
except ImportError:
print("SKIP")
raise SystemExit
ffi_lib_filename = "./" + usys.argv[0].rsplit("/", 1)[0] + "/ffi_lib.so"
try:
uos.stat(ffi_lib_filename)
except OSError:
print("SKIP")
raise SystemExit
ffi_lib = ffi.open(ffi_lib_filename)
f8i = ffi_lib.func("b", "f8i", "b")
f8u = ffi_lib.func("B", "f8u", "B")
f16i = ffi_lib.func("h", "f16i", "h")
f16u = ffi_lib.func("H", "f16u", "H")
f32i = ffi_lib.func("i", "f32i", "i")
f32u = ffi_lib.func("I", "f32u", "I")
f64i = ffi_lib.func("q", "f64i", "q")
f64u = ffi_lib.func("Q", "f64u", "Q")
for func_name in ("f8i", "f8u", "f16i", "f16u", "f32i", "f32u", "f64i", "f64u"):
func = globals()[func_name]
for val in (
0,
0x7F,
0x80,
0xFF,
0x100,
0x7FFF,
0x8000,
0xFFFF,
0x10000,
0x7FFFFFFF,
0x80000000,
0xFFFFFFFF,
0x100000000,
0x7FFF_FFFF_FFFF_FFFF,
0x8000_0000_0000_0000,
0xFFFF_FFFF_FFFF_FFFF,
0x1_0000_0000_0000_0000,
):
print("{}({:x}) = {:x}".format(func_name, val, func(val)))
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/unix/ffi_types.py
|
Python
|
apache-2.0
| 1,316
|
try:
import utime as time
except ImportError:
import time
DAYS_PER_MONTH = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
tzseconds = -time.mktime((1970, 1, 1, 14, 0, 0, 0, 0, 0))
def is_leap(year):
return (year % 4) == 0
def test():
seconds = 0
wday = 3 # Jan 1, 1970 was a Thursday
for year in range(1970, 2038):
print("Testing %d" % year)
yday = 1
for month in range(1, 13):
if month == 2 and is_leap(year):
DAYS_PER_MONTH[2] = 29
else:
DAYS_PER_MONTH[2] = 28
for day in range(1, DAYS_PER_MONTH[month] + 1):
secs = time.mktime((year, month, day, 14, 0, 0, 0, 0, 0)) + tzseconds
if secs != seconds:
print(
"mktime failed for %d-%02d-%02d got %d expected %d"
% (year, month, day, secs, seconds)
)
return
tuple = time.localtime(seconds)
secs = time.mktime(tuple)
if secs != seconds:
print(
"localtime failed for %d-%02d-%02d got %d expected %d"
% (year, month, day, secs, seconds)
)
return
seconds += 86400
if yday != tuple[7]:
print(
"locatime for %d-%02d-%02d got yday %d, expecting %d"
% (year, month, day, tuple[7], yday)
)
return
if wday != tuple[6]:
print(
"locatime for %d-%02d-%02d got wday %d, expecting %d"
% (year, month, day, tuple[6], wday)
)
return
yday += 1
wday = (wday + 1) % 7
test()
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/unix/time.py
|
Python
|
apache-2.0
| 1,924
|
"""
ADC test for the CC3200 based boards.
"""
from machine import ADC
import os
mch = os.uname().machine
if "LaunchPad" in mch:
adc_pin = "GP5"
adc_channel = 3
elif "WiPy" in mch:
adc_pin = "GP3"
adc_channel = 1
else:
raise Exception("Board not supported!")
adc = ADC(0)
print(adc)
adc = ADC()
print(adc)
adc = ADC(0, bits=12)
print(adc)
apin = adc.channel(adc_channel)
print(apin)
apin = adc.channel(id=adc_channel)
print(apin)
apin = adc.channel(adc_channel, pin=adc_pin)
print(apin)
apin = adc.channel(id=adc_channel, pin=adc_pin)
print(apin)
print(apin.value() > 3000)
print(apin() > 3000)
# de-init must work
apin.deinit()
print(apin)
adc.deinit()
print(adc)
print(apin)
adc.init()
print(adc)
print(apin)
apin.init()
print(apin)
print(apin() > 3000)
# check for memory leaks...
for i in range(0, 1000):
adc = ADC()
apin = adc.channel(adc_channel)
# next ones should raise
try:
adc = ADC(bits=17)
except:
print("Exception")
try:
adc = ADC(id=1)
except:
print("Exception")
try:
adc = ADC(0, 16)
except:
print("Exception")
adc = ADC()
try:
apin = adc.channel(4)
except:
print("Exception")
try:
apin = adc.channel(-1)
except:
print("Exception")
try:
apin = adc.channel(0, pin="GP3")
except:
print("Exception")
apin = adc.channel(1)
apin.deinit()
try:
apin()
except:
print("Exception")
try:
apin.value()
except:
print("Exception")
adc.deinit()
try:
apin.value()
except:
print("Exception")
try:
apin = adc.channel(1)
except:
print("Exception")
# re-init must work
adc.init()
apin.init()
print(apin)
print(apin() > 3000)
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/adc.py
|
Python
|
apache-2.0
| 1,646
|
"""
I2C test for the CC3200 based boards.
A MPU-9150 sensor must be connected to the I2C bus.
"""
from machine import I2C
import os
import time
mch = os.uname().machine
if "LaunchPad" in mch:
i2c_pins = ("GP11", "GP10")
elif "WiPy" in mch:
i2c_pins = ("GP15", "GP10")
else:
raise Exception("Board not supported!")
i2c = I2C(0, I2C.MASTER, baudrate=400000)
# try initing without the peripheral id
i2c = I2C()
print(i2c)
i2c = I2C(mode=I2C.MASTER, baudrate=50000, pins=i2c_pins)
print(i2c)
i2c = I2C(0, I2C.MASTER, baudrate=100000)
print(i2c)
i2c = I2C(0, mode=I2C.MASTER, baudrate=400000)
print(i2c)
i2c = I2C(0, mode=I2C.MASTER, baudrate=400000, pins=i2c_pins)
print(i2c)
addr = i2c.scan()[0]
print(addr)
reg = bytearray(1)
reg2 = bytearray(2)
reg2_r = bytearray(2)
# reset the sensor
reg[0] |= 0x80
print(1 == i2c.writeto_mem(addr, 107, reg))
time.sleep_ms(100) # wait for the sensor to reset...
print(1 == i2c.readfrom_mem_into(addr, 107, reg)) # read the power management register 1
print(0x40 == reg[0])
# now just read one byte
data = i2c.readfrom_mem(addr, 117, 1) # read the "who am I?" register
print(0x68 == data[0])
print(len(data) == 1)
print(1 == i2c.readfrom_mem_into(addr, 117, reg)) # read the "who am I?" register again
print(0x68 == reg[0])
# now try reading two bytes
data = i2c.readfrom_mem(addr, 116, 2) # read the "who am I?" register
print(0x68 == data[1])
print(data == b"\x00\x68")
print(len(data) == 2)
print(2 == i2c.readfrom_mem_into(addr, 116, reg2)) # read the "who am I?" register again
print(0x68 == reg2[1])
print(reg2 == b"\x00\x68")
print(1 == i2c.readfrom_mem_into(addr, 107, reg)) # read the power management register 1
print(0x40 == reg[0])
# clear the sleep bit
reg[0] = 0
print(1 == i2c.writeto_mem(addr, 107, reg))
# read it back
i2c.readfrom_mem_into(addr, 107, reg)
print(0 == reg[0])
# set the sleep bit
reg[0] = 0x40
print(1 == i2c.writeto_mem(addr, 107, reg))
# read it back
i2c.readfrom_mem_into(addr, 107, reg)
print(0x40 == reg[0])
# reset the sensor
reg[0] |= 0x80
print(1 == i2c.writeto_mem(addr, 107, reg))
time.sleep_ms(100) # wait for the sensor to reset...
# now read and write two register at a time
print(2 == i2c.readfrom_mem_into(addr, 107, reg2))
print(0x40 == reg2[0])
print(0x00 == reg2[1])
# clear the sleep bit
reg2[0] = 0
# set some other bits
reg2[1] |= 0x03
print(2 == i2c.writeto_mem(addr, 107, reg2))
# read it back
i2c.readfrom_mem_into(addr, 107, reg2_r)
print(reg2 == reg2_r)
# reset the sensor
reg[0] = 0x80
print(1 == i2c.writeto_mem(addr, 107, reg))
time.sleep_ms(100) # wait for the sensor to reset...
# try some raw read and writes
reg[0] = 117 # register address
print(1 == i2c.writeto(addr, reg, stop=False)) # just write the register address
# now read
print(1 == i2c.readfrom_into(addr, reg))
print(reg[0] == 0x68)
reg[0] = 117 # register address
print(1 == i2c.writeto(addr, reg, stop=False)) # just write the register address
# now read
print(0x68 == i2c.readfrom(addr, 1)[0])
i2c.readfrom_mem_into(addr, 107, reg2)
print(0x40 == reg2[0])
print(0x00 == reg2[1])
reg2[0] = 107 # register address
reg2[1] = 0
print(2 == i2c.writeto(addr, reg2, stop=True)) # write the register address and the data
i2c.readfrom_mem_into(addr, 107, reg) # check it back
print(reg[0] == 0)
# check for memory leaks...
for i in range(0, 1000):
i2c = I2C(0, I2C.MASTER, baudrate=100000)
# test deinit
i2c = I2C(0, I2C.MASTER, baudrate=100000)
i2c.deinit()
print(i2c)
# next ones should raise
try:
i2c.scan()
except Exception:
print("Exception")
try:
i2c.readfrom(addr, 1)
except Exception:
print("Exception")
try:
i2c.readfrom_into(addr, reg)
except Exception:
print("Exception")
try:
i2c.readfrom_mem_into(addr, 107, reg)
except Exception:
print("Exception")
try:
i2c.writeto(addr, reg, stop=False)
except Exception:
print("Exception")
try:
i2c.writeto_mem(addr, 107, reg)
except Exception:
print("Exception")
try:
i2c.readfrom_mem(addr, 116, 2)
except Exception:
print("Exception")
try:
I2C(1, I2C.MASTER, baudrate=100000)
except Exception:
print("Exception")
# reinitialization must work
i2c.init(baudrate=400000)
print(i2c)
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/i2c.py
|
Python
|
apache-2.0
| 4,212
|
"""
wipy module test for the CC3200 based boards
"""
import os
import wipy
mch = os.uname().machine
if not "LaunchPad" in mch and not "WiPy" in mch:
raise Exception("Board not supported!")
print(wipy.heartbeat() == True)
wipy.heartbeat(False)
print(wipy.heartbeat() == False)
wipy.heartbeat(True)
print(wipy.heartbeat() == True)
try:
wipy.heartbeat(True, 1)
except:
print("Exception")
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/modwipy.py
|
Python
|
apache-2.0
| 401
|
"""
os module test for the CC3200 based boards
"""
from machine import SD
import os
mch = os.uname().machine
if "LaunchPad" in mch:
sd_pins = ("GP16", "GP17", "GP15")
elif "WiPy" in mch:
sd_pins = ("GP10", "GP11", "GP15")
else:
raise Exception("Board not supported!")
sd = SD(pins=sd_pins)
os.mount(sd, "/sd")
os.mkfs("/sd")
os.chdir("/flash")
print(os.listdir())
os.chdir("/sd")
print(os.listdir())
# create a test directory in flash
os.mkdir("/flash/test")
os.chdir("/flash/test")
print(os.getcwd())
os.chdir("..")
print(os.getcwd())
os.chdir("test")
print(os.getcwd())
# create a new file
f = open("test.txt", "w")
test_bytes = os.urandom(1024)
n_w = f.write(test_bytes)
print(n_w == len(test_bytes))
f.close()
f = open("test.txt", "r")
r = bytes(f.read(), "ascii")
# check that we can write and read it correctly
print(r == test_bytes)
f.close()
os.rename("test.txt", "newtest.txt")
print(os.listdir())
os.rename("/flash/test", "/flash/newtest")
print(os.listdir("/flash"))
os.remove("newtest.txt")
os.chdir("..")
os.rmdir("newtest")
# create a test directory in the sd card
os.mkdir("/sd/test")
os.chdir("/sd/test")
print(os.getcwd())
os.chdir("..")
print(os.getcwd())
os.chdir("test")
print(os.getcwd())
# create a new file
f = open("test.txt", "w")
test_bytes = os.urandom(1024)
n_w = f.write(test_bytes)
print(n_w == len(test_bytes))
f.close()
f = open("test.txt", "r")
r = bytes(f.read(), "ascii")
# check that we can write and read it correctly
print(r == test_bytes)
f.close()
print("CC3200" in os.uname().machine)
print("WiPy" == os.uname().sysname)
os.sync()
os.stat("/flash")
os.stat("/flash/sys")
os.stat("/flash/boot.py")
os.stat("/sd")
os.stat("/")
os.chdir("/sd/test")
os.remove("test.txt")
os.chdir("/sd")
os.rmdir("test")
os.listdir("/sd")
print(os.listdir("/"))
os.unmount("/sd")
print(os.listdir("/"))
os.mkfs(sd)
os.mount(sd, "/sd")
print(os.listdir("/"))
os.chdir("/flash")
# next ones must raise
sd.deinit()
try:
os.listdir("/sd")
except:
print("Exception")
# re-initialization must work
sd.init()
print(os.listdir("/sd"))
try:
os.mount(sd, "/sd")
except:
print("Exception")
try:
os.mount(sd, "/sd2")
except:
print("Exception")
os.unmount("/sd")
try:
os.listdir("/sd")
except:
print("Exception")
try:
os.unmount("/flash")
except:
print("Exception")
try:
os.unmount("/something")
except:
print("Exception")
try:
os.unmount("something")
except:
print("Exception")
try:
os.mkfs("flash") # incorrect path format
except:
print("Exception")
try:
os.remove("/flash/nofile.txt")
except:
print("Exception")
try:
os.rename("/flash/nofile.txt", "/flash/nofile2.txt")
except:
print("Exception")
try:
os.chdir("/flash/nodir")
except:
print("Exception")
try:
os.listdir("/flash/nodir")
except:
print("Exception")
os.mount(sd, "/sd")
print(os.listdir("/"))
os.unmount("/sd")
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/os.py
|
Python
|
apache-2.0
| 2,917
|
"""
This test need a set of pins which can be set as inputs and have no external
pull up or pull down connected.
GP12 and GP17 must be connected together
"""
from machine import Pin
import os
mch = os.uname().machine
if "LaunchPad" in mch:
pin_map = [
"GP24",
"GP12",
"GP14",
"GP15",
"GP16",
"GP17",
"GP28",
"GP8",
"GP6",
"GP30",
"GP31",
"GP3",
"GP0",
"GP4",
"GP5",
]
max_af_idx = 15
elif "WiPy" in mch:
pin_map = [
"GP23",
"GP24",
"GP12",
"GP13",
"GP14",
"GP9",
"GP17",
"GP28",
"GP22",
"GP8",
"GP30",
"GP31",
"GP0",
"GP4",
"GP5",
]
max_af_idx = 15
else:
raise Exception("Board not supported!")
# test initial value
p = Pin("GP12", Pin.IN)
Pin("GP17", Pin.OUT, value=1)
print(p() == 1)
Pin("GP17", Pin.OUT, value=0)
print(p() == 0)
def test_noinit():
for p in pin_map:
pin = Pin(p)
pin.value()
def test_pin_read(pull):
# enable the pull resistor on all pins, then read the value
for p in pin_map:
pin = Pin(p, mode=Pin.IN, pull=pull)
for p in pin_map:
print(pin())
def test_pin_af():
for p in pin_map:
for af in Pin(p).alt_list():
if af[1] <= max_af_idx:
Pin(p, mode=Pin.ALT, alt=af[1])
Pin(p, mode=Pin.ALT_OPEN_DRAIN, alt=af[1])
# test un-initialized pins
test_noinit()
# test with pull-up and pull-down
test_pin_read(Pin.PULL_UP)
test_pin_read(Pin.PULL_DOWN)
# test all constructor combinations
pin = Pin(pin_map[0])
pin = Pin(pin_map[0], mode=Pin.IN)
pin = Pin(pin_map[0], mode=Pin.OUT)
pin = Pin(pin_map[0], mode=Pin.IN, pull=Pin.PULL_DOWN)
pin = Pin(pin_map[0], mode=Pin.IN, pull=Pin.PULL_UP)
pin = Pin(pin_map[0], mode=Pin.OPEN_DRAIN, pull=Pin.PULL_UP)
pin = Pin(pin_map[0], mode=Pin.OUT, pull=Pin.PULL_DOWN)
pin = Pin(pin_map[0], mode=Pin.OUT, pull=None)
pin = Pin(pin_map[0], mode=Pin.OUT, pull=Pin.PULL_UP)
pin = Pin(pin_map[0], mode=Pin.OUT, pull=Pin.PULL_UP, drive=pin.LOW_POWER)
pin = Pin(pin_map[0], mode=Pin.OUT, pull=Pin.PULL_UP, drive=pin.MED_POWER)
pin = Pin(pin_map[0], mode=Pin.OUT, pull=Pin.PULL_UP, drive=pin.HIGH_POWER)
pin = Pin(pin_map[0], mode=Pin.OUT, drive=pin.LOW_POWER)
pin = Pin(pin_map[0], Pin.OUT, Pin.PULL_DOWN)
pin = Pin(pin_map[0], Pin.ALT, Pin.PULL_UP)
pin = Pin(pin_map[0], Pin.ALT_OPEN_DRAIN, Pin.PULL_UP)
test_pin_af() # try the entire af range on all pins
# test pin init and printing
pin = Pin(pin_map[0])
pin.init(mode=Pin.IN)
print(pin)
pin.init(Pin.IN, Pin.PULL_DOWN)
print(pin)
pin.init(mode=Pin.OUT, pull=Pin.PULL_UP, drive=pin.LOW_POWER)
print(pin)
pin.init(mode=Pin.OUT, pull=Pin.PULL_UP, drive=pin.HIGH_POWER)
print(pin)
# test value in OUT mode
pin = Pin(pin_map[0], mode=Pin.OUT)
pin.value(0)
pin.toggle() # test toggle
print(pin())
pin.toggle() # test toggle again
print(pin())
# test different value settings
pin(1)
print(pin.value())
pin(0)
print(pin.value())
pin.value(1)
print(pin())
pin.value(0)
print(pin())
# test all getters and setters
pin = Pin(pin_map[0], mode=Pin.OUT)
# mode
print(pin.mode() == Pin.OUT)
pin.mode(Pin.IN)
print(pin.mode() == Pin.IN)
# pull
pin.pull(None)
print(pin.pull() == None)
pin.pull(Pin.PULL_DOWN)
print(pin.pull() == Pin.PULL_DOWN)
# drive
pin.drive(Pin.MED_POWER)
print(pin.drive() == Pin.MED_POWER)
pin.drive(Pin.HIGH_POWER)
print(pin.drive() == Pin.HIGH_POWER)
# id
print(pin.id() == pin_map[0])
# all the next ones MUST raise
try:
pin = Pin(pin_map[0], mode=Pin.OUT, pull=Pin.PULL_UP, drive=pin.IN) # incorrect drive value
except Exception:
print("Exception")
try:
pin = Pin(pin_map[0], mode=Pin.LOW_POWER, pull=Pin.PULL_UP) # incorrect mode value
except Exception:
print("Exception")
try:
pin = Pin(pin_map[0], mode=Pin.IN, pull=Pin.HIGH_POWER) # incorrect pull value
except Exception:
print("Exception")
try:
pin = Pin("A0", Pin.OUT, Pin.PULL_DOWN) # incorrect pin id
except Exception:
print("Exception")
try:
pin = Pin(pin_map[0], Pin.IN, Pin.PULL_UP, alt=0) # af specified in GPIO mode
except Exception:
print("Exception")
try:
pin = Pin(pin_map[0], Pin.OUT, Pin.PULL_UP, alt=7) # af specified in GPIO mode
except Exception:
print("Exception")
try:
pin = Pin(pin_map[0], Pin.ALT, Pin.PULL_UP, alt=0) # incorrect af
except Exception:
print("Exception")
try:
pin = Pin(pin_map[0], Pin.ALT_OPEN_DRAIN, Pin.PULL_UP, alt=-1) # incorrect af
except Exception:
print("Exception")
try:
pin = Pin(pin_map[0], Pin.ALT_OPEN_DRAIN, Pin.PULL_UP, alt=16) # incorrect af
except Exception:
print("Exception")
try:
pin.mode(Pin.PULL_UP) # incorrect pin mode
except Exception:
print("Exception")
try:
pin.pull(Pin.OUT) # incorrect pull
except Exception:
print("Exception")
try:
pin.drive(Pin.IN) # incorrect drive strength
except Exception:
print("Exception")
try:
pin.id("ABC") # id cannot be set
except Exception:
print("Exception")
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/pin.py
|
Python
|
apache-2.0
| 5,135
|
"""
Pin IRQ test for the CC3200 based boards.
"""
from machine import Pin
import machine
import os
import time
mch = os.uname().machine
if "LaunchPad" in mch:
pins = ["GP16", "GP13"]
elif "WiPy" in mch:
pins = ["GP16", "GP13"]
else:
raise Exception("Board not supported!")
pin0 = Pin(pins[0], mode=Pin.OUT, value=1)
pin1 = Pin(pins[1], mode=Pin.IN, pull=Pin.PULL_UP)
def pin_handler(pin_o):
global pin_irq_count_trigger
global pin_irq_count_total
global _trigger
if _trigger & pin1_irq.flags():
pin_irq_count_trigger += 1
pin_irq_count_total += 1
pin_irq_count_trigger = 0
pin_irq_count_total = 0
_trigger = Pin.IRQ_FALLING
pin1_irq = pin1.irq(trigger=_trigger, handler=pin_handler)
for i in range(0, 10):
pin0.toggle()
time.sleep_ms(5)
print(pin_irq_count_trigger == 5)
print(pin_irq_count_total == 5)
pin_irq_count_trigger = 0
pin_irq_count_total = 0
_trigger = Pin.IRQ_RISING
pin1_irq = pin1.irq(trigger=_trigger, handler=pin_handler)
for i in range(0, 200):
pin0.toggle()
time.sleep_ms(5)
print(pin_irq_count_trigger == 100)
print(pin_irq_count_total == 100)
pin1_irq.disable()
pin0(1)
pin_irq_count_trigger = 0
pin_irq_count_total = 0
_trigger = Pin.IRQ_FALLING
pin1_irq.init(trigger=_trigger, handler=pin_handler)
pin0(0)
time.sleep_us(50)
print(pin_irq_count_trigger == 1)
print(pin_irq_count_total == 1)
pin0(1)
time.sleep_us(50)
print(pin_irq_count_trigger == 1)
print(pin_irq_count_total == 1)
# check the call method
pin1_irq()
print(pin_irq_count_trigger == 1) # no flags since the irq was manually triggered
print(pin_irq_count_total == 2)
pin1_irq.disable()
pin_irq_count_trigger = 0
pin_irq_count_total = 0
for i in range(0, 10):
pin0.toggle()
time.sleep_ms(5)
print(pin_irq_count_trigger == 0)
print(pin_irq_count_total == 0)
# test waking up from suspended mode on low level
pin0(0)
t0 = time.ticks_ms()
pin1_irq.init(trigger=Pin.IRQ_LOW_LEVEL, wake=machine.SLEEP)
machine.sleep()
print(time.ticks_ms() - t0 < 10)
print("Awake")
# test waking up from suspended mode on high level
pin0(1)
t0 = time.ticks_ms()
pin1_irq.init(trigger=Pin.IRQ_HIGH_LEVEL, wake=machine.SLEEP)
machine.sleep()
print(time.ticks_ms() - t0 < 10)
print("Awake")
# check for memory leaks
for i in range(0, 1000):
pin0_irq = pin0.irq(trigger=_trigger, handler=pin_handler)
pin1_irq = pin1.irq(trigger=_trigger, handler=pin_handler)
# next ones must raise
try:
pin1_irq.init(trigger=123456, handler=pin_handler)
except:
print("Exception")
try:
pin1_irq.init(trigger=Pin.IRQ_LOW_LEVEL, wake=1789456)
except:
print("Exception")
try:
pin0_irq = pin0.irq(
trigger=Pin.IRQ_RISING, wake=machine.SLEEP
) # GP16 can't wake up from DEEPSLEEP
except:
print("Exception")
pin0_irq.disable()
pin1_irq.disable()
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/pin_irq.py
|
Python
|
apache-2.0
| 2,813
|
"""
Reset script for the cc3200 boards
This is needed to force the board to reboot
with the default WLAN AP settings
"""
from machine import WDT
import time
import os
mch = os.uname().machine
if not "LaunchPad" in mch and not "WiPy" in mch:
raise Exception("Board not supported!")
wdt = WDT(timeout=1000)
print(wdt)
time.sleep_ms(900)
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/reset/reset.py
|
Python
|
apache-2.0
| 342
|
"""
RTC test for the CC3200 based boards.
"""
from machine import RTC
import os
import time
mch = os.uname().machine
if not "LaunchPad" in mch and not "WiPy" in mch:
raise Exception("Board not supported!")
rtc = RTC()
print(rtc)
print(rtc.now()[:6])
rtc = RTC(datetime=(2015, 8, 29, 9, 0, 0, 0, None))
print(rtc.now()[:6])
rtc.deinit()
print(rtc.now()[:6])
rtc.init((2015, 8, 29, 9, 0, 0, 0, None))
print(rtc.now()[:6])
seconds = rtc.now()[5]
time.sleep_ms(1000)
print(rtc.now()[5] - seconds == 1)
seconds = rtc.now()[5]
time.sleep_ms(2000)
print(rtc.now()[5] - seconds == 2)
# initialization with shorter tuples
rtc.init((2015, 9, 19, 8, 0, 0, 0))
print(rtc.now()[5])
rtc.init((2015, 9, 19, 8, 0, 0))
print(rtc.now()[5])
rtc.init((2015, 9, 19, 8, 0))
print(rtc.now()[5])
rtc.init((2015, 9, 19, 8))
print(rtc.now()[4])
rtc.init((2015, 9, 19))
print(rtc.now()[3])
def set_and_print(datetime):
rtc.init(datetime)
print(rtc.now()[:6])
# make sure that setting works correctly
set_and_print((2000, 1, 1, 0, 0, 0, 0, None))
set_and_print((2000, 1, 31, 0, 0, 0, 0, None))
set_and_print((2000, 12, 31, 0, 0, 0, 0, None))
set_and_print((2016, 12, 31, 0, 0, 0, 0, None))
set_and_print((2016, 12, 31, 0, 0, 0, 0, None))
set_and_print((2016, 12, 31, 1, 0, 0, 0, None))
set_and_print((2016, 12, 31, 12, 0, 0, 0, None))
set_and_print((2016, 12, 31, 13, 0, 0, 0, None))
set_and_print((2016, 12, 31, 23, 0, 0, 0, None))
set_and_print((2016, 12, 31, 23, 1, 0, 0, None))
set_and_print((2016, 12, 31, 23, 59, 0, 50, None))
set_and_print((2016, 12, 31, 23, 59, 1, 900, None))
set_and_print((2016, 12, 31, 23, 59, 59, 100, None))
set_and_print((2048, 12, 31, 23, 59, 59, 99999, None))
rtc.init((2015, 8, 29, 9, 0, 0, 0, None))
rtc.alarm(0, 5000)
rtc.alarm(time=2000)
time.sleep_ms(1000)
left = rtc.alarm_left()
print(abs(left - 1000) <= 10)
time.sleep_ms(1000)
print(rtc.alarm_left() == 0)
time.sleep_ms(100)
print(rtc.alarm_left(0) == 0)
rtc.alarm(time=1000, repeat=True)
time.sleep_ms(1500)
left = rtc.alarm_left()
print(abs(left - 500) <= 15)
rtc.init((2015, 8, 29, 9, 0, 0, 0, None))
rtc.alarm(time=(2015, 8, 29, 9, 0, 45))
time.sleep_ms(1000)
left = rtc.alarm_left()
print(abs(left - 44000) <= 90)
rtc.alarm_cancel()
rtc.deinit()
# next ones must raise
try:
rtc.alarm(5000)
except:
print("Exception")
try:
rtc.alarm_left(1)
except:
print("Exception")
try:
rtc.alarm_cancel(1)
except:
print("Exception")
try:
rtc.alarm(5000)
except:
print("Exception")
try:
rtc = RTC(200000000)
except:
print("Exception")
try:
rtc = RTC((2015, 8, 29, 9, 0, 0, 0, None))
except:
print("Exception")
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/rtc.py
|
Python
|
apache-2.0
| 2,644
|
"""
SD card test for the CC3200 based boards.
"""
from machine import SD
import os
mch = os.uname().machine
if "LaunchPad" in mch:
sd_pins = ("GP16", "GP17", "GP15")
elif "WiPy" in mch:
sd_pins = ("GP10", "GP11", "GP15")
else:
raise Exception("Board not supported!")
sd = SD(pins=sd_pins)
print(sd)
sd.deinit()
print(sd)
sd.init(sd_pins)
print(sd)
sd = SD(0, pins=sd_pins)
sd = SD(id=0, pins=sd_pins)
sd = SD(0, sd_pins)
# check for memory leaks
for i in range(0, 1000):
sd = sd = SD(0, pins=sd_pins)
# next ones should raise
try:
sd = SD(pins=())
except Exception:
print("Exception")
try:
sd = SD(pins=("GP10", "GP11", "GP8"))
except Exception:
print("Exception")
try:
sd = SD(pins=("GP10", "GP11"))
except Exception:
print("Exception")
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/sd.py
|
Python
|
apache-2.0
| 786
|
"""
RTC IRQ test for the CC3200 based boards.
"""
from machine import RTC
import machine
import os
import time
mch = os.uname().machine
if not "LaunchPad" in mch and not "WiPy" in mch:
raise Exception("Board not supported!")
def rtc_ticks_ms(rtc):
timedate = rtc.now()
return (timedate[5] * 1000) + (timedate[6] // 1000)
rtc_irq_count = 0
def alarm_handler(rtc_o):
global rtc_irq
global rtc_irq_count
if rtc_irq.flags() & RTC.ALARM0:
rtc_irq_count += 1
rtc = RTC()
rtc.alarm(time=500, repeat=True)
rtc_irq = rtc.irq(trigger=RTC.ALARM0, handler=alarm_handler)
# active mode
time.sleep_ms(1000)
rtc.alarm_cancel()
print(rtc_irq_count == 2)
rtc_irq_count = 0
rtc.alarm(time=200, repeat=True)
time.sleep_ms(1000)
rtc.alarm_cancel()
print(rtc_irq_count == 5)
rtc_irq_count = 0
rtc.alarm(time=100, repeat=True)
time.sleep_ms(1000)
rtc.alarm_cancel()
print(rtc_irq_count == 10)
# deep sleep mode
rtc.alarm_cancel()
rtc_irq_count = 0
rtc.alarm(time=50, repeat=True)
rtc_irq.init(trigger=RTC.ALARM0, handler=alarm_handler, wake=machine.SLEEP | machine.IDLE)
while rtc_irq_count < 3:
machine.sleep()
print(rtc_irq_count == 3)
# no repetition
rtc.alarm_cancel()
rtc_irq_count = 0
rtc.alarm(time=100, repeat=False)
time.sleep_ms(250)
print(rtc_irq_count == 1)
rtc.alarm_cancel()
t0 = rtc_ticks_ms(rtc)
rtc.alarm(time=500, repeat=False)
machine.sleep()
t1 = rtc_ticks_ms(rtc)
print(abs(t1 - t0 - 500) < 20)
# deep sleep repeated mode
rtc.alarm_cancel()
rtc_irq_count = 0
rtc.alarm(time=500, repeat=True)
t0 = rtc_ticks_ms(rtc)
rtc_irq = rtc.irq(trigger=RTC.ALARM0, handler=alarm_handler, wake=machine.SLEEP)
while rtc_irq_count < 3:
machine.sleep()
t1 = rtc_ticks_ms(rtc)
print(abs(t1 - t0 - (500 * rtc_irq_count)) < 25)
# next ones must raise
try:
rtc_irq = rtc.irq(trigger=10, handler=alarm_handler)
except:
print("Exception")
try:
rtc_irq = rtc.irq(trigger=RTC.ALARM0, wake=1789456)
except:
print("Exception")
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/skipped/rtc_irq.py
|
Python
|
apache-2.0
| 1,982
|
"""
SPI test for the CC3200 based boards.
"""
from machine import SPI
import os
mch = os.uname().machine
if "LaunchPad" in mch:
spi_pins = ("GP14", "GP16", "GP30")
elif "WiPy" in mch:
spi_pins = ("GP14", "GP16", "GP30")
else:
raise Exception("Board not supported!")
spi = SPI(0, SPI.MASTER, baudrate=2000000, polarity=0, phase=0, firstbit=SPI.MSB, pins=spi_pins)
print(spi)
spi = SPI(baudrate=5000000)
print(spi)
spi = SPI(0, SPI.MASTER, baudrate=200000, bits=16, polarity=0, phase=0)
print(spi)
spi = SPI(0, SPI.MASTER, baudrate=10000000, polarity=0, phase=1)
print(spi)
spi = SPI(0, SPI.MASTER, baudrate=5000000, bits=32, polarity=1, phase=0)
print(spi)
spi = SPI(0, SPI.MASTER, baudrate=10000000, polarity=1, phase=1)
print(spi)
spi.init(baudrate=20000000, polarity=0, phase=0)
print(spi)
spi = SPI()
print(spi)
SPI(mode=SPI.MASTER)
SPI(mode=SPI.MASTER, pins=spi_pins)
SPI(id=0, mode=SPI.MASTER, polarity=0, phase=0, pins=("GP14", "GP16", "GP15"))
SPI(0, SPI.MASTER, polarity=0, phase=0, pins=("GP31", "GP16", "GP15"))
spi = SPI(0, SPI.MASTER, baudrate=10000000, polarity=0, phase=0, pins=spi_pins)
print(spi.write("123456") == 6)
buffer_r = bytearray(10)
print(spi.readinto(buffer_r) == 10)
print(spi.readinto(buffer_r, write=0x55) == 10)
read = spi.read(10)
print(len(read) == 10)
read = spi.read(10, write=0xFF)
print(len(read) == 10)
buffer_w = bytearray([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])
print(spi.write_readinto(buffer_w, buffer_r) == 10)
print(buffer_w == buffer_r)
# test all polaritiy and phase combinations
spi.init(polarity=1, phase=0, pins=None)
buffer_r = bytearray(10)
spi.write_readinto(buffer_w, buffer_r)
print(buffer_w == buffer_r)
spi.init(polarity=1, phase=1, pins=None)
buffer_r = bytearray(10)
spi.write_readinto(buffer_w, buffer_r)
print(buffer_w == buffer_r)
spi.init(polarity=0, phase=1, pins=None)
buffer_r = bytearray(10)
spi.write_readinto(buffer_w, buffer_r)
print(buffer_w == buffer_r)
# test 16 and 32 bit transfers
buffer_w = bytearray([1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2])
buffer_r = bytearray(12)
spi.init(SPI.MASTER, baudrate=10000000, bits=16, polarity=0, phase=0, pins=None)
print(spi.write_readinto(buffer_w, buffer_r) == 12)
print(buffer_w == buffer_r)
buffer_r = bytearray(12)
spi.init(SPI.MASTER, baudrate=10000000, bits=32, polarity=0, phase=0, pins=None)
print(spi.write_readinto(buffer_w, buffer_r) == 12)
print(buffer_w == buffer_r)
# check for memory leaks...
for i in range(0, 1000):
spi = SPI(0, SPI.MASTER, baudrate=1000000)
# test deinit
spi = SPI(0, SPI.MASTER, baudrate=1000000)
spi.deinit()
print(spi)
spi = SPI(0, SPI.MASTER, baudrate=1000000)
# next ones must fail
try:
spi = SPI(0, 10, baudrate=10000000, polarity=0, phase=0)
except:
print("Exception")
try:
spi = SPI(0, mode=SPI.MASTER, baudrate=10000000, polarity=1, phase=2)
except:
print("Exception")
try:
spi = SPI(1, mode=SPI.MASTER, baudrate=10000000, polarity=1, phase=1)
except:
print("Exception")
try:
spi = SPI(0, mode=SPI.MASTER, baudrate=2000000, polarity=2, phase=0)
except:
print("Exception")
try:
spi = SPI(0, mode=SPI.MASTER, baudrate=2000000, polarity=2, phase=0, firstbit=2)
except:
print("Exception")
try:
spi = SPI(0, mode=SPI.MASTER, baudrate=2000000, polarity=2, phase=0, pins=("GP1", "GP2"))
except:
print("Exception")
try:
spi = SPI(0, mode=SPI.MASTER, baudrate=2000000, polarity=0, phase=0, bits=9)
except:
print("Exception")
spi.deinit()
try:
spi.read(15)
except Exception:
print("Exception")
try:
spi.spi.readinto(buffer_r)
except Exception:
print("Exception")
try:
spi.spi.write("abc")
except Exception:
print("Exception")
try:
spi.write_readinto(buffer_w, buffer_r)
except Exception:
print("Exception")
# reinitialization must work
spi.init(baudrate=500000)
print(spi)
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/spi.py
|
Python
|
apache-2.0
| 3,833
|
import time
DAYS_PER_MONTH = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
def is_leap(year):
return (year % 4) == 0
def test():
seconds = 0
wday = 5 # Jan 1, 2000 was a Saturday
for year in range(2000, 2049):
print("Testing %d" % year)
yday = 1
for month in range(1, 13):
if month == 2 and is_leap(year):
DAYS_PER_MONTH[2] = 29
else:
DAYS_PER_MONTH[2] = 28
for day in range(1, DAYS_PER_MONTH[month] + 1):
secs = time.mktime((year, month, day, 0, 0, 0, 0, 0))
if secs != seconds:
print(
"mktime failed for %d-%02d-%02d got %d expected %d"
% (year, month, day, secs, seconds)
)
tuple = time.localtime(seconds)
secs = time.mktime(tuple)
if secs != seconds:
print(
"localtime failed for %d-%02d-%02d got %d expected %d"
% (year, month, day, secs, seconds)
)
return
seconds += 86400
if yday != tuple[7]:
print(
"locatime for %d-%02d-%02d got yday %d, expecting %d"
% (year, month, day, tuple[7], yday)
)
return
if wday != tuple[6]:
print(
"locatime for %d-%02d-%02d got wday %d, expecting %d"
% (year, month, day, tuple[6], wday)
)
return
yday += 1
wday = (wday + 1) % 7
def spot_test(seconds, expected_time):
actual_time = time.localtime(seconds)
for i in range(len(actual_time)):
if actual_time[i] != expected_time[i]:
print(
"time.localtime(", seconds, ") returned", actual_time, "expecting", expected_time
)
return
print("time.localtime(", seconds, ") returned", actual_time, "(pass)")
test()
# fmt: off
spot_test( 0, (2000, 1, 1, 0, 0, 0, 5, 1))
spot_test( 1, (2000, 1, 1, 0, 0, 1, 5, 1))
spot_test( 59, (2000, 1, 1, 0, 0, 59, 5, 1))
spot_test( 60, (2000, 1, 1, 0, 1, 0, 5, 1))
spot_test( 3599, (2000, 1, 1, 0, 59, 59, 5, 1))
spot_test( 3600, (2000, 1, 1, 1, 0, 0, 5, 1))
spot_test( -1, (1999, 12, 31, 23, 59, 59, 4, 365))
spot_test( 447549467, (2014, 3, 7, 23, 17, 47, 4, 66))
spot_test( -940984933, (1970, 3, 7, 23, 17, 47, 5, 66))
spot_test(-1072915199, (1966, 1, 1, 0, 0, 1, 5, 1))
spot_test(-1072915200, (1966, 1, 1, 0, 0, 0, 5, 1))
spot_test(-1072915201, (1965, 12, 31, 23, 59, 59, 4, 365))
# fmt: on
t1 = time.time()
time.sleep(2)
t2 = time.time()
print(abs(time.ticks_diff(t1, t2) - 2) <= 1)
t1 = time.ticks_ms()
time.sleep_ms(50)
t2 = time.ticks_ms()
print(abs(time.ticks_diff(t1, t2) - 50) <= 1)
t1 = time.ticks_us()
time.sleep_us(1000)
t2 = time.ticks_us()
print(time.ticks_diff(t1, t2) < 1500)
print(time.ticks_diff(time.ticks_cpu(), time.ticks_cpu()) < 16384)
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/time.py
|
Python
|
apache-2.0
| 3,272
|
"""
Timer test for the CC3200 based boards.
"""
from machine import Timer
import os
import time
mch = os.uname().machine
if "LaunchPad" in mch:
pwm_pin = "GP24"
elif "WiPy" in mch:
pwm_pin = "GP24"
else:
raise Exception("Board not supported!")
for i in range(4):
tim = Timer(i, mode=Timer.PERIODIC)
print(tim)
ch = tim.channel(Timer.A, freq=5)
print(ch)
ch = tim.channel(Timer.B, freq=5)
print(ch)
tim = Timer(i, mode=Timer.ONE_SHOT)
print(tim)
ch = tim.channel(Timer.A, freq=50)
print(ch)
ch = tim.channel(Timer.B, freq=50)
print(ch)
tim = Timer(i, mode=Timer.PWM)
print(tim)
ch = tim.channel(Timer.A, freq=50000, duty_cycle=2000, polarity=Timer.POSITIVE)
print(ch)
ch = tim.channel(Timer.B, freq=50000, duty_cycle=8000, polarity=Timer.NEGATIVE)
print(ch)
tim.deinit()
print(tim)
for i in range(4):
tim = Timer(i, mode=Timer.PERIODIC)
tim.deinit()
class TimerTest:
def __init__(self):
self.tim = Timer(0, mode=Timer.PERIODIC)
self.int_count = 0
def timer_isr(self, tim_ch):
self.int_count += 1
timer_test = TimerTest()
ch = timer_test.tim.channel(Timer.A, freq=5)
print(ch.freq() == 5)
ch.irq(handler=timer_test.timer_isr, trigger=Timer.TIMEOUT)
time.sleep_ms(1001)
print(timer_test.int_count == 5)
ch.freq(100)
timer_test.int_count = 0
time.sleep_ms(1001)
print(timer_test.int_count == 100)
ch.freq(1000)
time.sleep_ms(1500)
timer_test.int_count = 0
time.sleep_ms(2000)
print(timer_test.int_count == 2000)
timer_test.tim.deinit()
timer_test.tim.init(mode=Timer.ONE_SHOT)
ch = timer_test.tim.channel(Timer.A, period=100000)
ch.irq(handler=timer_test.timer_isr, trigger=Timer.TIMEOUT)
timer_test.int_count = 0
time.sleep_ms(101)
print(timer_test.int_count == 1)
time.sleep_ms(101)
print(timer_test.int_count == 1)
timer_test.tim.deinit()
print(timer_test.tim)
# 32 bit modes
tim = Timer(0, mode=Timer.PERIODIC, width=32)
ch = tim.channel(Timer.A | Timer.B, period=5000000)
# check for memory leaks...
for i in range(1000):
tim = Timer(0, mode=Timer.PERIODIC)
ch = tim.channel(Timer.A, freq=5)
# next ones must fail
try:
tim = Timer(0, mode=12)
except:
print("Exception")
try:
tim = Timer(4, mode=Timer.ONE_SHOT)
except:
print("Exception")
try:
tim = Timer(0, mode=Timer.PWM, width=32)
except:
print("Exception")
tim = Timer(0, mode=Timer.PWM)
try:
ch = tim.channel(TIMER_A | TIMER_B, freq=10)
except:
print("Exception")
try:
ch = tim.channel(TIMER_A, freq=4)
except:
print("Exception")
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/timer.py
|
Python
|
apache-2.0
| 2,586
|
"""
UART test for the CC3200 based boards.
UART0 and UART1 must be connected together for this test to pass.
"""
from machine import UART
from machine import Pin
import os
import time
mch = os.uname().machine
if "LaunchPad" in mch:
uart_id_range = range(0, 2)
uart_pins = [
[("GP12", "GP13"), ("GP12", "GP13", "GP7", "GP6")],
[("GP16", "GP17"), ("GP16", "GP17", "GP7", "GP6")],
]
elif "WiPy" in mch:
uart_id_range = range(0, 2)
uart_pins = [
[("GP12", "GP13"), ("GP12", "GP13", "GP7", "GP6")],
[("GP16", "GP17"), ("GP16", "GP17", "GP7", "GP6")],
]
else:
raise Exception("Board not supported!")
# just in case we have the repl duplicated on any of the uarts
os.dupterm(None)
for uart_id in uart_id_range:
uart = UART(uart_id, 38400)
print(uart)
uart.init(57600, 8, None, 1, pins=uart_pins[uart_id][0])
uart.init(baudrate=9600, stop=2, parity=UART.EVEN, pins=uart_pins[uart_id][1])
uart.init(baudrate=115200, parity=UART.ODD, stop=0, pins=uart_pins[uart_id][0])
uart = UART(baudrate=1000000)
uart.sendbreak()
uart = UART(baudrate=1000000)
uart = UART()
print(uart)
uart = UART(baudrate=38400, pins=("GP12", "GP13"))
print(uart)
uart = UART(pins=("GP12", "GP13"))
print(uart)
uart = UART(pins=(None, "GP17"))
print(uart)
uart = UART(baudrate=57600, pins=("GP16", "GP17"))
print(uart)
# now it's time for some loopback tests between the uarts
uart0 = UART(0, 1000000, pins=uart_pins[0][0])
print(uart0)
uart1 = UART(1, 1000000, pins=uart_pins[1][0])
print(uart1)
print(uart0.write(b"123456") == 6)
print(uart1.read() == b"123456")
print(uart1.write(b"123") == 3)
print(uart0.read(1) == b"1")
print(uart0.read(2) == b"23")
print(uart0.read() == None)
uart0.write(b"123")
buf = bytearray(3)
print(uart1.readinto(buf, 1) == 1)
print(buf)
print(uart1.readinto(buf) == 2)
print(buf)
# try initializing without the id
uart0 = UART(baudrate=1000000, pins=uart_pins[0][0])
uart0.write(b"1234567890")
time.sleep_ms(2) # because of the fifo interrupt levels
print(uart1.any() == 10)
print(uart1.readline() == b"1234567890")
print(uart1.any() == 0)
uart0.write(b"1234567890")
print(uart1.read() == b"1234567890")
# tx only mode
uart0 = UART(0, 1000000, pins=("GP12", None))
print(uart0.write(b"123456") == 6)
print(uart1.read() == b"123456")
print(uart1.write(b"123") == 3)
print(uart0.read() == None)
# rx only mode
uart0 = UART(0, 1000000, pins=(None, "GP13"))
print(uart0.write(b"123456") == 6)
print(uart1.read() == None)
print(uart1.write(b"123") == 3)
print(uart0.read() == b"123")
# leave pins as they were (rx only mode)
uart0 = UART(0, 1000000, pins=None)
print(uart0.write(b"123456") == 6)
print(uart1.read() == None)
print(uart1.write(b"123") == 3)
print(uart0.read() == b"123")
# no pin assignment
uart0 = UART(0, 1000000, pins=(None, None))
print(uart0.write(b"123456789") == 9)
print(uart1.read() == None)
print(uart1.write(b"123456789") == 9)
print(uart0.read() == None)
print(Pin.board.GP12)
print(Pin.board.GP13)
# check for memory leaks...
for i in range(0, 1000):
uart0 = UART(0, 1000000)
uart1 = UART(1, 1000000)
# next ones must raise
try:
UART(0, 9600, parity=None, pins=("GP12", "GP13", "GP7"))
except Exception:
print("Exception")
try:
UART(0, 9600, parity=UART.ODD, pins=("GP12", "GP7"))
except Exception:
print("Exception")
uart0 = UART(0, 1000000)
uart0.deinit()
try:
uart0.any()
except Exception:
print("Exception")
try:
uart0.read()
except Exception:
print("Exception")
try:
uart0.write("abc")
except Exception:
print("Exception")
try:
uart0.sendbreak("abc")
except Exception:
print("Exception")
try:
UART(2, 9600)
except Exception:
print("Exception")
for uart_id in uart_id_range:
uart = UART(uart_id, 1000000)
uart.deinit()
# test printing an unitialized uart
print(uart)
# initialize it back and check that it works again
uart.init(115200)
print(uart)
uart.read()
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/uart.py
|
Python
|
apache-2.0
| 3,991
|
"""
UART IRQ test for the CC3200 based boards.
"""
from machine import UART
import os
import time
mch = os.uname().machine
if "LaunchPad" in mch:
uart_pins = [
[("GP12", "GP13"), ("GP12", "GP13", "GP7", "GP6")],
[("GP16", "GP17"), ("GP16", "GP17", "GP7", "GP6")],
]
elif "WiPy" in mch:
uart_pins = [
[("GP12", "GP13"), ("GP12", "GP13", "GP7", "GP6")],
[("GP16", "GP17"), ("GP16", "GP17", "GP7", "GP6")],
]
else:
raise Exception("Board not supported!")
# just in case we have stdio duplicated on any of the uarts
os.dupterm(None)
uart0 = UART(0, 1000000, pins=uart_pins[0][0])
uart1 = UART(1, 1000000, pins=uart_pins[1][0])
uart0_int_count = 0
uart1_int_count = 0
def uart0_handler(uart_o):
global uart0_irq
global uart0_int_count
if uart0_irq.flags() & UART.RX_ANY:
uart0_int_count += 1
def uart1_handler(uart_o):
global uart1_irq
global uart1_int_count
if uart1_irq.flags() & UART.RX_ANY:
uart1_int_count += 1
uart0_irq = uart0.irq(trigger=UART.RX_ANY, handler=uart0_handler)
uart1_irq = uart1.irq(trigger=UART.RX_ANY, handler=uart1_handler)
uart0.write(b"123")
# wait for the characters to be received
while not uart1.any():
pass
time.sleep_us(100)
print(uart1.any() == 3)
print(uart1_int_count > 0)
print(uart1_irq.flags() == 0)
print(uart0_irq.flags() == 0)
print(uart1.read() == b"123")
uart1.write(b"12345")
# wait for the characters to be received
while not uart0.any():
pass
time.sleep_us(100)
print(uart0.any() == 5)
print(uart0_int_count > 0)
print(uart0_irq.flags() == 0)
print(uart1_irq.flags() == 0)
print(uart0.read() == b"12345")
# do it again
uart1_int_count = 0
uart0.write(b"123")
# wait for the characters to be received
while not uart1.any():
pass
time.sleep_us(100)
print(uart1.any() == 3)
print(uart1_int_count > 0)
print(uart1_irq.flags() == 0)
print(uart0_irq.flags() == 0)
print(uart1.read() == b"123")
# disable the interrupt
uart1_irq.disable()
# do it again
uart1_int_count = 0
uart0.write(b"123")
# wait for the characters to be received
while not uart1.any():
pass
time.sleep_us(100)
print(uart1.any() == 3)
print(uart1_int_count == 0) # no interrupt triggered this time
print(uart1_irq.flags() == 0)
print(uart0_irq.flags() == 0)
print(uart1.read() == b"123")
# enable the interrupt
uart1_irq.enable()
# do it again
uart1_int_count = 0
uart0.write(b"123")
# wait for the characters to be received
while not uart1.any():
pass
time.sleep_us(100)
print(uart1.any() == 3)
print(uart1_int_count > 0)
print(uart1_irq.flags() == 0)
print(uart0_irq.flags() == 0)
print(uart1.read() == b"123")
uart1_irq.init(trigger=UART.RX_ANY, handler=None) # No handler
# do it again
uart1_int_count = 0
uart0.write(b"123")
# wait for the characters to be received
while not uart1.any():
pass
time.sleep_us(100)
print(uart1.any() == 3)
print(uart1_int_count == 0) # no interrupt handler called
print(uart1_irq.flags() == 0)
print(uart0_irq.flags() == 0)
print(uart1.read() == b"123")
# check for memory leaks
for i in range(0, 1000):
uart0_irq = uart0.irq(trigger=UART.RX_ANY, handler=uart0_handler)
uart1_irq = uart1.irq(trigger=UART.RX_ANY, handler=uart1_handler)
# next ones must raise
try:
uart0_irq = uart0.irq(trigger=100, handler=uart0_handler)
except:
print("Exception")
try:
uart0_irq = uart0.irq(trigger=0)
except:
print("Exception")
try:
uart0_irq = uart0.irq(trigger=UART.RX_ANY, wake=Sleep.SUSPENDED)
except:
print("Exception")
uart0_irq.disable()
uart1_irq.disable()
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/uart_irq.py
|
Python
|
apache-2.0
| 3,569
|
"""
WDT test for the CC3200 based boards
"""
from machine import WDT
import time
# test the invalid cases first
try:
wdt = WDT(1)
except Exception:
print("Exception")
try:
wdt = WDT(0, 500)
except Exception:
print("Exception")
try:
wdt = WDT(1, timeout=2000)
except Exception:
print("Exception")
wdt = WDT(timeout=1000)
print(wdt)
try:
wdt = WDT(0, timeout=2000)
except Exception:
print("Exception")
time.sleep_ms(500)
wdt.feed()
print(wdt)
time.sleep_ms(900)
wdt.feed()
print(wdt)
time.sleep_ms(950)
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/wdt.py
|
Python
|
apache-2.0
| 540
|
"""
machine test for the CC3200 based boards.
"""
import machine
import os
from network import WLAN
mch = os.uname().machine
if not "LaunchPad" in mch and not "WiPy" in mch:
raise Exception("Board not supported!")
wifi = WLAN()
print(machine)
machine.idle()
print(machine.freq() == (80000000,))
print(machine.unique_id() == wifi.mac())
machine.main("main.py")
rand_nums = []
for i in range(0, 100):
rand = machine.rng()
if rand not in rand_nums:
rand_nums.append(rand)
else:
print("RNG number repeated")
break
for i in range(0, 10):
machine.idle()
print("Active")
print(machine.reset_cause() >= 0)
print(machine.wake_reason() >= 0)
try:
machine.main(123456)
except:
print("Exception")
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/wlan/machine.py
|
Python
|
apache-2.0
| 747
|
"""
network server test for the CC3200 based boards.
"""
import os
import network
mch = os.uname().machine
if not "LaunchPad" in mch and not "WiPy" in mch:
raise Exception("Board not supported!")
server = network.Server()
print(server.timeout() == 300)
print(server.isrunning() == True)
server.deinit()
print(server.isrunning() == False)
server.init(login=("test-user", "test-password"), timeout=60)
print(server.isrunning() == True)
print(server.timeout() == 60)
server.deinit()
print(server.isrunning() == False)
server.init()
print(server.isrunning() == True)
try:
server.init(1)
except:
print("Exception")
try:
server.init(0, login=("0000000000011111111111222222222222333333", "abc"))
except:
print("Exception")
try:
server.timeout(1)
except:
print("Exception")
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/wlan/server.py
|
Python
|
apache-2.0
| 803
|
"""
WLAN test for the CC3200 based boards.
"""
from network import WLAN
import os
import time
import testconfig
mch = os.uname().machine
if not "LaunchPad" in mch and not "WiPy" in mch:
raise Exception("Board not supported!")
def wait_for_connection(wifi, timeout=10):
while not wifi.isconnected() and timeout > 0:
time.sleep(1)
timeout -= 1
if wifi.isconnected():
print("Connected")
else:
print("Connection failed!")
wifi = WLAN(0, WLAN.STA)
print(wifi.mode() == WLAN.STA)
print(wifi.antenna() == WLAN.INT_ANT)
wifi = WLAN(mode=WLAN.AP)
print(wifi.mode() == WLAN.AP)
print(wifi.channel() == 1)
print(wifi.auth() == None)
print(wifi.antenna() == WLAN.INT_ANT)
wifi = WLAN(0, mode=WLAN.AP, ssid="test-wlan", auth=(WLAN.WPA, "123456abc"), channel=7)
print(wifi.mode() == WLAN.AP)
print(wifi.channel() == 7)
print(wifi.ssid() == "test-wlan")
print(wifi.auth() == (WLAN.WPA, "123456abc"))
print(wifi.antenna() == WLAN.INT_ANT)
wifi = WLAN(mode=WLAN.STA)
print(wifi.mode() == WLAN.STA)
time.sleep(5) # this ensures a full network scan
scan_r = wifi.scan()
print(len(scan_r) > 3)
for net in scan_r:
if net.ssid == testconfig.wlan_ssid:
# test that the scan results contains the desired params
print(len(net.bssid) == 6)
print(net.channel == None)
print(net.sec == testconfig.wlan_auth[0])
print(net.rssi < 0)
print("Network found")
break
wifi.mode(WLAN.STA)
print(wifi.mode() == WLAN.STA)
wifi.channel(7)
print(wifi.channel() == 7)
wifi.ssid("t-wlan")
print(wifi.ssid() == "t-wlan")
wifi.auth(None)
print(wifi.auth() == None)
wifi.auth((WLAN.WEP, "11223344556677889900"))
print(wifi.auth() == (WLAN.WEP, "11223344556677889900"))
wifi.antenna(WLAN.INT_ANT)
print(wifi.antenna() == WLAN.INT_ANT)
wifi.antenna(WLAN.EXT_ANT)
print(wifi.antenna() == WLAN.EXT_ANT)
time.sleep(2) # this ensures a full network scan
scan_r = wifi.scan()
print(len(scan_r) > 3)
for net in scan_r:
if net.ssid == testconfig.wlan_ssid:
print("Network found")
break
wifi.antenna(WLAN.INT_ANT)
wifi.mode(WLAN.STA)
print(wifi.mode() == WLAN.STA)
wifi.connect(testconfig.wlan_ssid, auth=testconfig.wlan_auth, timeout=10000)
wait_for_connection(wifi)
wifi.ifconfig(config="dhcp")
wait_for_connection(wifi)
print("0.0.0.0" not in wifi.ifconfig())
wifi.ifconfig(0, ("192.168.178.109", "255.255.255.0", "192.168.178.1", "8.8.8.8"))
wait_for_connection(wifi)
print(wifi.ifconfig(0) == ("192.168.178.109", "255.255.255.0", "192.168.178.1", "8.8.8.8"))
wait_for_connection(wifi)
print(wifi.isconnected() == True)
wifi.disconnect()
print(wifi.isconnected() == False)
t0 = time.ticks_ms()
wifi.connect(testconfig.wlan_ssid, auth=testconfig.wlan_auth, timeout=0)
print(time.ticks_ms() - t0 < 500)
wifi.disconnect()
print(wifi.isconnected() == False)
# test init again
wifi.init(WLAN.AP, ssid="www.wipy.io", auth=None, channel=5, antenna=WLAN.INT_ANT)
print(wifi.mode() == WLAN.AP)
# get the current instance without re-init
wifi = WLAN()
print(wifi.mode() == WLAN.AP)
wifi = WLAN(0)
print(wifi.mode() == WLAN.AP)
# test the MAC address length
print(len(wifi.mac()) == 6)
# next ones MUST raise
try:
wifi.init(mode=12345)
except:
print("Exception")
try:
wifi.init(1, mode=WLAN.AP)
except:
print("Exception")
try:
wifi.init(mode=WLAN.AP, ssid=None)
except:
print("Exception")
try:
wifi = WLAN(mode=WLAN.AP, channel=12)
except:
print("Exception")
try:
wifi.antenna(2)
except:
print("Exception")
try:
wifi.mode(10)
except:
print("Exception")
try:
wifi.ssid(
"11111sdfasdfasdfasdf564sdf654asdfasdf123451245ssdgfsdf1111111111111111111111111234123412341234asdfasdf"
)
except:
print("Exception")
try:
wifi.auth((0))
except:
print("Exception")
try:
wifi.auth((0, None))
except:
print("Exception")
try:
wifi.auth((10, 10))
except:
print("Exception")
try:
wifi.channel(0)
except:
print("Exception")
try:
wifi.ifconfig(1, "dhcp")
except:
print("Exception")
try:
wifi.ifconfig(config=())
except:
print("Exception")
|
YifuLiu/AliOS-Things
|
components/py_engine/tests/wipy/wlan/wlan.py
|
Python
|
apache-2.0
| 4,131
|
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#if AOS_COMP_CLI
#include "aos/cli.h"
#endif
#include "ramfs.h"
static void ramfs_example_fn(int argc, char **argv)
{
(void)argc;
(void)argv;
int fd;
int ret;
char teststring = "1234";
char readbuf[10];
ramfs_register("/test");
fd = open("/test/file1", O_RDWR);
if(fd < 0){
printf("ramfs: fd open fail!\r\n");
return;
}
ret = write(fd, teststring, 5);
if(ret < 0){
printf("ramfs: fd write fail!\r\n");
close(fd);
return;
}
lseek(fd, 0, SEEK_SET);
ret = read(fd, readbuf, 5);
if(ret < 0){
printf("ramfs: fd read fail!\r\n");
close(fd);
return;
}
if(strncmp(readbuf, teststring, 5)){
printf("ramfs: fd test fail! readbuf:%s\r\n",readbuf);
}else{
printf("ramfs: fd test success!\r\n");
}
close(fd);
printf("ramfs comp test success!\r\n");
return;
}
#if AOS_COMP_CLI
/* reg args: fun, cmd, description*/
ALIOS_CLI_CMD_REGISTER(ramfs_example_fn, ramfs_example, ramfs component base example)
#endif
|
YifuLiu/AliOS-Things
|
components/ramfs/example/ramfs_example.c
|
C
|
apache-2.0
| 1,231
|
/**
* @file ramfs.h
* @copyright Copyright (C) 2015-2018 Alibaba Group Holding Limited
*/
#ifndef FS_RAMFS_H
#define FS_RAMFS_H
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* @defgroup ramfs_aos_api ramfs
* ramfs 对外API.
* @{
*/
/**
* ramfs文件系统注册接口
* @param[in] mount_path 该文件系统挂载路径
* @return 0 表示注册成功, 负数表示失败
*
*/
int32_t ramfs_register(const char *mount_path);
/**
* ramfs文件系统去注册接口
* @param[in] mount_path 该文件系统挂载路径
* @return 0 表示去注册成功, 负数表示失败
*
*/
int32_t ramfs_unregister(const char *mount_path);
/** @} */
#ifdef __cplusplus
}
#endif
#endif
|
YifuLiu/AliOS-Things
|
components/ramfs/include/ramfs.h
|
C
|
apache-2.0
| 719
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef RAMFS_ADAPT_H
#define RAMFS_ADAPT_H
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief wrapper of MM allocation
*
* @param[in] size size of the mem to alloc
*
* @return NUll is error, other is memory address
*/
void *ramfs_mm_alloc(uint32_t size);
/**
* @brief wrapper of MM free
*
* @param[in] ptr address point of the mem
*/
void ramfs_mm_free(void *ptr);
/**
* @brief wrapper of MM realloc
*
* @param[in] oldmem pointer to the original memory
* @param[in] newsize the new size to realloc
*
* @return NULL is error, other is new memory address
*/
void *ramfs_mm_realloc(void *oldmem, uint32_t newsize);
#ifdef __cplusplus
}
#endif
#endif /* RAMFS_ADAPT_H */
|
YifuLiu/AliOS-Things
|
components/ramfs/internal/ramfs_adapt.h
|
C
|
apache-2.0
| 759
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef RAMFS_API_H
#define RAMFS_API_H
#include "ramfs_err.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
uint32_t st_mode;
uint32_t st_size;
uint8_t is_dir;
} ramfs_stat_t;
typedef enum {
RAMFS_MODE_WR = 0x01,
RAMFS_MODE_RD = 0x02,
} ramfs_mode_e;
/**
* @brief Initialize ramfs module
*
* @return None
*/
void ramfs_init(void);
/**
* @brief Deinitialize ramfs module
*
* @return None
*/
void ramfs_deinit(void);
/**
* @brief Give the state of the ramfs
*
* @return 0 if the ramfs is initialized and can be used else false
*/
int32_t ramfs_ready(void);
/**
* @brief Open a file in ramfs
*
* @param[out] fp pointer to a ramfs file object
* @param[in] fn name of the file. There are no directories. e.g. "a.txt"
* @param[in] mode file open mode (e.g. RAMFS_MODE_WR | RAMFS_MODE_RD)
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_open(void *fp, const char* fn, uint32_t mode);
/**
* @brief Create a file with a constant data
*
* @param[in] fn name of the file (directories are not supported)
* @param[in] data pointer to a constant data
* @param[in] len length of the constant data
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_create_const(const char *fn, const void *data, uint32_t len);
/**
* @brief Close an opened file
*
* @param[in] fp pointer to a ramfs file object
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_close(void *fp);
/**
* @brief Remove a file, the file should not be opened
*
* @param[in] fn pointer to a ramfs file object
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_remove(const char *fn);
/**
* @brief Remove a file, the file should not be opened
*
* @param[in] old pointer to old name
* @param[in] new pointer to new name
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_rename(const char *old, const char *new);
/**
* @brief Read data from an opened file
*
* @param[in] fp pointer to a ramfs file object
* @param[out] buf poiner to a memory block where to store the read data
* @param[in] btr number of bytes to read
* @param[out] br the real number of read bytes(Byte Read)
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_read(void *fp, void *buf, uint32_t btr, uint32_t *br);
/**
* @brief Write data to an opened file
*
* @param[in] fp pointer to a ramfs file object
* @param[in] buf pointer to a memory block which content will be written
* @param[in] btw number of bytes to write
* @param[out] bw the real number to write bytes(Byte Written)
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_write(void *fp, const void *buf, uint32_t btw, uint32_t *bw);
/**
* @brief Set the read/write pointer. Also expand the file size if necessary.
*
* @param[in] fp pointer to a ramfs file object (opened with ramfs_open)
* @param[in] pos the new position of read/write pointer
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_seek(void *fp, uint32_t pos);
/**
* @brief Give the position of the read/write pointer
*
* @param[in] fp pointer to a ramfs file object (opened with ramfs_open)
* @param[out] pos pointer to store the result
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_tell(void *fp, uint32_t *pos);
/**
* @brief Truncate the file size to the current position of the read/write pointer
*
* @param[in] fp pointer to a ramfs file object (opened with ramfs_open)
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_trunc(void *fp);
/**
* @brief Give the size of the file in bytes
*
* @param[in] fp pointer to a ramfs file object
* @param[out] size pointer to store the size
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_size(void *fp, uint32_t *size);
/**
* @brief Get access information
*
* @param[in] path the path of the file
* @param[in] mode the information to get
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_access(const char *path, int32_t mode);
/**
* @brief Create a directory
*
* @param[in] path the path of the directory
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_mkdir(const char *path);
/**
* @brief Open a directory in ramfs
*
* @param[out] dp pointer to a ramfs directory object
* @param[in] path the path of the directory
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_opendir(void *dp, const char *path);
/**
* @brief Read the next file name under the directory
*
* @param[in] dp pointer to a ramfs directory object
* @param[out] fn pointer to buffer to store the file name
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_readdir(void *dp, char *fn);
/**
* @brief Close the directory
*
* @param[in] dp pointer to a ramfs directory object
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_closedir(void *dp);
/**
* @brief Remove a directory
*
* @param[in] path the path of the directory
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_rmdir(const char *path);
/**
* @brief Get file info
*
* @param[in] path the path of the file to find info about
* @param[out] st the stat buffer to write to
*
* @return 0 on success, otherwise will be failed
*/
int32_t ramfs_stat(const char *path, ramfs_stat_t *st);
/**
* @brief Get path info
*
* @param[in] name the kind of path conf to get
*
* @return value of path info
*/
int32_t ramfs_pathconf(int32_t name);
/**
* @brief link path2 to path1
*
* @param[in] path1 the path to be linked
* @param[in] path2 the path to link
*
* @return 0 on success, negative error on failure
*
*/
int ramfs_link(const char *path1, const char *path2);
/**
* @brief Remove a file from the filesystem
*
* @param[in] path the path of the file to remove
*
* @return 0 on success, negative error on failure
*
*/
int ramfs_unlink(const char *path);
#ifdef __cplusplus
}
#endif
#endif /* RAMFS_API_H */
|
YifuLiu/AliOS-Things
|
components/ramfs/internal/ramfs_api.h
|
C
|
apache-2.0
| 6,127
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef RAMFS_ERR_H
#define RAMFS_ERR_H
#define RAMFS_OK 0
#define RAMFS_ERR_HW -10000 /* Low level hard ware error */
#define RAMFS_ERR_FS -10001 /* Error in the file system structure */
#define RAMFS_ERR_NOT_EXIST -10002 /* File or directory is not exists */
#define RAMFS_ERR_FULL -10003 /* File system is full */
#define RAMFS_ERR_LOCKED -10004 /* The file is already opened */
#define RAMFS_ERR_DENIED -10005 /* Access denied */
#define RAMFS_ERR_BUSY -10006 /* The file system can't handle it, try later */
#define RAMFS_ERR_TIMEOUT -10007 /* Process timeout */
#define RAMFS_ERR_NOT_IMP -10008 /* Request function is not implemented */
#define RAMFS_ERR_OUT_OF_MEM -10009 /* Not enough memory for an interal operation */
#define RAMFS_ERR_INV_PARAM -10010 /* Invalid parameter among arguments */
#define RAMFS_ERR_UNKOWN -10011 /* Other unknown error */
#define RAMFS_ERR_PATH -10012 /* Path error */
#define RAMFS_ERR_MALLOC -10013 /* Malloc error */
#define RAMFS_ERR_LINK_MAX -10014 /* Exceed RAMFS_LINK_MAX */
#define RAMFS_ERR_EXIST -10015 /* File or directory is existed */
#endif /* RAMFS_ERR_H */
|
YifuLiu/AliOS-Things
|
components/ramfs/internal/ramfs_err.h
|
C
|
apache-2.0
| 1,258
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef RAMFS_TYPES_H
#define RAMFS_TYPES_H
#include <stdint.h>
#include <unistd.h>
#define RAMFS_MAGIC 0x890910
#define RAMFS_LETTER 'U'
#define RAMFS_PATH_MAX 128
#define RAMFS_NAME_MAX RAMFS_PATH_MAX
#define RAMFS_LINK_MAX 1024
#define RAMFS_ALLOC_SIZE_MIN 1
/* Description of a link name */
typedef struct link_name_s
{
char *name;
struct link_name_s *next;
} link_name_t;
/* Description of a file entry */
typedef struct {
char *fn;
void *data;
uint32_t size; /* Data length in bytes */
uint16_t refs; /* Open count */
uint8_t const_data : 1;
uint8_t is_dir : 1;
uint8_t ar : 1; /* 1: Access for read is enabled */
uint8_t aw : 1; /* 1: Access for write is enabled */
link_name_t *link;
uint16_t link_count;
} ramfs_entry_t;
/* Description of a file */
typedef struct {
ramfs_entry_t *entry; /* Pointer to the file entry */
uint32_t rwp; /* Read write pointer */
} ramfs_file_t;
/* Description of a directory */
typedef struct {
char *dir_name;
ramfs_entry_t *last_entry;
} ramfs_dir_t;
typedef uint8_t ramfs_ll_node_t;
/* Description of a linked list */
typedef struct {
uint32_t size;
ramfs_ll_node_t *head;
ramfs_ll_node_t *tail;
} ramfs_ll_t;
#endif /* RAMFS_TYPES_H */
|
YifuLiu/AliOS-Things
|
components/ramfs/internal/ramfs_types.h
|
C
|
apache-2.0
| 1,417
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include "ramfs_types.h"
#include "ramfs_api.h"
#include "ramfs_adapt.h"
#define RAMFS_LL_NODE_META_SIZE (sizeof(ramfs_ll_node_t *) + \
sizeof(ramfs_ll_node_t *))
#define RAMFS_LL_PREV_OFFSET(ll) (ll->size)
#define RAMFS_LL_NEXT_OFFSET(ll) (ll->size + sizeof(ramfs_ll_node_t *))
#define RAMFS_LL_READ(ll, i) \
for (i = ramfs_ll_get_head(&ll); i != NULL; i = ramfs_ll_get_next(&ll, i))
#define RAMFS_LL_READ_BACK(ll, i) \
for (i = ramfs_ll_get_tail(&ll); i != NULL, u = ramfs_ll_get_prev(&ll, i))
static ramfs_ll_t g_file_ll;
static uint8_t g_inited = 0;
/**
* @brief Set the previous node pointer of a node
*
* @param[in] ll pointer to linked list
* @param[out] act pointer to a node which prev node pointer should be set
* @param[in] prev pointer to the previous node before act
*
* @return None
*/
static void ramfs_node_set_prev(ramfs_ll_t *ll, ramfs_ll_node_t *act,
ramfs_ll_node_t *prev)
{
memcpy(act + RAMFS_LL_PREV_OFFSET(ll), &prev, sizeof(ramfs_ll_node_t *));
}
/**
* @brief Set the next node pointer of a node
*
* @param[in] ll pointer to linked list
* @param[out] act poiner to a node which next node pointer should be set
* @param[in] next poiner to the next node after act
*
* @return None
*/
static void ramfs_node_set_next(ramfs_ll_t *ll, ramfs_ll_node_t *act,
ramfs_ll_node_t *next)
{
memcpy(act + RAMFS_LL_NEXT_OFFSET(ll), &next, sizeof(ramfs_ll_node_t *));
}
/**
* @brief Initialize ramfs linked list
*
* @param[out] ll pointer to the ramfs linked list
* @param[in] size the size of 1 node in bytes
*
* @return None
*/
static void ramfs_ll_init(ramfs_ll_t *ll, uint32_t size)
{
ll->head = NULL;
ll->tail = NULL;
if (size & 0x3) {
size &= ~0x3;
size += 4;
}
ll->size = size;
}
/**
* @brief Add a new head to the linked list
*
* @param[in] ll pointer to the linked list
*
* @return pointer to the new head, NULL if no memory
*/
static void *ramfs_ll_ins_head(ramfs_ll_t *ll)
{
ramfs_ll_node_t *new = NULL;
new = ramfs_mm_alloc(ll->size + RAMFS_LL_NODE_META_SIZE);
if (new != NULL) {
ramfs_node_set_prev(ll, new, NULL); /* No prev before the new head */
ramfs_node_set_next(ll, new, ll->head); /* After new comes the old head */
if (ll->head != NULL) { /* If there is old head then before it goes the new */
ramfs_node_set_prev(ll, ll->head, new);
}
ll->head = new; /* Set the new head in the linked list */
if (ll->tail == NULL) { /* If there is no tail, set the tail too */
ll->tail = new;
}
}
return new;
}
/**
* @brief Return with head node of the linked list
*
* @param[in] ll pointer to the linked list
*
* @return pointer to the head of linked list
*/
void *ramfs_ll_get_head(ramfs_ll_t *ll)
{
void *head = NULL;
if (ll->head != NULL) {
head = ll->head;
}
return head;
}
/**
* @brief Return with tail node of the linked list
*
* @param[in] ll pointer to the linked list
*
* @return pointer to the tail of linked list
*/
void *ramfs_ll_get_tail(ramfs_ll_t *ll)
{
void *tail = NULL;
if (ll->tail != NULL) {
tail = ll->tail;
}
return tail;
}
/**
* @brief Return with the pointer of the next node after act
*
* @param[in] ll pointer to the linked list
* @param[in] act pointer to a node
*
* @return pointer to the next node
*/
void *ramfs_ll_get_next(ramfs_ll_t *ll, void *act)
{
void *next = NULL;
ramfs_ll_node_t *node = act;
if (ll != NULL) {
memcpy(&next, node + RAMFS_LL_NEXT_OFFSET(ll), sizeof(void *));
}
return next;
}
/**
* @brief Return with the pointer of the previous node after act
*
* @param[in] ll pointer to the linked list
* @param[in] act pointer to a node
*
* @return pointer to the previous node
*/
void *ramfs_ll_get_prev(ramfs_ll_t *ll, void *act)
{
void *prev = NULL;
ramfs_ll_node_t *node = act;
if (ll != NULL) {
memcpy(&prev, node + RAMFS_LL_PREV_OFFSET(ll), sizeof(void *));
}
return prev;
}
/**
* @brief Remove the node from linked list
*
* @param[in] ll pointer to the linked list of node
* @param[in] node pointer to the node in linked list
*
* @return None
*/
static void ramfs_ll_remove(ramfs_ll_t *ll, void *node)
{
ramfs_ll_node_t *prev;
ramfs_ll_node_t *next;
if (ramfs_ll_get_head(ll) == node) {
ll->head = ramfs_ll_get_next(ll, node);
if (ll->head == NULL) {
ll->tail = NULL;
} else {
ramfs_node_set_prev(ll, ll->head, NULL);
}
} else if (ramfs_ll_get_tail(ll) == node) {
ll->tail = ramfs_ll_get_prev(ll, node);
if (ll->tail == NULL) {
ll->head = NULL;
} else {
ramfs_node_set_next(ll, ll->tail, NULL);
}
} else {
prev = ramfs_ll_get_prev(ll, node);
next = ramfs_ll_get_next(ll, node);
ramfs_node_set_next(ll, prev, next);
ramfs_node_set_prev(ll, next, prev);
}
}
/**
* @brief Search path in link
*
* @param[in] fn file name
*
* @return 0 if get path in link, RAMFS_ERR_FS if failed
*/
static int ramfs_search_link(ramfs_entry_t *entry, char *path)
{
link_name_t *link_name = entry->link;
while (link_name != NULL) {
if (strcmp(link_name->name, path) == 0) {
return RAMFS_OK;
} else {
link_name = link_name->next;
}
}
return RAMFS_ERR_FS;
}
/**
* @brief Search path in link
*
* @param[in] fn file name
*
* @return 0 if get path in link, RAMFS_ERR_FS if failed
*/
static int ramfs_search_link_part(ramfs_entry_t *entry, char *path)
{
link_name_t *link_name = entry->link;
while (link_name != NULL) {
if (strncmp(link_name->name, path, strlen(path)) == 0) {
return RAMFS_OK;
} else {
link_name = link_name->next;
}
}
return RAMFS_ERR_FS;
}
/**
* @brief Give the ramfs entry from a filename
*
* @param[in] fn file name
*
* @return pointer to the dynamically allocated entry with 'fn'.
* NULL if no entry found with that name
*/
static ramfs_entry_t *ramfs_entry_get(const char *fn)
{
ramfs_entry_t *entry;
int ret = -1;
RAMFS_LL_READ(g_file_ll, entry) {
if (strcmp(entry->fn, fn) == 0) {
return entry;
} else {
ret = ramfs_search_link(entry, (char *)fn);
if (ret == RAMFS_OK) {
return entry;
}
}
}
return NULL;
}
/**
* @brief Create dir involved in path
*
* @param[in] fn file name
*
* @return poiner to the dynamically allocated new entry
* NULL if no space for the entry
*/
static int ramfs_entry_dir_new(const char *path)
{
int i = 0;
int flag = 0;
char dir_buf[RAMFS_PATH_MAX];
ramfs_entry_t *new_entry = NULL;
/* create dir involved in path, if path is "/ramfs/f1/f2/file1", then
create dir "/ramfs/f1" and "/ramfs/f1/f2" */
for(i = 1; i < strlen(path); i++) {
if (path[i] == '/') {
memset(dir_buf, 0, sizeof(dir_buf));
memcpy(dir_buf, path, i);
flag = 0;
new_entry = NULL;
/* if the same dir is found, ignore this dir */
RAMFS_LL_READ(g_file_ll, new_entry) {
if ((strcmp(new_entry->fn, dir_buf) == 0) && (new_entry->is_dir == 1)) {
flag = 1;
break;
}
}
if (flag == 0) {
new_entry = ramfs_ll_ins_head(&g_file_ll); /* Create a new file */
if (new_entry == NULL) {
return RAMFS_ERR_MALLOC;
}
new_entry->fn = ramfs_mm_alloc(i + 1);
memset(new_entry->fn, 0, (i + 1));
strncpy(new_entry->fn, path, i);
new_entry->data = NULL;
new_entry->size = 0;
new_entry->refs = 0;
new_entry->const_data = 0;
new_entry->is_dir = 1;
new_entry->link = NULL;
new_entry->link_count = 0;
}
}
}
return RAMFS_OK;
}
/**
* @brief Create a new entry with 'fn' file name
*
* @param[in] fn file name
*
* @return poiner to the dynamically allocated new entry
* NULL if no space for the entry
*/
static ramfs_entry_t *ramfs_entry_new(const char *fn)
{
ramfs_entry_t *new_entry = NULL;
size_t fn_len;
int ret = -1;
/* create dir involved in path, if path is "/ramfs/f1/f2/file1", then
create dir "/ramfs/f1" and "/ramfs/f1/f2" */
ret = ramfs_entry_dir_new(fn);
if (ret != RAMFS_OK) {
return NULL;
}
new_entry = ramfs_ll_ins_head(&g_file_ll); /* Create a new file */
if (new_entry == NULL) {
return NULL;
}
fn_len = strlen(fn);
new_entry->fn = ramfs_mm_alloc(fn_len + 1);
strncpy(new_entry->fn, fn, fn_len);
new_entry->fn[fn_len] = '\0';
new_entry->data = NULL;
new_entry->size = 0;
new_entry->refs = 0;
new_entry->const_data = 0;
new_entry->is_dir = 0;
new_entry->link = NULL;
new_entry->link_count = 0;
return new_entry;
}
void ramfs_init(void)
{
ramfs_ll_init(&g_file_ll, sizeof(ramfs_entry_t));
g_inited = 1;
}
void ramfs_deinit(void)
{
if (g_inited) {
memset(&g_file_ll, 0 , sizeof(g_file_ll));
g_inited = 0;
}
}
int32_t ramfs_ready(void)
{
return g_inited;
}
int32_t ramfs_open(void *fp, const char* fn, uint32_t mode)
{
ramfs_file_t *file = (ramfs_file_t *)fp;
ramfs_entry_t *entry = ramfs_entry_get(fn);
file->entry = NULL;
if ((entry != NULL) && (entry->is_dir == 1)) {
return RAMFS_ERR_NOT_EXIST;
}
if (entry == NULL) {
if ((mode & RAMFS_MODE_WR) != 0) {
entry = ramfs_entry_new(fn);
if (entry == NULL) {
return RAMFS_ERR_FULL;
}
} else {
return RAMFS_ERR_NOT_EXIST;
}
}
file->entry = entry;
file->entry->ar = mode & RAMFS_MODE_RD ? 1 : 0;
file->entry->aw = mode & RAMFS_MODE_WR ? 1 : 0;
file->rwp = 0;
entry->refs++;
return RAMFS_OK;
}
int32_t ramfs_create_const(const char *fn, const void *data, uint32_t len)
{
int32_t res;
ramfs_file_t file;
ramfs_entry_t *entry;
res = ramfs_open(&file, fn, RAMFS_MODE_RD);
if (res == RAMFS_OK) {
ramfs_close(&file);
return RAMFS_ERR_DENIED;
}
res = ramfs_open(&file, fn, RAMFS_MODE_WR);
if (res != RAMFS_OK) {
return res;
}
entry = file.entry;
if (entry->data != NULL) {
return RAMFS_ERR_DENIED;
}
entry->data = (void *)data;
entry->size = len;
entry->const_data = 1;
entry->ar = 1;
entry->aw = 0;
res = ramfs_close(&file);
return res;
}
int32_t ramfs_close(void *fp)
{
ramfs_file_t *file = (ramfs_file_t *)fp;
if (file->entry == NULL) {
return RAMFS_OK;
}
if (file->entry->refs > 0) {
file->entry->refs--;
}
return RAMFS_OK;
}
int32_t ramfs_remove(const char *fn)
{
ramfs_entry_t *entry = ramfs_entry_get(fn);
link_name_t *link_name = NULL;
link_name_t *link_name_next = NULL;
if (entry == NULL) {
return RAMFS_ERR_NOT_EXIST;
}
if (entry->is_dir == 1) {
return ramfs_rmdir(fn);
}
if (entry->refs != 0) {
return RAMFS_ERR_DENIED;
}
ramfs_ll_remove(&g_file_ll, entry);
ramfs_mm_free(entry->fn);
entry->fn = NULL;
link_name = entry->link;
while(link_name != NULL) {
link_name_next = link_name->next;
ramfs_mm_free(link_name->name);
ramfs_mm_free(link_name);
link_name = link_name_next;
}
if (entry->const_data == 0) {
ramfs_mm_free(entry->data);
entry->data = NULL;
}
ramfs_mm_free(entry);
return RAMFS_OK;
}
int32_t ramfs_rename(const char *old, const char *new)
{
ramfs_entry_t *entry = NULL;
entry = ramfs_entry_get(new);
if (entry != NULL) {
return RAMFS_ERR_PATH;
}
entry = ramfs_entry_get(old);
if (entry == NULL) {
return RAMFS_ERR_NOT_EXIST;
}
if ((entry != NULL) && (entry->is_dir == 1)) {
return RAMFS_ERR_PATH;
}
/* rename linked name is not supported */
if (strcmp(entry->fn, old) != 0) {
return RAMFS_ERR_NOT_IMP;
}
entry->fn = ramfs_mm_realloc(entry->fn, strlen(new) + 1);
if (entry->fn == NULL) {
return RAMFS_ERR_MALLOC;
}
memset(entry->fn, 0 , strlen(new) + 1);
strncpy(entry->fn, new, strlen(new));
return RAMFS_OK;
}
int32_t ramfs_read(void *fp, void *buf, uint32_t btr, uint32_t *br)
{
uint8_t *data;
ramfs_file_t *file;
ramfs_entry_t *entry;
file = (ramfs_file_t *)fp;
entry = file->entry;
*br = 0;
if (entry->data == NULL || entry->size == 0) {
return RAMFS_OK;
} else if (entry->ar == 0) {
return RAMFS_ERR_DENIED;
}
if (file->rwp + btr > entry->size) {
*br = entry->size - file->rwp;
} else {
*br = btr;
}
if (entry->const_data == 0) {
data = (uint8_t *)entry->data;
} else {
data = entry->data;
}
data += file->rwp;
memcpy(buf, data, *br);
file->rwp += *br;
return RAMFS_OK;
}
int32_t ramfs_write(void *fp, const void *buf, uint32_t btw, uint32_t *bw)
{
uint32_t new_size;
uint8_t *new_data;
uint8_t *rwp;
ramfs_file_t *file;
ramfs_entry_t *entry;
file = (ramfs_file_t *)fp;
entry = file->entry;
*bw = 0;
if (entry->aw == 0) {
return RAMFS_ERR_DENIED;
}
new_size = file->rwp + btw;
if (new_size > entry->size) {
new_data = ramfs_mm_realloc(entry->data, new_size);
if (new_data == NULL) {
return RAMFS_ERR_FULL;
}
entry->data = new_data;
entry->size = new_size;
}
rwp = (uint8_t *)entry->data;
rwp += file->rwp;
memcpy(rwp, buf, btw);
*bw = btw;
file->rwp += *bw;
return RAMFS_OK;
}
int32_t ramfs_seek(void *fp, uint32_t pos)
{
uint8_t *new_data;
ramfs_file_t *file;
ramfs_entry_t *entry;
file = (ramfs_file_t *)fp;
entry = file->entry;
if (pos < entry->size) {
file->rwp = pos;
} else {
if (entry->aw == 0) {
return RAMFS_ERR_DENIED;
}
new_data = ramfs_mm_realloc(entry->data, pos);
if (new_data == NULL) {
return RAMFS_ERR_FULL;
}
entry->data = new_data;
entry->size = pos;
file->rwp = pos;
}
return RAMFS_OK;
}
int32_t ramfs_tell(void *fp, uint32_t *pos)
{
*pos = ((ramfs_file_t *)fp)->rwp;
return RAMFS_OK;
}
int32_t ramfs_trunc(void *fp)
{
void *new_data;
ramfs_file_t *file;
ramfs_entry_t *entry;
file = (ramfs_file_t *)fp;
entry = file->entry;
if (entry->aw == 0) {
return RAMFS_ERR_DENIED;
}
new_data = ramfs_mm_realloc(entry->data, file->rwp);
if (new_data == NULL) {
return RAMFS_ERR_FULL;
}
entry->data = new_data;
entry->size = file->rwp;
return RAMFS_OK;
}
int32_t ramfs_size(void *fp, uint32_t *size)
{
*size = ((ramfs_file_t *)fp)->entry->size;
return RAMFS_OK;
}
int32_t ramfs_access(const char *path, int32_t mode)
{
ramfs_entry_t *entry = ramfs_entry_get(path);
if (mode == F_OK) {
if (entry == NULL) {
return RAMFS_ERR_DENIED;
} else {
return RAMFS_OK;
}
}
if (mode == R_OK) {
if (entry == NULL) {
return RAMFS_OK;
} else {
if (entry->ar == 1) {
return RAMFS_OK;
} else {
return RAMFS_ERR_DENIED;
}
}
}
if (mode == W_OK) {
if (entry == NULL) {
return RAMFS_OK;
} else {
if (entry->aw == 1) {
return RAMFS_OK;
} else {
return RAMFS_ERR_DENIED;
}
}
}
if (mode == X_OK) {
return RAMFS_OK;
}
return RAMFS_ERR_DENIED;
}
int32_t ramfs_mkdir(const char *path)
{
ramfs_entry_t *entry = ramfs_entry_get(path);
if ((entry != NULL) && (entry->is_dir == 1)) {
return RAMFS_ERR_EXIST;
}
entry = ramfs_entry_new(path);
if (entry == NULL) {
return RAMFS_ERR_FULL;
}
entry->is_dir = 1;
return RAMFS_OK;
}
int32_t ramfs_opendir(void *dp, const char *path)
{
ramfs_dir_t *ramfs_dp;
ramfs_entry_t *entry;
ramfs_dp = (ramfs_dir_t *)dp;
entry = ramfs_entry_get(path);
if (entry == NULL) {
return RAMFS_ERR_NOT_EXIST;
}
if (entry->is_dir != 1) {
entry = ramfs_entry_get(path);
if (entry == NULL) {
return RAMFS_ERR_NOT_EXIST;
}
if (entry->is_dir != 1) {
return RAMFS_ERR_NOT_EXIST;
}
}
ramfs_dp->dir_name = ramfs_mm_alloc(strlen(path) + 1);
if (ramfs_dp->dir_name == NULL) {
return RAMFS_ERR_FULL;
}
memset(ramfs_dp->dir_name, 0 ,strlen(path) + 1);
strncpy(ramfs_dp->dir_name, path, strlen(path));
ramfs_dp->last_entry = NULL;
return RAMFS_OK;
}
int32_t ramfs_readdir(void *dp, char *fn)
{
int i = 0;
int len = 0;
int search = 1;
char *name = NULL;
char *data = NULL;
ramfs_dir_t *ramfs_dp = (ramfs_dir_t *)dp;
if (ramfs_dp->last_entry == NULL) {
ramfs_dp->last_entry = ramfs_ll_get_head(&g_file_ll);
}
while ((search == 1) && (ramfs_dp->last_entry != NULL)) {
if ((strncmp(ramfs_dp->dir_name, ramfs_dp->last_entry->fn, strlen(ramfs_dp->dir_name)) == 0)
&&(*(ramfs_dp->last_entry->fn + strlen(ramfs_dp->dir_name)) != '\0')) {
name = ramfs_dp->last_entry->fn + strlen(ramfs_dp->dir_name) + 1;
data = name;
len = strlen(ramfs_dp->last_entry->fn) - strlen(ramfs_dp->dir_name);
search = 0;
for (i = 0; i < len; i++) {
if (*name == '/') {
search = 1;
break;
}
name++;
}
}
ramfs_dp->last_entry = ramfs_ll_get_next(&g_file_ll, ramfs_dp->last_entry);
}
if (ramfs_dp->last_entry != NULL) {
strncpy(fn, data, strlen(data));
fn[strlen(data)] = '\0';
} else {
return RAMFS_ERR_NOT_EXIST;
}
return RAMFS_OK;
}
int32_t ramfs_closedir(void *dp)
{
ramfs_dir_t *ramfs_dp = (ramfs_dir_t *)dp;
if (ramfs_dp->dir_name != NULL) {
ramfs_mm_free(ramfs_dp->dir_name);
}
return RAMFS_OK;
}
int32_t ramfs_rmdir(const char *path)
{
ramfs_entry_t *entry;
int ret = -1;
int flag = 0;
/* if file existed in the dir return error ! */
RAMFS_LL_READ(g_file_ll, entry) {
if ((strncmp(entry->fn, path, strlen(path)) == 0)
&& (*(char*)(entry->fn + strlen(path)) == '/')) {
flag = 1;
break;
} else {
ret = ramfs_search_link_part(entry, (char *)path);
if (ret == RAMFS_OK) {
flag = 1;
break;
}
}
}
if (flag == 1) {
return RAMFS_ERR_DENIED;
}
/* if no file existed in the dir remove the dir ! */
RAMFS_LL_READ(g_file_ll, entry) {
if ((strncmp(entry->fn, path, strlen(path)) == 0) && (entry->is_dir == 1)) {
ramfs_ll_remove(&g_file_ll, entry);
ramfs_mm_free(entry->fn);
entry->fn = NULL;
ramfs_mm_free(entry);
}
}
return RAMFS_OK;
}
int32_t ramfs_stat(const char *path, ramfs_stat_t *st)
{
ramfs_entry_t *entry = ramfs_entry_get(path);
if (st == NULL) {
return RAMFS_ERR_INV_PARAM;
}
if (entry != NULL) {
st->st_size = entry->size;
if (entry->ar == 1) {
st->st_mode |= RAMFS_MODE_RD;
}
if (entry->aw == 1) {
st->st_mode |= RAMFS_MODE_WR;
}
if (entry->is_dir == 1) {
st->is_dir = 1;
}
} else {
return RAMFS_ERR_NOT_EXIST;
}
return RAMFS_OK;
}
int ramfs_add_link(ramfs_entry_t *entry, char *path)
{
link_name_t *link_name = entry->link;
link_name_t *link_name_c = NULL;
link_name_c = ramfs_mm_alloc(sizeof(link_name_t));
if (link_name_c != NULL) {
link_name_c->name = ramfs_mm_alloc(strlen(path) + 1);
if (link_name_c->name != NULL) {
memset(link_name_c->name, 0, strlen(path) + 1);
strncpy(link_name_c->name, path, strlen(path));
link_name_c->next = NULL;
entry->link_count += 1;
} else {
ramfs_mm_free(link_name_c);
return RAMFS_ERR_MALLOC;
}
} else {
return RAMFS_ERR_MALLOC;
}
if (link_name == NULL) {
entry->link = link_name_c;
} else {
while (link_name->next != NULL) {
link_name = link_name->next;
}
link_name->next = link_name_c;
}
return 0;
}
int ramfs_remove_link(ramfs_entry_t *entry, char *path)
{
link_name_t *link_name = entry->link;
link_name_t *link_name_c = NULL;
link_name_t *link_name_l = NULL;
if (link_name == NULL) {
return RAMFS_ERR_INV_PARAM;
}
if (strncmp(link_name->name, path, strlen(path)) == 0) {
ramfs_mm_free(link_name->name);
link_name->name = ramfs_mm_alloc(strlen(link_name->next->name) + 1);
if (link_name->name == NULL) {
return RAMFS_ERR_MALLOC;
}
memset(link_name->name, 0 , strlen(link_name->next->name) + 1);
strncpy(link_name->name, link_name->next->name, strlen(link_name->next->name));
link_name->next = link_name->next->next;
entry->link_count -= 1;
} else {
link_name_l = link_name;
link_name_c = link_name->next;
while (link_name_c != NULL) {
if (strncmp(link_name_c->name, path, strlen(path)) == 0) {
link_name_l->next = link_name_c->next;
ramfs_mm_free(link_name_c->name);
ramfs_mm_free(link_name_c);
entry->link_count -= 1;
}
link_name_l = link_name_c;
link_name_c = link_name_c->next;
}
}
return 0;
}
int ramfs_link(const char *path1, const char *path2)
{
ramfs_entry_t *entry = NULL;
int ret = -1;
entry = ramfs_entry_get(path2);
if (entry != NULL) {
return RAMFS_ERR_PATH;
}
entry = ramfs_entry_get(path1);
if (entry == NULL) {
return RAMFS_ERR_NOT_EXIST;
}
if ((entry != NULL) && (entry->is_dir == 1)) {
return RAMFS_ERR_PATH;
}
if (entry->link_count >= RAMFS_LINK_MAX) {
return RAMFS_ERR_LINK_MAX;
}
ret = ramfs_add_link(entry, (char *)path2);
if (ret != 0) {
return RAMFS_ERR_MALLOC;
}
return 0;
}
int ramfs_unlink(const char *path)
{
ramfs_entry_t *entry = NULL;
int ret = -1;
entry = ramfs_entry_get(path);
if (entry == NULL) {
return RAMFS_ERR_PATH;
}
if (strncmp(entry->fn, path, strlen(path)) == 0) {
ret = ramfs_remove(path);
} else {
ret = ramfs_remove_link(entry, (char *)path);
}
return ret;
}
int32_t ramfs_pathconf(int32_t name)
{
int32_t val = 0;
switch (name) {
case _PC_FILESIZEBITS :
val = -1;
break;
case _PC_LINK_MAX :
val = RAMFS_LINK_MAX;
break;
case _PC_MAX_CANON :
val = -1;
break;
case _PC_MAX_INPUT :
val = -1;
break;
case _PC_NAME_MAX :
val = RAMFS_NAME_MAX;
break;
case _PC_PATH_MAX :
val = RAMFS_PATH_MAX;
break;
case _PC_PIPE_BUF :
val = -1;
break;
case _PC_2_SYMLINKS :
val = -1;
break;
case _PC_ALLOC_SIZE_MIN :
val = RAMFS_ALLOC_SIZE_MIN;
break;
case _PC_REC_INCR_XFER_SIZE :
val = -1;
break;
case _PC_REC_MAX_XFER_SIZE :
val = -1;
break;
case _PC_REC_MIN_XFER_SIZE :
val = -1;
break;
case _PC_REC_XFER_ALIGN :
val = -1;
break;
case _PC_SYMLINK_MAX :
val = -1;
break;
case _PC_CHOWN_RESTRICTED :
val = -1;
break;
case _PC_NO_TRUNC :
val = -1;
break;
case _PC_VDISABLE :
val = -1;
break;
case _PC_ASYNC_IO :
val = -1;
break;
case _PC_PRIO_IO :
val = -1;
break;
case _PC_SYNC_IO :
val = -1;
break;
default:
val = -1;
break;
}
return val;
}
|
YifuLiu/AliOS-Things
|
components/ramfs/src/ramfs.c
|
C
|
apache-2.0
| 25,655
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include "k_api.h"
#include "ramfs_adapt.h"
void *ramfs_mm_alloc(uint32_t size)
{
return krhino_mm_alloc(size);
}
void ramfs_mm_free(void *ptr)
{
krhino_mm_free(ptr);
}
void *ramfs_mm_realloc(void *oldmem, uint32_t newsize)
{
return krhino_mm_realloc(oldmem, newsize);
}
|
YifuLiu/AliOS-Things
|
components/ramfs/src/ramfs_adapt.c
|
C
|
apache-2.0
| 353
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include "vfs_types.h"
#include "vfs_api.h"
#include "ramfs.h"
#include "ramfs_api.h"
#include "ramfs_adapt.h"
#include "ramfs_types.h"
#define MAX_RAMFS_FILE_NAME_BYTES 32
#define RAMFS_DEFAULT_MOUNT_PATH "/RAMFS"
typedef struct {
vfs_dir_t vfs_dir;
ramfs_dir_t ramfs_dir;
vfs_dirent_t vfs_dirent;
} ramfs_vfs_dir_t;
static int32_t ramfs_vfs_open(vfs_file_t *fp, const char *path, int32_t flags)
{
int32_t ret = RAMFS_ERR_NOT_IMP;
int32_t ramfs_flags = 0;
ramfs_file_t ramfs_file;
memset(&ramfs_file, 0, sizeof(ramfs_file));
if (flags == O_RDWR) {
ramfs_flags = RAMFS_MODE_WR | RAMFS_MODE_RD;
} else if (flags == O_RDONLY) {
ramfs_flags = RAMFS_MODE_RD;
} else if (flags == O_WRONLY) {
ramfs_flags = RAMFS_MODE_WR;
} else {
ramfs_flags = RAMFS_MODE_WR | RAMFS_MODE_RD;
}
ret = ramfs_open(&ramfs_file, path, ramfs_flags);
if (ret == 0) {
fp->f_arg = ramfs_file.entry;
}
return ret;
}
static int32_t ramfs_vfs_close(vfs_file_t *fp)
{
ramfs_file_t ramfs_file;
int32_t ret = RAMFS_ERR_NOT_IMP;
memset(&ramfs_file, 0, sizeof(ramfs_file));
ramfs_file.entry = (ramfs_entry_t *)fp->f_arg;
ret = ramfs_close(&ramfs_file);
return ret;
}
static int32_t ramfs_vfs_read(vfs_file_t *fp, char *buf, uint32_t len)
{
ramfs_file_t ramfs_file;
int32_t ret = RAMFS_ERR_NOT_IMP;
int32_t res = -1;
uint32_t read_bytes = 0;
memset(&ramfs_file, 0, sizeof(ramfs_file));
ramfs_file.entry = (ramfs_entry_t *)fp->f_arg;
ramfs_file.rwp = fp->offset;
ret = ramfs_read(&ramfs_file, buf, len, &read_bytes);
if (ret == 0) {
fp->offset = ramfs_file.rwp;
res = read_bytes;
} else {
res = -1;
}
return res;
}
static int32_t ramfs_vfs_write(vfs_file_t *fp, const char *buf, uint32_t len)
{
ramfs_file_t ramfs_file;
int32_t ret = RAMFS_ERR_NOT_IMP;
int32_t res = -1;
uint32_t write_bytes = 0;
memset(&ramfs_file, 0, sizeof(ramfs_file));
ramfs_file.entry = (ramfs_entry_t *)fp->f_arg;
ramfs_file.rwp = fp->offset;
ret = ramfs_write(&ramfs_file, buf, len, &write_bytes);
if (ret == 0) {
fp->offset = ramfs_file.rwp;
res = write_bytes;
} else {
res = -1;
}
return res;
}
static int32_t ramfs_vfs_access(vfs_file_t *fp, const char *path, int32_t amode)
{
int32_t ret = RAMFS_ERR_NOT_IMP;
if ((amode == R_OK) || (amode == W_OK) || (amode == X_OK)) {
return 0;
}
ret = ramfs_access(path, amode);
if (ret != 0) {
ret = -1;
}
return ret;
}
static uint32_t ramfs_vfs_lseek(vfs_file_t *fp, int64_t off, int32_t whence)
{
ramfs_file_t ramfs_file;
int64_t offset = 0;
memset(&ramfs_file, 0, sizeof(ramfs_file));
ramfs_file.entry = (ramfs_entry_t *)fp->f_arg;
offset = fp->offset;
if (whence == SEEK_SET) {
offset = off;
} else if (whence == SEEK_CUR) {
offset += off;
} else if (whence == SEEK_END) {
offset += ramfs_file.entry->size - 1;
}
if ((offset < ramfs_file.entry->size) && (offset >= 0)) {
fp->offset = offset;
}
return fp->offset;
}
static int32_t ramfs_vfs_link(vfs_file_t *fp, const char *path1, const char *path2)
{
return ramfs_link(path1, path2);
}
static int32_t ramfs_vfs_unlink(vfs_file_t *fp, const char *path)
{
return ramfs_unlink(path);
}
static int32_t ramfs_vfs_remove(vfs_file_t *fp, const char *path)
{
return ramfs_remove(path);
}
static int32_t ramfs_vfs_rename(vfs_file_t *fp, const char *old, const char *new)
{
return ramfs_rename(old, new);
}
static vfs_dir_t *ramfs_vfs_opendir(vfs_file_t *fp, const char *path)
{
ramfs_vfs_dir_t *dp = NULL;
vfs_dir_t *ret = NULL;
int32_t res = -1;
dp = ramfs_mm_alloc(sizeof(ramfs_vfs_dir_t) + MAX_RAMFS_FILE_NAME_BYTES);
if (dp != NULL) {
fp->f_arg = dp;
res = ramfs_opendir(&dp->ramfs_dir, path);
if (res == 0) {
ret = &(dp->vfs_dir);
}
}
return ret;
}
static int32_t ramfs_vfs_closedir(vfs_file_t *fp, vfs_dir_t *dir)
{
ramfs_vfs_dir_t *dp;
dp = (ramfs_vfs_dir_t *)fp->f_arg;
if (dp != NULL) {
ramfs_closedir(&dp->ramfs_dir);
ramfs_mm_free((void*)dp);
}
return 0;
}
static int32_t ramfs_vfs_stat(vfs_file_t *fp, const char *path, vfs_stat_t *st)
{
ramfs_stat_t ramfs_st;
int32_t ret = 0;
if (st == NULL) {
return -1;
}
memset(&ramfs_st, 0, sizeof(ramfs_st));
ret = ramfs_stat(path, &ramfs_st);
if (ret == 0) {
st->st_size = ramfs_st.st_size;
st->st_mode = S_IXUSR | S_IXGRP | S_IXOTH;
if ((ramfs_st.st_mode & RAMFS_MODE_RD) == RAMFS_MODE_RD) {
st->st_mode |= S_IRUSR | S_IRGRP | S_IROTH;
}
if ((ramfs_st.st_mode & RAMFS_MODE_WR) == RAMFS_MODE_WR) {
st->st_mode |= S_IWUSR | S_IWGRP | S_IWOTH;
}
if (ramfs_st.is_dir == 1) {
st->st_mode |= S_IFDIR;
} else {
st->st_mode |= S_IFREG;
}
} else {
ret = -1;
}
return ret;
}
static int32_t ramfs_vfs_fstat(vfs_file_t *fp, vfs_stat_t *st)
{
ramfs_stat_t ramfs_st;
ramfs_file_t ramfs_file;
int32_t ret = 0;
if (st == NULL) {
return -1;
}
memset(&ramfs_st, 0, sizeof(ramfs_st));
memset(&ramfs_file, 0, sizeof(ramfs_file));
ramfs_file.entry = (ramfs_entry_t *)fp->f_arg;
ret = ramfs_stat(ramfs_file.entry->fn, &ramfs_st);
if (ret == 0) {
st->st_size = ramfs_st.st_size;
st->st_mode = S_IXUSR | S_IXGRP | S_IXOTH;
if ((ramfs_st.st_mode & RAMFS_MODE_RD) == RAMFS_MODE_RD) {
st->st_mode |= S_IRUSR | S_IRGRP | S_IROTH;
}
if ((ramfs_st.st_mode & RAMFS_MODE_WR) == RAMFS_MODE_WR) {
st->st_mode |= S_IWUSR | S_IWGRP | S_IWOTH;
}
if (ramfs_st.is_dir == 1) {
st->st_mode |= S_IFDIR;
} else {
st->st_mode |= S_IFREG;
}
} else {
ret = -1;
}
return ret;
}
static int32_t ramfs_vfs_statfs(vfs_file_t *fp, const char *path, vfs_statfs_t *buf)
{
if (buf == NULL) {
return -1;
}
buf->f_type = RAMFS_MAGIC;
buf->f_bsize = 0xFFFFFFFF;
buf->f_blocks = 0xFFFFFFFF;
buf->f_bfree = 0xFFFFFFFF;
buf->f_bavail = 0xFFFFFFFF;
buf->f_files = 0xFFFFFFFF;
buf->f_ffree = 0xFFFFFFFF;
buf->f_fsid = RAMFS_MAGIC;
buf->f_namelen = MAX_RAMFS_FILE_NAME_BYTES;
return 0;
}
static int32_t ramfs_vfs_mkdir(vfs_file_t *fp, const char *path)
{
return ramfs_mkdir(path);
}
static vfs_dirent_t *ramfs_vfs_readdir(vfs_file_t *fp, vfs_dir_t *dir)
{
ramfs_vfs_dir_t *dp = NULL;
vfs_dirent_t *ret = NULL;
int32_t res = -1;
dp = fp->f_arg;
res = ramfs_readdir(&(dp->ramfs_dir), dp->vfs_dirent.d_name);
if (res == 0) {
ret = &dp->vfs_dirent;
}
return ret;
}
static int32_t ramfs_vfs_pathconf(vfs_file_t *fp, const char *path, int32_t name)
{
return ramfs_pathconf(name);
}
static int32_t ramfs_vfs_fpathconf(vfs_file_t *fp, int32_t name)
{
return ramfs_pathconf(name);
}
static int32_t ramfs_vfs_utime(vfs_file_t *fp, const char *path, const vfs_utimbuf_t *times)
{
return RAMFS_ERR_NOT_IMP;
}
static void ramfs_vfs_rewinddir(vfs_file_t *fp, vfs_dir_t *dir)
{
ramfs_vfs_dir_t *dp = NULL;
dp = fp->f_arg;
dp->ramfs_dir.last_entry = NULL;
}
static int ramfs_vfs_rmdir(vfs_file_t *fp, const char *path)
{
return ramfs_rmdir(path);
}
static int ramfs_vfs_sync(vfs_file_t *fp)
{
return 0;
}
vfs_filesystem_ops_t ramfs_ops = {
.open = &ramfs_vfs_open,
.close = &ramfs_vfs_close,
.read = &ramfs_vfs_read,
.write = &ramfs_vfs_write,
.access = &ramfs_vfs_access,
.lseek = &ramfs_vfs_lseek,
.sync = &ramfs_vfs_sync,
.stat = &ramfs_vfs_stat,
.fstat = &ramfs_vfs_fstat,
.statfs = &ramfs_vfs_statfs,
.link = &ramfs_vfs_link,
.unlink = &ramfs_vfs_unlink,
.remove = &ramfs_vfs_remove,
.rename = &ramfs_vfs_rename,
.opendir = &ramfs_vfs_opendir,
.readdir = &ramfs_vfs_readdir,
.closedir = &ramfs_vfs_closedir,
.mkdir = &ramfs_vfs_mkdir,
.seekdir = NULL,
.ioctl = NULL,
.pathconf = &ramfs_vfs_pathconf,
.fpathconf = &ramfs_vfs_fpathconf,
.utime = &ramfs_vfs_utime,
.rewinddir = &ramfs_vfs_rewinddir,
.rmdir = &ramfs_vfs_rmdir
};
int32_t ramfs_register(const char *mount_path)
{
int32_t ret = RAMFS_ERR_NOT_IMP;
ramfs_init();
if (mount_path != NULL) {
ret = ramfs_mkdir(mount_path);
if (ret == 0) {
return vfs_register_fs(mount_path, &ramfs_ops, NULL);
}
} else {
ret = ramfs_mkdir(RAMFS_DEFAULT_MOUNT_PATH);
if (ret == 0) {
return vfs_register_fs(RAMFS_DEFAULT_MOUNT_PATH, &ramfs_ops, NULL);
}
}
return ret;
}
static int32_t ramfs_vfs_rmdir_r(const char *path)
{
vfs_file_t fp;
vfs_dir_t *dir;
vfs_dirent_t *dirent;
int newpath_len;
char *newpath = NULL;
vfs_stat_t st;
int ret = 0;
dir = ramfs_vfs_opendir(&fp, path);
if(dir) {
newpath_len = strlen(path) + MAX_RAMFS_FILE_NAME_BYTES;
newpath = ramfs_mm_alloc(newpath_len);
if (NULL == newpath) {
ramfs_vfs_closedir(&fp, dir);
return -1;
}
while ((dirent = (ramfs_vfs_readdir(&fp, dir))) != NULL) {
if (strcmp(dirent->d_name, ".") == 0 || strcmp(dirent->d_name, "..") == 0) {
continue;
} else {
memset(newpath, 0, newpath_len);
snprintf(newpath, newpath_len, "%s/%s", path, dirent->d_name);
memset(&st, 0, sizeof(vfs_stat_t));
if (!ramfs_vfs_stat(NULL, newpath, &st)) {
if (st.st_mode & S_IFDIR) {
ret = ramfs_vfs_rmdir_r(newpath);
if (ret) {
break;
}
ret = ramfs_vfs_rmdir(NULL, newpath);
if (ret) {
break;
}
} else if (st.st_mode & S_IFREG){
ramfs_unlink(newpath);
}
} else {
ret = -1;
break;
}
}
}
ramfs_mm_free(newpath);
ramfs_vfs_closedir(&fp, dir);
return ret;
}
return -1;
}
int32_t ramfs_unregister(const char *mount_path)
{
int32_t ret;
if (NULL == mount_path) {
mount_path = RAMFS_DEFAULT_MOUNT_PATH;
}
// 1. recursively delete the files and dirs in ramfs
ret = ramfs_vfs_rmdir_r(mount_path);
if (ret) {
return ret;
}
// 2. unregister the fs from vfs
ret = vfs_unregister_fs(mount_path);
if (ret) {
return ret;
}
// 3. rm mount path
ret = ramfs_rmdir(mount_path);
// 4. deinit ramfs
ramfs_deinit();
return ret;
}
|
YifuLiu/AliOS-Things
|
components/ramfs/src/ramfs_vfs.c
|
C
|
apache-2.0
| 11,514
|
/*
* Copyright (C) 2020-2021 Alibaba Group Holding Limited
*/
#include <stdlib.h>
#include <fcntl.h>
#include <stdio.h>
#include "select.h"
#include "aos/vfs.h"
#if AOS_COMP_CLI
#include "aos/cli.h"
#endif
extern int vfs_test_device_init(void);
extern int vfs_test_device_deinit(void);
static void select_example()
{
int ret;
int test_fd;
int maxfd;
int write_val = 1;
fd_set readset;
fd_set writeset;
fd_set exceptset;
struct timeval tv = {
.tv_sec = 2,
.tv_usec = 0,
};
FD_ZERO(&readset);
FD_ZERO(&writeset);
FD_ZERO(&exceptset);
test_fd = aos_open("/dev/test", O_RDWR);
if(test_fd < 0) {
printf("open test device err\r\n");
return;
}
FD_SET(test_fd, &readset);
maxfd = test_fd + 1;
ret = aos_select(maxfd, &readset, &writeset, &exceptset, &tv);
printf("aos_select timeout:ret = %d\r\n", ret);
aos_write(test_fd, &write_val, sizeof(write_val));
FD_SET(test_fd, &readset);
ret = aos_select(maxfd, &readset, &writeset, &exceptset, &tv);
printf("aos_select ret = %d\r\n", ret);
if (FD_ISSET(test_fd, &readset)) {
int data = 0;
int len = aos_read(test_fd, &data, sizeof(data));
if(len > 0) {
printf(" read fd =%d,data = %d\r\n", test_fd, data);
} else {
printf("err: read no data\r\n");
}
}
aos_close(test_fd);
}
static void poll_example()
{
int ret;
int test_fd;
int write_val = 1;
struct pollfd poll_array[2] = {0};
test_fd = aos_open("/dev/test", O_RDWR);
if(test_fd < 0) {
printf("open test device err\r\n");
return;
}
poll_array[0].events = POLLIN;
poll_array[0].fd = test_fd;
ret = aos_poll(poll_array, 2, 1000);
printf("aos_poll timeout, ret = %d \r\n", ret);
/* test write event1 */
ret = aos_write(test_fd, &write_val, sizeof(write_val));
ret = aos_poll(poll_array, 2, 1000);
printf("aos_poll ret = %d \r\n", ret);
if (poll_array[0].revents & POLLIN) {
int data = 0;
int len = aos_read(test_fd, &data, sizeof(data));
if(len > 0) {
printf(" read fd =%d,data = %d\r\n", test_fd, data);
} else {
printf("err: read no data\r\n");
}
}
aos_close(test_fd);
}
static void select_comp_example(int argc, char **argv)
{
/* init a test vfs device for poll and select */
vfs_test_device_init();
/* select test */
printf("+++++++select example+++++++++\r\n");
select_example();
/* poll test */
printf("+++++++poll example+++++++++\r\n");
poll_example();
vfs_test_device_deinit();
return;
}
#if AOS_COMP_CLI
/* reg args: fun, cmd, description*/
ALIOS_CLI_CMD_REGISTER(select_comp_example, select_example, select and poll API base example)
#endif
|
YifuLiu/AliOS-Things
|
components/select/example/select_example.c
|
C
|
apache-2.0
| 2,849
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "aos/list.h"
#include "aos/vfs.h"
#include "poll.h"
#define CACHE_COUNT 5
#define MK_CMD(c, l) ((l << 4) | (c))
#define _GET_LEN(cmd) ((cmd) >> 4)
#define _GET_CMD(cmd) ((cmd) & 0xf)
typedef struct {
aos_mutex_t mutex;
poll_notify_t poll_cb;
struct pollfd *fd;
void *poll_data;
int counter;
dlist_t bufs;
int cache_count;
dlist_t buf_cache;
} event_dev_t;
typedef struct {
dlist_t node;
size_t len;
char buf[];
} dev_event_t;
static int event_open(inode_t *node, file_t *file)
{
event_dev_t *pdev = (event_dev_t *)aos_malloc(sizeof * pdev);
memset(pdev, 0, sizeof (*pdev));
aos_mutex_new(&pdev->mutex);
dlist_init(&pdev->bufs);
dlist_init(&pdev->buf_cache);
file->f_arg = pdev;
return 0;
}
static int event_close(file_t *file)
{
event_dev_t *pdev = file->f_arg;
aos_mutex_free(&pdev->mutex);
while (!dlist_empty(&pdev->bufs)) {
dlist_t *n = pdev->bufs.next;
dlist_del(n);
aos_free(n);
}
while (!dlist_empty(&pdev->buf_cache)) {
dlist_t *n = pdev->buf_cache.next;
dlist_del(n);
aos_free(n);
}
aos_free(pdev);
return 0;
}
static ssize_t _event_write(file_t *f, const void *buf, size_t len, bool urgent)
{
event_dev_t *pdev = f->f_arg;
aos_mutex_lock(&pdev->mutex, AOS_WAIT_FOREVER);
ssize_t ret = len;
dev_event_t *evt;
evt = (dev_event_t *)pdev->buf_cache.next;
if (pdev->cache_count > 0 && evt->len == len) {
dlist_del(&evt->node);
pdev->cache_count --;
} else {
evt = (dev_event_t *)aos_malloc(sizeof(*evt) + len);
}
if (evt == NULL) {
ret = -1;
goto out;
}
pdev->counter ++;
evt->len = len;
memcpy(evt->buf, buf, len);
if (urgent) {
dlist_add(&evt->node, &pdev->bufs);
} else {
dlist_add_tail(&evt->node, &pdev->bufs);
}
if (pdev->poll_cb != NULL) {
pdev->fd->revents |= POLLIN;
pdev->poll_cb(pdev->fd, pdev->poll_data);
}
out:
aos_mutex_unlock(&pdev->mutex);
return ret;
}
static ssize_t event_write(file_t *f, const void *buf, size_t len)
{
return _event_write(f, buf, len, false);
}
static int event_ioctl(file_t *f, int cmd, unsigned long arg)
{
int len = _GET_LEN(cmd);
void *buf = (void *)arg;
cmd = _GET_CMD(cmd);
switch (cmd) {
case 1:
return _event_write(f, buf, len, false);
case 2:
return _event_write(f, buf, len, true);
}
return -1;
}
static ssize_t event_read(file_t *f, void *buf, size_t len)
{
event_dev_t *pdev = f->f_arg;
int cnt = pdev->counter;
if (!cnt) {
return 0;
}
aos_mutex_lock(&pdev->mutex, AOS_WAIT_FOREVER);
dev_event_t *evt = (dev_event_t *)pdev->bufs.next;
dlist_del(&evt->node);
cnt = (len > evt->len) ? evt->len : len;
memcpy(buf, evt->buf, cnt);
if (pdev->cache_count < CACHE_COUNT) {
dlist_add(&evt->node, &pdev->buf_cache);
pdev->cache_count ++;
} else {
aos_free(evt);
}
if (-- pdev->counter == 0) {
if (pdev->fd != NULL) {
pdev->fd->revents &= ~POLLIN;
}
}
aos_mutex_unlock(&pdev->mutex);
return cnt;
}
static int event_poll(file_t *f, int setup, poll_notify_t notify,
void *fd, void *opa)
{
event_dev_t *pdev = f->f_arg;
aos_mutex_lock(&pdev->mutex, AOS_WAIT_FOREVER);
if (!setup) {
pdev->poll_cb = NULL;
pdev->poll_data = NULL;
goto out;
}
pdev->poll_cb = notify;
pdev->fd = (struct pollfd *)fd;
pdev->poll_data = opa;
if (pdev->counter) {
pdev->fd->revents |= POLLIN;
(*notify)(fd, opa);
} else {
pdev->fd->revents &= ~POLLIN;
}
out:
aos_mutex_unlock(&pdev->mutex);
return 0;
}
static file_ops_t event_fops = {
.open = event_open,
.read = event_read,
.write = event_write,
.close = event_close,
.poll = event_poll,
.ioctl = event_ioctl,
};
int vfs_test_device_init(void)
{
return aos_register_driver("/dev/test", &event_fops, NULL);
}
int vfs_test_device_deinit(void)
{
return aos_unregister_driver("/dev/test");
}
|
YifuLiu/AliOS-Things
|
components/select/example/test_device.c
|
C
|
apache-2.0
| 4,449
|
/*
* Copyright (C) 2020-2021 Alibaba Group Holding Limited
*/
#ifndef AOS_SELECT_H
#define AOS_SELECT_H
#include <poll.h>
#undef POLLIN
#define POLLIN 0x001
#undef POLLOUT
#define POLLOUT 0x004
#undef POLLERR
#define POLLERR 0x008
int aos_poll(struct pollfd *fds, int nfds, int timeout);
int aos_select(int maxfd, fd_set *readset, fd_set *writeset, fd_set *exceptset,
struct timeval *timeout);
#endif
|
YifuLiu/AliOS-Things
|
components/select/include/select.h
|
C
|
apache-2.0
| 437
|
/*
* Copyright (C) 2020-2021 Alibaba Group Holding Limited
*/
#include <stdbool.h>
#include <stdio.h>
#include <limits.h>
#include <string.h>
#include <errno.h>
#include "aos/kernel.h"
#include "aos/vfs.h"
#include <select.h>
#ifndef CONFIG_AOS_LWIP
#define CONFIG_NO_TCPIP
#endif
#ifdef CONFIG_NO_TCPIP
struct poll_arg {
aos_sem_t sem;
};
static void vfs_poll_notify(void *fd, void *arg)
{
struct poll_arg *parg = arg;
aos_sem_signal(&parg->sem);
}
static int wait_io(int maxfd, fd_set *rfds, fd_set *wfds, fd_set *efds, struct poll_arg *parg, int timeout)
{
timeout = timeout >= 0 ? timeout : AOS_WAIT_FOREVER;
aos_sem_wait(&parg->sem, timeout);
return 0;
}
static int init_parg(struct poll_arg *parg)
{
aos_sem_new(&parg->sem, 0);
return 0;
}
static void deinit_parg(struct poll_arg *parg)
{
aos_sem_free(&parg->sem);
}
#else
#include <sys/socket.h>
struct poll_arg {
int efd;
};
extern int lwip_write(int s, const void *dataptr, size_t size);
extern int lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset,
struct timeval *timeout);
extern int lwip_eventfd(unsigned int initval, int flags);
extern int lwip_close(int s);
static void vfs_poll_notify(void *fd, void *arg)
{
struct poll_arg *parg = arg;
uint64_t val = 1;
lwip_write(parg->efd, &val, sizeof val);
}
static int init_parg(struct poll_arg *parg)
{
int efd;
efd = lwip_eventfd(0, 0);
if (efd < 0) {
errno = EINVAL;
return -1;
}
parg->efd = efd;
return 0;
}
static void deinit_parg(struct poll_arg *parg)
{
lwip_close(parg->efd);
}
static int wait_io(int maxfd, fd_set *rfds, fd_set *wfds, fd_set *efds, struct poll_arg *parg, int timeout)
{
int ret;
struct timeval tv = {
.tv_sec = timeout / 1000,
.tv_usec = (timeout % 1000) * 1000,
};
FD_SET(parg->efd, rfds);
maxfd = parg->efd > maxfd ? parg->efd : maxfd;
ret = lwip_select(maxfd + 1, rfds, wfds, efds, timeout >= 0 ? &tv : NULL);
/* return socketfd event num only ,so we sub event fd num */
if (ret > 0) {
if (FD_ISSET(parg->efd, rfds)) {
ret--;
}
if (FD_ISSET(parg->efd, wfds)) {
errno = EINVAL;
return -1;
}
if (FD_ISSET(parg->efd, efds)) {
errno = EINVAL;
return -1;
}
}
return ret;
}
#endif
static int pre_poll(struct pollfd *fds, int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, void *parg)
{
int i;
int maxfd = 0;
for (i = 0; i < nfds; i++) {
struct pollfd *pfd = &fds[i];
pfd->revents = 0;
}
for (i = 0; i < nfds; i++) {
struct pollfd *pfd = &fds[i];
if (pfd->fd < aos_vfs_fd_offset_get()) {
if (pfd->fd > FD_SETSIZE - 1) {
errno = EINVAL;
return -1;
}
if (pfd->events & POLLIN) {
FD_SET(pfd->fd, rfds);
}
if (pfd->events & POLLOUT) {
FD_SET(pfd->fd, wfds);
}
if (pfd->events & POLLERR) {
FD_SET(pfd->fd, efds);
}
maxfd = pfd->fd > maxfd ? pfd->fd : maxfd;
} else {
if (aos_do_pollfd(pfd->fd, true, vfs_poll_notify, pfd, parg) == -ENOENT) {
errno = ENOENT;
return -1;
}
}
}
return maxfd;
}
static int post_poll(struct pollfd *fds, int nfds)
{
int j;
int ret = 0;
for (j = 0; j < nfds; j++) {
struct pollfd *pfd = &fds[j];
if (pfd->fd < aos_vfs_fd_offset_get()) {
continue;
}
if (aos_do_pollfd(pfd->fd, false, NULL, NULL, NULL) == -ENOENT) {
continue;
}
if (pfd->revents) {
ret ++;
}
}
return ret;
}
int aos_poll(struct pollfd *fds, int nfds, int timeout)
{
fd_set rfds;
fd_set wfds;
fd_set efds;
int ret = 0;
int nset = 0;
struct poll_arg parg;
if (init_parg(&parg) < 0) {
return -1;
}
FD_ZERO(&rfds);
FD_ZERO(&wfds);
FD_ZERO(&efds);
ret = pre_poll(fds, nfds, &rfds, &wfds, &efds, &parg);
if (ret < 0) {
goto check_poll;
}
ret = wait_io(ret, &rfds, &wfds, &efds, &parg, timeout);
if (ret > 0) {
int i;
for (i = 0; i < nfds; i++) {
struct pollfd *pfd = &fds[i];
if (FD_ISSET(pfd->fd, &rfds)) {
pfd->revents |= POLLIN;
}
if (FD_ISSET(pfd->fd, &wfds)) {
pfd->revents |= POLLOUT;
}
if (FD_ISSET(pfd->fd, &efds)) {
pfd->revents |= POLLERR;
}
}
nset += ret;
}
check_poll:
nset += post_poll(fds, nfds);
deinit_parg(&parg);
return ret < 0 ? -1 : nset;
}
|
YifuLiu/AliOS-Things
|
components/select/poll/poll.c
|
C
|
apache-2.0
| 4,919
|
/*
* Copyright (C) 2020-2021 Alibaba Group Holding Limited
*/
#include <stdbool.h>
#include <stdio.h>
#include <limits.h>
#include <string.h>
#include <errno.h>
#include <poll.h>
#include "aos/kernel.h"
#include "aos/vfs.h"
#include "aos/list.h"
#include "sys/socket.h"
#include <select.h>
#define WRITE_VAL 1
#ifndef CONFIG_AOS_LWIP
#define CONFIG_NO_TCPIP
#endif
typedef struct poll_node {
struct pollfd pfd;
dlist_t next;
} poll_node_t;
#ifdef CONFIG_NO_TCPIP
struct poll_arg {
aos_sem_t sem;
};
static void vfs_poll_notify(void *fd, void *arg)
{
struct poll_arg *parg = arg;
aos_sem_signal(&parg->sem);
}
static int init_parg(struct poll_arg *parg)
{
aos_sem_new(&parg->sem, 0);
return 0;
}
static int wait_io(int maxfd, fd_set *readset, fd_set *writeset, fd_set *exceptset,
struct poll_arg *parg, struct timeval *timeout)
{
uint64_t ms = timeout ? (timeout->tv_sec * 1000 + timeout->tv_usec / 1000) : AOS_WAIT_FOREVER;
aos_sem_wait(&parg->sem, ms);
return 0;
}
static void deinit_parg(struct poll_arg *parg)
{
aos_sem_free(&parg->sem);
}
#else
#include <sys/socket.h>
extern int lwip_write(int s, const void *dataptr, size_t size);
extern int lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset,
struct timeval *timeout);
extern int lwip_eventfd(unsigned int initval, int flags);
extern int lwip_close(int s);
struct poll_arg {
int efd;
};
static void vfs_poll_notify(void *fd, void *arg)
{
struct poll_arg *parg = arg;
uint64_t val = WRITE_VAL;
net_write(parg->efd, &val, sizeof val);
}
static int init_parg(struct poll_arg *parg)
{
int efd;
efd = net_eventfd(0, 0);
if (efd < 0) {
errno = EINVAL;
return -1;
}
parg->efd = efd;
return 0;
}
static int wait_io(int maxfd, fd_set *readset, fd_set *writeset, fd_set *exceptset,
struct poll_arg *parg, struct timeval *timeout)
{
int ret = 0;
fd_set *real_rset = readset;
fd_set bk_rset;
if (readset == NULL) {
real_rset = &bk_rset;
memset(real_rset, 0, sizeof(fd_set));
}
FD_SET(parg->efd, real_rset);
maxfd = parg->efd > maxfd - 1 ? (parg->efd + 1) : maxfd;
ret = net_select(maxfd, real_rset, writeset, exceptset, timeout);
if (ret > 0) {
if (FD_ISSET(parg->efd, real_rset)) {
/*mask eventfd event to user*/
ret--;
}
}
FD_CLR(parg->efd, real_rset);
return ret;
}
static void deinit_parg(struct poll_arg *parg)
{
net_close(parg->efd);
}
#endif
static int pre_select(int fd, dlist_t *list, struct poll_arg *parg, fd_set *readset, fd_set *writeset,
fd_set *exceptset)
{
poll_node_t *node;
struct pollfd *pfd = NULL;
if (readset != NULL && FD_ISSET(fd, readset)) {
if (fd < aos_vfs_fd_offset_get()) {
return 0;
}
node = aos_malloc(sizeof(poll_node_t));
if (node == NULL) {
errno = ENOMEM;
return -1;
}
memset(node, 0, sizeof(poll_node_t));
pfd = &node->pfd;
pfd->fd = fd;
pfd->events = POLLIN;
dlist_add(&node->next, list);
/* delete from socket select events */
FD_CLR(fd, readset);
if (aos_do_pollfd(fd, true, vfs_poll_notify, pfd, parg) == -ENOENT) {
return -1;
}
/* read\write\except event add one time only, so continue here */
return 0;
}
if (writeset != NULL && FD_ISSET(fd, writeset)) {
poll_node_t *node;
if (fd < aos_vfs_fd_offset_get()) {
return 0;
}
node = aos_malloc(sizeof(poll_node_t));
if (node == NULL) {
errno = ENOMEM;
return -1;
}
memset(node, 0, sizeof(poll_node_t));
pfd = &node->pfd;
pfd->fd = fd;
pfd->events = POLLOUT;
dlist_add(&node->next, list);
FD_CLR(fd, writeset);
if (aos_do_pollfd(fd, true, vfs_poll_notify, pfd, parg) == -ENOENT) {
return -1;
}
return 0;
}
if (exceptset != NULL && FD_ISSET(fd, exceptset)) {
poll_node_t *node;
if (fd < aos_vfs_fd_offset_get()) {
return 0;
}
node = aos_malloc(sizeof(poll_node_t));
if (node == NULL) {
errno = ENOMEM;
return -1;
}
memset(node, 0, sizeof(poll_node_t));
pfd = &node->pfd;
pfd->fd = fd;
pfd->events = POLLERR;
dlist_add(&node->next, list);
FD_CLR(fd, exceptset);
if (aos_do_pollfd(fd, true, vfs_poll_notify, pfd, parg) == -ENOENT) {
errno = ENOENT;
return -1;
}
return 0;
}
return 0;
}
static int post_select(dlist_t *list, fd_set *readset, fd_set *writeset, fd_set *exceptset)
{
int ret = 0;
dlist_t *temp;
poll_node_t *node;
dlist_for_each_entry_safe(list, temp, node, poll_node_t, next) {
struct pollfd *pfd = &node->pfd;
if (pfd->fd < aos_vfs_fd_offset_get()) {
continue;
}
/* unregister vfs event */
if (aos_do_pollfd(pfd->fd, false, NULL, NULL, NULL) == -ENOENT) {
continue;
}
/* change poll event to select event */
if ((pfd->revents & POLLIN) && (readset != NULL)) {
FD_SET(pfd->fd, readset);
ret ++;
}
if ((pfd->revents & POLLOUT) && (writeset != NULL)) {
FD_SET(pfd->fd, writeset);
ret ++;
}
if ((pfd->revents & POLLERR) && (exceptset != NULL)) {
FD_SET(pfd->fd, exceptset);
ret ++;
}
}
return ret;
}
int aos_select(int maxfd, fd_set *readset, fd_set *writeset, fd_set *exceptset,
struct timeval *timeout)
{
int i;
int ret = -1;
int nset = 0;
struct poll_arg parg;
dlist_t *temp;
poll_node_t *node;
dlist_t vfs_list;
dlist_init(&vfs_list);
if (init_parg(&parg) < 0) {
goto err;
}
for (i = 0; i < maxfd; i++) {
if (pre_select(i, &vfs_list, &parg, readset, writeset, exceptset) < 0) {
deinit_parg(&parg);
goto err;
}
}
ret = wait_io(maxfd, readset, writeset, exceptset, &parg, timeout);
nset = ret + post_select(&vfs_list, readset, writeset, exceptset);
deinit_parg(&parg);
err:
dlist_for_each_entry_safe(&vfs_list, temp, node, poll_node_t, next) {
dlist_del(&node->next);
aos_free(node);
}
return ret < 0 ? -1 : nset;
}
|
YifuLiu/AliOS-Things
|
components/select/select/select.c
|
C
|
apache-2.0
| 6,660
|
ifeq ($(AOS_SENSOR_ACC_ADI_ADXL372),y)
$(NAME)_SOURCES += drv/drv_acc_adi_adxl372.c
endif
ifeq ($(AOS_SENSOR_ACC_ADI_ADXL345),y)
$(NAME)_SOURCES += drv/drv_acc_adi_adxl345.c
endif
ifeq ($(AOS_SENSOR_ACC_ADI_ADXL355),y)
$(NAME)_SOURCES += drv/drv_acc_adi_adxl355.c
endif
ifeq ($(AOS_SENSOR_ACC_BOSCH_BMA253),y)
$(NAME)_SOURCES += drv/drv_acc_bosch_bma253.c
endif
ifeq ($(AOS_SENSOR_ACC_BOSCH_BMA280),y)
$(NAME)_SOURCES += drv/drv_acc_bosch_bma280.c
endif
ifeq ($(AOS_SENSOR_ACC_BOSCH_BMA421),y)
$(NAME)_SOURCES += drv/drv_acc_bosch_bma421.c
endif
ifeq ($(AOS_SENSOR_ACC_BOSCH_BMA422),y)
$(NAME)_SOURCES += drv/drv_acc_bosch_bma422.c
endif
ifeq ($(AOS_SENSOR_ACC_BOSCH_BMA455),y)
$(NAME)_SOURCES += drv/drv_acc_bosch_bma455.c
endif
ifeq ($(AOS_SENSOR_ACC_BOSCH_BMA456),y)
$(NAME)_SOURCES += drv/drv_acc_bosch_bma456.c
endif
ifeq ($(AOS_SENSOR_ACC_BOSCH_BMI055),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_bosch_bmi055.c
endif
ifeq ($(AOS_SENSOR_ACC_BOSCH_BMI088),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_bosch_bmi088.c
endif
ifeq ($(AOS_SENSOR_ACC_BOSCH_BMI120),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_bosch_bmi120.c
endif
ifeq ($(AOS_SENSOR_ACC_BOSCH_BMI160),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_bosch_bmi160.c
endif
ifeq ($(AOS_SENSOR_ACC_BOSCH_BMI260),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_bosch_bmi260.c
endif
ifeq ($(AOS_SENSOR_ACC_SENODIA_SH200L),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_senodia_sh200l.c
endif
ifeq ($(AOS_SENSOR_ACC_SENODIA_SH200Q),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_senodia_sh200q.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_LSM6DS3),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_st_lsm6ds3.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_LSM6DS3TR_C),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_st_lsm6ds3tr_c.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_LSM6DSL),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_st_lsm6dsl.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_LSM6DSM),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_st_lsm6dsm.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_LSM6DSOQ),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_st_lsm6dsoq.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_LSM6DSR),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_st_lsm6dsr.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_LSM303AGR),y)
$(NAME)_SOURCES += drv/drv_acc_mag_st_lsm303agr.c
endif
ifeq ($(AOS_SENSOR_ACC_MIR3_DA213B),y)
$(NAME)_SOURCES += drv/drv_acc_mir3_da213B.c
endif
ifeq ($(AOS_SENSOR_ACC_MIR3_DA215),y)
$(NAME)_SOURCES += drv/drv_acc_mir3_da215.c
endif
ifeq ($(AOS_SENSOR_ACC_MIR3_DA217),y)
$(NAME)_SOURCES += drv/drv_acc_mir3_da217.c
endif
ifeq ($(AOS_SENSOR_ACC_MIR3_DA270),y)
$(NAME)_SOURCES += drv/drv_acc_mir3_da270.c
endif
ifeq ($(AOS_SENSOR_ACC_MIR3_DA312B),y)
$(NAME)_SOURCES += drv/drv_acc_mir3_da312B.c
endif
ifeq ($(AOS_SENSOR_ACC_MIR3_DA380B),y)
$(NAME)_SOURCES += drv/drv_acc_mir3_da380B.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_AIS328DQ),y)
$(NAME)_SOURCES += drv/drv_acc_st_ais328dq.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_H3LIS100DL),y)
$(NAME)_SOURCES += drv/drv_acc_st_h3lis100dl.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_H3LIS331DL),y)
$(NAME)_SOURCES += drv/drv_acc_st_h3lis331dl.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_LIS2DH12),y)
$(NAME)_SOURCES += drv/drv_acc_st_lis2dh12.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_LIS2DW12),y)
$(NAME)_SOURCES += drv/drv_acc_st_lis2dw12.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_LIS2HH12),y)
$(NAME)_SOURCES += drv/drv_acc_st_lis2hh12.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_LIS3DH),y)
$(NAME)_SOURCES += drv/drv_acc_st_lis3dh.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_LIS331HH),y)
$(NAME)_SOURCES += drv/drv_acc_st_lis331hh.c
endif
ifeq ($(AOS_SENSOR_ACC_ST_N2DM),y)
$(NAME)_SOURCES += drv/drv_acc_st_n2dm.c
endif
ifeq ($(AOS_SENSOR_GYRO_BOSCH_BMI055),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_bosch_bmi055.c
endif
ifeq ($(AOS_SENSOR_GYRO_BOSCH_BMI088),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_bosch_bmi088.c
endif
ifeq ($(AOS_SENSOR_GYRO_BOSCH_BMI120),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_bosch_bmi120.c
endif
ifeq ($(AOS_SENSOR_GYRO_BOSCH_BMI160),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_bosch_bmi160.c
endif
ifeq ($(AOS_SENSOR_GYRO_BOSCH_BMI260),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_bosch_bmi260.c
endif
ifeq ($(AOS_SENSOR_GYRO_SENODIA_SH200L),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_senodia_sh200l.c
endif
ifeq ($(AOS_SENSOR_GYRO_SENODIA_SH200Q),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_senodia_sh200q.c
endif
ifeq ($(AOS_SENSOR_GYRO_ST_LSM6DS3),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_st_lsm6ds3.c
endif
ifeq ($(AOS_SENSOR_GYRO_ST_LSM6DS3TR_C),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_st_lsm6ds3tr_c.c
endif
ifeq ($(AOS_SENSOR_GYRO_ST_LSM6DSL),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_st_lsm6dsl.c
endif
ifeq ($(AOS_SENSOR_GYRO_ST_LSM6DSM),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_st_lsm6dsm.c
endif
ifeq ($(AOS_SENSOR_GYRO_ST_LSM6DSOQ),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_st_lsm6dsoq.c
endif
ifeq ($(AOS_SENSOR_GYRO_ST_LSM6DSR),y)
$(NAME)_SOURCES += drv/drv_acc_gyro_st_lsm6dsr.c
endif
ifeq ($(AOS_SENSOR_GYRO_BOSCH_BMG160),y)
$(NAME)_SOURCES += drv/drv_gyro_bosch_bmg160.c
endif
ifeq ($(AOS_SENSOR_GYRO_ST_A3G4250D),y)
$(NAME)_SOURCES += drv/drv_gyro_st_a3g4250d.c
endif
ifeq ($(AOS_SENSOR_GYRO_ST_I3G4250D),y)
$(NAME)_SOURCES += drv/drv_gyro_st_i3g4250d.c
endif
ifeq ($(AOS_SENSOR_GYRO_ST_L3GD20H),y)
$(NAME)_SOURCES += drv/drv_gyro_st_l3gd20h.c
endif
ifeq ($(AOS_SENSOR_MAG_BOSCH_BMM150),y)
$(NAME)_SOURCES += drv/drv_mag_bosch_bmm150.c
endif
ifeq ($(AOS_SENSOR_MAG_ST_LSM303AGR),y)
$(NAME)_SOURCES += drv/drv_acc_mag_st_lsm303agr.c
endif
ifeq ($(AOS_SENSOR_MAG_AKM_AK09917),y)
$(NAME)_SOURCES += drv/drv_mag_akm_ak09917.c
endif
ifeq ($(AOS_SENSOR_MAG_AKM_AK09918),y)
$(NAME)_SOURCES += drv/drv_mag_akm_ak09918.c
endif
ifeq ($(AOS_SENSOR_MAG_AKM_AK09940),y)
$(NAME)_SOURCES += drv/drv_mag_akm_ak09940.c
endif
ifeq ($(AOS_SENSOR_MAG_ROHM_BM1422A),y)
$(NAME)_SOURCES += drv/drv_mag_rohm_bm1422a.c
endif
ifeq ($(AOS_SENSOR_MAG_SENODIA_ST350),y)
$(NAME)_SOURCES += drv/drv_mag_senodia_st350.c
endif
ifeq ($(AOS_SENSOR_MAG_SENODIA_ST480),y)
$(NAME)_SOURCES += drv/drv_mag_senodia_st480.c
endif
ifeq ($(AOS_SENSOR_MAG_ST_LIS2MDL),y)
$(NAME)_SOURCES += drv/drv_mag_st_lis2mdl.c
endif
ifeq ($(AOS_SENSOR_MAG_ST_LIS3MDL),y)
$(NAME)_SOURCES += drv/drv_mag_st_lis3mdl.c
endif
ifeq ($(AOS_SENSOR_MAG_MEMSIC_MMC3680KJ),y)
$(NAME)_SOURCES += drv/drv_mag_temp_memsic_mmc3680kj.c
endif
ifeq ($(AOS_SENSOR_ALS_AMS_TCS3400),y)
$(NAME)_SOURCES += drv/drv_als_ams_tcs3400.c
endif
ifeq ($(AOS_SENSOR_ALS_AMS_TMD2725),y)
$(NAME)_SOURCES += drv/drv_als_ps_ams_tmd2725.c
endif
ifeq ($(AOS_SENSOR_ALS_LITEON_LTR303),y)
$(NAME)_SOURCES += drv/drv_als_liteon_ltr303.c
endif
ifeq ($(AOS_SENSOR_ALS_LITEON_LTR568),y)
$(NAME)_SOURCES += drv/drv_als_liteon_ltr568.c
endif
ifeq ($(AOS_SENSOR_ALS_LITEON_LTR507),y)
$(NAME)_SOURCES += drv/drv_als_ps_liteon_ltr507.c
endif
ifeq ($(AOS_SENSOR_ALS_LITEON_LTR553),y)
$(NAME)_SOURCES += drv/drv_als_ps_liteon_ltr553.c
endif
ifeq ($(AOS_SENSOR_ALS_LITEON_LTR559),y)
$(NAME)_SOURCES += drv/drv_als_ps_liteon_ltr559.c
endif
ifeq ($(AOS_SENSOR_ALS_ROHM_BH1730),y)
$(NAME)_SOURCES += drv/drv_als_rohm_bh1730.c
endif
ifeq ($(AOS_SENSOR_PS_AMS_TMD2725),y)
$(NAME)_SOURCES += drv/drv_als_ps_ams_tmd2725.c
endif
ifeq ($(AOS_SENSOR_PS_LITEON_LTR507),y)
$(NAME)_SOURCES += drv/drv_als_ps_liteon_ltr507.c
endif
ifeq ($(AOS_SENSOR_PS_LITEON_LTR553),y)
$(NAME)_SOURCES += drv/drv_als_ps_liteon_ltr553.c
endif
ifeq ($(AOS_SENSOR_PS_LITEON_LTR559),y)
$(NAME)_SOURCES += drv/drv_als_ps_liteon_ltr559.c
endif
ifeq ($(AOS_SENSOR_PS_LITEON_LTR659),y)
$(NAME)_SOURCES += drv/drv_ps_liteon_ltr659.c
endif
ifeq ($(AOS_SENSOR_PS_LITEON_LTR690),y)
$(NAME)_SOURCES += drv/drv_ps_liteon_ltr690.c
endif
ifeq ($(AOS_SENSOR_PS_LITEON_LTR706),y)
$(NAME)_SOURCES += drv/drv_ps_liteon_ltr706.c
endif
ifeq ($(AOS_SENSOR_BARO_IFX_DSP310),y)
$(NAME)_SOURCES += drv/drv_baro_ifx_dps310.c
endif
ifeq ($(AOS_SENSOR_BARO_BOSCH_BMP280),y)
$(NAME)_SOURCES += drv/drv_baro_bosch_bmp280.c
endif
ifeq ($(AOS_SENSOR_BARO_BOSCH_BMP380),y)
$(NAME)_SOURCES += drv/drv_baro_bosch_bmp38x.c
endif
ifeq ($(AOS_SENSOR_BARO_ROHM_BM1383A),y)
$(NAME)_SOURCES += drv/drv_baro_rohm_bm1383a.c
endif
ifeq ($(AOS_SENSOR_BARO_ST_LPS22HB),y)
$(NAME)_SOURCES += drv/drv_baro_st_lps22hb.c
endif
ifeq ($(AOS_SENSOR_BARO_ST_LPS33HB),y)
$(NAME)_SOURCES += drv/drv_baro_st_lps33hb.c
endif
ifeq ($(AOS_SENSOR_BARO_ST_LPS35HB),y)
$(NAME)_SOURCES += drv/drv_baro_st_lps35hb.c
endif
ifeq ($(AOS_SENSOR_BARO_BOSCH_BME280),y)
$(NAME)_SOURCES += drv/drv_temp_humi_baro_bosch_bme280.c
endif
ifeq ($(AOS_SENSOR_GESTURE_PIXART_PAJ7620),y)
$(NAME)_SOURCES += drv/drv_gs_pixart_paj7620.c
endif
ifeq ($(AOS_SENSOR_IR_AKM_AK9754),y)
$(NAME)_SOURCES += drv/drv_ir_akm_ak9754.c
endif
ifeq ($(AOS_SENSOR_RGB_LITEON_LTR381),y)
$(NAME)_SOURCES += drv/drv_rgb_liteon_ltr381.c
endif
ifeq ($(AOS_SENSOR_RTC_MAXIM_DS1307),y)
$(NAME)_SOURCES += drv/drv_rtc_maxim_ds1307.c
endif
ifeq ($(AOS_SENSOR_UV_LITEON_LTR390),y)
$(NAME)_SOURCES += drv/drv_uv_liteon_ltr390.c
endif
ifeq ($(AOS_SENSOR_TEMP_AMS_ENS210),y)
$(NAME)_SOURCES += drv/drv_temp_humi_ams_ens210.c
endif
ifeq ($(AOS_SENSOR_TEMP_ADI_ADT7410),y)
$(NAME)_SOURCES += drv/drv_temp_adi_adt7410.c
endif
ifeq ($(AOS_SENSOR_TEMP_BOSCH_BME280),y)
$(NAME)_SOURCES += drv/drv_temp_humi_baro_bosch_bme280.c
endif
ifeq ($(AOS_SENSOR_TEMP_SENSIRION_SHT30),y)
$(NAME)_SOURCES += drv/drv_temp_humi_sensirion_sht30.c
endif
ifeq ($(AOS_SENSOR_TEMP_SENSIRION_SHT31),y)
$(NAME)_SOURCES += drv/drv_temp_humi_sensirion_sht31.c
endif
ifeq ($(AOS_SENSOR_TEMP_SENSIRION_SHTC1),y)
$(NAME)_SOURCES += drv/drv_temp_humi_sensirion_shtc1.c
endif
ifeq ($(AOS_SENSOR_TEMP_ST_HTS221),y)
$(NAME)_SOURCES += drv/drv_temp_humi_st_hts221.c
endif
ifeq ($(AOS_SENSOR_HUMI_AMS_ENS210),y)
$(NAME)_SOURCES += drv/drv_temp_humi_ams_ens210.c
endif
ifeq ($(AOS_SENSOR_HUMI_BOSCH_BME280),y)
$(NAME)_SOURCES += drv/drv_temp_humi_baro_bosch_bme280.c
endif
ifeq ($(AOS_SENSOR_HUMI_SENSIRION_SHT30),y)
$(NAME)_SOURCES += drv/drv_temp_humi_sensirion_sht30.c
endif
ifeq ($(AOS_SENSOR_HUMI_SENSIRION_SHT31),y)
$(NAME)_SOURCES += drv/drv_temp_humi_sensirion_sht31.c
endif
ifeq ($(AOS_SENSOR_HUMI_SENSIRION_SHTC1),y)
$(NAME)_SOURCES += drv/drv_temp_humi_sensirion_shtc1.c
endif
ifeq ($(AOS_SENSOR_HUMI_ST_HTS221),y)
$(NAME)_SOURCES += drv/drv_temp_humi_st_hts221.c
endif
ifeq ($(AOS_SENSOR_CO2_SENSIRION_SCD30),y)
$(NAME)_SOURCES += drv/drv_co2_sensirion_scd30.c
endif
ifeq ($(AOS_SENSOR_ECG_ADI_ADPD188GG),y)
$(NAME)_SOURCES += drv/drv_ecg_adi_adpd188gg.c
endif
ifeq ($(AOS_SENSOR_TVOC_SENSIRION_SGP30),y)
$(NAME)_SOURCES += drv/drv_tvoc_sensirion_sgp30.c
endif
ifeq ($(AOS_SENSOR_TVOC_AMS_CCS811),y)
$(NAME)_SOURCES += drv/drv_tvoc_ams_ccs811.c
endif
ifeq ($(AOS_SENSOR_HUMI_BME280_SPI),y)
$(NAME)_SOURCES += drv/drv_temp_humi_baro_bosch_bme280.c
endif
ifeq ($(AOS_SENSOR_BARO_BME280_SPI),y)
$(NAME)_SOURCES += drv/drv_temp_humi_baro_bosch_bme280.c
endif
ifeq ($(AOS_SENSOR_TEMP_BME280_SPI),y)
$(NAME)_SOURCES += drv/drv_temp_humi_baro_bosch_bme280.c
endif
ifeq ($(AOS_SENSOR_CANBUS_INV_MPU9250),y)
$(NAME)_SOURCES += drv/drv_canbus_inv_mpu9250.c
endif
ifeq ($(AOS_SENSOR_PS_ST_VL53L0X),y)
$(NAME)_SOURCES += drv/drv_ps_st_vl53l0x/drv_ps_st_vl53l0x.c
$(NAME)_SOURCES += drv/drv_ps_st_vl53l0x/vl53l0x_platform.c
$(NAME)_SOURCES += drv/drv_ps_st_vl53l0x/vl53l0x/vl53l0x_api.c
$(NAME)_SOURCES += drv/drv_ps_st_vl53l0x/vl53l0x/vl53l0x_api_calibration.c
$(NAME)_SOURCES += drv/drv_ps_st_vl53l0x/vl53l0x/vl53l0x_api_core.c
$(NAME)_SOURCES += drv/drv_ps_st_vl53l0x/vl53l0x/vl53l0x_api_ranging.c
$(NAME)_SOURCES += drv/drv_ps_st_vl53l0x/vl53l0x/vl53l0x_api_strings.c
$(NAME)_SOURCES += drv/drv_ps_st_vl53l0x/vl53l0x/vl53l0x_platform_log.c
endif
|
YifuLiu/AliOS-Things
|
components/sensor/drv.mk
|
Makefile
|
apache-2.0
| 11,475
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define ADXL345_I2C_ADDR1 (0x1D)
#define ADXL345_I2C_ADDR2 (0x53)
#define ADXL345_I2C_ADDR_TRANS(n) ((n) << 1)
#define ADXL345_I2C_ADDR ADXL345_I2C_ADDR_TRANS(ADXL345_I2C_ADDR2)
#define ADXL345_DEVID 0x00
#define ADXL345_RESERVED1 0x01
#define ADXL345_THRESH_TAP 0x1d
#define ADXL345_OFSX 0x1e
#define ADXL345_OFSY 0x1f
#define ADXL345_OFSZ 0x20
#define ADXL345_DUR 0x21
#define ADXL345_LATENT 0x22
#define ADXL345_WINDOW 0x23
#define ADXL345_THRESH_ACT 0x24
#define ADXL345_THRESH_INACT 0x25
#define ADXL345_TIME_INACT 0x26
#define ADXL345_ACT_INACT_CTL 0x27
#define ADXL345_THRESH_FF 0x28
#define ADXL345_TIME_FF 0x29
#define ADXL345_TAP_AXES 0x2a
#define ADXL345_ACT_TAP_STATUS 0x2b
#define ADXL345_BW_RATE 0x2c
#define ADXL345_POWER_CTL 0x2d
#define ADXL345_INT_ENABLE 0x2e
#define ADXL345_INT_MAP 0x2f
#define ADXL345_INT_SOURCE 0x30
#define ADXL345_DATA_FORMAT 0x31
#define ADXL345_DATAX0 0x32
#define ADXL345_DATAX1 0x33
#define ADXL345_DATAY0 0x34
#define ADXL345_DATAY1 0x35
#define ADXL345_DATAZ0 0x36
#define ADXL345_DATAZ1 0x37
#define ADXL345_FIFO_CTL 0x38
#define ADXL345_FIFO_STATUS 0x39
#define ADXL345_DEVICE_ID_VALUE 0xE5
#define ADXL345_POWER_CTL_MSK 0xC0
#define ADXL345_MEASURE_MODE (0x01 << 3)
#define ADXL345_STAND_BY_MODE (0x00 << 3)
#define ADXL345_SLEEP_MODE (0X01 << 2)
#define ADXL345_ODR_3200HZ 0x0F // 3200Hz
#define ADXL345_ODR_1600HZ 0x0E // 1600Hz
#define ADXL345_ODR_800HZ 0x0D // 800Hz
#define ADXL345_ODR_400HZ 0x0C // 400Hz
#define ADXL345_ODR_200HZ 0x0B // 200Hz
#define ADXL345_ODR_100HZ 0x0A // 100Hz
#define ADXL345_ODR_50HZ 0x09 // 50Hz
#define ADXL345_ODR_25HZ 0x08 // 25Hz
#define ADXL345_ODR_12_5HZ 0x07 // 12.5Hz
#define ADXL345_ODR_6_25HZ 0x06 // 6.25Hz
#define ADXL345_ODR_3_13HZ 0x05 // 3.13Hz
#define ADXL345_ODR_1_56HZ 0x04 // 1.56Hz
#define ADXL345_ODR_0_78HZ 0x03 // 0.78Hz
#define ADXL345_ODR_0_39HZ 0x02 // 0.39Hz
#define ADXL345_ODR_0_2HZ 0x01 // 0.2Hz
#define ADXL345_ODR_0_1HZ 0x00 // 0.1Hz
#define ADXL345_ODR_BIT_MASK 0xF0
#define ADXL345_DEFAULT_ODR_100HZ 100
#define ADXL345_RANGE_2G 0x00
#define ADXL345_RANGE_4G 0x01
#define ADXL345_RANGE_8G 0x02
#define ADXL345_RANGE_16G 0x03
#define ADXL345_RANGE_MSK 0xFC
#define ADXL345_DEFAULT_RANG_2G ACC_RANGE_2G
// adxl345 sensitivity factor table, the unit is LSB/g
int32_t adxl345_factor = 1;
uint32_t g_adxl345_range = ACC_RANGE_2G;
i2c_dev_t adxl345_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = ADXL345_I2C_ADDR,
};
static int drv_acc_adi_adxl345_validate_id(i2c_dev_t *drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if (drv == NULL) {
return -1;
}
ret =
sensor_i2c_read(drv, ADXL345_DEVID, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
if (id_value != value) {
return -1;
}
return 0;
}
static int drv_acc_adi_adxl345_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
uint8_t value;
int ret = 0;
ret = sensor_i2c_read(drv, ADXL345_POWER_CTL, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_ON: {
value &= ADXL345_POWER_CTL_MSK;
value |= ADXL345_MEASURE_MODE;
ret = sensor_i2c_write(drv, ADXL345_POWER_CTL, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_POWER_OFF: {
value &= ADXL345_POWER_CTL_MSK;
value |= ADXL345_STAND_BY_MODE;
ret = sensor_i2c_write(drv, ADXL345_POWER_CTL, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_SLEEP: {
value &= ADXL345_POWER_CTL_MSK;
value |= ADXL345_SLEEP_MODE;
ret = sensor_i2c_write(drv, ADXL345_POWER_CTL, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
default:
break;
}
return 0;
}
static int drv_acc_adi_adxl345_set_odr(i2c_dev_t *drv, float odr)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, ADXL345_BW_RATE, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (odr >= 3200) {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_3200HZ;
} else if (odr >= 1600) {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_1600HZ;
} else if (odr >= 800) {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_800HZ;
} else if (odr >= 400) {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_400HZ;
} else if (odr >= 200) {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_200HZ;
} else if (odr >= 100) {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_100HZ;
} else if (odr >= 50) {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_50HZ;
} else if (odr >= 25) {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_25HZ;
} else if (odr >= 12.5) {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_12_5HZ;
} else if (odr >= 6.25) {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_6_25HZ;
} else if (odr >= 3.13) {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_3_13HZ;
} else if (odr >= 1.56) {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_1_56HZ;
} else if (odr >= 0.78) {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_0_78HZ;
} else if (odr >= 0.39) {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_0_39HZ;
} else if (odr >= 0.20) {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_0_2HZ;
} else {
value &= ADXL345_ODR_BIT_MASK;
value |= ADXL345_ODR_0_1HZ;
}
ret = sensor_i2c_write(drv, ADXL345_BW_RATE, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_adi_adxl345_set_range(i2c_dev_t *drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, ADXL345_DATA_FORMAT, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (range) {
case ACC_RANGE_2G: {
value &= ADXL345_RANGE_MSK;
value |= ADXL345_RANGE_2G;
} break;
case ACC_RANGE_4G: {
value &= ADXL345_RANGE_MSK;
value |= ADXL345_RANGE_4G;
adxl345_factor = 2;
} break;
case ACC_RANGE_8G: {
value &= ADXL345_RANGE_MSK;
value |= ADXL345_RANGE_8G;
adxl345_factor = 4;
} break;
case ACC_RANGE_16G: {
value &= ADXL345_RANGE_MSK;
value |= ADXL345_RANGE_16G;
adxl345_factor = 8;
} break;
default:
break;
}
/* Write the range register 0x31*/
ret = sensor_i2c_write(drv, ADXL345_DATA_FORMAT, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
g_adxl345_range = range;
return 0;
}
static void drv_acc_adi_adxl345_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_adi_adxl345_open(void)
{
int ret = 0;
ret = drv_acc_adi_adxl345_set_power_mode(&adxl345_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_acc_adi_adxl345_close(void)
{
int ret = 0;
ret = drv_acc_adi_adxl345_set_power_mode(&adxl345_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_acc_adi_adxl345_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t LocalBuf[6];
int32_t x_val = 0, y_val = 0, z_val = 0;
accel_data_t *accel = (accel_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(&adxl345_ctx, ADXL345_DATAX0, &LocalBuf[0],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl345_ctx, ADXL345_DATAX1, &LocalBuf[1],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl345_ctx, ADXL345_DATAY0, &LocalBuf[2],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl345_ctx, ADXL345_DATAY1, &LocalBuf[3],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl345_ctx, ADXL345_DATAZ0, &LocalBuf[4],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl345_ctx, ADXL345_DATAZ1, &LocalBuf[5],
I2C_REG_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
x_val = (int16_t)((LocalBuf[1] << 8) | LocalBuf[0]);
y_val = (int16_t)((LocalBuf[3] << 8) | LocalBuf[2]);
z_val = (int16_t)((LocalBuf[5] << 8) | LocalBuf[4]);
accel->data[DATA_AXIS_X] = (int32_t)(x_val * 39 * adxl345_factor / 10);
accel->data[DATA_AXIS_Y] = (int32_t)(y_val * 39 * adxl345_factor / 10);
accel->data[DATA_AXIS_Z] = (int32_t)(z_val * 39 * adxl345_factor / 10);
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_adi_adxl345_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch (cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_acc_adi_adxl345_set_odr(&adxl345_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_acc_adi_adxl345_set_range(&adxl345_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_adi_adxl345_set_power_mode(&adxl345_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
info->model = "ADXL345";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
} break;
default:
break;
}
return 0;
}
int drv_acc_adi_adxl345_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_adi_adxl345_open;
sensor.close = drv_acc_adi_adxl345_close;
sensor.read = drv_acc_adi_adxl345_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_adi_adxl345_ioctl;
sensor.irq_handle = drv_acc_adi_adxl345_irq_handle;
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
ret =
drv_acc_adi_adxl345_validate_id(&adxl345_ctx, ADXL345_DEVICE_ID_VALUE);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_adi_adxl345_set_range(&adxl345_ctx, ACC_RANGE_4G);
if (unlikely(ret)) {
return -1;
}
// set odr is 125hz, and will update
ret = drv_acc_adi_adxl345_set_odr(&adxl345_ctx, ADXL345_DEFAULT_ODR_100HZ);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_adi_adxl345_set_power_mode(&adxl345_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_adi_adxl345_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_adi_adxl345.c
|
C
|
apache-2.0
| 12,512
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define ADXL355_I2C_ADDR1 (0x1D)
#define ADXL355_I2C_ADDR2 (0x53)
#define ADXL355_I2C_ADDR_TRANS(n) ((n) << 1)
#define ADXL355_I2C_ADDR ADXL355_I2C_ADDR_TRANS(ADXL355_I2C_ADDR1)
#define ADI_ADXL355_ADI_DEVID \
0x00u /* Analog Devices, Inc., accelerometer ID \
*/
#define ADI_ADXL355_MST_DEVID 0x01u /* Analog Devices MEMS device ID */
#define ADI_ADXL355_DEVID 0x02u /* Device ID */
#define ADI_ADXL355_REVID 0x03u /* product revision ID*/
#define ADI_ADXL355_STATUS 0x04u /* Status register */
#define ADI_ADXL355_FIFO_ENTRIES 0x05u /* Valid data samples in the FIFO */
#define ADI_ADXL355_TEMP_DATA_2 \
0x06u /* Temperature sensor output data MSBs [11:8]*/
#define ADI_ADXL355_TEMP_DATA_1 \
0x07u /* Temperature sensor output data LSBs [7:0]*/
#define ADI_ADXL355_XDATA3 0x08u /* X-axis acceleration data [19:12]*/
#define ADI_ADXL355_XDATA2 0x09u /* X-axis acceleration data [11:4]*/
#define ADI_ADXL355_XDATA1 \
0x0Au /* X-axis acceleration data [3:0] | LSBs reserved*/
#define ADI_ADXL355_YDATA3 0x0Bu /* Y-axis acceleration data [19:12]*/
#define ADI_ADXL355_YDATA2 0x0Cu /* Y-axis acceleration data [11:4]*/
#define ADI_ADXL355_YDATA1 \
0x0Du /* Y-axis acceleration data [3:0] | LSBs reserved*/
#define ADI_ADXL355_ZDATA3 0x0Eu /* Z-axis acceleration data [19:12]*/
#define ADI_ADXL355_ZDATA2 0x0Fu /* Z-axis acceleration data [11:4]*/
#define ADI_ADXL355_ZDATA1 \
0x10u /* Z-axis acceleration data [3:0] | LSBs reserved*/
#define ADI_ADXL355_OFFSET_X_H 0x1Eu /* X axis offset [15:8] */
#define ADI_ADXL355_OFFSET_X_L 0x1Fu /* X axis offset [7:0] */
#define ADI_ADYL355_OFFSET_Y_H 0x20u /* Y axis offset [15:8] */
#define ADI_ADYL355_OFFSET_Y_L 0x21u /* Y axis offset [7:0] */
#define ADI_ADZL355_OFFSET_Z_H 0x22u /* Z axis offset [15:8] */
#define ADI_ADZL355_OFFSET_Z_L 0x23u /* Z axis offset [7:0] */
#define ADI_ADXL355_ACT_EN 0x24u /* Act Control */
#define ADI_ADXL355_ACT_THRESH_H 0x25u /* Activity threshold MSBs*/
#define ADI_ADXL355_ACT_THRESH_L 0x26u /* Activity threshold LSBs*/
#define ADI_ADXL355_ACT_COUNT 0x27u /* Activity Count */
#define ADI_ADXL355_FILTER 0x28u /* Filter Options */
#define ADI_ADXL355_FIFO_SAMPLES 0x29u /* FIFO samples */
#define ADI_ADXL355_INT_MAP 0x2Au /* Interrupt mapping control */
#define ADI_ADXL355_SYNC 0x2Bu /* Sync */
#define ADI_ADXL355_RANGE 0x2Cu /* Capture Range */
#define ADI_ADXL355_POWER_CTL 0x2Du /* Power control */
#define ADI_ADXL355_SELF_TEST 0x2Eu /* Self Test */
#define ADI_ADXL355_SRESET 0x2Fu /* Soft Reset */
#define ADXL355_ENABLE_SOFT_RESET_VALUE 0x52u
#define ADXL355_DEVICE_ID_VALUE 0xEDu
#define ADXL355_POWER_CTL_MSK 0x01u
#define ADXL355_MEASURE_MODE 0x00u
#define ADXL355_STAND_BY_MODE 0x01u
#define ADXL355_ODR_3_9HZ 0x0Au
#define ADXL355_ODR_7_8HZ 0x09u
#define ADXL355_ODR_15_6HZ 0x08u
#define ADXL355_ODR_31_2HZ 0x07u
#define ADXL355_ODR_62_5HZ 0x06u
#define ADXL355_ODR_125HZ 0x05u
#define ADXL355_ODR_250HZ 0x04u
#define ADXL355_ODR_500HZ 0x03u
#define ADXL355_ODR_1000HZ 0x02u
#define ADXL355_ODR_2000HZ 0x01u
#define ADXL355_ODR_4000HZ 0x00u
#define ADXL355_ODR_BIT_MASK 0xF0u
#define ADXL355_DEFAULT_ODR_125HZ 125
#define BITP_ADXL355_RANGE 0x00u
#define BITM_ADXL355_RANGE 0x03u
#define BITM_ADXL355_ACT_EN 0x03u /*ACT_Z, ACT_Y and ACT_X */
#define BITM_ADXL355_INT_POL 0x40u
#define BITM_ADXL355_INT_DATA_READY 0x01u
#define BITM_ADXL355_MEASURE_EN 0x01u
#define BITM_ADXL355_ODR 0x0Fu
#define BITM_ADXL355_SELFTEST_EN 0x03u
// adxl355 sensitivity factor table, the unit is LSB/g
typedef enum _adxl355_self_test_type_
{
en_adxl355_test_disable,
en_adxl355_test_x,
en_adxl355_test_y,
en_adxl355_test_z,
en_adxl355_test_invalid,
} adxl355_self_test_type;
i2c_dev_t adxl355_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = ADXL355_I2C_ADDR,
};
// adxl355 sensitivity factor table, the unit is LSB/g
uint32_t current_factor = 10240;
uint32_t g_adxl355_range = ACC_RANGE_2G;
// static int drv_acc_adi_adxl355_self_test(i2c_dev_t* drv,int32_t* data);
UNUSED static int drv_acc_adi_adxl355_soft_reset(i2c_dev_t *drv)
{
int ret = 0;
uint8_t value = ADXL355_ENABLE_SOFT_RESET_VALUE;
ret = sensor_i2c_write(drv, ADI_ADXL355_SRESET, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
return ret;
}
static int drv_acc_adi_adxl355_validate_id(i2c_dev_t *drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, ADI_ADXL355_DEVID, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
if (id_value != value) {
return -1;
}
return 0;
}
static int drv_acc_adi_adxl355_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
uint8_t value;
int ret = 0;
ret = sensor_i2c_read(drv, ADI_ADXL355_POWER_CTL, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_ON: {
value &= 0xFE;
ret = sensor_i2c_write(drv, ADI_ADXL355_POWER_CTL, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_POWER_OFF: {
value |= 0x01;
ret = sensor_i2c_write(drv, ADI_ADXL355_POWER_CTL, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
default:
break;
}
return 0;
}
static int drv_acc_adi_adxl355_set_odr(i2c_dev_t *drv, uint32_t odr)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, ADI_ADXL355_FILTER, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (odr > 2000) {
value &= ADXL355_ODR_BIT_MASK;
value |= ADXL355_ODR_4000HZ;
} else if (odr > 1000) {
value &= ADXL355_ODR_BIT_MASK;
value |= ADXL355_ODR_2000HZ;
} else if (odr > 500) {
value &= ADXL355_ODR_BIT_MASK;
value |= ADXL355_ODR_1000HZ;
} else if (odr > 250) {
value &= ADXL355_ODR_BIT_MASK;
value |= ADXL355_ODR_500HZ;
} else if (odr > 125) {
value &= ADXL355_ODR_BIT_MASK;
value |= ADXL355_ODR_250HZ;
} else if (odr > 63) {
value &= ADXL355_ODR_BIT_MASK;
value |= ADXL355_ODR_125HZ;
} else if (odr > 32) {
value &= ADXL355_ODR_BIT_MASK;
value |= ADXL355_ODR_62_5HZ;
} else if (odr > 16) {
value &= ADXL355_ODR_BIT_MASK;
value |= ADXL355_ODR_31_2HZ;
} else if (odr > 8) {
value &= ADXL355_ODR_BIT_MASK;
value |= ADXL355_ODR_15_6HZ;
} else if (odr > 4) {
value &= ADXL355_ODR_BIT_MASK;
value |= ADXL355_ODR_7_8HZ;
} else {
value &= ADXL355_ODR_BIT_MASK;
value |= ADXL355_ODR_3_9HZ;
}
ret = sensor_i2c_write(drv, ADI_ADXL355_FILTER, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_adi_adxl355_set_range(i2c_dev_t *drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, ADI_ADXL355_RANGE, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (range) {
case ACC_RANGE_2G: {
value &= 0xFC;
value |= 0x01;
} break;
case ACC_RANGE_4G: {
value &= 0xFC;
value |= 0x02;
} break;
case ACC_RANGE_8G: {
value &= 0xFC;
value |= 0x03;
} break;
default:
break;
}
/* Write the range register 0x2C*/
ret = sensor_i2c_write(drv, ADI_ADXL355_RANGE, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
g_adxl355_range = range;
return 0;
}
static void drv_acc_adi_adxl355_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_adi_adxl355_open(void)
{
int ret = 0;
ret = drv_acc_adi_adxl355_set_power_mode(&adxl355_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_acc_adi_adxl355_close(void)
{
int ret = 0;
ret = drv_acc_adi_adxl355_set_power_mode(&adxl355_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_acc_adi_adxl355_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t LocalBuf[9];
int32_t x_val = 0, y_val = 0, z_val = 0;
int8_t SignBit;
accel_data_t *accel = (accel_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(&adxl355_ctx, ADI_ADXL355_XDATA3, &LocalBuf[0],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl355_ctx, ADI_ADXL355_XDATA2, &LocalBuf[1],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl355_ctx, ADI_ADXL355_XDATA1, &LocalBuf[2],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl355_ctx, ADI_ADXL355_YDATA3, &LocalBuf[3],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl355_ctx, ADI_ADXL355_YDATA2, &LocalBuf[4],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl355_ctx, ADI_ADXL355_YDATA1, &LocalBuf[5],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl355_ctx, ADI_ADXL355_ZDATA3, &LocalBuf[6],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl355_ctx, ADI_ADXL355_ZDATA2, &LocalBuf[7],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl355_ctx, ADI_ADXL355_ZDATA1, &LocalBuf[8],
I2C_REG_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
x_val = (int32_t)(((LocalBuf[0] << 16) | (LocalBuf[1] << 8) |
((LocalBuf[2] << 0) & 0xF0)) >>
4);
SignBit = (x_val & (1 << 19)) != 0;
if (SignBit)
x_val = x_val | ~((1 << 20) - 1);
y_val = (int32_t)(((LocalBuf[3] << 16) | (LocalBuf[4] << 8) |
((LocalBuf[5] << 0) & 0xF0)) >>
4);
SignBit = (y_val & (1 << 19)) != 0;
if (SignBit)
y_val = y_val | ~((1 << 20) - 1);
z_val = (int32_t)(((LocalBuf[6] << 16) | (LocalBuf[7] << 8) |
((LocalBuf[8] << 0) & 0xF0)) >>
4);
SignBit = (z_val & (1 << 19)) != 0;
if (SignBit)
z_val = z_val | ~((1 << 20) - 1);
if (g_adxl355_range == ACC_RANGE_4G) {
current_factor = 5120;
} else if (g_adxl355_range == ACC_RANGE_8G) {
current_factor = 2160;
}
accel->data[DATA_AXIS_X] = (int32_t)(x_val * 39 / (int32_t)current_factor);
accel->data[DATA_AXIS_Y] = (int32_t)(y_val * 39 / (int32_t)current_factor);
accel->data[DATA_AXIS_Z] = (int32_t)(z_val * 39 / (int32_t)current_factor);
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_adi_adxl355_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch (cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_acc_adi_adxl355_set_odr(&adxl355_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_acc_adi_adxl355_set_range(&adxl355_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_adi_adxl355_set_power_mode(&adxl355_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
info->model = "ADXL355";
info->range_max = 8;
info->range_min = 2;
info->unit = mg;
} break;
default:
break;
}
return 0;
}
int drv_acc_adi_adxl355_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_adi_adxl355_open;
sensor.close = drv_acc_adi_adxl355_close;
sensor.read = drv_acc_adi_adxl355_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_adi_adxl355_ioctl;
sensor.irq_handle = drv_acc_adi_adxl355_irq_handle;
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
ret =
drv_acc_adi_adxl355_validate_id(&adxl355_ctx, ADXL355_DEVICE_ID_VALUE);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_adi_adxl355_set_range(&adxl355_ctx, ACC_RANGE_4G);
if (unlikely(ret)) {
return -1;
}
// set odr is 125hz, and will update
ret = drv_acc_adi_adxl355_set_odr(&adxl355_ctx, ADXL355_DEFAULT_ODR_125HZ);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_adi_adxl355_set_power_mode(&adxl355_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_adi_adxl355_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_adi_adxl355.c
|
C
|
apache-2.0
| 14,475
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define ADXL372_I2C_ADDR1 (0x1D)
#define ADXL372_I2C_ADDR2 (0x53)
#define ADXL372_I2C_ADDR_TRANS(n) ((n) << 1)
#define ADXL372_I2C_ADDR ADXL372_I2C_ADDR_TRANS(ADXL372_I2C_ADDR1)
/* ADXL372 registers definition */
#define ADXL372_DEVID 0x00
#define ADXL372_DEVID_MST 0x01
#define ADXL372_PARTID 0x02
#define ADXL372_REVID 0x03
#define ADXL372_STATUS_1 0x04
#define ADXL372_STATUS_2 0x05
#define ADXL372_FIFO_ENTRIES_2 0x06
#define ADXL372_FIFO_ENTRIES_1 0x07
#define ADXL372_X_DATA_H 0x08
#define ADXL372_X_DATA_L 0x09
#define ADXL372_Y_DATA_H 0x0A
#define ADXL372_Y_DATA_L 0x0B
#define ADXL372_Z_DATA_H 0x0C
#define ADXL372_Z_DATA_L 0x0D
#define ADXL372_X_MAXPEAK_H 0x15
#define ADXL372_X_MAXPEAK_L 0x16
#define ADXL372_Y_MAXPEAK_H 0x17
#define ADXL372_Y_MAXPEAK_L 0x18
#define ADXL372_Z_MAXPEAK_H 0x19
#define ADXL372_Z_MAXPEAK_L 0x1A
#define ADXL372_OFFSET_X 0x20
#define ADXL372_OFFSET_Y 0x21
#define ADXL372_OFFSET_Z 0x22
#define ADXL372_X_THRESH_ACT_H 0x23
#define ADXL372_X_THRESH_ACT_L 0x24
#define ADXL372_Y_THRESH_ACT_H 0x25
#define ADXL372_Y_THRESH_ACT_L 0x26
#define ADXL372_Z_THRESH_ACT_H 0x27
#define ADXL372_Z_THRESH_ACT_L 0x28
#define ADXL372_TIME_ACT 0x29
#define ADXL372_X_THRESH_INACT_H 0x2A
#define ADXL372_X_THRESH_INACT_L 0x2B
#define ADXL372_Y_THRESH_INACT_H 0x2C
#define ADXL372_Y_THRESH_INACT_L 0x2D
#define ADXL372_Z_THRESH_INACT_H 0x2E
#define ADXL372_Z_THRESH_INACT_L 0x2F
#define ADXL372_TIME_INACT_H 0x30
#define ADXL372_TIME_INACT_L 0x31
#define ADXL372_X_THRESH_ACT2_H 0x32
#define ADXL372_X_THRESH_ACT2_L 0x33
#define ADXL372_Y_THRESH_ACT2_H 0x34
#define ADXL372_Y_THRESH_ACT2_L 0x35
#define ADXL372_Z_THRESH_ACT2_H 0x36
#define ADXL372_Z_THRESH_ACT2_L 0x37
#define ADXL372_HPF 0x38
#define ADXL372_FIFO_SAMPLES 0x39
#define ADXL372_FIFO_CTL 0x3A
#define ADXL372_INT1_MAP 0x3B
#define ADXL372_INT2_MAP 0x3C
#define ADXL372_TIMING 0x3D
#define ADXL372_MEASURE 0x3E
#define ADXL372_POWER_CTL 0x3F
#define ADXL372_SELF_TEST 0x40
#define ADXL372_RESET 0x41
#define ADXL372_FIFO_DATA 0x42
#define ADXL372_DEVID_VAL 0xAD
#define ADXL372_PARTID_VAL 0xFA
#define ADXL372_RESET_CODE 0x52
#define ADXL372_ODR_6400HZ (0x04 << 5)
#define ADXL372_ODR_3200HZ (0x03 << 5)
#define ADXL372_ODR_1600HZ (0x02 << 5)
#define ADXL372_ODR_800HZ (0x01 << 5)
#define ADXL372_ODR_400HZ (0x00 << 5)
#define ADXL372_ODR_BIT_MASK 0x1F
#define ADXL372_DEFAULT_ODR 400
#define ADXL372_BW_3200HZ 0x04
#define ADXL372_BW_1600HZ 0x03
#define ADXL372_BW_800HZ 0x02
#define ADXL372_BW_400HZ 0x01
#define ADXL372_BW_200HZ 0x00
#define ADXL372_BW_BIT_MASK 0xF8
#define ADXL372_DEFAULT_BW 200
i2c_dev_t adxl372_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = ADXL372_I2C_ADDR,
};
static int drv_acc_adi_adxl372_soft_reset(i2c_dev_t *drv)
{
int ret = 0;
uint8_t value = ADXL372_RESET_CODE;
ret = sensor_i2c_write(drv, ADXL372_RESET, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_acc_adi_adxl372_validate_id(i2c_dev_t *drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, ADXL372_PARTID, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
if (id_value != value) {
return -1;
}
return 0;
}
static int drv_acc_adi_adxl372_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
uint8_t value;
int ret = 0;
ret = sensor_i2c_read(drv, ADXL372_POWER_CTL, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_ON: {
value &= 0xFC;
value |= 0x03;
ret = sensor_i2c_write(drv, ADXL372_POWER_CTL, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_POWER_OFF: {
value &= 0xFC;
ret = sensor_i2c_write(drv, ADXL372_POWER_CTL, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
default:
break;
}
return 0;
}
static int drv_acc_adi_adxl372_set_odr(i2c_dev_t *drv, uint32_t odr)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, ADXL372_TIMING, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (odr >= 6400) {
value &= ADXL372_ODR_BIT_MASK;
value |= ADXL372_ODR_6400HZ;
} else if (odr >= 3200) {
value &= ADXL372_ODR_BIT_MASK;
value |= ADXL372_ODR_3200HZ;
} else if (odr >= 1600) {
value &= ADXL372_ODR_BIT_MASK;
value |= ADXL372_ODR_1600HZ;
} else if (odr >= 800) {
value &= ADXL372_ODR_BIT_MASK;
value |= ADXL372_ODR_800HZ;
} else {
value &= ADXL372_ODR_BIT_MASK;
value |= ADXL372_ODR_400HZ;
}
ret = sensor_i2c_write(drv, ADXL372_TIMING, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_adi_adxl372_set_bw(i2c_dev_t *drv, uint32_t bw)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, ADXL372_MEASURE, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (bw >= 3200) {
value &= ADXL372_BW_BIT_MASK;
value |= ADXL372_BW_3200HZ;
} else if (bw >= 1600) {
value &= ADXL372_BW_BIT_MASK;
value |= ADXL372_BW_1600HZ;
} else if (bw >= 800) {
value &= ADXL372_BW_BIT_MASK;
value |= ADXL372_BW_800HZ;
} else if (bw >= 400) {
value &= ADXL372_BW_BIT_MASK;
value |= ADXL372_BW_400HZ;
} else {
value &= ADXL372_BW_BIT_MASK;
value |= ADXL372_BW_200HZ;
}
ret = sensor_i2c_write(drv, ADXL372_MEASURE, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static void drv_acc_adi_adxl372_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_adi_adxl372_open(void)
{
int ret = 0;
ret = drv_acc_adi_adxl372_set_power_mode(&adxl372_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_acc_adi_adxl372_close(void)
{
int ret = 0;
ret = drv_acc_adi_adxl372_set_power_mode(&adxl372_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_acc_adi_adxl372_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t LocalBuf[6];
int32_t x_val = 0, y_val = 0, z_val = 0;
int8_t SignBit;
accel_data_t *accel = (accel_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(&adxl372_ctx, ADXL372_X_DATA_H, &LocalBuf[0],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl372_ctx, ADXL372_X_DATA_L, &LocalBuf[1],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl372_ctx, ADXL372_Y_DATA_H, &LocalBuf[2],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl372_ctx, ADXL372_Y_DATA_L, &LocalBuf[3],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl372_ctx, ADXL372_Z_DATA_H, &LocalBuf[4],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&adxl372_ctx, ADXL372_Z_DATA_L, &LocalBuf[5],
I2C_REG_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
x_val = (int32_t)(((LocalBuf[0] << 8) | ((LocalBuf[1] << 0) & 0xF0)) >> 4);
SignBit = (x_val & (1 << 11)) != 0;
if (SignBit)
x_val = x_val | ~((1 << 12) - 1);
y_val = (int32_t)(((LocalBuf[2] << 8) | ((LocalBuf[3] << 0) & 0xF0)) >> 4);
SignBit = (y_val & (1 << 11)) != 0;
if (SignBit)
y_val = y_val | ~((1 << 12) - 1);
z_val = (int32_t)(((LocalBuf[4] << 8) | ((LocalBuf[5] << 0) & 0xF0)) >> 4);
SignBit = (z_val & (1 << 11)) != 0;
if (SignBit)
z_val = z_val | ~((1 << 12) - 1);
accel->data[DATA_AXIS_X] = (int32_t)(x_val * 100);
accel->data[DATA_AXIS_Y] = (int32_t)(y_val * 100);
accel->data[DATA_AXIS_Z] = (int32_t)(z_val * 100);
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_adi_adxl372_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch (cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_acc_adi_adxl372_set_odr(&adxl372_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_adi_adxl372_set_power_mode(&adxl372_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
info->model = "ADXL372";
info->range_max = 200;
info->range_min = 0;
info->unit = mg;
} break;
default:
break;
}
return 0;
}
int drv_acc_adi_adxl372_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_adi_adxl372_open;
sensor.close = drv_acc_adi_adxl372_close;
sensor.read = drv_acc_adi_adxl372_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_adi_adxl372_ioctl;
sensor.irq_handle = drv_acc_adi_adxl372_irq_handle;
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_adi_adxl372_validate_id(&adxl372_ctx, ADXL372_PARTID_VAL);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_adi_adxl372_soft_reset(&adxl372_ctx);
if (unlikely(ret)) {
return -1;
}
// set odr is 400hz, and will update
ret = drv_acc_adi_adxl372_set_odr(&adxl372_ctx, ADXL372_DEFAULT_ODR);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_adi_adxl372_set_bw(&adxl372_ctx, ADXL372_DEFAULT_BW);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_adi_adxl372_set_power_mode(&adxl372_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_adi_adxl372_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_adi_adxl372.c
|
C
|
apache-2.0
| 11,476
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define BMA253_I2C_ADDR1 (0x18)
#define BMA253_I2C_ADDR2 (0x19)
#define BMA253_I2C_ADDR3 (0x10)
#define BMA253_I2C_ADDR4 (0x11)
#define BMA253_I2C_ADDR_TRANS(n) ((n) << 1)
#define BMA253_I2C_ADDR BMA253_I2C_ADDR_TRANS(BMA253_I2C_ADDR1)
#define BMA253_INIT_VALUE (0)
#define BMA253_GEN_READ_WRITE_LENGTH (1)
#define BMA253_INTERFACE_IDLE_TIME_DELAY (1)
#define BMA253_LSB_MSB_READ_LENGTH (2)
#define BMA253_SHIFT_TWO_BITS (2)
#define BMA253_SHIFT_FOUR_BITS (4)
#define BMA253_SHIFT_FIVE_BITS (5)
#define BMA253_SHIFT_SIX_BITS (6)
#define BMA253_SHIFT_EIGHT_BITS (8)
#define BMA253_12_BIT_SHIFT (0xF0)
#define BMA253_FIFO_MODE_STATUS_RANGE (2)
#define BMA253_FIFO_DATA_SELECT_RANGE (4)
#define BMA253_FIFO_MODE_RANGE (4)
#define BMA253_FIFO_WML_RANGE (32)
#define BMA253_FIFO_XYZ_DATA_ENABLED (0x00)
#define BMA253_FIFO_X_DATA_ENABLED (0x01)
#define BMA253_FIFO_Y_DATA_ENABLED (0x02)
#define BMA253_FIFO_Z_DATA_ENABLED (0x03)
#define BMA253_FIFO_DATA_ENABLED_MASK (0x03)
#define BMA253_FIFO_XYZ_AXES_FRAME_SIZE (6)
#define BMA253_FIFO_SINGLE_AXIS_FRAME_SIZE (2)
#define BMA253_ACCEL_BW_MIN_RANGE (7)
#define BMA253_ACCEL_BW_1000HZ_RANGE (15)
#define BMA253_ACCEL_BW_MAX_RANGE (16)
#define BMA253_SLEEP_DURN_MIN_RANGE (4)
#define BMA253_SLEEP_TIMER_MODE_RANGE (2)
#define BMA253_SLEEP_DURN_MAX_RANGE (16)
#define BMA253_POWER_MODE_RANGE (6)
#define BMA253_SELF_TEST_AXIS_RANGE (4)
#define BMA253_SELF_TEST_SIGN_RANGE (2)
#define BMA253_EEP_OFFSET (0x16)
#define BMA253_IMAGE_BASE (0x38)
#define BMA253_IMAGE_LEN (22)
#define BMA253_CHIP_ID_ADDR (0x00)
#define BMA253_CHIP_ID_VALUE (0xFA)
#define BMA253_X_AXIS_LSB_ADDR (0x02)
#define BMA253_X_AXIS_MSB_ADDR (0x03)
#define BMA253_Y_AXIS_LSB_ADDR (0x04)
#define BMA253_Y_AXIS_MSB_ADDR (0x05)
#define BMA253_Z_AXIS_LSB_ADDR (0x06)
#define BMA253_Z_AXIS_MSB_ADDR (0x07)
#define BMA253_TEMP_ADDR (0x08)
#define BMA253_STAT1_ADDR (0x09)
#define BMA253_STAT2_ADDR (0x0A)
#define BMA253_STAT_TAP_SLOPE_ADDR (0x0B)
#define BMA253_STAT_ORIENT_HIGH_ADDR (0x0C)
#define BMA253_STAT_FIFO_ADDR (0x0E)
#define BMA253_RANGE_SELECT_ADDR (0x0F)
#define BMA253_BW_SELECT_ADDR (0x10)
#define BMA253_MODE_CTRL_ADDR (0x11)
#define BMA253_LOW_NOISE_CTRL_ADDR (0x12)
#define BMA253_DATA_CTRL_ADDR (0x13)
#define BMA253_RST_ADDR (0x14)
#define BMA253_INTR_ENABLE1_ADDR (0x16)
#define BMA253_INTR_ENABLE2_ADDR (0x17)
#define BMA253_INTR_SLOW_NO_MOTION_ADDR (0x18)
#define BMA253_INTR1_PAD_SELECT_ADDR (0x19)
#define BMA253_INTR_DATA_SELECT_ADDR (0x1A)
#define BMA253_INTR2_PAD_SELECT_ADDR (0x1B)
#define BMA253_INTR_SOURCE_ADDR (0x1E)
#define BMA253_INTR_SET_ADDR (0x20)
#define BMA253_INTR_CTRL_ADDR (0x21)
#define BMA253_LOW_DURN_ADDR (0x22)
#define BMA253_LOW_THRES_ADDR (0x23)
#define BMA253_LOW_HIGH_HYST_ADDR (0x24)
#define BMA253_HIGH_DURN_ADDR (0x25)
#define BMA253_HIGH_THRES_ADDR (0x26)
#define BMA253_SLOPE_DURN_ADDR (0x27)
#define BMA253_SLOPE_THRES_ADDR (0x28)
#define BMA253_SLOW_NO_MOTION_THRES_ADDR (0x29)
#define BMA253_TAP_PARAM_ADDR (0x2A)
#define BMA253_TAP_THRES_ADDR (0x2B)
#define BMA253_ORIENT_PARAM_ADDR (0x2C)
#define BMA253_THETA_BLOCK_ADDR (0x2D)
#define BMA253_THETA_FLAT_ADDR (0x2E)
#define BMA253_FLAT_HOLD_TIME_ADDR (0x2F)
#define BMA253_SELFTEST_ADDR (0x32)
#define BMA253_EEPROM_CTRL_ADDR (0x33)
#define BMA253_SERIAL_CTRL_ADDR (0x34)
#define BMA253_OFFSET_CTRL_ADDR (0x36)
#define BMA253_OFFSET_PARAMS_ADDR (0x37)
#define BMA253_OFFSET_X_AXIS_ADDR (0x38)
#define BMA253_OFFSET_Y_AXIS_ADDR (0x39)
#define BMA253_OFFSET_Z_AXIS_ADDR (0x3A)
#define BMA253_GP0_ADDR (0x3B)
#define BMA253_GP1_ADDR (0x3C)
#define BMA253_FIFO_MODE_ADDR (0x3E)
#define BMA253_FIFO_DATA_OUTPUT_ADDR (0x3F)
#define BMA253_FIFO_WML_TRIG (0x30)
#define BMA253_12_RESOLUTION (0)
#define BMA253_10_RESOLUTION (1)
#define BMA253_14_RESOLUTION (2)
#define BMA253_ENABLE_SOFT_RESET_VALUE (0xB6)
#define BMA253_RANGE_SELECT_POS (0)
#define BMA253_RANGE_SELECT_LEN (4)
#define BMA253_RANGE_SELECT_MSK (0x0F)
#define BMA253_RANGE_SELECT_REG BMA253_RANGE_SELECT_ADDR
#define BMA253_RANGE_2G (3)
#define BMA253_RANGE_4G (5)
#define BMA253_RANGE_8G (8)
#define BMA253_RANGE_16G (12)
#define BMA253_BW_15_63 (15)
#define BMA253_BW_31_25 (31)
#define BMA253_BW_62_5 (62)
#define BMA253_BW_125 (125)
#define BMA253_BW_250 (250)
#define BMA253_BW_500 (500)
#define BMA253_BW_1000 (1000)
#define BMA253_BW_7_81HZ (0x08)
#define BMA253_BW_15_63HZ (0x09)
#define BMA253_BW_31_25HZ (0x0A)
#define BMA253_BW_62_50HZ (0x0B)
#define BMA253_BW_125HZ (0x0C)
#define BMA253_BW_250HZ (0x0D)
#define BMA253_BW_500HZ (0x0E)
#define BMA253_BW_1000HZ (0x0F)
#define BMA253_BW_BIT_MASK (~0x0F)
#define BMA253_SLEEP_DURN_0_5MS (0x05)
#define BMA253_SLEEP_DURN_1MS (0x06)
#define BMA253_SLEEP_DURN_2MS (0x07)
#define BMA253_SLEEP_DURN_4MS (0x08)
#define BMA253_SLEEP_DURN_6MS (0x09)
#define BMA253_SLEEP_DURN_10MS (0x0A)
#define BMA253_SLEEP_DURN_25MS (0x0B)
#define BMA253_SLEEP_DURN_50MS (0x0C)
#define BMA253_SLEEP_DURN_100MS (0x0D)
#define BMA253_SLEEP_DURN_500MS (0x0E)
#define BMA253_SLEEP_DURN_1S (0x0F)
#define BMA253_SLEEP_DURN_POS (1)
#define BMA253_SLEEP_DURN_LEN (4)
#define BMA253_SLEEP_DURN_MSK (0x1E)
#define BMA253_SLEEP_DURN_REG BMA253_MODE_CTRL_ADDR
#define BMA253_SLEEP_MODE (0x40)
#define BMA253_DEEP_SUSPEND_MODE (0x20)
#define BMA253_SUSPEND_MODE (0x80)
#define BMA253_NORMAL_MODE (0x40)
#define BMA253_LOWPOWER_MODE (0x40)
#define BMA253_MODE_CTRL_POS (5)
#define BMA253_MODE_CTRL_LEN (3)
#define BMA253_MODE_CTRL_MSK (0xE0)
#define BMA253_MODE_CTRL_REG BMA253_MODE_CTRL_ADDR
#define BMA253_LOW_POWER_MODE_POS (6)
#define BMA253_LOW_POWER_MODE_LEN (1)
#define BMA253_LOW_POWER_MODE_MSK (0x40)
#define BMA253_LOW_POWER_MODE_REG BMA253_LOW_NOISE_CTRL_ADDR
#define BMA253_DEFAULT_ODR_100HZ (100)
#define BMA253_FIFO_DEPTH_MAX (32)
#define BMA253_FIFO_DATA_NUM (6)
#define BMA253_FIFO_BUFF_LEN (BMA253_FIFO_DEPTH_MAX * BMA253_FIFO_DATA_NUM)
// bma253 sensitivity factor table, the unit is LSB/g
#define BMA253_IRQ_CLEAR_VAL (0x80)
#define BMA253_IRQ_LATCHED (0x0f)
#define BMA253_IRQ_NON_LATCHED (0)
#define BMA253_IRQ_FIFO_STAT (0x40)
#define BMA253_IRQ_DATA_READY_STAT (0x80)
#define BMA253_IRQ_DATA_READY_ENABLE (0x10)
#define BMA253_IRQ_FIFO_FULL_ENABLE (0x20)
#define BMA253_IRQ_FIFO_WML_ENABLE (0x40)
#define BMA253_IRQ_MAP_DATA_INT2 (0x80)
#define BMA253_IRQ_MAP_FIFO_WML_INT2 (0x40)
#define BMA253_IRQ_CONFIG_PUSH_PULL (0x04)
#define BMA253_IRQ_FIFO_WML_MODE (0x40)
#define BMA253_IRQ_PIN (62)
#define BMA253_FIFO_DEPTH_USD (20)
#define BMA253_GET_BITSLICE(regvar, bitname) \
((regvar & bitname##_MSK) >> bitname##_POS)
#define BMA253_SET_BITSLICE(regvar, bitname, val) \
((regvar & ~bitname##_MSK) | ((val << bitname##_POS) & bitname##_MSK))
// bma253 sensitivity factor table, the unit is LSB/g
static uint32_t bma253_factor[4] = { 1024, 512, 256, 128 };
static uint32_t current_factor = 0;
static uint32_t bma253_fifo_wml = 0;
static work_mode_e bma253_work_mode = 0;
static gpio_irq_trigger_t bma253_irq_mode_rising = IRQ_TRIGGER_RISING_EDGE;
uint8_t bma253_fifo_data[BMA253_FIFO_BUFF_LEN] = { 0 };
i2c_dev_t bma253_ctx = {
.port = 1,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr = BMA253_I2C_ADDR>>1,
};
static int drv_acc_bosch_bma253_data_ready_init(void);
static int drv_acc_bosch_bma253_fifo_init(void);
static int drv_acc_bosch_bma253_fifo_wml_set(uint32_t num)
{
if (num > BMA253_FIFO_DEPTH_MAX) {
return -1;
}
bma253_fifo_wml = num;
return 0;
}
int drv_acc_bosch_bma253_soft_reset(i2c_dev_t *drv)
{
int ret = 0;
uint8_t value = BMA253_ENABLE_SOFT_RESET_VALUE;
ret = sensor_i2c_write(drv, BMA253_RST_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma253_validate_id(i2c_dev_t *drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, BMA253_CHIP_ID_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (id_value != value) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma253_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, BMA253_MODE_CTRL_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_ON: {
if ((value & BMA253_MODE_CTRL_MSK) == BMA253_NORMAL_MODE) {
return 0;
}
value |= BMA253_NORMAL_MODE;
ret = sensor_i2c_write(drv, BMA253_MODE_CTRL_REG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_POWER_OFF: {
if ((value & BMA253_MODE_CTRL_MSK) == BMA253_DEEP_SUSPEND_MODE) {
return 0;
}
value |= BMA253_DEEP_SUSPEND_MODE;
ret = sensor_i2c_write(drv, BMA253_MODE_CTRL_REG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_SLEEP: {
if ((value & BMA253_MODE_CTRL_MSK) == BMA253_SLEEP_MODE) {
return 0;
}
value |= BMA253_SLEEP_MODE;
ret = sensor_i2c_write(drv, BMA253_MODE_CTRL_REG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_SUSPEND: {
if ((value & BMA253_MODE_CTRL_MSK) == BMA253_SUSPEND_MODE) {
return 0;
}
value |= BMA253_SUSPEND_MODE;
ret = sensor_i2c_write(drv, BMA253_MODE_CTRL_REG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
default:
break;
}
return 0;
}
int drv_acc_bosch_bma253_set_odr(i2c_dev_t *drv, uint32_t odr)
{
int ret = 0;
uint8_t value = 0x00;
uint32_t bw = odr / 2;
ret = sensor_i2c_read(drv, BMA253_BW_SELECT_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (bw >= BMA253_BW_1000) {
value &= BMA253_BW_BIT_MASK;
value |= BMA253_BW_1000HZ;
} else if (bw >= BMA253_BW_500) {
value &= BMA253_BW_BIT_MASK;
value |= BMA253_BW_500HZ;
} else if (bw >= BMA253_BW_250) {
value &= BMA253_BW_BIT_MASK;
value |= BMA253_BW_250HZ;
} else if (bw >= BMA253_BW_125) {
value &= BMA253_BW_BIT_MASK;
value |= BMA253_BW_125HZ;
} else if (bw >= BMA253_BW_62_5) {
value &= BMA253_BW_BIT_MASK;
value |= BMA253_BW_62_50HZ;
} else if (bw >= BMA253_BW_31_25) {
value &= BMA253_BW_BIT_MASK;
value |= BMA253_BW_31_25HZ;
} else {
value &= BMA253_BW_BIT_MASK;
value |= BMA253_BW_15_63HZ;
}
ret = sensor_i2c_write(drv, BMA253_BW_SELECT_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
int drv_acc_bosch_bma253_set_range(i2c_dev_t *drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, BMA253_RANGE_SELECT_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (range) {
case ACC_RANGE_2G: {
value =
BMA253_SET_BITSLICE(value, BMA253_RANGE_SELECT, BMA253_RANGE_2G);
} break;
case ACC_RANGE_4G: {
value =
BMA253_SET_BITSLICE(value, BMA253_RANGE_SELECT, BMA253_RANGE_4G);
} break;
case ACC_RANGE_8G: {
value =
BMA253_SET_BITSLICE(value, BMA253_RANGE_SELECT, BMA253_RANGE_8G);
} break;
case ACC_RANGE_16G: {
value =
BMA253_SET_BITSLICE(value, BMA253_RANGE_SELECT, BMA253_RANGE_16G);
} break;
default:
break;
}
/* Write the range register 0x0F*/
ret = sensor_i2c_write(drv, BMA253_RANGE_SELECT_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (range <= ACC_RANGE_16G) {
current_factor = bma253_factor[range];
}
return 0;
}
int drv_acc_bosch_bma253_open(void)
{
int ret = 0;
if (bma253_work_mode == DEV_DATA_READY) {
ret = drv_acc_bosch_bma253_data_ready_init();
if (unlikely(ret)) {
return -1;
}
} else if (bma253_work_mode == DEV_FIFO) {
ret = drv_acc_bosch_bma253_fifo_init();
if (unlikely(ret)) {
return -1;
}
}
ret = drv_acc_bosch_bma253_set_power_mode(&bma253_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma253_close(void)
{
int ret = 0;
ret = drv_acc_bosch_bma253_set_power_mode(&bma253_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_acc_bosch_bma253_read_origion(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(&bma253_ctx, BMA253_X_AXIS_LSB_ADDR, ®[0],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma253_ctx, BMA253_X_AXIS_MSB_ADDR, ®[1],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma253_ctx, BMA253_Y_AXIS_LSB_ADDR, ®[2],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma253_ctx, BMA253_Y_AXIS_MSB_ADDR, ®[3],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma253_ctx, BMA253_Z_AXIS_LSB_ADDR, ®[4],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma253_ctx, BMA253_Z_AXIS_MSB_ADDR, ®[5],
I2C_REG_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
accel->data[DATA_AXIS_X] =
(int32_t)((((int32_t)((int8_t)reg[1])) << BMA253_SHIFT_EIGHT_BITS) |
(reg[0] & BMA253_12_BIT_SHIFT));
accel->data[DATA_AXIS_X] =
accel->data[DATA_AXIS_X] >> BMA253_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Y] =
(int32_t)((((int32_t)((int8_t)reg[3])) << BMA253_SHIFT_EIGHT_BITS) |
(reg[2] & BMA253_12_BIT_SHIFT));
accel->data[DATA_AXIS_Y] =
accel->data[DATA_AXIS_Y] >> BMA253_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Z] =
(int32_t)((((int32_t)((int8_t)reg[5])) << BMA253_SHIFT_EIGHT_BITS) |
(reg[4] & BMA253_12_BIT_SHIFT));
accel->data[DATA_AXIS_Z] =
accel->data[DATA_AXIS_Z] >> BMA253_SHIFT_FOUR_BITS;
if (current_factor != 0) {
// the unit of acc is mg, 1000 mg = 1 g.
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] *
ACCELEROMETER_UNIT_FACTOR /
(int32_t)current_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] *
ACCELEROMETER_UNIT_FACTOR /
(int32_t)current_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] *
ACCELEROMETER_UNIT_FACTOR /
(int32_t)current_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_bosch_bma253_read_fifo(accel_data_t *accel, size_t len)
{
int i;
int ret;
int num = len / sizeof(accel_data_t);
if (num != bma253_fifo_wml) {
return -1;
}
ret = sensor_i2c_read(
&bma253_ctx, BMA253_FIFO_DATA_OUTPUT_ADDR, &bma253_fifo_data[0],
BMA253_FIFO_DATA_NUM * bma253_fifo_wml, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
for (i = 0; i < num; i++) {
accel[i].data[DATA_AXIS_X] =
(int32_t)((((int32_t)((int8_t)bma253_fifo_data[6 * i + 1]))
<< BMA253_SHIFT_EIGHT_BITS) |
(bma253_fifo_data[6 * i + 0] & BMA253_12_BIT_SHIFT));
accel[i].data[DATA_AXIS_X] =
accel[i].data[DATA_AXIS_X] >> BMA253_SHIFT_FOUR_BITS;
accel[i].data[DATA_AXIS_Y] =
(int32_t)((((int32_t)((int8_t)bma253_fifo_data[6 * i + 3]))
<< BMA253_SHIFT_EIGHT_BITS) |
(bma253_fifo_data[6 * i + 2] & BMA253_12_BIT_SHIFT));
accel[i].data[DATA_AXIS_Y] =
accel[i].data[DATA_AXIS_Y] >> BMA253_SHIFT_FOUR_BITS;
accel[i].data[DATA_AXIS_Z] =
(int32_t)((((int32_t)((int8_t)bma253_fifo_data[6 * i + 5]))
<< BMA253_SHIFT_EIGHT_BITS) |
(bma253_fifo_data[6 * i + 4] & BMA253_12_BIT_SHIFT));
accel[i].data[DATA_AXIS_Z] =
accel[i].data[DATA_AXIS_Z] >> BMA253_SHIFT_FOUR_BITS;
if (current_factor != 0) {
accel[i].data[DATA_AXIS_X] = accel[i].data[DATA_AXIS_X] *
ACCELEROMETER_UNIT_FACTOR /
(int32_t)current_factor;
accel[i].data[DATA_AXIS_Y] = accel[i].data[DATA_AXIS_Y] *
ACCELEROMETER_UNIT_FACTOR /
(int32_t)current_factor;
accel[i].data[DATA_AXIS_Z] = accel[i].data[DATA_AXIS_Z] *
ACCELEROMETER_UNIT_FACTOR /
(int32_t)current_factor;
}
accel[i].timestamp = aos_now_ms();
}
return len;
}
int drv_acc_bosch_bma253_workmode_set(work_mode_e mode)
{
if (mode >= DEV_MODE_INVALID) {
return -1;
}
bma253_work_mode = mode;
return 0;
}
UNUSED static work_mode_e drv_acc_bosch_bma253_workmode_get(void)
{
return bma253_work_mode;
}
static int drv_acc_bosch_bma253_data_ready_init(void)
{
int ret;
uint8_t value;
value = BMA253_IRQ_DATA_READY_ENABLE;
ret = sensor_i2c_write(&bma253_ctx, BMA253_INTR_ENABLE2_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = BMA253_IRQ_MAP_DATA_INT2;
ret = sensor_i2c_write(&bma253_ctx, BMA253_INTR_DATA_SELECT_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = BMA253_IRQ_CONFIG_PUSH_PULL;
ret = sensor_i2c_write(&bma253_ctx, BMA253_INTR_SET_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = BMA253_IRQ_CLEAR_VAL | BMA253_IRQ_NON_LATCHED;
ret = sensor_i2c_write(&bma253_ctx, BMA253_INTR_CTRL_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_bosch_bma253_fifo_init(void)
{
int ret;
uint8_t value;
value = BMA253_IRQ_FIFO_WML_MODE;
ret = sensor_i2c_write(&bma253_ctx, BMA253_FIFO_MODE_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = BMA253_IRQ_FIFO_WML_ENABLE;
ret = sensor_i2c_write(&bma253_ctx, BMA253_INTR_ENABLE2_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = bma253_fifo_wml;
ret = sensor_i2c_write(&bma253_ctx, BMA253_FIFO_WML_TRIG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = BMA253_IRQ_MAP_FIFO_WML_INT2;
ret = sensor_i2c_write(&bma253_ctx, BMA253_INTR_DATA_SELECT_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = BMA253_IRQ_CONFIG_PUSH_PULL;
ret = sensor_i2c_write(&bma253_ctx, BMA253_INTR_SET_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = BMA253_IRQ_CLEAR_VAL | BMA253_IRQ_NON_LATCHED;
ret = sensor_i2c_write(&bma253_ctx, BMA253_INTR_CTRL_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
int drv_acc_bosch_bma253_read(void *buf, size_t len)
{
if (0 == bma253_fifo_wml) {
return drv_acc_bosch_bma253_read_origion(buf, len);
} else {
return drv_acc_bosch_bma253_read_fifo(buf, len);
}
}
static void drv_acc_bosch_bma253_irq_clear(void)
{
uint8_t value;
int ret;
value = BMA253_IRQ_CLEAR_VAL | BMA253_IRQ_NON_LATCHED;
ret = sensor_i2c_write(&bma253_ctx, BMA253_INTR_CTRL_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return;
}
}
UNUSED static work_mode_e drv_acc_bosch_bma253_irq_mode_active(void)
{
uint8_t value;
int ret;
ret = sensor_i2c_read(&bma253_ctx, BMA253_STAT2_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return DEV_MODE_INVALID;
}
if ((value & BMA253_IRQ_FIFO_STAT) == BMA253_IRQ_FIFO_STAT) {
return DEV_FIFO;
}
else if ((value & BMA253_IRQ_DATA_READY_STAT) ==
BMA253_IRQ_DATA_READY_STAT) {
return DEV_DATA_READY;
} else {
return DEV_INT;
}
}
void drv_acc_bosch_bma253_irq_handle(void)
{
drv_acc_bosch_bma253_irq_clear();
}
static int drv_acc_bosch_bma253_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_acc_bosch_bma253_set_odr(&bma253_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_acc_bosch_bma253_set_range(&bma253_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_bosch_bma253_set_power_mode(&bma253_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMA253";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
} break;
default:
break;
}
return 0;
}
int drv_acc_bosch_bma253_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_bosch_bma253_open;
sensor.close = drv_acc_bosch_bma253_close;
sensor.read = drv_acc_bosch_bma253_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_bosch_bma253_ioctl;
sensor.irq_handle = drv_acc_bosch_bma253_irq_handle;
sensor.mode = DEV_POLLING;
sensor.gpio.port = BMA253_IRQ_PIN;
sensor.gpio.config = IRQ_MODE;
sensor.gpio.priv = &bma253_irq_mode_rising;
if (DEV_FIFO == sensor.mode) {
ret = drv_acc_bosch_bma253_fifo_wml_set(BMA253_FIFO_DEPTH_USD);
if (unlikely(ret)) {
return -1;
}
sensor.data_len = bma253_fifo_wml * sizeof(accel_data_t);
} else {
sensor.data_len = sizeof(accel_data_t);
}
ret = drv_acc_bosch_bma253_workmode_set(sensor.mode);
if (unlikely(ret)) {
return -1;
}
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma253_validate_id(&bma253_ctx, BMA253_CHIP_ID_VALUE);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma253_soft_reset(&bma253_ctx);
if (unlikely(ret)) {
return -1;
}
aos_msleep(5);
ret = drv_acc_bosch_bma253_set_range(&bma253_ctx, ACC_RANGE_8G);
if (unlikely(ret)) {
return -1;
}
// set odr is 100hz, and will update
ret = drv_acc_bosch_bma253_set_odr(&bma253_ctx, BMA253_DEFAULT_ODR_100HZ);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma253_set_power_mode(&bma253_ctx, DEV_SLEEP);
if (unlikely(ret)) {
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_bosch_bma253_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_bosch_bma253.c
|
C
|
apache-2.0
| 25,794
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define BMA280_I2C_ADDR1 (0x18)
#define BMA280_I2C_ADDR2 (0x19)
#define BMA280_I2C_ADDR3 (0x10)
#define BMA280_I2C_ADDR4 (0x11)
#define BMA280_I2C_ADDR_TRANS(n) ((n) << 1)
#define BMA280_I2C_ADDR BMA280_I2C_ADDR_TRANS(BMA280_I2C_ADDR1)
#define BMA280_INIT_VALUE (0)
#define BMA280_GEN_READ_WRITE_LENGTH (1)
#define BMA280_INTERFACE_IDLE_TIME_DELAY (1)
#define BMA280_LSB_MSB_READ_LENGTH (2)
#define BMA280_SHIFT_TWO_BITS (2)
#define BMA280_SHIFT_FOUR_BITS (4)
#define BMA280_SHIFT_FIVE_BITS (5)
#define BMA280_SHIFT_SIX_BITS (6)
#define BMA280_SHIFT_EIGHT_BITS (8)
#define BMA280_12_BIT_SHIFT (0xF0)
#define BMA280_FIFO_MODE_STATUS_RANGE (2)
#define BMA280_FIFO_DATA_SELECT_RANGE (4)
#define BMA280_FIFO_MODE_RANGE (4)
#define BMA280_FIFO_WML_RANGE (32)
#define BMA280_FIFO_XYZ_DATA_ENABLED (0x00)
#define BMA280_FIFO_X_DATA_ENABLED (0x01)
#define BMA280_FIFO_Y_DATA_ENABLED (0x02)
#define BMA280_FIFO_Z_DATA_ENABLED (0x03)
#define BMA280_FIFO_DATA_ENABLED_MASK (0x03)
#define BMA280_FIFO_XYZ_AXES_FRAME_SIZE (6)
#define BMA280_FIFO_SINGLE_AXIS_FRAME_SIZE (2)
#define BMA280_ACCEL_BW_MIN_RANGE (7)
#define BMA280_ACCEL_BW_1000HZ_RANGE (15)
#define BMA280_ACCEL_BW_MAX_RANGE (16)
#define BMA280_SLEEP_DURN_MIN_RANGE (4)
#define BMA280_SLEEP_TIMER_MODE_RANGE (2)
#define BMA280_SLEEP_DURN_MAX_RANGE (16)
#define BMA280_POWER_MODE_RANGE (6)
#define BMA280_SELF_TEST_AXIS_RANGE (4)
#define BMA280_SELF_TEST_SIGN_RANGE (2)
#define BMA280_EEP_OFFSET (0x16)
#define BMA280_IMAGE_BASE (0x38)
#define BMA280_IMAGE_LEN (22)
#define BMA280_CHIP_ID_ADDR (0x00)
#define BMA280_CHIP_ID_VALUE (0xFB)
#define BMA280_X_AXIS_LSB_ADDR (0x02)
#define BMA280_X_AXIS_MSB_ADDR (0x03)
#define BMA280_Y_AXIS_LSB_ADDR (0x04)
#define BMA280_Y_AXIS_MSB_ADDR (0x05)
#define BMA280_Z_AXIS_LSB_ADDR (0x06)
#define BMA280_Z_AXIS_MSB_ADDR (0x07)
#define BMA280_TEMP_ADDR (0x08)
#define BMA280_STAT1_ADDR (0x09)
#define BMA280_STAT2_ADDR (0x0A)
#define BMA280_STAT_TAP_SLOPE_ADDR (0x0B)
#define BMA280_STAT_ORIENT_HIGH_ADDR (0x0C)
#define BMA280_STAT_FIFO_ADDR (0x0E)
#define BMA280_RANGE_SELECT_ADDR (0x0F)
#define BMA280_BW_SELECT_ADDR (0x10)
#define BMA280_MODE_CTRL_ADDR (0x11)
#define BMA280_LOW_NOISE_CTRL_ADDR (0x12)
#define BMA280_DATA_CTRL_ADDR (0x13)
#define BMA280_RST_ADDR (0x14)
#define BMA280_INTR_ENABLE1_ADDR (0x16)
#define BMA280_INTR_ENABLE2_ADDR (0x17)
#define BMA280_INTR_SLOW_NO_MOTION_ADDR (0x18)
#define BMA280_INTR1_PAD_SELECT_ADDR (0x19)
#define BMA280_INTR_DATA_SELECT_ADDR (0x1A)
#define BMA280_INTR2_PAD_SELECT_ADDR (0x1B)
#define BMA280_INTR_SOURCE_ADDR (0x1E)
#define BMA280_INTR_SET_ADDR (0x20)
#define BMA280_INTR_CTRL_ADDR (0x21)
#define BMA280_LOW_DURN_ADDR (0x22)
#define BMA280_LOW_THRES_ADDR (0x23)
#define BMA280_LOW_HIGH_HYST_ADDR (0x24)
#define BMA280_HIGH_DURN_ADDR (0x25)
#define BMA280_HIGH_THRES_ADDR (0x26)
#define BMA280_SLOPE_DURN_ADDR (0x27)
#define BMA280_SLOPE_THRES_ADDR (0x28)
#define BMA280_SLOW_NO_MOTION_THRES_ADDR (0x29)
#define BMA280_TAP_PARAM_ADDR (0x2A)
#define BMA280_TAP_THRES_ADDR (0x2B)
#define BMA280_ORIENT_PARAM_ADDR (0x2C)
#define BMA280_THETA_BLOCK_ADDR (0x2D)
#define BMA280_THETA_FLAT_ADDR (0x2E)
#define BMA280_FLAT_HOLD_TIME_ADDR (0x2F)
#define BMA280_SELFTEST_ADDR (0x32)
#define BMA280_EEPROM_CTRL_ADDR (0x33)
#define BMA280_SERIAL_CTRL_ADDR (0x34)
#define BMA280_OFFSET_CTRL_ADDR (0x36)
#define BMA280_OFFSET_PARAMS_ADDR (0x37)
#define BMA280_OFFSET_X_AXIS_ADDR (0x38)
#define BMA280_OFFSET_Y_AXIS_ADDR (0x39)
#define BMA280_OFFSET_Z_AXIS_ADDR (0x3A)
#define BMA280_GP0_ADDR (0x3B)
#define BMA280_GP1_ADDR (0x3C)
#define BMA280_FIFO_MODE_ADDR (0x3E)
#define BMA280_FIFO_DATA_OUTPUT_ADDR (0x3F)
#define BMA280_FIFO_WML_TRIG (0x30)
#define BMA280_12_RESOLUTION (0)
#define BMA280_10_RESOLUTION (1)
#define BMA280_14_RESOLUTION (2)
#define BMA280_ENABLE_SOFT_RESET_VALUE (0xB6)
#define BMA280_RANGE_SELECT_POS (0)
#define BMA280_RANGE_SELECT_LEN (4)
#define BMA280_RANGE_SELECT_MSK (0x0F)
#define BMA280_RANGE_SELECT_REG BMA280_RANGE_SELECT_ADDR
#define BMA280_RANGE_2G (3)
#define BMA280_RANGE_4G (5)
#define BMA280_RANGE_8G (8)
#define BMA280_RANGE_16G (12)
#define BMA280_BW_15_63 (15)
#define BMA280_BW_31_25 (31)
#define BMA280_BW_62_5 (62)
#define BMA280_BW_125 (125)
#define BMA280_BW_250 (250)
#define BMA280_BW_500 (500)
#define BMA280_BW_1000 (1000)
#define BMA280_BW_7_81HZ (0x08)
#define BMA280_BW_15_63HZ (0x09)
#define BMA280_BW_31_25HZ (0x0A)
#define BMA280_BW_62_50HZ (0x0B)
#define BMA280_BW_125HZ (0x0C)
#define BMA280_BW_250HZ (0x0D)
#define BMA280_BW_500HZ (0x0E)
#define BMA280_BW_1000HZ (0x0F)
#define BMA280_BW_BIT_MASK (~0x0F)
#define BMA280_SLEEP_DURN_0_5MS (0x05)
#define BMA280_SLEEP_DURN_1MS (0x06)
#define BMA280_SLEEP_DURN_2MS (0x07)
#define BMA280_SLEEP_DURN_4MS (0x08)
#define BMA280_SLEEP_DURN_6MS (0x09)
#define BMA280_SLEEP_DURN_10MS (0x0A)
#define BMA280_SLEEP_DURN_25MS (0x0B)
#define BMA280_SLEEP_DURN_50MS (0x0C)
#define BMA280_SLEEP_DURN_100MS (0x0D)
#define BMA280_SLEEP_DURN_500MS (0x0E)
#define BMA280_SLEEP_DURN_1S (0x0F)
#define BMA280_SLEEP_DURN_POS (1)
#define BMA280_SLEEP_DURN_LEN (4)
#define BMA280_SLEEP_DURN_MSK (0x1E)
#define BMA280_SLEEP_DURN_REG BMA280_MODE_CTRL_ADDR
#define BMA280_SLEEP_MODE (0x40)
#define BMA280_DEEP_SUSPEND_MODE (0x20)
#define BMA280_SUSPEND_MODE (0x80)
#define BMA280_NORMAL_MODE (0x40)
#define BMA280_LOWPOWER_MODE (0x40)
#define BMA280_MODE_CTRL_POS (5)
#define BMA280_MODE_CTRL_LEN (3)
#define BMA280_MODE_CTRL_MSK (0xE0)
#define BMA280_MODE_CTRL_REG BMA280_MODE_CTRL_ADDR
#define BMA280_LOW_POWER_MODE_POS (6)
#define BMA280_LOW_POWER_MODE_LEN (1)
#define BMA280_LOW_POWER_MODE_MSK (0x40)
#define BMA280_LOW_POWER_MODE_REG BMA280_LOW_NOISE_CTRL_ADDR
#define BMA280_DEFAULT_ODR_100HZ (100)
#define BMA280_FIFO_DEPTH_MAX (32)
#define BMA280_FIFO_DATA_NUM (6)
#define BMA280_FIFO_BUFF_LEN (BMA280_FIFO_DEPTH_MAX * BMA280_FIFO_DATA_NUM)
// bma280 sensitivity factor table, the unit is LSB/g
#define BMA280_IRQ_CLEAR_VAL (0x80)
#define BMA280_IRQ_LATCHED (0x0f)
#define BMA280_IRQ_NON_LATCHED (0)
#define BMA280_IRQ_FIFO_STAT (0x40)
#define BMA280_IRQ_DATA_READY_STAT (0x80)
#define BMA280_IRQ_DATA_READY_ENABLE (0x10)
#define BMA280_IRQ_FIFO_FULL_ENABLE (0x20)
#define BMA280_IRQ_FIFO_WML_ENABLE (0x40)
#define BMA280_IRQ_MAP_DATA_INT2 (0x80)
#define BMA280_IRQ_MAP_FIFO_WML_INT2 (0x40)
#define BMA280_IRQ_CONFIG_PUSH_PULL (0x04)
#define BMA280_IRQ_FIFO_WML_MODE (0x40)
#define BMA280_IRQ_PIN (62)
#define BMA280_FIFO_DEPTH_USD (20)
#define BMA280_GET_BITSLICE(regvar, bitname) \
((regvar & bitname##_MSK) >> bitname##_POS)
#define BMA280_SET_BITSLICE(regvar, bitname, val) \
((regvar & ~bitname##_MSK) | ((val << bitname##_POS) & bitname##_MSK))
// bma280 sensitivity factor table, the unit is LSB/g
static uint32_t bma280_factor[4] = { 1024, 512, 256, 128 };
static uint32_t current_factor = 0;
i2c_dev_t bma280_ctx = {
.port = 3,
.config.dev_addr = BMA280_I2C_ADDR,
};
static int drv_acc_bosch_bma280_data_ready_init(void);
int drv_acc_bosch_bma280_soft_reset(i2c_dev_t *drv)
{
int ret = 0;
uint8_t value = BMA280_ENABLE_SOFT_RESET_VALUE;
ret = sensor_i2c_write(drv, BMA280_RST_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma280_validate_id(i2c_dev_t *drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, BMA280_CHIP_ID_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (id_value != value) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma280_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, BMA280_MODE_CTRL_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_ON: {
if ((value & BMA280_MODE_CTRL_MSK) == BMA280_NORMAL_MODE) {
return 0;
}
value |= BMA280_NORMAL_MODE;
ret = sensor_i2c_write(drv, BMA280_MODE_CTRL_REG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_POWER_OFF: {
if ((value & BMA280_MODE_CTRL_MSK) == BMA280_DEEP_SUSPEND_MODE) {
return 0;
}
value |= BMA280_DEEP_SUSPEND_MODE;
ret = sensor_i2c_write(drv, BMA280_MODE_CTRL_REG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_SLEEP: {
if ((value & BMA280_MODE_CTRL_MSK) == BMA280_SLEEP_MODE) {
return 0;
}
value |= BMA280_SLEEP_MODE;
ret = sensor_i2c_write(drv, BMA280_MODE_CTRL_REG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_SUSPEND: {
if ((value & BMA280_MODE_CTRL_MSK) == BMA280_SUSPEND_MODE) {
return 0;
}
value |= BMA280_SUSPEND_MODE;
ret = sensor_i2c_write(drv, BMA280_MODE_CTRL_REG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
default:
break;
}
return 0;
}
int drv_acc_bosch_bma280_set_odr(i2c_dev_t *drv, uint32_t odr)
{
int ret = 0;
uint8_t value = 0x00;
uint32_t bw = odr / 2;
ret = sensor_i2c_read(drv, BMA280_BW_SELECT_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (bw >= BMA280_BW_1000) {
value &= BMA280_BW_BIT_MASK;
value |= BMA280_BW_1000HZ;
} else if (bw >= BMA280_BW_500) {
value &= BMA280_BW_BIT_MASK;
value |= BMA280_BW_500HZ;
} else if (bw >= BMA280_BW_250) {
value &= BMA280_BW_BIT_MASK;
value |= BMA280_BW_250HZ;
} else if (bw >= BMA280_BW_125) {
value &= BMA280_BW_BIT_MASK;
value |= BMA280_BW_125HZ;
} else if (bw >= BMA280_BW_62_5) {
value &= BMA280_BW_BIT_MASK;
value |= BMA280_BW_62_50HZ;
} else if (bw >= BMA280_BW_31_25) {
value &= BMA280_BW_BIT_MASK;
value |= BMA280_BW_31_25HZ;
} else {
value &= BMA280_BW_BIT_MASK;
value |= BMA280_BW_15_63HZ;
}
ret = sensor_i2c_write(drv, BMA280_BW_SELECT_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
int drv_acc_bosch_bma280_set_range(i2c_dev_t *drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, BMA280_RANGE_SELECT_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (range) {
case ACC_RANGE_2G: {
value =
BMA280_SET_BITSLICE(value, BMA280_RANGE_SELECT, BMA280_RANGE_2G);
} break;
case ACC_RANGE_4G: {
value =
BMA280_SET_BITSLICE(value, BMA280_RANGE_SELECT, BMA280_RANGE_4G);
} break;
case ACC_RANGE_8G: {
value =
BMA280_SET_BITSLICE(value, BMA280_RANGE_SELECT, BMA280_RANGE_8G);
} break;
case ACC_RANGE_16G: {
value =
BMA280_SET_BITSLICE(value, BMA280_RANGE_SELECT, BMA280_RANGE_16G);
} break;
default:
break;
}
/* Write the range register 0x0F*/
ret = sensor_i2c_write(drv, BMA280_RANGE_SELECT_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (range <= ACC_RANGE_16G) {
current_factor = bma280_factor[range];
}
return 0;
}
int drv_acc_bosch_bma280_open(void)
{
int ret = 0;
ret = drv_acc_bosch_bma280_data_ready_init();
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma280_set_power_mode(&bma280_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma280_close(void)
{
int ret = 0;
ret = drv_acc_bosch_bma280_set_power_mode(&bma280_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_acc_bosch_bma280_data_ready_init(void)
{
int ret;
uint8_t value;
value = BMA280_IRQ_DATA_READY_ENABLE;
ret = sensor_i2c_write(&bma280_ctx, BMA280_INTR_ENABLE2_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = BMA280_IRQ_MAP_DATA_INT2;
ret = sensor_i2c_write(&bma280_ctx, BMA280_INTR_DATA_SELECT_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = BMA280_IRQ_CONFIG_PUSH_PULL;
ret = sensor_i2c_write(&bma280_ctx, BMA280_INTR_SET_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = BMA280_IRQ_CLEAR_VAL | BMA280_IRQ_NON_LATCHED;
ret = sensor_i2c_write(&bma280_ctx, BMA280_INTR_CTRL_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
int drv_acc_bosch_bma280_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(&bma280_ctx, BMA280_X_AXIS_LSB_ADDR, ®[0],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma280_ctx, BMA280_X_AXIS_MSB_ADDR, ®[1],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma280_ctx, BMA280_Y_AXIS_LSB_ADDR, ®[2],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma280_ctx, BMA280_Y_AXIS_MSB_ADDR, ®[3],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma280_ctx, BMA280_Z_AXIS_LSB_ADDR, ®[4],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma280_ctx, BMA280_Z_AXIS_MSB_ADDR, ®[5],
I2C_REG_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
accel->data[DATA_AXIS_X] =
(int32_t)((((int32_t)((int8_t)reg[1])) << BMA280_SHIFT_EIGHT_BITS) |
(reg[0] & BMA280_12_BIT_SHIFT));
accel->data[DATA_AXIS_X] =
accel->data[DATA_AXIS_X] >> BMA280_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Y] =
(int32_t)((((int32_t)((int8_t)reg[3])) << BMA280_SHIFT_EIGHT_BITS) |
(reg[2] & BMA280_12_BIT_SHIFT));
accel->data[DATA_AXIS_Y] =
accel->data[DATA_AXIS_Y] >> BMA280_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Z] =
(int32_t)((((int32_t)((int8_t)reg[5])) << BMA280_SHIFT_EIGHT_BITS) |
(reg[4] & BMA280_12_BIT_SHIFT));
accel->data[DATA_AXIS_Z] =
accel->data[DATA_AXIS_Z] >> BMA280_SHIFT_FOUR_BITS;
if (current_factor != 0) {
// the unit of acc is mg, 1000 mg = 1 g.
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] *
ACCELEROMETER_UNIT_FACTOR /
(int32_t)current_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] *
ACCELEROMETER_UNIT_FACTOR /
(int32_t)current_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] *
ACCELEROMETER_UNIT_FACTOR /
(int32_t)current_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
void drv_acc_bosch_bma280_irq_handle(void)
{
}
static int drv_acc_bosch_bma280_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_acc_bosch_bma280_set_odr(&bma280_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_acc_bosch_bma280_set_range(&bma280_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_bosch_bma280_set_power_mode(&bma280_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMA280";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
} break;
default:
break;
}
return 0;
}
int drv_acc_bosch_bma280_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_bosch_bma280_open;
sensor.close = drv_acc_bosch_bma280_close;
sensor.read = drv_acc_bosch_bma280_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_bosch_bma280_ioctl;
sensor.irq_handle = drv_acc_bosch_bma280_irq_handle;
sensor.mode = DEV_POLLING;
sensor.data_len = sizeof(accel_data_t);
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma280_validate_id(&bma280_ctx, BMA280_CHIP_ID_VALUE);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma280_soft_reset(&bma280_ctx);
if (unlikely(ret)) {
return -1;
}
aos_msleep(5);
ret = drv_acc_bosch_bma280_set_range(&bma280_ctx, ACC_RANGE_8G);
if (unlikely(ret)) {
return -1;
}
// set odr is 100hz, and will update
ret = drv_acc_bosch_bma280_set_odr(&bma280_ctx, BMA280_DEFAULT_ODR_100HZ);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma280_set_power_mode(&bma280_ctx, DEV_SLEEP);
if (unlikely(ret)) {
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_bosch_bma280_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_bosch_bma280.c
|
C
|
apache-2.0
| 21,010
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include "aos/kernel.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define BMA421_I2C_ADDR_LOW (0x18)
#define BMA421_I2C_ADDR_HIGH (0x19)
#define BMA421_I2C_ADDR_TRANS(n) ((n)<<1)
#define BMA421_I2C_ADDR BMA421_I2C_ADDR_TRANS(BMA421_I2C_ADDR_LOW)
#define BMA421_CHIP_ID_ADDR UINT8_C(0X00)
#define BMA421_CHIP_ID_VALUE (0x11)
#define BMA421_POWER_CONF_ADDR UINT8_C(0x7C)
#define BMA421_POWER_CTRL_ADDR UINT8_C(0x7D)
#define BMA421_ACCEL_CONFIG_ADDR UINT8_C(0X40)
#define BMA421_ACCEL_CONFIG1_ADDR UINT8_C(0X41)
#define BMA421_DEFAULT_ODR_100HZ (100)
#define BMA421_CMD_ADDR UINT8_C(0X7E)
#define BMA421_OUTPUT_DATA_RATE_0_78HZ UINT8_C(0x01)
#define BMA421_OUTPUT_DATA_RATE_1_56HZ UINT8_C(0x02)
#define BMA421_OUTPUT_DATA_RATE_3_12HZ UINT8_C(0x03)
#define BMA421_OUTPUT_DATA_RATE_6_25HZ UINT8_C(0x04)
#define BMA421_OUTPUT_DATA_RATE_12_5HZ UINT8_C(0x05)
#define BMA421_OUTPUT_DATA_RATE_25HZ UINT8_C(0x06)
#define BMA421_OUTPUT_DATA_RATE_50HZ UINT8_C(0x07)
#define BMA421_OUTPUT_DATA_RATE_100HZ UINT8_C(0x08)
#define BMA421_OUTPUT_DATA_RATE_200HZ UINT8_C(0x09)
#define BMA421_OUTPUT_DATA_RATE_400HZ UINT8_C(0x0A)
#define BMA421_OUTPUT_DATA_RATE_800HZ UINT8_C(0x0B)
#define BMA421_OUTPUT_DATA_RATE_1600HZ UINT8_C(0x0C)
#define BMA421_ACCEL_OSR4_AVG1 UINT8_C(0)
#define BMA421_ACCEL_OSR2_AVG2 UINT8_C(1)
#define BMA421_ACCEL_NORMAL_AVG4 UINT8_C(2)
#define BMA421_ACCEL_CIC_AVG8 UINT8_C(3)
#define BMA421_ACCEL_RES_AVG16 UINT8_C(4)
#define BMA421_ACCEL_RES_AVG32 UINT8_C(5)
#define BMA421_ACCEL_RES_AVG64 UINT8_C(6)
#define BMA421_ACCEL_RES_AVG128 UINT8_C(7)
#define BMA421_ACCEL_RANGE_2G UINT8_C(0)
#define BMA421_ACCEL_RANGE_4G UINT8_C(1)
#define BMA421_ACCEL_RANGE_8G UINT8_C(2)
#define BMA421_ACCEL_RANGE_16G UINT8_C(3)
#define BMA421_DATA_0_ADDR UINT8_C(0X0A)
#define BMA421_DATA_8_ADDR UINT8_C(0X12)
#define BMA421_ACCEL_DATA_LENGTH UINT8_C(6)
#define BMA421_ENABLE UINT8_C(0x01)
#define BMA421_DISABLE UINT8_C(0x00)
#define BMA421_ADVANCE_POWER_SAVE_MSK UINT8_C(0x01)
#define BMA421_ACCEL_ENABLE_POS UINT8_C(2)
#define BMA421_ACCEL_ENABLE_MSK UINT8_C(0x04)
#define BMA421_ACCEL_PERF_POS UINT8_C(7)
#define BMA421_ACCEL_ODR_POS UINT8_C(0)
#define BMA421_ACCEL_ODR_MSK UINT8_C(0x0F)
#define BMA421_ACCEL_RANGE_POS UINT8_C(0)
#define BMA421_ACCEL_RANGE_MSK UINT8_C(0x03)
#define BMA421_ENABLE_SOFT_RESET_VALUE UINT8_C(0XB6)
#define BMA421_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define BMA421_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | \
((val<<bitname##_POS)&bitname##_MSK))
#define BMA421_SET_BITS_POS_0(reg_data, bitname, data) \
((reg_data & ~(bitname##_MSK)) | \
(data & bitname##_MSK))
#define BMA421_GET_BITS_POS_0(reg_data, bitname) (reg_data & (bitname##_MSK))
static uint32_t bma421_factor[4] = { 16384, 8192, 4096, 2048 };
static uint32_t current_factor = 0;
static uint32_t set_range_failed = 0;
i2c_dev_t bma421_ctx = {
.port = 3,
.config.dev_addr = BMA421_I2C_ADDR,
};
int drv_acc_bosch_bma421_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = BMA421_ENABLE_SOFT_RESET_VALUE;
ret = sensor_i2c_write(drv, BMA421_CMD_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma421_validate_id(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, BMA421_CHIP_ID_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
LOG("%s %s sensor_i2c_read \n", SENSOR_STR, __func__);
return ret;
}
if(BMA421_CHIP_ID_VALUE != value) {
LOG("%s %s value=%x \n", SENSOR_STR, __func__, value);
return -1;
}
return 0;
}
int drv_acc_bosch_bma421_set_power_mode(i2c_dev_t* drv,
dev_power_mode_e mode)
{
uint8_t value, value1 = 0x00;
int ret = 0;
switch(mode) {
case DEV_POWER_ON: {
ret = sensor_i2c_read(drv, BMA421_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value |= (BMA421_ENABLE << BMA421_ACCEL_PERF_POS);
ret = sensor_i2c_write(drv, BMA421_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, BMA421_POWER_CTRL_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value1 = BMA421_SET_BITSLICE(value1, BMA421_ACCEL_ENABLE, BMA421_ENABLE);
ret = sensor_i2c_write(drv, BMA421_POWER_CTRL_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
}
break;
case DEV_POWER_OFF:
case DEV_SLEEP:
case DEV_SUSPEND: {
ret = sensor_i2c_read(drv, BMA421_POWER_CTRL_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value = BMA421_SET_BITSLICE(value, BMA421_ACCEL_ENABLE, BMA421_DISABLE);
ret = sensor_i2c_write(drv, BMA421_POWER_CTRL_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, BMA421_POWER_CONF_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value1 = BMA421_SET_BITS_POS_0(value1, BMA421_ADVANCE_POWER_SAVE, BMA421_ENABLE);
ret = sensor_i2c_write(drv, BMA421_POWER_CONF_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
}
break;
default:
break;
}
return 0;
}
int drv_acc_bosch_bma421_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = 0x00;
ret = sensor_i2c_read(drv, BMA421_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
if(hz >= 800) {
odr = BMA421_OUTPUT_DATA_RATE_1600HZ;
} else if(hz >= 400) {
odr = BMA421_OUTPUT_DATA_RATE_800HZ;
} else if(hz >= 200) {
odr = BMA421_OUTPUT_DATA_RATE_400HZ;
} else if(hz >= 100) {
odr = BMA421_OUTPUT_DATA_RATE_200HZ;
} else if(hz >= 50) {
odr = BMA421_OUTPUT_DATA_RATE_100HZ;
} else if(hz >= 25) {
odr = BMA421_OUTPUT_DATA_RATE_50HZ;
} else if(hz >= 12) {
odr = BMA421_OUTPUT_DATA_RATE_25HZ;
} else if(hz >= 6) {
odr = BMA421_OUTPUT_DATA_RATE_12_5HZ;
} else if(hz >= 3) {
odr = BMA421_OUTPUT_DATA_RATE_6_25HZ;
} else {
odr = BMA421_OUTPUT_DATA_RATE_3_12HZ;
}
value = BMA421_SET_BITSLICE(value, BMA421_ACCEL_ODR, odr);
ret = sensor_i2c_write(drv, BMA421_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
return 0;
}
int drv_acc_bosch_bma421_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t acc_range = 0x00;
ret = sensor_i2c_read(drv, BMA421_ACCEL_CONFIG1_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
set_range_failed = 1;
return ret;
}
switch(range) {
case ACC_RANGE_2G: {
acc_range = BMA421_ACCEL_RANGE_2G;
}
break;
case ACC_RANGE_4G: {
acc_range = BMA421_ACCEL_RANGE_4G;
}
break;
case ACC_RANGE_8G: {
acc_range = BMA421_ACCEL_RANGE_8G;
}
break;
case ACC_RANGE_16G: {
acc_range = BMA421_ACCEL_RANGE_16G;
}
break;
default:
break;
}
value = BMA421_SET_BITSLICE(value, BMA421_ACCEL_RANGE, acc_range);
ret = sensor_i2c_write(drv, BMA421_ACCEL_CONFIG1_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
set_range_failed = 2;
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)) {
current_factor = bma421_factor[range];
}
set_range_failed = 3;
return 0;
}
void drv_acc_bosch_bma421_irq_handle(void)
{
/* no handle so far */
}
int drv_acc_bosch_bma421_open(void)
{
int ret = 0;
ret = drv_acc_bosch_bma421_set_power_mode(&bma421_ctx, DEV_POWER_ON);
if(unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma421_close(void)
{
int ret = 0;
ret = drv_acc_bosch_bma421_set_power_mode(&bma421_ctx, DEV_POWER_OFF);
if(unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma421_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
uint8_t range = 0;
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if(len < size) {
return -1;
}
ret = sensor_i2c_read(&bma421_ctx, 0x41, &range, I2C_REG_LEN, I2C_OP_RETRIES);
ret = sensor_i2c_read(&bma421_ctx, BMA421_DATA_8_ADDR, ®[0], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma421_ctx, BMA421_DATA_8_ADDR+1, ®[1], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma421_ctx, BMA421_DATA_8_ADDR+2, ®[2], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma421_ctx, BMA421_DATA_8_ADDR+3, ®[3], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma421_ctx, BMA421_DATA_8_ADDR+4, ®[4], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma421_ctx, BMA421_DATA_8_ADDR+5, ®[5], I2C_REG_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return -1;
}
accel->data[DATA_AXIS_X] = ((int16_t)((reg[1] << 8) | reg[0]));
accel->data[DATA_AXIS_Y] = ((int16_t)((reg[3] << 8) | reg[2]));
accel->data[DATA_AXIS_Z] = ((int16_t)((reg[5] << 8) | reg[4]));
if(current_factor != 0) {
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)current_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)current_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)current_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_bosch_bma421_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_acc_bosch_bma421_set_odr(&bma421_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}
break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_acc_bosch_bma421_set_range(&bma421_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}
break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_bosch_bma421_set_power_mode(&bma421_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}
break;
case SENSOR_IOCTL_GET_INFO: {
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMA421";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}
break;
default:
break;
}
return 0;
}
int drv_acc_bosch_bma421_init(void) {
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_bosch_bma421_open;
sensor.close = drv_acc_bosch_bma421_close;
sensor.read = drv_acc_bosch_bma421_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_bosch_bma421_ioctl;
sensor.irq_handle = drv_acc_bosch_bma421_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma421_validate_id(&bma421_ctx);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma421_soft_reset(&bma421_ctx);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma421_set_range(&bma421_ctx, ACC_RANGE_8G);
if(unlikely(ret)) {
return -1;
}
/* set odr is 100hz, and will update */
ret = drv_acc_bosch_bma421_set_odr(&bma421_ctx, BMA421_DEFAULT_ODR_100HZ);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma421_set_power_mode(&bma421_ctx, DEV_SLEEP);
if(unlikely(ret)) {
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_bosch_bma421_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_bosch_bma421.c
|
C
|
apache-2.0
| 14,789
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include "aos/kernel.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define BMA422_I2C_ADDR_LOW (0x18)
#define BMA422_I2C_ADDR_HIGH (0x19)
#define BMA422_I2C_ADDR_TRANS(n) ((n)<<1)
#define BMA422_I2C_ADDR BMA422_I2C_ADDR_TRANS(BMA422_I2C_ADDR_LOW)
#define BMA422_CHIP_ID_ADDR UINT8_C(0X00)
#define BMA422_CHIP_ID_VALUE (0x12)
#define BMA422_POWER_CONF_ADDR UINT8_C(0x7C)
#define BMA422_POWER_CTRL_ADDR UINT8_C(0x7D)
#define BMA422_ACCEL_CONFIG_ADDR UINT8_C(0X40)
#define BMA422_ACCEL_CONFIG1_ADDR UINT8_C(0X41)
#define BMA422_DEFAULT_ODR_100HZ (100)
#define BMA422_CMD_ADDR UINT8_C(0X7E)
#define BMA422_OUTPUT_DATA_RATE_0_78HZ UINT8_C(0x01)
#define BMA422_OUTPUT_DATA_RATE_1_56HZ UINT8_C(0x02)
#define BMA422_OUTPUT_DATA_RATE_3_12HZ UINT8_C(0x03)
#define BMA422_OUTPUT_DATA_RATE_6_25HZ UINT8_C(0x04)
#define BMA422_OUTPUT_DATA_RATE_12_5HZ UINT8_C(0x05)
#define BMA422_OUTPUT_DATA_RATE_25HZ UINT8_C(0x06)
#define BMA422_OUTPUT_DATA_RATE_50HZ UINT8_C(0x07)
#define BMA422_OUTPUT_DATA_RATE_100HZ UINT8_C(0x08)
#define BMA422_OUTPUT_DATA_RATE_200HZ UINT8_C(0x09)
#define BMA422_OUTPUT_DATA_RATE_400HZ UINT8_C(0x0A)
#define BMA422_OUTPUT_DATA_RATE_800HZ UINT8_C(0x0B)
#define BMA422_OUTPUT_DATA_RATE_1600HZ UINT8_C(0x0C)
#define BMA422_ACCEL_OSR4_AVG1 UINT8_C(0)
#define BMA422_ACCEL_OSR2_AVG2 UINT8_C(1)
#define BMA422_ACCEL_NORMAL_AVG4 UINT8_C(2)
#define BMA422_ACCEL_CIC_AVG8 UINT8_C(3)
#define BMA422_ACCEL_RES_AVG16 UINT8_C(4)
#define BMA422_ACCEL_RES_AVG32 UINT8_C(5)
#define BMA422_ACCEL_RES_AVG64 UINT8_C(6)
#define BMA422_ACCEL_RES_AVG128 UINT8_C(7)
#define BMA422_ACCEL_RANGE_2G UINT8_C(0)
#define BMA422_ACCEL_RANGE_4G UINT8_C(1)
#define BMA422_ACCEL_RANGE_8G UINT8_C(2)
#define BMA422_ACCEL_RANGE_16G UINT8_C(3)
#define BMA422_DATA_0_ADDR UINT8_C(0X0A)
#define BMA422_DATA_8_ADDR UINT8_C(0X12)
#define BMA422_ACCEL_DATA_LENGTH UINT8_C(6)
#define BMA422_ENABLE UINT8_C(0x01)
#define BMA422_DISABLE UINT8_C(0x00)
#define BMA422_ADVANCE_POWER_SAVE_MSK UINT8_C(0x01)
#define BMA422_ACCEL_ENABLE_POS UINT8_C(2)
#define BMA422_ACCEL_ENABLE_MSK UINT8_C(0x04)
#define BMA422_ACCEL_PERF_POS UINT8_C(7)
#define BMA422_ACCEL_ODR_POS UINT8_C(0)
#define BMA422_ACCEL_ODR_MSK UINT8_C(0x0F)
#define BMA422_ACCEL_RANGE_POS UINT8_C(0)
#define BMA422_ACCEL_RANGE_MSK UINT8_C(0x03)
#define BMA422_ENABLE_SOFT_RESET_VALUE UINT8_C(0XB6)
#define BMA422_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define BMA422_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | \
((val<<bitname##_POS)&bitname##_MSK))
#define BMA422_SET_BITS_POS_0(reg_data, bitname, data) \
((reg_data & ~(bitname##_MSK)) | \
(data & bitname##_MSK))
#define BMA422_GET_BITS_POS_0(reg_data, bitname) (reg_data & (bitname##_MSK))
static uint32_t bma422_factor[4] = { 16384, 8192, 4096, 2048 };
static uint32_t current_factor = 0;
static uint32_t set_range_failed = 0;
i2c_dev_t bma422_ctx = {
.port = 3,
.config.dev_addr = BMA422_I2C_ADDR,
};
int drv_acc_bosch_bma422_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = BMA422_ENABLE_SOFT_RESET_VALUE;
ret = sensor_i2c_write(drv, BMA422_CMD_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma422_validate_id(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, BMA422_CHIP_ID_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
LOG("%s %s sensor_i2c_read \n", SENSOR_STR, __func__);
return ret;
}
if(BMA422_CHIP_ID_VALUE != value) {
LOG("%s %s value=%x \n", SENSOR_STR, __func__, value);
return -1;
}
return 0;
}
int drv_acc_bosch_bma422_set_power_mode(i2c_dev_t* drv,
dev_power_mode_e mode)
{
uint8_t value, value1 = 0x00;
int ret = 0;
switch(mode) {
case DEV_POWER_ON: {
ret = sensor_i2c_read(drv, BMA422_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value |= (BMA422_ENABLE << BMA422_ACCEL_PERF_POS);
ret = sensor_i2c_write(drv, BMA422_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, BMA422_POWER_CTRL_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value1 = BMA422_SET_BITSLICE(value1, BMA422_ACCEL_ENABLE, BMA422_ENABLE);
ret = sensor_i2c_write(drv, BMA422_POWER_CTRL_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
}
break;
case DEV_POWER_OFF:
case DEV_SLEEP:
case DEV_SUSPEND: {
ret = sensor_i2c_read(drv, BMA422_POWER_CTRL_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value = BMA422_SET_BITSLICE(value, BMA422_ACCEL_ENABLE, BMA422_DISABLE);
ret = sensor_i2c_write(drv, BMA422_POWER_CTRL_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, BMA422_POWER_CONF_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value1 = BMA422_SET_BITS_POS_0(value1, BMA422_ADVANCE_POWER_SAVE, BMA422_ENABLE);
ret = sensor_i2c_write(drv, BMA422_POWER_CONF_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
}
break;
default:
break;
}
return 0;
}
int drv_acc_bosch_bma422_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = 0x00;
ret = sensor_i2c_read(drv, BMA422_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
if(hz >= 800) {
odr = BMA422_OUTPUT_DATA_RATE_1600HZ;
} else if(hz >= 400) {
odr = BMA422_OUTPUT_DATA_RATE_800HZ;
} else if(hz >= 200) {
odr = BMA422_OUTPUT_DATA_RATE_400HZ;
} else if(hz >= 100) {
odr = BMA422_OUTPUT_DATA_RATE_200HZ;
} else if(hz >= 50) {
odr = BMA422_OUTPUT_DATA_RATE_100HZ;
} else if(hz >= 25) {
odr = BMA422_OUTPUT_DATA_RATE_50HZ;
} else if(hz >= 12) {
odr = BMA422_OUTPUT_DATA_RATE_25HZ;
} else if(hz >= 6) {
odr = BMA422_OUTPUT_DATA_RATE_12_5HZ;
} else if(hz >= 3) {
odr = BMA422_OUTPUT_DATA_RATE_6_25HZ;
} else {
odr = BMA422_OUTPUT_DATA_RATE_3_12HZ;
}
value = BMA422_SET_BITSLICE(value, BMA422_ACCEL_ODR, odr);
ret = sensor_i2c_write(drv, BMA422_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
return 0;
}
int drv_acc_bosch_bma422_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t acc_range = 0x00;
ret = sensor_i2c_read(drv, BMA422_ACCEL_CONFIG1_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
set_range_failed = 1;
return ret;
}
switch(range) {
case ACC_RANGE_2G: {
acc_range = BMA422_ACCEL_RANGE_2G;
}
break;
case ACC_RANGE_4G: {
acc_range = BMA422_ACCEL_RANGE_4G;
}
break;
case ACC_RANGE_8G: {
acc_range = BMA422_ACCEL_RANGE_8G;
}
break;
case ACC_RANGE_16G: {
acc_range = BMA422_ACCEL_RANGE_16G;
}
break;
default:
break;
}
value = BMA422_SET_BITSLICE(value, BMA422_ACCEL_RANGE, acc_range);
ret = sensor_i2c_write(drv, BMA422_ACCEL_CONFIG1_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
set_range_failed = 2;
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)) {
current_factor = bma422_factor[range];
}
set_range_failed = 3;
return 0;
}
void drv_acc_bosch_bma422_irq_handle(void)
{
/* no handle so far */
}
int drv_acc_bosch_bma422_open(void)
{
int ret = 0;
ret = drv_acc_bosch_bma422_set_power_mode(&bma422_ctx, DEV_POWER_ON);
if(unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma422_close(void)
{
int ret = 0;
ret = drv_acc_bosch_bma422_set_power_mode(&bma422_ctx, DEV_POWER_OFF);
if(unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma422_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
uint8_t range = 0;
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if(len < size) {
return -1;
}
ret = sensor_i2c_read(&bma422_ctx, 0x41, &range, I2C_REG_LEN, I2C_OP_RETRIES);
ret = sensor_i2c_read(&bma422_ctx, BMA422_DATA_8_ADDR, ®[0], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma422_ctx, BMA422_DATA_8_ADDR+1, ®[1], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma422_ctx, BMA422_DATA_8_ADDR+2, ®[2], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma422_ctx, BMA422_DATA_8_ADDR+3, ®[3], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma422_ctx, BMA422_DATA_8_ADDR+4, ®[4], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma422_ctx, BMA422_DATA_8_ADDR+5, ®[5], I2C_REG_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return -1;
}
accel->data[DATA_AXIS_X] = ((int16_t)((reg[1] << 8) | reg[0]));
accel->data[DATA_AXIS_Y] = ((int16_t)((reg[3] << 8) | reg[2]));
accel->data[DATA_AXIS_Z] = ((int16_t)((reg[5] << 8) | reg[4]));
if(current_factor != 0) {
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)current_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)current_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)current_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_bosch_bma422_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_acc_bosch_bma422_set_odr(&bma422_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}
break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_acc_bosch_bma422_set_range(&bma422_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}
break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_bosch_bma422_set_power_mode(&bma422_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}
break;
case SENSOR_IOCTL_GET_INFO: {
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMA422";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}
break;
default:
break;
}
return 0;
}
int drv_acc_bosch_bma422_init(void) {
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_bosch_bma422_open;
sensor.close = drv_acc_bosch_bma422_close;
sensor.read = drv_acc_bosch_bma422_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_bosch_bma422_ioctl;
sensor.irq_handle = drv_acc_bosch_bma422_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma422_validate_id(&bma422_ctx);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma422_soft_reset(&bma422_ctx);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma422_set_range(&bma422_ctx, ACC_RANGE_8G);
if(unlikely(ret)) {
return -1;
}
/* set odr is 100hz, and will update */
ret = drv_acc_bosch_bma422_set_odr(&bma422_ctx, BMA422_DEFAULT_ODR_100HZ);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma422_set_power_mode(&bma422_ctx, DEV_SLEEP);
if(unlikely(ret)) {
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_bosch_bma422_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_bosch_bma422.c
|
C
|
apache-2.0
| 14,787
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include "aos/kernel.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define BMA455_I2C_ADDR_LOW (0x18)
#define BMA455_I2C_ADDR_HIGH (0x19)
#define BMA455_I2C_ADDR_TRANS(n) ((n)<<1)
#define BMA455_I2C_ADDR BMA455_I2C_ADDR_TRANS(BMA455_I2C_ADDR_LOW)
#define BMA455_CHIP_ID_ADDR UINT8_C(0X00)
#define BMA455_CHIP_ID_VALUE (0x15)
#define BMA455_POWER_CONF_ADDR UINT8_C(0x7C)
#define BMA455_POWER_CTRL_ADDR UINT8_C(0x7D)
#define BMA455_ACCEL_CONFIG_ADDR UINT8_C(0X40)
#define BMA455_ACCEL_CONFIG1_ADDR UINT8_C(0X41)
#define BMA455_DEFAULT_ODR_100HZ (100)
#define BMA455_CMD_ADDR UINT8_C(0X7E)
#define BMA455_OUTPUT_DATA_RATE_0_78HZ UINT8_C(0x01)
#define BMA455_OUTPUT_DATA_RATE_1_56HZ UINT8_C(0x02)
#define BMA455_OUTPUT_DATA_RATE_3_12HZ UINT8_C(0x03)
#define BMA455_OUTPUT_DATA_RATE_6_25HZ UINT8_C(0x04)
#define BMA455_OUTPUT_DATA_RATE_12_5HZ UINT8_C(0x05)
#define BMA455_OUTPUT_DATA_RATE_25HZ UINT8_C(0x06)
#define BMA455_OUTPUT_DATA_RATE_50HZ UINT8_C(0x07)
#define BMA455_OUTPUT_DATA_RATE_100HZ UINT8_C(0x08)
#define BMA455_OUTPUT_DATA_RATE_200HZ UINT8_C(0x09)
#define BMA455_OUTPUT_DATA_RATE_400HZ UINT8_C(0x0A)
#define BMA455_OUTPUT_DATA_RATE_800HZ UINT8_C(0x0B)
#define BMA455_OUTPUT_DATA_RATE_1600HZ UINT8_C(0x0C)
#define BMA455_ACCEL_OSR4_AVG1 UINT8_C(0)
#define BMA455_ACCEL_OSR2_AVG2 UINT8_C(1)
#define BMA455_ACCEL_NORMAL_AVG4 UINT8_C(2)
#define BMA455_ACCEL_CIC_AVG8 UINT8_C(3)
#define BMA455_ACCEL_RES_AVG16 UINT8_C(4)
#define BMA455_ACCEL_RES_AVG32 UINT8_C(5)
#define BMA455_ACCEL_RES_AVG64 UINT8_C(6)
#define BMA455_ACCEL_RES_AVG128 UINT8_C(7)
#define BMA455_ACCEL_RANGE_2G UINT8_C(0)
#define BMA455_ACCEL_RANGE_4G UINT8_C(1)
#define BMA455_ACCEL_RANGE_8G UINT8_C(2)
#define BMA455_ACCEL_RANGE_16G UINT8_C(3)
#define BMA455_DATA_0_ADDR UINT8_C(0X0A)
#define BMA455_DATA_8_ADDR UINT8_C(0X12)
#define BMA455_ACCEL_DATA_LENGTH UINT8_C(6)
#define BMA455_ENABLE UINT8_C(0x01)
#define BMA455_DISABLE UINT8_C(0x00)
#define BMA455_ADVANCE_POWER_SAVE_MSK UINT8_C(0x01)
#define BMA455_ACCEL_ENABLE_POS UINT8_C(2)
#define BMA455_ACCEL_ENABLE_MSK UINT8_C(0x04)
#define BMA455_ACCEL_PERF_POS UINT8_C(7)
#define BMA455_ACCEL_ODR_POS UINT8_C(0)
#define BMA455_ACCEL_ODR_MSK UINT8_C(0x0F)
#define BMA455_ACCEL_RANGE_POS UINT8_C(0)
#define BMA455_ACCEL_RANGE_MSK UINT8_C(0x03)
#define BMA455_ENABLE_SOFT_RESET_VALUE UINT8_C(0XB6)
#define BMA455_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define BMA455_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | \
((val<<bitname##_POS)&bitname##_MSK))
#define BMA455_SET_BITS_POS_0(reg_data, bitname, data) \
((reg_data & ~(bitname##_MSK)) | \
(data & bitname##_MSK))
#define BMA455_GET_BITS_POS_0(reg_data, bitname) (reg_data & (bitname##_MSK))
static uint32_t bma455_factor[4] = { 16384, 8192, 4096, 2048 };
static uint32_t current_factor = 0;
static uint32_t set_range_failed = 0;
i2c_dev_t bma455_ctx = {
.port = 3,
.config.dev_addr = BMA455_I2C_ADDR,
};
int drv_acc_bosch_bma455_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = BMA455_ENABLE_SOFT_RESET_VALUE;
ret = sensor_i2c_write(drv, BMA455_CMD_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma455_validate_id(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, BMA455_CHIP_ID_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
LOG("%s %s sensor_i2c_read \n", SENSOR_STR, __func__);
return ret;
}
if(BMA455_CHIP_ID_VALUE != value) {
LOG("%s %s value=%x \n", SENSOR_STR, __func__, value);
return -1;
}
return 0;
}
int drv_acc_bosch_bma455_set_power_mode(i2c_dev_t* drv,
dev_power_mode_e mode)
{
uint8_t value, value1 = 0x00;
int ret = 0;
switch(mode) {
case DEV_POWER_ON: {
ret = sensor_i2c_read(drv, BMA455_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value |= (BMA455_ENABLE << BMA455_ACCEL_PERF_POS);
ret = sensor_i2c_write(drv, BMA455_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, BMA455_POWER_CTRL_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value1 = BMA455_SET_BITSLICE(value1, BMA455_ACCEL_ENABLE, BMA455_ENABLE);
ret = sensor_i2c_write(drv, BMA455_POWER_CTRL_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
}
break;
case DEV_POWER_OFF:
case DEV_SLEEP:
case DEV_SUSPEND: {
ret = sensor_i2c_read(drv, BMA455_POWER_CTRL_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value = BMA455_SET_BITSLICE(value, BMA455_ACCEL_ENABLE, BMA455_DISABLE);
ret = sensor_i2c_write(drv, BMA455_POWER_CTRL_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, BMA455_POWER_CONF_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value1 = BMA455_SET_BITS_POS_0(value1, BMA455_ADVANCE_POWER_SAVE, BMA455_ENABLE);
ret = sensor_i2c_write(drv, BMA455_POWER_CONF_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
}
break;
default:
break;
}
return 0;
}
int drv_acc_bosch_bma455_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = 0x00;
ret = sensor_i2c_read(drv, BMA455_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
if(hz >= 800) {
odr = BMA455_OUTPUT_DATA_RATE_1600HZ;
} else if(hz >= 400) {
odr = BMA455_OUTPUT_DATA_RATE_800HZ;
} else if(hz >= 200) {
odr = BMA455_OUTPUT_DATA_RATE_400HZ;
} else if(hz >= 100) {
odr = BMA455_OUTPUT_DATA_RATE_200HZ;
} else if(hz >= 50) {
odr = BMA455_OUTPUT_DATA_RATE_100HZ;
} else if(hz >= 25) {
odr = BMA455_OUTPUT_DATA_RATE_50HZ;
} else if(hz >= 12) {
odr = BMA455_OUTPUT_DATA_RATE_25HZ;
} else if(hz >= 6) {
odr = BMA455_OUTPUT_DATA_RATE_12_5HZ;
} else if(hz >= 3) {
odr = BMA455_OUTPUT_DATA_RATE_6_25HZ;
} else {
odr = BMA455_OUTPUT_DATA_RATE_3_12HZ;
}
value = BMA455_SET_BITSLICE(value, BMA455_ACCEL_ODR, odr);
ret = sensor_i2c_write(drv, BMA455_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
return 0;
}
int drv_acc_bosch_bma455_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t acc_range = 0x00;
ret = sensor_i2c_read(drv, BMA455_ACCEL_CONFIG1_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
set_range_failed = 1;
return ret;
}
switch(range) {
case ACC_RANGE_2G: {
acc_range = BMA455_ACCEL_RANGE_2G;
}
break;
case ACC_RANGE_4G: {
acc_range = BMA455_ACCEL_RANGE_4G;
}
break;
case ACC_RANGE_8G: {
acc_range = BMA455_ACCEL_RANGE_8G;
}
break;
case ACC_RANGE_16G: {
acc_range = BMA455_ACCEL_RANGE_16G;
}
break;
default:
break;
}
value = BMA455_SET_BITSLICE(value, BMA455_ACCEL_RANGE, acc_range);
ret = sensor_i2c_write(drv, BMA455_ACCEL_CONFIG1_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
set_range_failed = 2;
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)) {
current_factor = bma455_factor[range];
}
set_range_failed = 3;
return 0;
}
void drv_acc_bosch_bma455_irq_handle(void)
{
/* no handle so far */
}
int drv_acc_bosch_bma455_open(void)
{
int ret = 0;
ret = drv_acc_bosch_bma455_set_power_mode(&bma455_ctx, DEV_POWER_ON);
if(unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma455_close(void)
{
int ret = 0;
ret = drv_acc_bosch_bma455_set_power_mode(&bma455_ctx, DEV_POWER_OFF);
if(unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma455_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
uint8_t range = 0;
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if(len < size) {
return -1;
}
ret = sensor_i2c_read(&bma455_ctx, 0x41, &range, I2C_REG_LEN, I2C_OP_RETRIES);
ret = sensor_i2c_read(&bma455_ctx, BMA455_DATA_8_ADDR, ®[0], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma455_ctx, BMA455_DATA_8_ADDR+1, ®[1], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma455_ctx, BMA455_DATA_8_ADDR+2, ®[2], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma455_ctx, BMA455_DATA_8_ADDR+3, ®[3], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma455_ctx, BMA455_DATA_8_ADDR+4, ®[4], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma455_ctx, BMA455_DATA_8_ADDR+5, ®[5], I2C_REG_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return -1;
}
accel->data[DATA_AXIS_X] = ((int16_t)((reg[1] << 8) | reg[0]));
accel->data[DATA_AXIS_Y] = ((int16_t)((reg[3] << 8) | reg[2]));
accel->data[DATA_AXIS_Z] = ((int16_t)((reg[5] << 8) | reg[4]));
if(current_factor != 0) {
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)current_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)current_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)current_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_bosch_bma455_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_acc_bosch_bma455_set_odr(&bma455_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}
break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_acc_bosch_bma455_set_range(&bma455_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}
break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_bosch_bma455_set_power_mode(&bma455_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}
break;
case SENSOR_IOCTL_GET_INFO: {
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMA455";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}
break;
default:
break;
}
return 0;
}
int drv_acc_bosch_bma455_init(void) {
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_bosch_bma455_open;
sensor.close = drv_acc_bosch_bma455_close;
sensor.read = drv_acc_bosch_bma455_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_bosch_bma455_ioctl;
sensor.irq_handle = drv_acc_bosch_bma455_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma455_validate_id(&bma455_ctx);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma455_soft_reset(&bma455_ctx);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma455_set_range(&bma455_ctx, ACC_RANGE_8G);
if(unlikely(ret)) {
return -1;
}
/* set odr is 100hz, and will update */
ret = drv_acc_bosch_bma455_set_odr(&bma455_ctx, BMA455_DEFAULT_ODR_100HZ);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma455_set_power_mode(&bma455_ctx, DEV_SLEEP);
if(unlikely(ret)) {
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_bosch_bma455_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_bosch_bma455.c
|
C
|
apache-2.0
| 14,789
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include "aos/kernel.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define BMA456_I2C_ADDR_LOW (0x18)
#define BMA456_I2C_ADDR_HIGH (0x19)
#define BMA456_I2C_ADDR_TRANS(n) ((n)<<1)
#define BMA456_I2C_ADDR BMA456_I2C_ADDR_TRANS(BMA456_I2C_ADDR_LOW)
#define BMA456_CHIP_ID_ADDR UINT8_C(0X00)
#define BMA456_CHIP_ID_VALUE (0x16)
#define BMA456_POWER_CONF_ADDR UINT8_C(0x7C)
#define BMA456_POWER_CTRL_ADDR UINT8_C(0x7D)
#define BMA456_ACCEL_CONFIG_ADDR UINT8_C(0X40)
#define BMA456_ACCEL_CONFIG1_ADDR UINT8_C(0X41)
#define BMA456_DEFAULT_ODR_100HZ (100)
#define BMA456_CMD_ADDR UINT8_C(0X7E)
#define BMA456_OUTPUT_DATA_RATE_0_78HZ UINT8_C(0x01)
#define BMA456_OUTPUT_DATA_RATE_1_56HZ UINT8_C(0x02)
#define BMA456_OUTPUT_DATA_RATE_3_12HZ UINT8_C(0x03)
#define BMA456_OUTPUT_DATA_RATE_6_25HZ UINT8_C(0x04)
#define BMA456_OUTPUT_DATA_RATE_12_5HZ UINT8_C(0x05)
#define BMA456_OUTPUT_DATA_RATE_25HZ UINT8_C(0x06)
#define BMA456_OUTPUT_DATA_RATE_50HZ UINT8_C(0x07)
#define BMA456_OUTPUT_DATA_RATE_100HZ UINT8_C(0x08)
#define BMA456_OUTPUT_DATA_RATE_200HZ UINT8_C(0x09)
#define BMA456_OUTPUT_DATA_RATE_400HZ UINT8_C(0x0A)
#define BMA456_OUTPUT_DATA_RATE_800HZ UINT8_C(0x0B)
#define BMA456_OUTPUT_DATA_RATE_1600HZ UINT8_C(0x0C)
#define BMA456_ACCEL_OSR4_AVG1 UINT8_C(0)
#define BMA456_ACCEL_OSR2_AVG2 UINT8_C(1)
#define BMA456_ACCEL_NORMAL_AVG4 UINT8_C(2)
#define BMA456_ACCEL_CIC_AVG8 UINT8_C(3)
#define BMA456_ACCEL_RES_AVG16 UINT8_C(4)
#define BMA456_ACCEL_RES_AVG32 UINT8_C(5)
#define BMA456_ACCEL_RES_AVG64 UINT8_C(6)
#define BMA456_ACCEL_RES_AVG128 UINT8_C(7)
#define BMA456_ACCEL_RANGE_2G UINT8_C(0)
#define BMA456_ACCEL_RANGE_4G UINT8_C(1)
#define BMA456_ACCEL_RANGE_8G UINT8_C(2)
#define BMA456_ACCEL_RANGE_16G UINT8_C(3)
#define BMA456_DATA_0_ADDR UINT8_C(0X0A)
#define BMA456_DATA_8_ADDR UINT8_C(0X12)
#define BMA456_ACCEL_DATA_LENGTH UINT8_C(6)
#define BMA456_ENABLE UINT8_C(0x01)
#define BMA456_DISABLE UINT8_C(0x00)
#define BMA456_ADVANCE_POWER_SAVE_MSK UINT8_C(0x01)
#define BMA456_ACCEL_ENABLE_POS UINT8_C(2)
#define BMA456_ACCEL_ENABLE_MSK UINT8_C(0x04)
#define BMA456_ACCEL_PERF_POS UINT8_C(7)
#define BMA456_ACCEL_ODR_POS UINT8_C(0)
#define BMA456_ACCEL_ODR_MSK UINT8_C(0x0F)
#define BMA456_ACCEL_RANGE_POS UINT8_C(0)
#define BMA456_ACCEL_RANGE_MSK UINT8_C(0x03)
#define BMA456_ENABLE_SOFT_RESET_VALUE UINT8_C(0XB6)
#define BMA456_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define BMA456_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | \
((val<<bitname##_POS)&bitname##_MSK))
#define BMA456_SET_BITS_POS_0(reg_data, bitname, data) \
((reg_data & ~(bitname##_MSK)) | \
(data & bitname##_MSK))
#define BMA456_GET_BITS_POS_0(reg_data, bitname) (reg_data & (bitname##_MSK))
static uint32_t bma456_factor[4] = { 16384, 8192, 4096, 2048 };
static uint32_t current_factor = 0;
static uint32_t set_range_failed = 0;
i2c_dev_t bma456_ctx = {
.port = 3,
.config.dev_addr = BMA456_I2C_ADDR,
};
int drv_acc_bosch_bma456_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = BMA456_ENABLE_SOFT_RESET_VALUE;
ret = sensor_i2c_write(drv, BMA456_CMD_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma456_validate_id(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, BMA456_CHIP_ID_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
LOG("%s %s sensor_i2c_read \n", SENSOR_STR, __func__);
return ret;
}
if(BMA456_CHIP_ID_VALUE != value) {
LOG("%s %s value=%x \n", SENSOR_STR, __func__, value);
return -1;
}
return 0;
}
int drv_acc_bosch_bma456_set_power_mode(i2c_dev_t* drv,
dev_power_mode_e mode)
{
uint8_t value, value1 = 0x00;
int ret = 0;
switch(mode) {
case DEV_POWER_ON: {
ret = sensor_i2c_read(drv, BMA456_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value |= (BMA456_ENABLE << BMA456_ACCEL_PERF_POS);
ret = sensor_i2c_write(drv, BMA456_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, BMA456_POWER_CTRL_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value1 = BMA456_SET_BITSLICE(value1, BMA456_ACCEL_ENABLE, BMA456_ENABLE);
ret = sensor_i2c_write(drv, BMA456_POWER_CTRL_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
}
break;
case DEV_POWER_OFF:
case DEV_SLEEP:
case DEV_SUSPEND: {
ret = sensor_i2c_read(drv, BMA456_POWER_CTRL_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value = BMA456_SET_BITSLICE(value, BMA456_ACCEL_ENABLE, BMA456_DISABLE);
ret = sensor_i2c_write(drv, BMA456_POWER_CTRL_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, BMA456_POWER_CONF_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
value1 = BMA456_SET_BITS_POS_0(value1, BMA456_ADVANCE_POWER_SAVE, BMA456_ENABLE);
ret = sensor_i2c_write(drv, BMA456_POWER_CONF_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
}
break;
default:
break;
}
return 0;
}
int drv_acc_bosch_bma456_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = 0x00;
ret = sensor_i2c_read(drv, BMA456_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
if(hz >= 800) {
odr = BMA456_OUTPUT_DATA_RATE_1600HZ;
} else if(hz >= 400) {
odr = BMA456_OUTPUT_DATA_RATE_800HZ;
} else if(hz >= 200) {
odr = BMA456_OUTPUT_DATA_RATE_400HZ;
} else if(hz >= 100) {
odr = BMA456_OUTPUT_DATA_RATE_200HZ;
} else if(hz >= 50) {
odr = BMA456_OUTPUT_DATA_RATE_100HZ;
} else if(hz >= 25) {
odr = BMA456_OUTPUT_DATA_RATE_50HZ;
} else if(hz >= 12) {
odr = BMA456_OUTPUT_DATA_RATE_25HZ;
} else if(hz >= 6) {
odr = BMA456_OUTPUT_DATA_RATE_12_5HZ;
} else if(hz >= 3) {
odr = BMA456_OUTPUT_DATA_RATE_6_25HZ;
} else {
odr = BMA456_OUTPUT_DATA_RATE_3_12HZ;
}
value = BMA456_SET_BITSLICE(value, BMA456_ACCEL_ODR, odr);
ret = sensor_i2c_write(drv, BMA456_ACCEL_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
return ret;
}
return 0;
}
int drv_acc_bosch_bma456_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t acc_range = 0x00;
ret = sensor_i2c_read(drv, BMA456_ACCEL_CONFIG1_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
set_range_failed = 1;
return ret;
}
switch(range) {
case ACC_RANGE_2G: {
acc_range = BMA456_ACCEL_RANGE_2G;
}
break;
case ACC_RANGE_4G: {
acc_range = BMA456_ACCEL_RANGE_4G;
}
break;
case ACC_RANGE_8G: {
acc_range = BMA456_ACCEL_RANGE_8G;
}
break;
case ACC_RANGE_16G: {
acc_range = BMA456_ACCEL_RANGE_16G;
}
break;
default:
break;
}
value = BMA456_SET_BITSLICE(value, BMA456_ACCEL_RANGE, acc_range);
ret = sensor_i2c_write(drv, BMA456_ACCEL_CONFIG1_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret)) {
set_range_failed = 2;
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)) {
current_factor = bma456_factor[range];
}
set_range_failed = 3;
return 0;
}
void drv_acc_bosch_bma456_irq_handle(void)
{
/* no handle so far */
}
int drv_acc_bosch_bma456_open(void)
{
int ret = 0;
ret = drv_acc_bosch_bma456_set_power_mode(&bma456_ctx, DEV_POWER_ON);
if(unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma456_close(void)
{
int ret = 0;
ret = drv_acc_bosch_bma456_set_power_mode(&bma456_ctx, DEV_POWER_OFF);
if(unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bma456_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
uint8_t range = 0;
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if(len < size) {
return -1;
}
ret = sensor_i2c_read(&bma456_ctx, 0x41, &range, I2C_REG_LEN, I2C_OP_RETRIES);
ret = sensor_i2c_read(&bma456_ctx, BMA456_DATA_8_ADDR, ®[0], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma456_ctx, BMA456_DATA_8_ADDR+1, ®[1], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma456_ctx, BMA456_DATA_8_ADDR+2, ®[2], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma456_ctx, BMA456_DATA_8_ADDR+3, ®[3], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma456_ctx, BMA456_DATA_8_ADDR+4, ®[4], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma456_ctx, BMA456_DATA_8_ADDR+5, ®[5], I2C_REG_LEN,
I2C_OP_RETRIES);
if(unlikely(ret)) {
return -1;
}
accel->data[DATA_AXIS_X] = ((int16_t)((reg[1] << 8) | reg[0]));
accel->data[DATA_AXIS_Y] = ((int16_t)((reg[3] << 8) | reg[2]));
accel->data[DATA_AXIS_Z] = ((int16_t)((reg[5] << 8) | reg[4]));
if(current_factor != 0) {
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)current_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)current_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)current_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_bosch_bma456_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_acc_bosch_bma456_set_odr(&bma456_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}
break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_acc_bosch_bma456_set_range(&bma456_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}
break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_bosch_bma456_set_power_mode(&bma456_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}
break;
case SENSOR_IOCTL_GET_INFO: {
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMA456";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}
break;
default:
break;
}
return 0;
}
int drv_acc_bosch_bma456_init(void) {
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_bosch_bma456_open;
sensor.close = drv_acc_bosch_bma456_close;
sensor.read = drv_acc_bosch_bma456_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_bosch_bma456_ioctl;
sensor.irq_handle = drv_acc_bosch_bma456_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma456_validate_id(&bma456_ctx);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma456_soft_reset(&bma456_ctx);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma456_set_range(&bma456_ctx, ACC_RANGE_8G);
if(unlikely(ret)) {
return -1;
}
/* set odr is 100hz, and will update */
ret = drv_acc_bosch_bma456_set_odr(&bma456_ctx, BMA456_DEFAULT_ODR_100HZ);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bma456_set_power_mode(&bma456_ctx, DEV_SLEEP);
if(unlikely(ret)) {
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_bosch_bma456_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_bosch_bma456.c
|
C
|
apache-2.0
| 14,780
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define BMI055_ACC_I2C_ADDR1 (0x18)
#define BMI055_ACC_I2C_ADDR2 (0x19)
#define BMI055_ACC_I2C_ADDR3 (0x10)
#define BMI055_ACC_I2C_ADDR4 (0x11)
#define BMI055_ACC_I2C_ADDR_TRANS(n) ((n) << 1)
#define BMI055_ACC_I2C_ADDR BMI055_ACC_I2C_ADDR_TRANS(BMI055_ACC_I2C_ADDR1)
#define BMI055_ACC_INIT_VALUE (0)
#define BMI055_ACC_GEN_READ_WRITE_LENGTH (1)
#define BMI055_ACC_INTERFACE_IDLE_TIME_DELAY (1)
#define BMI055_ACC_LSB_MSB_READ_LENGTH (2)
#define BMI055_ACC_SHIFT_TWO_BITS (2)
#define BMI055_ACC_SHIFT_FOUR_BITS (4)
#define BMI055_ACC_SHIFT_FIVE_BITS (5)
#define BMI055_ACC_SHIFT_SIX_BITS (6)
#define BMI055_ACC_SHIFT_EIGHT_BITS (8)
#define BMI055_ACC_12_BIT_SHIFT (0xF0)
#define BMI055_ACC_FIFO_MODE_STATUS_RANGE (2)
#define BMI055_ACC_FIFO_DATA_SELECT_RANGE (4)
#define BMI055_ACC_FIFO_MODE_RANGE (4)
#define BMI055_ACC_FIFO_WML_RANGE (32)
#define BMI055_ACC_FIFO_XYZ_DATA_ENABLED (0x00)
#define BMI055_ACC_FIFO_X_DATA_ENABLED (0x01)
#define BMI055_ACC_FIFO_Y_DATA_ENABLED (0x02)
#define BMI055_ACC_FIFO_Z_DATA_ENABLED (0x03)
#define BMI055_ACC_FIFO_DATA_ENABLED_MASK (0x03)
#define BMI055_ACC_FIFO_XYZ_AXES_FRAME_SIZE (6)
#define BMI055_ACC_FIFO_SINGLE_AXIS_FRAME_SIZE (2)
#define BMI055_ACC_ACCEL_BW_MIN_RANGE (7)
#define BMI055_ACC_ACCEL_BW_1000HZ_RANGE (15)
#define BMI055_ACC_ACCEL_BW_MAX_RANGE (16)
#define BMI055_ACC_SLEEP_DURN_MIN_RANGE (4)
#define BMI055_ACC_SLEEP_TIMER_MODE_RANGE (2)
#define BMI055_ACC_SLEEP_DURN_MAX_RANGE (16)
#define BMI055_ACC_POWER_MODE_RANGE (6)
#define BMI055_ACC_SELF_TEST_AXIS_RANGE (4)
#define BMI055_ACC_SELF_TEST_SIGN_RANGE (2)
#define BMI055_ACC_EEP_OFFSET (0x16)
#define BMI055_ACC_IMAGE_BASE (0x38)
#define BMI055_ACC_IMAGE_LEN (22)
#define BMI055_ACC_CHIP_ID_ADDR (0x00)
#define BMI055_ACC_CHIP_ID_VALUE (0xFA)
#define BMI055_ACC_X_AXIS_LSB_ADDR (0x02)
#define BMI055_ACC_X_AXIS_MSB_ADDR (0x03)
#define BMI055_ACC_Y_AXIS_LSB_ADDR (0x04)
#define BMI055_ACC_Y_AXIS_MSB_ADDR (0x05)
#define BMI055_ACC_Z_AXIS_LSB_ADDR (0x06)
#define BMI055_ACC_Z_AXIS_MSB_ADDR (0x07)
#define BMI055_ACC_TEMP_ADDR (0x08)
#define BMI055_ACC_STAT1_ADDR (0x09)
#define BMI055_ACC_STAT2_ADDR (0x0A)
#define BMI055_ACC_STAT_TAP_SLOPE_ADDR (0x0B)
#define BMI055_ACC_STAT_ORIENT_HIGH_ADDR (0x0C)
#define BMI055_ACC_STAT_FIFO_ADDR (0x0E)
#define BMI055_ACC_RANGE_SELECT_ADDR (0x0F)
#define BMI055_ACC_BW_SELECT_ADDR (0x10)
#define BMI055_ACC_MODE_CTRL_ADDR (0x11)
#define BMI055_ACC_LOW_NOISE_CTRL_ADDR (0x12)
#define BMI055_ACC_DATA_CTRL_ADDR (0x13)
#define BMI055_ACC_RST_ADDR (0x14)
#define BMI055_ACC_INTR_ENABLE1_ADDR (0x16)
#define BMI055_ACC_INTR_ENABLE2_ADDR (0x17)
#define BMI055_ACC_INTR_SLOW_NO_MOTION_ADDR (0x18)
#define BMI055_ACC_INTR1_PAD_SELECT_ADDR (0x19)
#define BMI055_ACC_INTR_DATA_SELECT_ADDR (0x1A)
#define BMI055_ACC_INTR2_PAD_SELECT_ADDR (0x1B)
#define BMI055_ACC_INTR_SOURCE_ADDR (0x1E)
#define BMI055_ACC_INTR_SET_ADDR (0x20)
#define BMI055_ACC_INTR_CTRL_ADDR (0x21)
#define BMI055_ACC_LOW_DURN_ADDR (0x22)
#define BMI055_ACC_LOW_THRES_ADDR (0x23)
#define BMI055_ACC_LOW_HIGH_HYST_ADDR (0x24)
#define BMI055_ACC_HIGH_DURN_ADDR (0x25)
#define BMI055_ACC_HIGH_THRES_ADDR (0x26)
#define BMI055_ACC_SLOPE_DURN_ADDR (0x27)
#define BMI055_ACC_SLOPE_THRES_ADDR (0x28)
#define BMI055_ACC_SLOW_NO_MOTION_THRES_ADDR (0x29)
#define BMI055_ACC_TAP_PARAM_ADDR (0x2A)
#define BMI055_ACC_TAP_THRES_ADDR (0x2B)
#define BMI055_ACC_ORIENT_PARAM_ADDR (0x2C)
#define BMI055_ACC_THETA_BLOCK_ADDR (0x2D)
#define BMI055_ACC_THETA_FLAT_ADDR (0x2E)
#define BMI055_ACC_FLAT_HOLD_TIME_ADDR (0x2F)
#define BMI055_ACC_SELFTEST_ADDR (0x32)
#define BMI055_ACC_EEPROM_CTRL_ADDR (0x33)
#define BMI055_ACC_SERIAL_CTRL_ADDR (0x34)
#define BMI055_ACC_OFFSET_CTRL_ADDR (0x36)
#define BMI055_ACC_OFFSET_PARAMS_ADDR (0x37)
#define BMI055_ACC_OFFSET_X_AXIS_ADDR (0x38)
#define BMI055_ACC_OFFSET_Y_AXIS_ADDR (0x39)
#define BMI055_ACC_OFFSET_Z_AXIS_ADDR (0x3A)
#define BMI055_ACC_GP0_ADDR (0x3B)
#define BMI055_ACC_GP1_ADDR (0x3C)
#define BMI055_ACC_FIFO_MODE_ADDR (0x3E)
#define BMI055_ACC_FIFO_DATA_OUTPUT_ADDR (0x3F)
#define BMI055_ACC_FIFO_WML_TRIG (0x30)
#define BMI055_ACC_12_RESOLUTION (0)
#define BMI055_ACC_10_RESOLUTION (1)
#define BMI055_ACC_14_RESOLUTION (2)
#define BMI055_ACC_ENABLE_SOFT_RESET_VALUE (0xB6)
#define BMI055_ACC_RANGE_SELECT_POS (0)
#define BMI055_ACC_RANGE_SELECT_LEN (4)
#define BMI055_ACC_RANGE_SELECT_MSK (0x0F)
#define BMI055_ACC_RANGE_SELECT_REG BMI055_ACC_RANGE_SELECT_ADDR
#define BMI055_ACC_RANGE_2G (3)
#define BMI055_ACC_RANGE_4G (5)
#define BMI055_ACC_RANGE_8G (8)
#define BMI055_ACC_RANGE_16G (12)
#define BMI055_ACC_BW_15_63 (15)
#define BMI055_ACC_BW_31_25 (31)
#define BMI055_ACC_BW_62_5 (62)
#define BMI055_ACC_BW_125 (125)
#define BMI055_ACC_BW_250 (250)
#define BMI055_ACC_BW_500 (500)
#define BMI055_ACC_BW_1000 (1000)
#define BMI055_ACC_BW_7_81HZ (0x08)
#define BMI055_ACC_BW_15_63HZ (0x09)
#define BMI055_ACC_BW_31_25HZ (0x0A)
#define BMI055_ACC_BW_62_50HZ (0x0B)
#define BMI055_ACC_BW_125HZ (0x0C)
#define BMI055_ACC_BW_250HZ (0x0D)
#define BMI055_ACC_BW_500HZ (0x0E)
#define BMI055_ACC_BW_1000HZ (0x0F)
#define BMI055_ACC_BW_BIT_MASK (~0x0F)
#define BMI055_ACC_SLEEP_DURN_0_5MS (0x05)
#define BMI055_ACC_SLEEP_DURN_1MS (0x06)
#define BMI055_ACC_SLEEP_DURN_2MS (0x07)
#define BMI055_ACC_SLEEP_DURN_4MS (0x08)
#define BMI055_ACC_SLEEP_DURN_6MS (0x09)
#define BMI055_ACC_SLEEP_DURN_10MS (0x0A)
#define BMI055_ACC_SLEEP_DURN_25MS (0x0B)
#define BMI055_ACC_SLEEP_DURN_50MS (0x0C)
#define BMI055_ACC_SLEEP_DURN_100MS (0x0D)
#define BMI055_ACC_SLEEP_DURN_500MS (0x0E)
#define BMI055_ACC_SLEEP_DURN_1S (0x0F)
#define BMI055_ACC_SLEEP_DURN_POS (1)
#define BMI055_ACC_SLEEP_DURN_LEN (4)
#define BMI055_ACC_SLEEP_DURN_MSK (0x1E)
#define BMI055_ACC_SLEEP_DURN_REG BMI055_ACC_MODE_CTRL_ADDR
#define BMI055_ACC_SLEEP_MODE (0x40)
#define BMI055_ACC_DEEP_SUSPEND_MODE (0x20)
#define BMI055_ACC_SUSPEND_MODE (0x80)
#define BMI055_ACC_NORMAL_MODE (0x40)
#define BMI055_ACC_LOWPOWER_MODE (0x40)
#define BMI055_ACC_MODE_CTRL_POS (5)
#define BMI055_ACC_MODE_CTRL_LEN (3)
#define BMI055_ACC_MODE_CTRL_MSK (0xE0)
#define BMI055_ACC_MODE_CTRL_REG BMI055_ACC_MODE_CTRL_ADDR
#define BMI055_ACC_LOW_POWER_MODE_POS (6)
#define BMI055_ACC_LOW_POWER_MODE_LEN (1)
#define BMI055_ACC_LOW_POWER_MODE_MSK (0x40)
#define BMI055_ACC_LOW_POWER_MODE_REG BMI055_ACC_LOW_NOISE_CTRL_ADDR
#define BMI055_ACC_DEFAULT_ODR_100HZ (100)
#define BMI055_ACC_FIFO_DEPTH_MAX (32)
#define BMI055_ACC_FIFO_DATA_NUM (6)
#define BMI055_ACC_FIFO_BUFF_LEN (BMI055_ACC_FIFO_DEPTH_MAX * BMI055_ACC_FIFO_DATA_NUM)
// bmi055 sensitivity factor table, the unit is LSB/g
#define BMI055_ACC_IRQ_CLEAR_VAL (0x80)
#define BMI055_ACC_IRQ_LATCHED (0x0f)
#define BMI055_ACC_IRQ_NON_LATCHED (0)
#define BMI055_ACC_IRQ_FIFO_STAT (0x40)
#define BMI055_ACC_IRQ_DATA_READY_STAT (0x80)
#define BMI055_ACC_IRQ_DATA_READY_ENABLE (0x10)
#define BMI055_ACC_IRQ_FIFO_FULL_ENABLE (0x20)
#define BMI055_ACC_IRQ_FIFO_WML_ENABLE (0x40)
#define BMI055_ACC_IRQ_MAP_DATA_INT2 (0x80)
#define BMI055_ACC_IRQ_MAP_FIFO_WML_INT2 (0x40)
#define BMI055_ACC_IRQ_CONFIG_PUSH_PULL (0x04)
#define BMI055_ACC_IRQ_FIFO_WML_MODE (0x40)
#define BMI055_ACC_IRQ_PIN (62)
#define BMI055_ACC_FIFO_DEPTH_USD (20)
#define BMI055_ACC_DEFAULT_ODR (100)
#define BMI055_ACC_GET_BITSLICE(regvar, bitname) \
((regvar & bitname##_MSK) >> bitname##_POS)
#define BMI055_ACC_SET_BITSLICE(regvar, bitname, val) \
((regvar & ~bitname##_MSK) | ((val << bitname##_POS) & bitname##_MSK))
#define BMI055_GYRO_DEFAULT_ODR (200)
#define BMI055_GYRO_I2C_ADDR1 (0x68 << 1)
#define BMI055_GYRO_I2C_ADDR2 (0x69 << 1)
#define BMI055_GYRO_CHIP_ID_ADDR (0x00)
#define BMI055_GYRO_CHIP_ID_VALUE (0x0F)
#define BMI055_GYRO_RATE_X_LSB_ADDR (0x02)
#define BMI055_GYRO_RATE_X_MSB_ADDR (0x03)
#define BMI055_GYRO_RATE_Y_LSB_ADDR (0x04)
#define BMI055_GYRO_RATE_Y_MSB_ADDR (0x05)
#define BMI055_GYRO_RATE_Z_LSB_ADDR (0x06)
#define BMI055_GYRO_RATE_Z_MSB_ADDR (0x07)
#define BMI055_GYRO_TEMP_ADDR (0x08)
#define BMI055_GYRO_INTR_STAT0_ADDR (0x09)
#define BMI055_GYRO_INTR_STAT1_ADDR (0x0A)
#define BMI055_GYRO_INTR_STAT2_ADDR (0x0B)
#define BMI055_GYRO_INTR_STAT3_ADDR (0x0C)
#define BMI055_GYRO_FIFO_STAT_ADDR (0x0E)
#define BMI055_GYRO_RANGE_ADDR (0x0F)
#define BMI055_GYRO_BW_ADDR (0x10)
#define BMI055_GYRO_MODE_LPM1_ADDR (0x11)
#define BMI055_GYRO_MODE_LPM2_ADDR (0x12)
#define BMI055_GYRO_HIGH_BW_ADDR (0x13)
#define BMI055_GYRO_BGW_SOFT_RST_ADDR (0x14)
#define BMI055_GYRO_INTR_ENABLE0_ADDR (0x15)
#define BMI055_GYRO_INTR_ENABLE1_ADDR (0x16)
#define BMI055_GYRO_INTR_MAP_ZERO_ADDR (0x17)
#define BMI055_GYRO_INTR_MAP_ONE_ADDR (0x18)
#define BMI055_GYRO_INTR_MAP_TWO_ADDR (0x19)
#define BMI055_GYRO_INTR_ZERO_ADDR (0x1A)
#define BMI055_GYRO_INTR_ONE_ADDR (0x1B)
#define BMI055_GYRO_INTR_TWO_ADDR (0x1C)
#define BMI055_GYRO_INTR_4_ADDR (0x1E)
#define BMI055_GYRO_RST_LATCH_ADDR (0x21)
#define BMI055_GYRO_HIGHRATE_THRES_X_ADDR (0x22)
#define BMI055_GYRO_HIGHRATE_DURN_X_ADDR (0x23)
#define BMI055_GYRO_HIGHRATE_THRES_Y_ADDR (0x24)
#define BMI055_GYRO_HIGHRATE_DURN_Y_ADDR (0x25)
#define BMI055_GYRO_HIGHRATE_THRES_Z_ADDR (0x26)
#define BMI055_GYRO_HIGHRATE_DURN_Z_ADDR (0x27)
#define BMI055_GYRO_SOC_ADDR (0x31)
#define BMI055_GYRO_A_FOC_ADDR (0x32)
#define BMI055_GYRO_TRIM_NVM_CTRL_ADDR (0x33)
#define BMI055_GYRO_BGW_SPI3_WDT_ADDR (0x34)
#define BMI055_GYRO_OFFSET_OFC1_ADDR (0x36)
#define BMI055_GYRO_OFC2_ADDR (0x37)
#define BMI055_GYRO_OFC3_ADDR (0x38)
#define BMI055_GYRO_OFC4_ADDR (0x39)
#define BMI055_GYRO_TRIM_GP0_ADDR (0x3A)
#define BMI055_GYRO_TRIM_GP1_ADDR (0x3B)
#define BMI055_GYRO_SELFTEST_ADDR (0x3C)
#define BMI055_GYRO_FIFO_CGF1_ADDR (0x3D)
#define BMI055_GYRO_FIFO_CGF0_ADDR (0x3E)
#define BMI055_GYRO_FIFO_DATA_ADDR (0x3F)
#define BMI055_GYRO_RANGE_RANGE_2000DPS (0x00)
#define BMI055_GYRO_RANGE_RANGE_1000DPS (0x01)
#define BMI055_GYRO_RANGE_RANGE_500DPS (0x02)
#define BMI055_GYRO_RANGE_RANGE_250DPS (0x03)
#define BMI055_GYRO_RANGE_RANGE_125DPS (0x04)
#define BMI055_GYRO_RANGE_ADDR_RANGE_POS (0)
#define BMI055_GYRO_RANGE_ADDR_RANGE_LEN (3)
#define BMI055_GYRO_RANGE_ADDR_RANGE_MSK (0x07)
#define BMI055_GYRO_RANGE_ADDR_RANGE_REG (BMI055_GYRO_RANGE_ADDR)
#define BMI055_GYRO_BW_ADDR_POS (0)
#define BMI055_GYRO_BW_ADDR_LEN (3)
#define BMI055_GYRO_BW_ADDR_MSK (0x07)
#define BMI055_GYRO_BW_ADDR_REG (BMI055_GYRO_BW_ADDR)
#define BMI055_GYRO_MODE_LPM1_POS (5)
#define BMI055_GYRO_MODE_LPM1_LEN (3)
#define BMI055_GYRO_MODE_LPM1_MSK (0xA0)
#define BMI055_GYRO_MODE_LPM1_REG (BMI055_GYRO_MODE_LPM1_ADDR)
#define BMI055_GYRO_ODR_100 (100)
#define BMI055_GYRO_ODR_200 (200)
#define BMI055_GYRO_ODR_400 (400)
#define BMI055_GYRO_ODR_1000 (1000)
#define BMI055_GYRO_ODR_2000 (2000)
#define BMI055_GYRO_ODR_100_REG (0x07)
#define BMI055_GYRO_ODR_200_REG (0x06)
#define BMI055_GYRO_ODR_400_REG (0x03)
#define BMI055_GYRO_ODR_1000_REG (0x02)
#define BMI055_GYRO_ODR_2000_REG (0x01)
#define BMI055_GYRO_POWER_BIT_MASK (0xA0)
#define BMI055_GYRO_POWER_NORMAL_REG (0x00)
#define BMI055_GYRO_POWER_SLEEP_REG (0x80)
#define BMI055_GYRO_POWER_DEEP_SUSPEND_REG (0x20)
#define BMI055_GYRO_SHIFT_EIGHT_BITS (8)
#define BMI055_GYRO_DEFAULT_ODR (200)
static uint32_t bmi055_acc_factor[4] = { 1024, 512, 256, 128 };
static uint32_t acc_current_factor = 0;
static uint32_t bmi055_gyro_factor[5] = { 2624, 1312, 656, 328,
164 };
static uint32_t gyro_current_factor = 0;
i2c_dev_t bmi055_acc_ctx = {
.port = 3,
.config.dev_addr = BMI055_ACC_I2C_ADDR,
};
i2c_dev_t bmi055_gyro_ctx = {
.port = 3,
.config.dev_addr = BMI055_GYRO_I2C_ADDR1,
};
int drv_acc_bosch_bmi055_soft_reset(i2c_dev_t *drv)
{
int ret = 0;
uint8_t value = BMI055_ACC_ENABLE_SOFT_RESET_VALUE;
ret = sensor_i2c_write(drv, BMI055_ACC_RST_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bmi055_validate_id(i2c_dev_t *drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, BMI055_ACC_CHIP_ID_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (id_value != value) {
return -1;
}
return 0;
}
int drv_acc_bosch_bmi055_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, BMI055_ACC_MODE_CTRL_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_ON: {
if ((value & BMI055_ACC_MODE_CTRL_MSK) == BMI055_ACC_NORMAL_MODE) {
return 0;
}
value |= BMI055_ACC_NORMAL_MODE;
ret = sensor_i2c_write(drv, BMI055_ACC_MODE_CTRL_REG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_POWER_OFF: {
if ((value & BMI055_ACC_MODE_CTRL_MSK) == BMI055_ACC_DEEP_SUSPEND_MODE) {
return 0;
}
value |= BMI055_ACC_DEEP_SUSPEND_MODE;
ret = sensor_i2c_write(drv, BMI055_ACC_MODE_CTRL_REG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_SLEEP: {
if ((value & BMI055_ACC_MODE_CTRL_MSK) == BMI055_ACC_SLEEP_MODE) {
return 0;
}
value |= BMI055_ACC_SLEEP_MODE;
ret = sensor_i2c_write(drv, BMI055_ACC_MODE_CTRL_REG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_SUSPEND: {
if ((value & BMI055_ACC_MODE_CTRL_MSK) == BMI055_ACC_SUSPEND_MODE) {
return 0;
}
value |= BMI055_ACC_SUSPEND_MODE;
ret = sensor_i2c_write(drv, BMI055_ACC_MODE_CTRL_REG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
default:
break;
}
return 0;
}
int drv_acc_bosch_bmi055_set_odr(i2c_dev_t *drv, uint32_t odr)
{
int ret = 0;
uint8_t value = 0x00;
uint32_t bw = odr / 2;
ret = sensor_i2c_read(drv, BMI055_ACC_BW_SELECT_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (bw >= BMI055_ACC_BW_1000) {
value &= BMI055_ACC_BW_BIT_MASK;
value |= BMI055_ACC_BW_1000HZ;
} else if (bw >= BMI055_ACC_BW_500) {
value &= BMI055_ACC_BW_BIT_MASK;
value |= BMI055_ACC_BW_500HZ;
} else if (bw >= BMI055_ACC_BW_250) {
value &= BMI055_ACC_BW_BIT_MASK;
value |= BMI055_ACC_BW_250HZ;
} else if (bw >= BMI055_ACC_BW_125) {
value &= BMI055_ACC_BW_BIT_MASK;
value |= BMI055_ACC_BW_125HZ;
} else if (bw >= BMI055_ACC_BW_62_5) {
value &= BMI055_ACC_BW_BIT_MASK;
value |= BMI055_ACC_BW_62_50HZ;
} else if (bw >= BMI055_ACC_BW_31_25) {
value &= BMI055_ACC_BW_BIT_MASK;
value |= BMI055_ACC_BW_31_25HZ;
} else {
value &= BMI055_ACC_BW_BIT_MASK;
value |= BMI055_ACC_BW_15_63HZ;
}
ret = sensor_i2c_write(drv, BMI055_ACC_BW_SELECT_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
int drv_acc_bosch_bmi055_set_range(i2c_dev_t *drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, BMI055_ACC_RANGE_SELECT_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (range) {
case ACC_RANGE_2G: {
value =
BMI055_ACC_SET_BITSLICE(value, BMI055_ACC_RANGE_SELECT, BMI055_ACC_RANGE_2G);
} break;
case ACC_RANGE_4G: {
value =
BMI055_ACC_SET_BITSLICE(value, BMI055_ACC_RANGE_SELECT, BMI055_ACC_RANGE_4G);
} break;
case ACC_RANGE_8G: {
value =
BMI055_ACC_SET_BITSLICE(value, BMI055_ACC_RANGE_SELECT, BMI055_ACC_RANGE_8G);
} break;
case ACC_RANGE_16G: {
value =
BMI055_ACC_SET_BITSLICE(value, BMI055_ACC_RANGE_SELECT, BMI055_ACC_RANGE_16G);
} break;
default:
break;
}
ret = sensor_i2c_write(drv, BMI055_ACC_RANGE_SELECT_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if ((range >= ACC_RANGE_2G) && (range <= ACC_RANGE_16G)) {
acc_current_factor = bmi055_acc_factor[range];
}
return 0;
}
int drv_acc_bosch_bmi055_open(void)
{
int ret = 0;
ret = drv_acc_bosch_bmi055_set_power_mode(&bmi055_acc_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bmi055_close(void)
{
int ret = 0;
ret = drv_acc_bosch_bmi055_set_power_mode(&bmi055_acc_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
return 0;
}
int drv_acc_bosch_bmi055_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(&bmi055_acc_ctx, BMI055_ACC_X_AXIS_LSB_ADDR, ®[0],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi055_acc_ctx, BMI055_ACC_X_AXIS_MSB_ADDR, ®[1],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi055_acc_ctx, BMI055_ACC_Y_AXIS_LSB_ADDR, ®[2],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi055_acc_ctx, BMI055_ACC_Y_AXIS_MSB_ADDR, ®[3],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi055_acc_ctx, BMI055_ACC_Z_AXIS_LSB_ADDR, ®[4],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi055_acc_ctx, BMI055_ACC_Z_AXIS_MSB_ADDR, ®[5],
I2C_REG_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
accel->data[DATA_AXIS_X] =
(int32_t)((((int32_t)((int8_t)reg[1])) << BMI055_ACC_SHIFT_EIGHT_BITS) |
(reg[0] & BMI055_ACC_12_BIT_SHIFT));
accel->data[DATA_AXIS_X] =
accel->data[DATA_AXIS_X] >> BMI055_ACC_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Y] =
(int32_t)((((int32_t)((int8_t)reg[3])) << BMI055_ACC_SHIFT_EIGHT_BITS) |
(reg[2] & BMI055_ACC_12_BIT_SHIFT));
accel->data[DATA_AXIS_Y] =
accel->data[DATA_AXIS_Y] >> BMI055_ACC_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Z] =
(int32_t)((((int32_t)((int8_t)reg[5])) << BMI055_ACC_SHIFT_EIGHT_BITS) |
(reg[4] & BMI055_ACC_12_BIT_SHIFT));
accel->data[DATA_AXIS_Z] =
accel->data[DATA_AXIS_Z] >> BMI055_ACC_SHIFT_FOUR_BITS;
if (acc_current_factor != 0) {
// the unit of acc is mg, 1000 mg = 1 g.
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] *
ACCELEROMETER_UNIT_FACTOR /
(int32_t)acc_current_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] *
ACCELEROMETER_UNIT_FACTOR /
(int32_t)acc_current_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] *
ACCELEROMETER_UNIT_FACTOR /
(int32_t)acc_current_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
void drv_acc_bosch_bmi055_irq_handle(void)
{
}
static int drv_acc_bosch_bmi055_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_acc_bosch_bmi055_set_odr(&bmi055_acc_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_acc_bosch_bmi055_set_range(&bmi055_acc_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_bosch_bmi055_set_power_mode(&bmi055_acc_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMI055";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
} break;
default:
break;
}
return 0;
}
int drv_acc_bosch_bmi055_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_bosch_bmi055_open;
sensor.close = drv_acc_bosch_bmi055_close;
sensor.read = drv_acc_bosch_bmi055_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_bosch_bmi055_ioctl;
sensor.irq_handle = drv_acc_bosch_bmi055_irq_handle;
sensor.mode = DEV_POLLING;
sensor.data_len = sizeof(accel_data_t);
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bmi055_validate_id(&bmi055_acc_ctx, BMI055_ACC_CHIP_ID_VALUE);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bmi055_soft_reset(&bmi055_acc_ctx);
if (unlikely(ret)) {
return -1;
}
aos_msleep(5);
ret = drv_acc_bosch_bmi055_set_range(&bmi055_acc_ctx, ACC_RANGE_8G);
if (unlikely(ret)) {
return -1;
}
// set odr is 100hz, and will update
ret = drv_acc_bosch_bmi055_set_odr(&bmi055_acc_ctx, BMI055_ACC_DEFAULT_ODR);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_bosch_bmi055_set_power_mode(&bmi055_acc_ctx, DEV_SLEEP);
if (unlikely(ret)) {
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_gyro_bosch_bmi055_validate_id(i2c_dev_t *drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, BMI055_GYRO_CHIP_ID_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (id_value != value) {
return -1;
}
return 0;
}
static int drv_gyro_bosch_bmi055_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, BMI055_GYRO_MODE_LPM1_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_ON: {
if ((value & BMI055_GYRO_POWER_BIT_MASK) == BMI055_GYRO_POWER_NORMAL_REG) {
return 0;
}
value &= (~BMI055_GYRO_POWER_BIT_MASK);
value |= BMI055_GYRO_POWER_NORMAL_REG;
ret = sensor_i2c_write(drv, BMI055_GYRO_MODE_LPM1_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_POWER_OFF: {
if ((value & BMI055_GYRO_POWER_BIT_MASK) ==
BMI055_GYRO_POWER_DEEP_SUSPEND_REG) {
return 0;
}
value &= (~BMI055_GYRO_POWER_BIT_MASK);
value |= BMI055_GYRO_POWER_DEEP_SUSPEND_REG;
ret = sensor_i2c_write(drv, BMI055_GYRO_MODE_LPM1_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_SLEEP: {
if ((value & BMI055_GYRO_POWER_BIT_MASK) == BMI055_GYRO_POWER_SLEEP_REG) {
return 0;
}
value &= (~BMI055_GYRO_POWER_BIT_MASK);
value |= BMI055_GYRO_POWER_SLEEP_REG;
ret = sensor_i2c_write(drv, BMI055_GYRO_MODE_LPM1_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
default:
break;
}
return 0;
}
static int drv_gyro_bosch_bmi055_set_odr(i2c_dev_t *drv, uint32_t odr)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, BMI055_GYRO_BW_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (odr >= BMI055_GYRO_ODR_2000) {
value &= BMI055_GYRO_BW_ADDR_MSK;
value |= BMI055_GYRO_ODR_2000_REG;
} else if (odr >= BMI055_GYRO_ODR_1000) {
value &= BMI055_GYRO_BW_ADDR_MSK;
value |= BMI055_GYRO_ODR_1000_REG;
} else if (odr >= BMI055_GYRO_ODR_400) {
value &= BMI055_GYRO_BW_ADDR_MSK;
value |= BMI055_GYRO_ODR_400_REG;
} else if (odr >= BMI055_GYRO_ODR_200) {
value &= BMI055_GYRO_BW_ADDR_MSK;
value |= BMI055_GYRO_ODR_200_REG;
} else {
value &= BMI055_GYRO_BW_ADDR_MSK;
value |= BMI055_GYRO_ODR_100_REG;
}
/* Write the range register 0x0F*/
ret = sensor_i2c_write(drv, BMI055_GYRO_BW_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_gyro_bosch_bmi055_set_range(i2c_dev_t *drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, BMI055_GYRO_RANGE_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (range) {
case GYRO_RANGE_125DPS: {
value &= BMI055_GYRO_RANGE_ADDR_RANGE_MSK;
value |= BMI055_GYRO_RANGE_RANGE_125DPS;
} break;
case GYRO_RANGE_250DPS: {
value &= BMI055_GYRO_RANGE_ADDR_RANGE_MSK;
value |= BMI055_GYRO_RANGE_RANGE_250DPS;
} break;
case GYRO_RANGE_500DPS: {
value &= BMI055_GYRO_RANGE_ADDR_RANGE_MSK;
value |= BMI055_GYRO_RANGE_RANGE_500DPS;
} break;
case GYRO_RANGE_1000DPS: {
value &= BMI055_GYRO_RANGE_ADDR_RANGE_MSK;
value |= BMI055_GYRO_RANGE_RANGE_1000DPS;
} break;
case GYRO_RANGE_2000DPS: {
value &= BMI055_GYRO_RANGE_ADDR_RANGE_MSK;
value |= BMI055_GYRO_RANGE_RANGE_2000DPS;
} break;
default:
break;
}
/* Write the range register 0x0F*/
ret = sensor_i2c_write(drv, BMI055_GYRO_RANGE_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if ((range >= GYRO_RANGE_125DPS) && (range <= GYRO_RANGE_2000DPS)) {
gyro_current_factor = bmi055_gyro_factor[range];
}
return 0;
}
static void drv_gyro_bosch_bmi055_irq_handle(void)
{
/* no handle so far */
}
static int drv_gyro_bosch_bmi055_open(void)
{
int ret = 0;
ret = drv_gyro_bosch_bmi055_set_power_mode(&bmi055_gyro_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_gyro_bosch_bmi055_close(void)
{
int ret = 0;
ret = drv_gyro_bosch_bmi055_set_power_mode(&bmi055_gyro_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_gyro_bosch_bmi055_read(void *buf, size_t len)
{
int ret = 0;
size_t size = 0;
uint8_t reg[6];
gyro_data_t *gyro = (gyro_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(gyro_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(&bmi055_gyro_ctx, BMI055_GYRO_RATE_X_LSB_ADDR, ®[0],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi055_gyro_ctx, BMI055_GYRO_RATE_X_MSB_ADDR, ®[1],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi055_gyro_ctx, BMI055_GYRO_RATE_Y_LSB_ADDR, ®[2],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi055_gyro_ctx, BMI055_GYRO_RATE_Y_MSB_ADDR, ®[3],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi055_gyro_ctx, BMI055_GYRO_RATE_Z_LSB_ADDR, ®[4],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi055_gyro_ctx, BMI055_GYRO_RATE_Z_MSB_ADDR, ®[5],
I2C_REG_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
gyro->data[DATA_AXIS_X] = (int32_t)(
(((int32_t)((int8_t)reg[1])) << BMI055_GYRO_SHIFT_EIGHT_BITS) | reg[0]);
gyro->data[DATA_AXIS_Y] = (int32_t)(
(((int32_t)((int8_t)reg[3])) << BMI055_GYRO_SHIFT_EIGHT_BITS) | reg[2]);
gyro->data[DATA_AXIS_Z] = (int32_t)(
(((int32_t)((int8_t)reg[5])) << BMI055_GYRO_SHIFT_EIGHT_BITS) | reg[4]);
if (gyro_current_factor != 0) {
// the unit of gyro is uDPS, 1000 000 uDPS = 1 DPS
gyro->data[DATA_AXIS_X] = (int32_t)((int64_t)gyro->data[DATA_AXIS_X] * GYROSCOPE_UNIT_FACTOR * 10 / gyro_current_factor);
gyro->data[DATA_AXIS_Y] = (int32_t)((int64_t)gyro->data[DATA_AXIS_Y] * GYROSCOPE_UNIT_FACTOR * 10 / gyro_current_factor);
gyro->data[DATA_AXIS_Z] = (int32_t)((int64_t)gyro->data[DATA_AXIS_Z] * GYROSCOPE_UNIT_FACTOR * 10 / gyro_current_factor);
}
gyro->timestamp = aos_now_ms();
return (int)size;
}
static int drv_gyro_bosch_bmi055_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_gyro_bosch_bmi055_set_odr(&bmi055_gyro_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_gyro_bosch_bmi055_set_range(&bmi055_gyro_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_gyro_bosch_bmi055_set_power_mode(&bmi055_gyro_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMI055";
info->range_max = 2000;
info->range_min = 125;
info->unit = udps;
} break;
default:
break;
}
return 0;
}
int drv_gyro_bosch_bmi055_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_GYRO;
sensor.path = dev_gyro_path;
sensor.open = drv_gyro_bosch_bmi055_open;
sensor.close = drv_gyro_bosch_bmi055_close;
sensor.read = drv_gyro_bosch_bmi055_read;
sensor.write = NULL;
sensor.ioctl = drv_gyro_bosch_bmi055_ioctl;
sensor.irq_handle = drv_gyro_bosch_bmi055_irq_handle;
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
ret = drv_gyro_bosch_bmi055_validate_id(&bmi055_gyro_ctx, BMI055_GYRO_CHIP_ID_VALUE);
if (unlikely(ret)) {
return -1;
}
ret = drv_gyro_bosch_bmi055_set_range(&bmi055_gyro_ctx, GYRO_RANGE_2000DPS);
if (unlikely(ret)) {
return -1;
}
ret = drv_gyro_bosch_bmi055_set_odr(&bmi055_gyro_ctx, BMI055_GYRO_DEFAULT_ODR);
if (unlikely(ret)) {
return -1;
}
ret = drv_gyro_bosch_bmi055_set_power_mode(&bmi055_gyro_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_bosch_bmi055_init);
SENSOR_DRV_ADD(drv_gyro_bosch_bmi055_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_gyro_bosch_bmi055.c
|
C
|
apache-2.0
| 35,853
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include "aos/kernel.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define BMI088_ACC_I2C_ADDR_LOW (0x18)
#define BMI088_ACC_I2C_ADDR_HIGH (0x19)
#define BMI088_ACC_I2C_ADDR_TRANS(n) ((n)<<1)
#define BMI088_ACC_I2C_ADDR BMI088_ACC_I2C_ADDR_TRANS(BMI088_ACC_I2C_ADDR_LOW)
#define BMI088_ACC_CHIP_ID_ADDR UINT8_C(0X00)
#define BMI088_ACC_CHIP_ID_VALUE (0x1E)
#define BMI088_ACC_POWER_CONF_ADDR UINT8_C(0x7C)
#define BMI088_ACC_POWER_CTRL_ADDR UINT8_C(0x7D)
#define BMI088_ACC_CONFIG_ADDR UINT8_C(0X40)
#define BMI088_ACC_CONFIG1_ADDR UINT8_C(0X41)
#define BMI088_ACC_DEFAULT_ODR_100HZ (100)
#define BMI088_ACC_CMD_ADDR UINT8_C(0X7E)
#define BMI088_ACC_OUTPUT_DATA_RATE_0_78HZ UINT8_C(0x01)
#define BMI088_ACC_OUTPUT_DATA_RATE_1_56HZ UINT8_C(0x02)
#define BMI088_ACC_OUTPUT_DATA_RATE_3_12HZ UINT8_C(0x03)
#define BMI088_ACC_OUTPUT_DATA_RATE_6_25HZ UINT8_C(0x04)
#define BMI088_ACC_OUTPUT_DATA_RATE_12_5HZ UINT8_C(0x05)
#define BMI088_ACC_OUTPUT_DATA_RATE_25HZ UINT8_C(0x06)
#define BMI088_ACC_OUTPUT_DATA_RATE_50HZ UINT8_C(0x07)
#define BMI088_ACC_OUTPUT_DATA_RATE_100HZ UINT8_C(0x08)
#define BMI088_ACC_OUTPUT_DATA_RATE_200HZ UINT8_C(0x09)
#define BMI088_ACC_OUTPUT_DATA_RATE_400HZ UINT8_C(0x0A)
#define BMI088_ACC_OUTPUT_DATA_RATE_800HZ UINT8_C(0x0B)
#define BMI088_ACC_OUTPUT_DATA_RATE_1600HZ UINT8_C(0x0C)
#define BMI088_ACC_OSR4_AVG1 UINT8_C(0)
#define BMI088_ACC_OSR2_AVG2 UINT8_C(1)
#define BMI088_ACC_NORMAL_AVG4 UINT8_C(2)
#define BMI088_ACC_CIC_AVG8 UINT8_C(3)
#define BMI088_ACC_RES_AVG16 UINT8_C(4)
#define BMI088_ACC_RES_AVG32 UINT8_C(5)
#define BMI088_ACC_RES_AVG64 UINT8_C(6)
#define BMI088_ACC_RES_AVG128 UINT8_C(7)
#define BMI088_ACC_RANGE_2G UINT8_C(0)
#define BMI088_ACC_RANGE_4G UINT8_C(1)
#define BMI088_ACC_RANGE_8G UINT8_C(2)
#define BMI088_ACC_RANGE_16G UINT8_C(3)
#define BMI088_ACC_DATA_0_ADDR UINT8_C(0X0A)
#define BMI088_ACC_DATA_8_ADDR UINT8_C(0X12)
#define BMI088_ACC_DATA_LENGTH UINT8_C(6)
#define BMI088_ACC_ENABLE UINT8_C(0x01)
#define BMI088_ACC_DISABLE UINT8_C(0x00)
#define BMI088_ACC_ADVANCE_POWER_SAVE_MSK UINT8_C (0x01)
#define BMI088_ACC_ENABLE_POS UINT8_C(2)
#define BMI088_ACC_ENABLE_MSK UINT8_C(0x04)
#define BMI088_ACC_PERF_POS UINT8_C(7)
#define BMI088_ACC_ODR_POS UINT8_C(0)
#define BMI088_ACC_ODR_MSK UINT8_C(0x0F)
#define BMI088_ACC_RANGE_POS UINT8_C(0)
#define BMI088_ACC_RANGE_MSK UINT8_C(0x03)
#define BMI088_ACC_DEFAULT_ODR (100)
#define BMI088_ACC_ENABLE_SOFT_RESET_VALUE UINT8_C(0XB6)
#define BMI088_ACC_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define BMI088_ACC_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | \
((val<<bitname##_POS)&bitname##_MSK))
#define BMI088_ACC_SET_BITS_POS_0(reg_data, bitname, data) \
((reg_data & ~(bitname##_MSK)) | \
(data & bitname##_MSK))
#define BMI088_ACC_GET_BITS_POS_0(reg_data, bitname) (reg_data & (bitname##_MSK))
#define BMI088_GYRO_I2C_ADDR1 (0x68 << 1)
#define BMI088_GYRO_I2C_ADDR2 (0x69 << 1)
#define BMI088_GYRO_CHIP_ID_ADDR (0x00)
#define BMI088_GYRO_CHIP_ID_VALUE (0x0F)
#define BMI088_GYRO_RATE_X_LSB_ADDR (0x02)
#define BMI088_GYRO_RATE_X_MSB_ADDR (0x03)
#define BMI088_GYRO_RATE_Y_LSB_ADDR (0x04)
#define BMI088_GYRO_RATE_Y_MSB_ADDR (0x05)
#define BMI088_GYRO_RATE_Z_LSB_ADDR (0x06)
#define BMI088_GYRO_RATE_Z_MSB_ADDR (0x07)
#define BMI088_GYRO_TEMP_ADDR (0x08)
#define BMI088_GYRO_INTR_STAT0_ADDR (0x09)
#define BMI088_GYRO_INTR_STAT1_ADDR (0x0A)
#define BMI088_GYRO_INTR_STAT2_ADDR (0x0B)
#define BMI088_GYRO_INTR_STAT3_ADDR (0x0C)
#define BMI088_GYRO_FIFO_STAT_ADDR (0x0E)
#define BMI088_GYRO_RANGE_ADDR (0x0F)
#define BMI088_GYRO_BW_ADDR (0x10)
#define BMI088_GYRO_MODE_LPM1_ADDR (0x11)
#define BMI088_GYRO_MODE_LPM2_ADDR (0x12)
#define BMI088_GYRO_HIGH_BW_ADDR (0x13)
#define BMI088_GYRO_BGW_SOFT_RST_ADDR (0x14)
#define BMI088_GYRO_INTR_ENABLE0_ADDR (0x15)
#define BMI088_GYRO_INTR_ENABLE1_ADDR (0x16)
#define BMI088_GYRO_INTR_MAP_ZERO_ADDR (0x17)
#define BMI088_GYRO_INTR_MAP_ONE_ADDR (0x18)
#define BMI088_GYRO_INTR_MAP_TWO_ADDR (0x19)
#define BMI088_GYRO_INTR_ZERO_ADDR (0x1A)
#define BMI088_GYRO_INTR_ONE_ADDR (0x1B)
#define BMI088_GYRO_INTR_TWO_ADDR (0x1C)
#define BMI088_GYRO_INTR_4_ADDR (0x1E)
#define BMI088_GYRO_RST_LATCH_ADDR (0x21)
#define BMI088_GYRO_HIGHRATE_THRES_X_ADDR (0x22)
#define BMI088_GYRO_HIGHRATE_DURN_X_ADDR (0x23)
#define BMI088_GYRO_HIGHRATE_THRES_Y_ADDR (0x24)
#define BMI088_GYRO_HIGHRATE_DURN_Y_ADDR (0x25)
#define BMI088_GYRO_HIGHRATE_THRES_Z_ADDR (0x26)
#define BMI088_GYRO_HIGHRATE_DURN_Z_ADDR (0x27)
#define BMI088_GYRO_SOC_ADDR (0x31)
#define BMI088_GYRO_A_FOC_ADDR (0x32)
#define BMI088_GYRO_TRIM_NVM_CTRL_ADDR (0x33)
#define BMI088_GYRO_BGW_SPI3_WDT_ADDR (0x34)
#define BMI088_GYRO_OFFSET_OFC1_ADDR (0x36)
#define BMI088_GYRO_OFC2_ADDR (0x37)
#define BMI088_GYRO_OFC3_ADDR (0x38)
#define BMI088_GYRO_OFC4_ADDR (0x39)
#define BMI088_GYRO_TRIM_GP0_ADDR (0x3A)
#define BMI088_GYRO_TRIM_GP1_ADDR (0x3B)
#define BMI088_GYRO_SELFTEST_ADDR (0x3C)
#define BMI088_GYRO_FIFO_CGF1_ADDR (0x3D)
#define BMI088_GYRO_FIFO_CGF0_ADDR (0x3E)
#define BMI088_GYRO_FIFO_DATA_ADDR (0x3F)
#define BMI088_GYRO_RANGE_RANGE_2000DPS (0x00)
#define BMI088_GYRO_RANGE_RANGE_1000DPS (0x01)
#define BMI088_GYRO_RANGE_RANGE_500DPS (0x02)
#define BMI088_GYRO_RANGE_RANGE_250DPS (0x03)
#define BMI088_GYRO_RANGE_RANGE_125DPS (0x04)
#define BMI088_GYRO_RANGE_ADDR_RANGE_POS (0)
#define BMI088_GYRO_RANGE_ADDR_RANGE_LEN (3)
#define BMI088_GYRO_RANGE_ADDR_RANGE_MSK (0x07)
#define BMI088_GYRO_RANGE_ADDR_RANGE_REG (BMI088_GYRO_RANGE_ADDR)
#define BMI088_GYRO_BW_ADDR_POS (0)
#define BMI088_GYRO_BW_ADDR_LEN (3)
#define BMI088_GYRO_BW_ADDR_MSK (0x07)
#define BMI088_GYRO_BW_ADDR_REG (BMI088_GYRO_BW_ADDR)
#define BMI088_GYRO_MODE_LPM1_POS (5)
#define BMI088_GYRO_MODE_LPM1_LEN (3)
#define BMI088_GYRO_MODE_LPM1_MSK (0xA0)
#define BMI088_GYRO_MODE_LPM1_REG (BMI088_GYRO_MODE_LPM1_ADDR)
#define BMI088_GYRO_ODR_100 (100)
#define BMI088_GYRO_ODR_200 (200)
#define BMI088_GYRO_ODR_400 (400)
#define BMI088_GYRO_ODR_1000 (1000)
#define BMI088_GYRO_ODR_2000 (2000)
#define BMI088_GYRO_ODR_100_REG (0x07)
#define BMI088_GYRO_ODR_200_REG (0x06)
#define BMI088_GYRO_ODR_400_REG (0x03)
#define BMI088_GYRO_ODR_1000_REG (0x02)
#define BMI088_GYRO_ODR_2000_REG (0x01)
#define BMI088_GYRO_POWER_BIT_MASK (0xA0)
#define BMI088_GYRO_POWER_NORMAL_REG (0x00)
#define BMI088_GYRO_POWER_SLEEP_REG (0x80)
#define BMI088_GYRO_POWER_DEEP_SUSPEND_REG (0x20)
#define BMI088_GYRO_SHIFT_EIGHT_BITS (8)
#define BMI088_GYRO_DEFAULT_ODR (200)
static uint32_t bmi088_acc_factor[4] = { 16384, 8192, 4096, 2048 };
static uint32_t acc_current_factor = 0;
static uint32_t set_range_failed = 0;
static uint32_t bmi088_gyro_factor[5] = { 2624, 1312, 656, 328,
164 };
static uint32_t gyro_current_factor = 0;
i2c_dev_t bmi088_acc_ctx = {
.port = 3,
.config.dev_addr = BMI088_ACC_I2C_ADDR,
};
i2c_dev_t bmi088_gyro_ctx = {
.port = 3,
.config.dev_addr = BMI088_GYRO_I2C_ADDR1,
};
static int drv_acc_bosch_bmi088_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = BMI088_ACC_ENABLE_SOFT_RESET_VALUE;
ret = sensor_i2c_write(drv, BMI088_ACC_CMD_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return -1;
}
return 0;
}
static int drv_acc_bosch_bmi088_validate_id(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, BMI088_ACC_CHIP_ID_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return ret;
}
if(BMI088_ACC_CHIP_ID_VALUE != value) {
return -1;
}
return 0;
}
static int drv_acc_bosch_bmi088_set_power_mode(i2c_dev_t* drv,
dev_power_mode_e mode)
{
uint8_t value, value1 = 0x00;
int ret = 0;
switch(mode) {
case DEV_POWER_ON: {
ret = sensor_i2c_read(drv, BMI088_ACC_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return ret;
}
value |= (BMI088_ACC_ENABLE << BMI088_ACC_PERF_POS);
ret = sensor_i2c_write(drv, BMI088_ACC_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
ret = sensor_i2c_read(drv, BMI088_ACC_POWER_CTRL_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return ret;
}
value1 = BMI088_ACC_SET_BITSLICE(value1, BMI088_ACC_ENABLE, BMI088_ACC_ENABLE);
ret = sensor_i2c_write(drv, BMI088_ACC_POWER_CTRL_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
}
break;
case DEV_POWER_OFF:
case DEV_SLEEP:
case DEV_SUSPEND: {
ret = sensor_i2c_read(drv, BMI088_ACC_POWER_CTRL_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return ret;
}
value = BMI088_ACC_SET_BITSLICE(value, BMI088_ACC_ENABLE, BMI088_ACC_DISABLE);
ret = sensor_i2c_write(drv, BMI088_ACC_POWER_CTRL_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
ret = sensor_i2c_read(drv, BMI088_ACC_POWER_CONF_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return ret;
}
value1 = BMI088_ACC_SET_BITS_POS_0(value1, BMI088_ACC_ADVANCE_POWER_SAVE, BMI088_ACC_ENABLE);
ret = sensor_i2c_write(drv, BMI088_ACC_POWER_CONF_ADDR, &value1, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
}
break;
default:
break;
}
return 0;
}
static int drv_acc_bosch_bmi088_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = 0x00;
ret = sensor_i2c_read(drv, BMI088_ACC_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return ret;
}
if(hz >= 800) {
odr = BMI088_ACC_OUTPUT_DATA_RATE_1600HZ;
} else if(hz >= 400) {
odr = BMI088_ACC_OUTPUT_DATA_RATE_800HZ;
} else if(hz >= 200) {
odr = BMI088_ACC_OUTPUT_DATA_RATE_400HZ;
} else if(hz >= 100) {
odr = BMI088_ACC_OUTPUT_DATA_RATE_200HZ;
} else if(hz >= 50) {
odr = BMI088_ACC_OUTPUT_DATA_RATE_100HZ;
} else if(hz >= 25) {
odr = BMI088_ACC_OUTPUT_DATA_RATE_50HZ;
} else if(hz >= 12) {
odr = BMI088_ACC_OUTPUT_DATA_RATE_25HZ;
} else if(hz >= 6) {
odr = BMI088_ACC_OUTPUT_DATA_RATE_12_5HZ;
} else if(hz >= 3) {
odr = BMI088_ACC_OUTPUT_DATA_RATE_6_25HZ;
} else {
odr = BMI088_ACC_OUTPUT_DATA_RATE_3_12HZ;
}
value = BMI088_ACC_SET_BITSLICE(value, BMI088_ACC_ODR, odr);
ret = sensor_i2c_write(drv, BMI088_ACC_CONFIG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
return 0;
}
static int drv_acc_bosch_bmi088_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t acc_range = 0x00;
ret = sensor_i2c_read(drv, BMI088_ACC_CONFIG1_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
set_range_failed = 1;
return ret;
}
switch(range) {
case ACC_RANGE_2G: {
acc_range = BMI088_ACC_RANGE_2G;
}
break;
case ACC_RANGE_4G: {
acc_range = BMI088_ACC_RANGE_4G;
}
break;
case ACC_RANGE_8G: {
acc_range = BMI088_ACC_RANGE_8G;
}
break;
case ACC_RANGE_16G: {
acc_range = BMI088_ACC_RANGE_16G;
}
break;
default:
break;
}
value = BMI088_ACC_SET_BITSLICE(value, BMI088_ACC_RANGE, acc_range);
ret = sensor_i2c_write(drv, BMI088_ACC_CONFIG1_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
set_range_failed = 2;
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)) {
acc_current_factor = bmi088_acc_factor[range];
}
set_range_failed = 3;
return 0;
}
static void drv_acc_bosch_bmi088_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_bosch_bmi088_open(void)
{
int ret = 0;
ret = drv_acc_bosch_bmi088_set_power_mode(&bmi088_acc_ctx, DEV_POWER_ON);
if(unlikely(ret) != 0) {
return -1;
}
return 0;
}
static int drv_acc_bosch_bmi088_close(void)
{
int ret = 0;
ret = drv_acc_bosch_bmi088_set_power_mode(&bmi088_acc_ctx, DEV_POWER_OFF);
if(unlikely(ret) != 0) {
return -1;
}
return 0;
}
static int drv_acc_bosch_bmi088_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
uint8_t range = 0;
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if(len < size) {
return -1;
}
ret = sensor_i2c_read(&bmi088_acc_ctx, 0x41, &range, I2C_REG_LEN, I2C_OP_RETRIES);
ret = sensor_i2c_read(&bmi088_acc_ctx, BMI088_ACC_DATA_8_ADDR, ®[0], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi088_acc_ctx, BMI088_ACC_DATA_8_ADDR+1, ®[1], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi088_acc_ctx, BMI088_ACC_DATA_8_ADDR+2, ®[2], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi088_acc_ctx, BMI088_ACC_DATA_8_ADDR+3, ®[3], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi088_acc_ctx, BMI088_ACC_DATA_8_ADDR+4, ®[4], I2C_REG_LEN,
I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi088_acc_ctx, BMI088_ACC_DATA_8_ADDR+5, ®[5], I2C_REG_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return -1;
}
accel->data[DATA_AXIS_X] = ((int16_t)((reg[1] << 8) | reg[0]));
accel->data[DATA_AXIS_Y] = ((int16_t)((reg[3] << 8) | reg[2]));
accel->data[DATA_AXIS_Z] = ((int16_t)((reg[5] << 8) | reg[4]));
if(acc_current_factor != 0) {
/* the unit of acc is mg, 1000 mg = 1 g */
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)acc_current_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)acc_current_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)acc_current_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_bosch_bmi088_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_acc_bosch_bmi088_set_odr(&bmi088_acc_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_acc_bosch_bmi088_set_range(&bmi088_acc_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_bosch_bmi088_set_power_mode(&bmi088_acc_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMI088";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}
break;
default:
break;
}
return 0;
}
int drv_acc_bosch_bmi088_init(void) {
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_bosch_bmi088_open;
sensor.close = drv_acc_bosch_bmi088_close;
sensor.read = drv_acc_bosch_bmi088_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_bosch_bmi088_ioctl;
sensor.irq_handle = drv_acc_bosch_bmi088_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_acc_bosch_bmi088_validate_id(&bmi088_acc_ctx);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_acc_bosch_bmi088_soft_reset(&bmi088_acc_ctx);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_acc_bosch_bmi088_set_range(&bmi088_acc_ctx, ACC_RANGE_8G);
if(unlikely(ret) != 0) {
return -1;
}
/* set odr is 100hz, and will update */
ret = drv_acc_bosch_bmi088_set_odr(&bmi088_acc_ctx, BMI088_ACC_DEFAULT_ODR);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_acc_bosch_bmi088_set_power_mode(&bmi088_acc_ctx, DEV_SLEEP);
if(unlikely(ret) != 0) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
/* update the phy sensor info to sensor hal */
return 0;
}
static int drv_gyro_bosch_bmi088_validate_id(i2c_dev_t *drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, BMI088_GYRO_CHIP_ID_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (id_value != value) {
return -1;
}
return 0;
}
static int drv_gyro_bosch_bmi088_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, BMI088_GYRO_MODE_LPM1_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_ON: {
if ((value & BMI088_GYRO_POWER_BIT_MASK) == BMI088_GYRO_POWER_NORMAL_REG) {
return 0;
}
value &= (~BMI088_GYRO_POWER_BIT_MASK);
value |= BMI088_GYRO_POWER_NORMAL_REG;
ret = sensor_i2c_write(drv, BMI088_GYRO_MODE_LPM1_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_POWER_OFF: {
if ((value & BMI088_GYRO_POWER_BIT_MASK) ==
BMI088_GYRO_POWER_DEEP_SUSPEND_REG) {
return 0;
}
value &= (~BMI088_GYRO_POWER_BIT_MASK);
value |= BMI088_GYRO_POWER_DEEP_SUSPEND_REG;
ret = sensor_i2c_write(drv, BMI088_GYRO_MODE_LPM1_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_SLEEP: {
if ((value & BMI088_GYRO_POWER_BIT_MASK) == BMI088_GYRO_POWER_SLEEP_REG) {
return 0;
}
value &= (~BMI088_GYRO_POWER_BIT_MASK);
value |= BMI088_GYRO_POWER_SLEEP_REG;
ret = sensor_i2c_write(drv, BMI088_GYRO_MODE_LPM1_ADDR, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
default:
break;
}
return 0;
}
static int drv_gyro_bosch_bmi088_set_odr(i2c_dev_t *drv, uint32_t odr)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, BMI088_GYRO_BW_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (odr >= BMI088_GYRO_ODR_2000) {
value &= BMI088_GYRO_BW_ADDR_MSK;
value |= BMI088_GYRO_ODR_2000_REG;
} else if (odr >= BMI088_GYRO_ODR_1000) {
value &= BMI088_GYRO_BW_ADDR_MSK;
value |= BMI088_GYRO_ODR_1000_REG;
} else if (odr >= BMI088_GYRO_ODR_400) {
value &= BMI088_GYRO_BW_ADDR_MSK;
value |= BMI088_GYRO_ODR_400_REG;
} else if (odr >= BMI088_GYRO_ODR_200) {
value &= BMI088_GYRO_BW_ADDR_MSK;
value |= BMI088_GYRO_ODR_200_REG;
} else {
value &= BMI088_GYRO_BW_ADDR_MSK;
value |= BMI088_GYRO_ODR_100_REG;
}
ret = sensor_i2c_write(drv, BMI088_GYRO_BW_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_gyro_bosch_bmi088_set_range(i2c_dev_t *drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, BMI088_GYRO_RANGE_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (range) {
case GYRO_RANGE_125DPS: {
value &= BMI088_GYRO_RANGE_ADDR_RANGE_MSK;
value |= BMI088_GYRO_RANGE_RANGE_125DPS;
} break;
case GYRO_RANGE_250DPS: {
value &= BMI088_GYRO_RANGE_ADDR_RANGE_MSK;
value |= BMI088_GYRO_RANGE_RANGE_250DPS;
} break;
case GYRO_RANGE_500DPS: {
value &= BMI088_GYRO_RANGE_ADDR_RANGE_MSK;
value |= BMI088_GYRO_RANGE_RANGE_500DPS;
} break;
case GYRO_RANGE_1000DPS: {
value &= BMI088_GYRO_RANGE_ADDR_RANGE_MSK;
value |= BMI088_GYRO_RANGE_RANGE_1000DPS;
} break;
case GYRO_RANGE_2000DPS: {
value &= BMI088_GYRO_RANGE_ADDR_RANGE_MSK;
value |= BMI088_GYRO_RANGE_RANGE_2000DPS;
} break;
default:
break;
}
ret = sensor_i2c_write(drv, BMI088_GYRO_RANGE_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if ((range >= GYRO_RANGE_125DPS) && (range <= GYRO_RANGE_2000DPS)) {
gyro_current_factor = bmi088_gyro_factor[range];
}
return 0;
}
static void drv_gyro_bosch_bmi088_irq_handle(void)
{
/* no handle so far */
}
static int drv_gyro_bosch_bmi088_open(void)
{
int ret = 0;
ret = drv_gyro_bosch_bmi088_set_power_mode(&bmi088_gyro_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_gyro_bosch_bmi088_close(void)
{
int ret = 0;
ret = drv_gyro_bosch_bmi088_set_power_mode(&bmi088_gyro_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_gyro_bosch_bmi088_read(void *buf, size_t len)
{
int ret = 0;
size_t size = 0;
uint8_t reg[6];
gyro_data_t *gyro = (gyro_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(gyro_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(&bmi088_gyro_ctx, BMI088_GYRO_RATE_X_LSB_ADDR, ®[0],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi088_gyro_ctx, BMI088_GYRO_RATE_X_MSB_ADDR, ®[1],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi088_gyro_ctx, BMI088_GYRO_RATE_Y_LSB_ADDR, ®[2],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi088_gyro_ctx, BMI088_GYRO_RATE_Y_MSB_ADDR, ®[3],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi088_gyro_ctx, BMI088_GYRO_RATE_Z_LSB_ADDR, ®[4],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi088_gyro_ctx, BMI088_GYRO_RATE_Z_MSB_ADDR, ®[5],
I2C_REG_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
gyro->data[DATA_AXIS_X] = (int32_t)(
(((int32_t)((int8_t)reg[1])) << BMI088_GYRO_SHIFT_EIGHT_BITS) | reg[0]);
gyro->data[DATA_AXIS_Y] = (int32_t)(
(((int32_t)((int8_t)reg[3])) << BMI088_GYRO_SHIFT_EIGHT_BITS) | reg[2]);
gyro->data[DATA_AXIS_Z] = (int32_t)(
(((int32_t)((int8_t)reg[5])) << BMI088_GYRO_SHIFT_EIGHT_BITS) | reg[4]);
if (gyro_current_factor != 0) {
// the unit of gyro is uDPS, 1000 000 uDPS = 1 DPS
gyro->data[DATA_AXIS_X] = (int32_t)((int64_t)gyro->data[DATA_AXIS_X] * GYROSCOPE_UNIT_FACTOR * 10 / gyro_current_factor);
gyro->data[DATA_AXIS_Y] = (int32_t)((int64_t)gyro->data[DATA_AXIS_Y] * GYROSCOPE_UNIT_FACTOR * 10 / gyro_current_factor);
gyro->data[DATA_AXIS_Z] = (int32_t)((int64_t)gyro->data[DATA_AXIS_Z] * GYROSCOPE_UNIT_FACTOR * 10 / gyro_current_factor);
}
gyro->timestamp = aos_now_ms();
return (int)size;
}
static int drv_gyro_bosch_bmi088_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_gyro_bosch_bmi088_set_odr(&bmi088_gyro_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_gyro_bosch_bmi088_set_range(&bmi088_gyro_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_gyro_bosch_bmi088_set_power_mode(&bmi088_gyro_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMI088";
info->range_max = 2000;
info->range_min = 125;
info->unit = udps;
} break;
default:
break;
}
return 0;
}
int drv_gyro_bosch_bmi088_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_GYRO;
sensor.path = dev_gyro_path;
sensor.open = drv_gyro_bosch_bmi088_open;
sensor.close = drv_gyro_bosch_bmi088_close;
sensor.read = drv_gyro_bosch_bmi088_read;
sensor.write = NULL;
sensor.ioctl = drv_gyro_bosch_bmi088_ioctl;
sensor.irq_handle = drv_gyro_bosch_bmi088_irq_handle;
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
ret = drv_gyro_bosch_bmi088_validate_id(&bmi088_gyro_ctx, BMI088_GYRO_CHIP_ID_VALUE);
if (unlikely(ret)) {
return -1;
}
ret = drv_gyro_bosch_bmi088_set_range(&bmi088_gyro_ctx, GYRO_RANGE_2000DPS);
if (unlikely(ret)) {
return -1;
}
ret = drv_gyro_bosch_bmi088_set_odr(&bmi088_gyro_ctx, BMI088_GYRO_DEFAULT_ODR);
if (unlikely(ret)) {
return -1;
}
ret = drv_gyro_bosch_bmi088_set_power_mode(&bmi088_gyro_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_bosch_bmi088_init);
SENSOR_DRV_ADD(drv_gyro_bosch_bmi088_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_gyro_bosch_bmi088.c
|
C
|
apache-2.0
| 30,290
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
/*********************************************************************************************
*
*Copyright (C) 2016 - 2020 Bosch Sensortec GmbH
*Redistribution and use in source and binary forms, with or without
*modification, are permitted provided that the following conditions are met:
*Redistributions of source code must retain the above copyright
*notice, this list of conditions and the following disclaimer.
*Redistributions in binary form must reproduce the above copyright
*notice, this list of conditions and the following disclaimer in the
*documentation and/or other materials provided with the distribution.
*Neither the name of the copyright holder nor the names of the
*contributors may be used to endorse or promote products derived from
*this software without specific prior written permission.
*THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
*CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
*IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
*WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
*DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
*OR CONTRIBUTORS BE LIABLE FOR ANY
*DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
*OR CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED TO,
*PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
*LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
*HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
*WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
*(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
*ANY WAY OUT OF THE USE OF THIS
*SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
*The information provided is believed to be accurate and reliable.
*The copyright holder assumes no responsibility
*for the consequences of use
*of such information nor for any infringement of patents or
*other rights of third parties which may result from its use.
*No license is granted by implication or otherwise under any patent or
*patent rights of the copyright holder.
*
*
*******************************************************************************************/
#include "aos/kernel.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define BMI120_I2C_ADDR_TRANS(n) ((n)<<1)
#define BMI120_I2C_SLAVE_ADDR_LOW 0x68
#define BMI120_I2C_ADDR BMI120_I2C_ADDR_TRANS(BMI120_I2C_SLAVE_ADDR_LOW)
/* COMMAND REGISTER */
#define BMI120_CMD_COMMANDS_ADDR (0X7E)
/* CHIP ID */
#define BMI120_USER_CHIP_ID_ADDR (0x00)
/* ACCEL CONFIG REGISTERS FOR ODR, BANDWIDTH AND UNDERSAMPLING */
#define BMI120_USER_ACCEL_CONFIG_ADDR (0X40)
/* ACCEL RANGE */
#define BMI120_USER_ACCEL_RANGE_ADDR (0X41)
/* ACCEL DATA REGISTERS */
#define BMI120_USER_DATA_14_ADDR (0X12)
#define BMI120_USER_DATA_15_ADDR (0X13)
#define BMI120_USER_DATA_16_ADDR (0X14)
#define BMI120_USER_DATA_17_ADDR (0X15)
#define BMI120_USER_DATA_18_ADDR (0X16)
#define BMI120_USER_DATA_19_ADDR (0X17)
/* GYRO DATA REGISTERS */
#define BMI120_USER_DATA_8_ADDR (0X0C)
#define BMI120_USER_DATA_9_ADDR (0X0D)
#define BMI120_USER_DATA_10_ADDR (0X0E)
#define BMI120_USER_DATA_11_ADDR (0X0F)
#define BMI120_USER_DATA_12_ADDR (0X10)
#define BMI120_USER_DATA_13_ADDR (0X11)
#define BMI120_MODE_SWITCHING_DELAY (30)
/* GYRO CONFIG REGISTERS FOR ODR AND BANDWIDTH */
#define BMI120_USER_GYRO_CONFIG_ADDR (0X42)
/* GYRO RANGE */
#define BMI120_USER_GYRO_RANGE_ADDR (0X43)
/* BMI120 CHIPID */
#define BMI120_CHIP_ID_VALUE (0xD3)
/* CMD REGISTERS DEFINITION START */
/* COMMAND REGISTER LENGTH, POSITION AND MASK */
/* Command description address - Reg Addr --> 0x7E, Bit --> 0....7 */
#define BMI120_CMD_COMMANDS__POS (0)
#define BMI120_CMD_COMMANDS__LEN (8)
#define BMI120_CMD_COMMANDS__MSK (0xFF)
#define BMI120_CMD_COMMANDS__REG (BMI120_CMD_COMMANDS_ADDR)
/* CMD */
#define BMI120_CMD_SOFTRESET (0xB6)
/* name ACCEL POWER MODE */
#define ACCEL_MODE_NORMAL (0x11)
#define ACCEL_LOWPOWER (0X12)
#define ACCEL_SUSPEND (0X10)
/* BMI120 Accel power modes */
#define BMI120_ACCEL_SUSPEND 0
#define BMI120_ACCEL_NORMAL_MODE 1
#define BMI120_ACCEL_LOW_POWER 2
/* GYRO POWER MODE */
#define GYRO_MODE_SUSPEND (0x14)
#define GYRO_MODE_NORMAL (0x15)
#define GYRO_MODE_FASTSTARTUP (0x17)
/* CHIP ID LENGTH, POSITION AND MASK */
/* Chip ID Description - Reg Addr --> (0x00), Bit --> 0...7 */
#define BMI120_USER_CHIP_ID__POS (0)
#define BMI120_USER_CHIP_ID__MSK (0xFF)
#define BMI120_USER_CHIP_ID__LEN (8)
#define BMI120_USER_CHIP_ID__REG (BMI120_USER_CHIP_ID_ADDR)
/* ACCEL CONFIGURATION LENGTH, POSITION AND MASK */
/* Acc_Conf Description - Reg Addr --> (0x40), Bit --> 0...3 */
#define BMI120_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE__POS (0)
#define BMI120_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE__LEN (4)
#define BMI120_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE__MSK (0x0F)
#define BMI120_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE__REG \
(BMI120_USER_ACCEL_CONFIG_ADDR)
/* Acc_Conf Description - Reg Addr --> (0x40), Bit --> 4...6 */
#define BMI120_USER_ACCEL_CONFIG_ACCEL_BW__POS (4)
#define BMI120_USER_ACCEL_CONFIG_ACCEL_BW__LEN (3)
#define BMI120_USER_ACCEL_CONFIG_ACCEL_BW__MSK (0x70)
#define BMI120_USER_ACCEL_CONFIG_ACCEL_BW__REG (BMI120_USER_ACCEL_CONFIG_ADDR)
/* Acc_Conf Description - Reg Addr --> (0x40), Bit --> 7 */
#define BMI120_USER_ACCEL_CONFIG_ACCEL_UNDER_SAMPLING__POS (7)
#define BMI120_USER_ACCEL_CONFIG_ACCEL_UNDER_SAMPLING__LEN (1)
#define BMI120_USER_ACCEL_CONFIG_ACCEL_UNDER_SAMPLING__MSK (0x80)
#define BMI120_USER_ACCEL_CONFIG_ACCEL_UNDER_SAMPLING__REG \
(BMI120_USER_ACCEL_CONFIG_ADDR)
/* Acc_Range Description - Reg Addr --> 0x41, Bit --> 0...3 */
#define BMI120_USER_ACCEL_RANGE__POS (0)
#define BMI120_USER_ACCEL_RANGE__LEN (4)
#define BMI120_USER_ACCEL_RANGE__MSK (0x0F)
#define BMI120_USER_ACCEL_RANGE__REG \
(BMI120_USER_ACCEL_RANGE_ADDR)
/* GYRO CONFIGURATION LENGTH, POSITION AND MASK */
/* Gyro_Conf Description - Reg Addr --> (0x42), Bit --> 0...3 */
#define BMI120_USER_GYRO_CONFIG_OUTPUT_DATA_RATE__POS (0)
#define BMI120_USER_GYRO_CONFIG_OUTPUT_DATA_RATE__LEN (4)
#define BMI120_USER_GYRO_CONFIG_OUTPUT_DATA_RATE__MSK (0x0F)
#define BMI120_USER_GYRO_CONFIG_OUTPUT_DATA_RATE__REG \
(BMI120_USER_GYRO_CONFIG_ADDR)
/* Gyro_Conf Description - Reg Addr --> (0x42), Bit --> 4...5 */
#define BMI120_USER_GYRO_CONFIG_BW__POS (4)
#define BMI120_USER_GYRO_CONFIG_BW__LEN (2)
#define BMI120_USER_GYRO_CONFIG_BW__MSK (0x30)
#define BMI120_USER_GYRO_CONFIG_BW__REG \
(BMI120_USER_GYRO_CONFIG_ADDR)
/* Gyr_Range Description - Reg Addr --> 0x43, Bit --> 0...2 */
#define BMI120_USER_GYRO_RANGE__POS (0)
#define BMI120_USER_GYRO_RANGE__LEN (3)
#define BMI120_USER_GYRO_RANGE__MSK (0x07)
#define BMI120_USER_GYRO_RANGE__REG (BMI120_USER_GYRO_RANGE_ADDR)
/* ACCEL ODR */
#define BMI120_ACCEL_OUTPUT_DATA_RATE_RESERVED (0x00)
#define BMI120_ACCEL_OUTPUT_DATA_RATE_0_78HZ (0x01)
#define BMI120_ACCEL_OUTPUT_DATA_RATE_1_56HZ (0x02)
#define BMI120_ACCEL_OUTPUT_DATA_RATE_3_12HZ (0x03)
#define BMI120_ACCEL_OUTPUT_DATA_RATE_6_25HZ (0x04)
#define BMI120_ACCEL_OUTPUT_DATA_RATE_12_5HZ (0x05)
#define BMI120_ACCEL_OUTPUT_DATA_RATE_25HZ (0x06)
#define BMI120_ACCEL_OUTPUT_DATA_RATE_50HZ (0x07)
#define BMI120_ACCEL_OUTPUT_DATA_RATE_100HZ (0x08)
#define BMI120_ACCEL_OUTPUT_DATA_RATE_200HZ (0x09)
#define BMI120_ACCEL_OUTPUT_DATA_RATE_400HZ (0x0A)
#define BMI120_ACCEL_OUTPUT_DATA_RATE_800HZ (0x0B)
#define BMI120_ACCEL_OUTPUT_DATA_RATE_1600HZ (0x0C)
#define BMI120_ACCEL_OUTPUT_DATA_RATE_RESERVED0 (0x0D)
#define BMI120_ACCEL_OUTPUT_DATA_RATE_RESERVED1 (0x0E)
#define BMI120_ACCEL_OUTPUT_DATA_RATE_RESERVED2 (0x0F)
/* GYRO ODR */
#define BMI120_GYRO_OUTPUT_DATA_RATE_RESERVED (0x00)
#define BMI120_GYRO_OUTPUT_DATA_RATE_25HZ (0x06)
#define BMI120_GYRO_OUTPUT_DATA_RATE_50HZ (0x07)
#define BMI120_GYRO_OUTPUT_DATA_RATE_100HZ (0x08)
#define BMI120_GYRO_OUTPUT_DATA_RATE_200HZ (0x09)
#define BMI120_GYRO_OUTPUT_DATA_RATE_400HZ (0x0A)
#define BMI120_GYRO_OUTPUT_DATA_RATE_800HZ (0x0B)
#define BMI120_GYRO_OUTPUT_DATA_RATE_1600HZ (0x0C)
#define BMI120_GYRO_OUTPUT_DATA_RATE_3200HZ (0x0D)
/* default HZ */
#define BMI120_ACC_DEFAULT_ODR_100HZ (100)
#define BMI120_ACC_DEFAULT_ODR_25HZ (25)
#define BMI120_GYRO_DEFAULT_ODR_100HZ (100)
#define BMI120_GYRO_DEFAULT_ODR_25HZ (25)
/* ACCEL RANGE */
#define BMI120_ACCEL_RANGE_2G (0X03)
#define BMI120_ACCEL_RANGE_4G (0X05)
#define BMI120_ACCEL_RANGE_8G (0X08)
#define BMI120_ACCEL_RANGE_16G (0X0C)
/* ACC sensitivity */
#define BMI120_ACC_SENSITIVITY_2G (16384)
#define BMI120_ACC_SENSITIVITY_4G (8192)
#define BMI120_ACC_SENSITIVITY_8G (4096)
#define BMI120_ACC_SENSITIVITY_16G (2048)
/* GYROSCOPE RANGE PARAMETER */
#define BMI120_GYRO_RANGE_2000_DEG_SEC (0x00)
#define BMI120_GYRO_RANGE_1000_DEG_SEC (0x01)
#define BMI120_GYRO_RANGE_500_DEG_SEC (0x02)
#define BMI120_GYRO_RANGE_250_DEG_SEC (0x03)
#define BMI120_GYRO_RANGE_125_DEG_SEC (0x04)
/* GYRO sensitivity */
#define BMI120_GYRO_SENSITIVITY_125DPS (262)
#define BMI120_GYRO_SENSITIVITY_250DPS (131)
#define BMI120_GYRO_SENSITIVITY_500DPS (66)
#define BMI120_GYRO_SENSITIVITY_1000DPS (33)
#define BMI120_GYRO_SENSITIVITY_2000DPS (16)
/* ACCEL DATA XYZ LENGTH, POSITION AND MASK */
/* ACC_X (LSB) Description - Reg Addr --> (0x12), Bit --> 0...7 */
#define BMI120_USER_DATA_14_ACCEL_X_LSB__POS (0)
#define BMI120_USER_DATA_14_ACCEL_X_LSB__LEN (8)
#define BMI120_USER_DATA_14_ACCEL_X_LSB__MSK (0xFF)
#define BMI120_USER_DATA_14_ACCEL_X_LSB__REG (BMI120_USER_DATA_14_ADDR)
/* ACC_X (MSB) Description - Reg Addr --> 0x13, Bit --> 0...7 */
#define BMI120_USER_DATA_15_ACCEL_X_MSB__POS (0)
#define BMI120_USER_DATA_15_ACCEL_X_MSB__LEN (8)
#define BMI120_USER_DATA_15_ACCEL_X_MSB__MSK (0xFF)
#define BMI120_USER_DATA_15_ACCEL_X_MSB__REG (BMI120_USER_DATA_15_ADDR)
/* ACC_Y (LSB) Description - Reg Addr --> (0x14), Bit --> 0...7 */
#define BMI120_USER_DATA_16_ACCEL_Y_LSB__POS (0)
#define BMI120_USER_DATA_16_ACCEL_Y_LSB__LEN (8)
#define BMI120_USER_DATA_16_ACCEL_Y_LSB__MSK (0xFF)
#define BMI120_USER_DATA_16_ACCEL_Y_LSB__REG (BMI120_USER_DATA_16_ADDR)
/* ACC_Y (MSB) Description - Reg Addr --> (0x15), Bit --> 0...7 */
#define BMI120_USER_DATA_17_ACCEL_Y_MSB__POS (0)
#define BMI120_USER_DATA_17_ACCEL_Y_MSB__LEN (8)
#define BMI120_USER_DATA_17_ACCEL_Y_MSB__MSK (0xFF)
#define BMI120_USER_DATA_17_ACCEL_Y_MSB__REG (BMI120_USER_DATA_17_ADDR)
/* ACC_Z (LSB) Description - Reg Addr --> 0x16, Bit --> 0...7 */
#define BMI120_USER_DATA_18_ACCEL_Z_LSB__POS (0)
#define BMI120_USER_DATA_18_ACCEL_Z_LSB__LEN (8)
#define BMI120_USER_DATA_18_ACCEL_Z_LSB__MSK (0xFF)
#define BMI120_USER_DATA_18_ACCEL_Z_LSB__REG (BMI120_USER_DATA_18_ADDR)
/* ACC_Z (MSB) Description - Reg Addr --> (0x17), Bit --> 0...7 */
#define BMI120_USER_DATA_19_ACCEL_Z_MSB__POS (0)
#define BMI120_USER_DATA_19_ACCEL_Z_MSB__LEN (8)
#define BMI120_USER_DATA_19_ACCEL_Z_MSB__MSK (0xFF)
#define BMI120_USER_DATA_19_ACCEL_Z_MSB__REG (BMI120_USER_DATA_19_ADDR)
/* GYRO DATA XYZ LENGTH, POSITION AND MASK */
/* GYR_X (LSB) Description - Reg Addr --> (0x0C), Bit --> 0...7 */
#define BMI120_USER_DATA_8_GYRO_X_LSB__POS (0)
#define BMI120_USER_DATA_8_GYRO_X_LSB__LEN (8)
#define BMI120_USER_DATA_8_GYRO_X_LSB__MSK (0xFF)
#define BMI120_USER_DATA_8_GYRO_X_LSB__REG (BMI120_USER_DATA_8_ADDR)
/* GYR_X (MSB) Description - Reg Addr --> (0x0D), Bit --> 0...7 */
#define BMI120_USER_DATA_9_GYRO_X_MSB__POS (0)
#define BMI120_USER_DATA_9_GYRO_X_MSB__LEN (8)
#define BMI120_USER_DATA_9_GYRO_X_MSB__MSK (0xFF)
#define BMI120_USER_DATA_9_GYRO_X_MSB__REG (BMI120_USER_DATA_9_ADDR)
/* GYR_Y (LSB) Description - Reg Addr --> 0x0E, Bit --> 0...7 */
#define BMI120_USER_DATA_10_GYRO_Y_LSB__POS (0)
#define BMI120_USER_DATA_10_GYRO_Y_LSB__LEN (8)
#define BMI120_USER_DATA_10_GYRO_Y_LSB__MSK (0xFF)
#define BMI120_USER_DATA_10_GYRO_Y_LSB__REG (BMI120_USER_DATA_10_ADDR)
/* GYR_Y (MSB) Description - Reg Addr --> (0x0F), Bit --> 0...7 */
#define BMI120_USER_DATA_11_GYRO_Y_MSB__POS (0)
#define BMI120_USER_DATA_11_GYRO_Y_MSB__LEN (8)
#define BMI120_USER_DATA_11_GYRO_Y_MSB__MSK (0xFF)
#define BMI120_USER_DATA_11_GYRO_Y_MSB__REG (BMI120_USER_DATA_11_ADDR)
/* GYR_Z (LSB) Description - Reg Addr --> (0x10), Bit --> 0...7 */
#define BMI120_USER_DATA_12_GYRO_Z_LSB__POS (0)
#define BMI120_USER_DATA_12_GYRO_Z_LSB__LEN (8)
#define BMI120_USER_DATA_12_GYRO_Z_LSB__MSK (0xFF)
#define BMI120_USER_DATA_12_GYRO_Z_LSB__REG (BMI120_USER_DATA_12_ADDR)
/* GYR_Z (MSB) Description - Reg Addr --> (0x11), Bit --> 0...7 */
#define BMI120_USER_DATA_13_GYRO_Z_MSB__POS (0)
#define BMI120_USER_DATA_13_GYRO_Z_MSB__LEN (8)
#define BMI120_USER_DATA_13_GYRO_Z_MSB__MSK (0xFF)
#define BMI120_USER_DATA_13_GYRO_Z_MSB__REG (BMI120_USER_DATA_13_ADDR)
/* SHIFT VALUE DEFINITION */
#define BMI120_SHIFT_BIT_POSITION_BY_01_BIT (1)
#define BMI120_SHIFT_BIT_POSITION_BY_02_BITS (2)
#define BMI120_SHIFT_BIT_POSITION_BY_03_BITS (3)
#define BMI120_SHIFT_BIT_POSITION_BY_04_BITS (4)
#define BMI120_SHIFT_BIT_POSITION_BY_05_BITS (5)
#define BMI120_SHIFT_BIT_POSITION_BY_06_BITS (6)
#define BMI120_SHIFT_BIT_POSITION_BY_07_BITS (7)
#define BMI120_SHIFT_BIT_POSITION_BY_08_BITS (8)
#define BMI120_SHIFT_BIT_POSITION_BY_09_BITS (9)
#define BMI120_SHIFT_BIT_POSITION_BY_12_BITS (12)
#define BMI120_SHIFT_BIT_POSITION_BY_13_BITS (13)
#define BMI120_SHIFT_BIT_POSITION_BY_14_BITS (14)
#define BMI120_SHIFT_BIT_POSITION_BY_15_BITS (15)
#define BMI120_SHIFT_BIT_POSITION_BY_16_BITS (16)
/* BIT SLICE GET AND SET FUNCTIONS */
#define BMI120_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##__MSK) >> bitname##__POS)
#define BMI120_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##__MSK) | \
((val<<bitname##__POS)&bitname##__MSK))
static int32_t g_bmi120_acc_factor[ACC_RANGE_MAX] = { BMI120_ACC_SENSITIVITY_2G, BMI120_ACC_SENSITIVITY_4G,
BMI120_ACC_SENSITIVITY_8G, BMI120_ACC_SENSITIVITY_16G
};
static int32_t g_bmi120_gyro_factor[GYRO_RANGE_MAX] = {BMI120_GYRO_SENSITIVITY_125DPS, BMI120_GYRO_SENSITIVITY_250DPS, BMI120_GYRO_SENSITIVITY_500DPS,
BMI120_GYRO_SENSITIVITY_1000DPS, BMI120_GYRO_SENSITIVITY_2000DPS
};
static int32_t g_cur_acc_factor = 0;
static int32_t g_cur_gyro_factor = 0;
static int32_t g_bmi120flag = 0;
i2c_dev_t bmi120_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = BMI120_I2C_ADDR,
};
/**
* This function does the soft reset
*
* @param[in] drv pointer to the i2c dev
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_gyro_bosch_bmi120_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = BMI120_CMD_SOFTRESET;
ret = sensor_i2c_write(drv, BMI120_CMD_COMMANDS__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return -1;
}
return 0;
}
/**
* This function validates the chip ID of device
*
* @param[in] drv pointer to the i2c dev
* @param[in] id_value the expected CHIPID
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_gyro_bosch_bmi120_validate_id(i2c_dev_t* drv,
uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, BMI120_USER_CHIP_ID__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read CHIPID failed \n");
return ret;
}
printf("read CHIPID %x\n", value);
if(id_value != value) {
printf("failed read CHIPID %x\n", value);
//return -1;
}
return 0;
}
/**
* This function sets the acc powermode
*
* @param[in] drv pointer to the i2c dev
* @param[in] mode the powermode to be setted
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi120_set_power_mode(i2c_dev_t* drv,
dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
switch(mode) {
case DEV_POWER_ON: {
value = ACCEL_MODE_NORMAL;
ret = sensor_i2c_write(drv, BMI120_CMD_COMMANDS__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
}
break;
case DEV_POWER_OFF:
case DEV_SLEEP: {
value = ACCEL_SUSPEND;
ret = sensor_i2c_write(drv, BMI120_CMD_COMMANDS__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
}
break;
default:
break;
}
return 0;
}
/**
* This function gets the acc ODR according to HZ
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the frequency required
* @return the conrresponding acc ODR
*/
static uint8_t drv_acc_bosch_bmi120_hz2odr(uint32_t hz)
{
if(hz > 800)
return BMI120_ACCEL_OUTPUT_DATA_RATE_1600HZ;
else if(hz > 400)
return BMI120_ACCEL_OUTPUT_DATA_RATE_800HZ;
else if(hz > 200)
return BMI120_ACCEL_OUTPUT_DATA_RATE_400HZ;
else if(hz > 100)
return BMI120_ACCEL_OUTPUT_DATA_RATE_200HZ;
else if(hz > 50)
return BMI120_ACCEL_OUTPUT_DATA_RATE_100HZ;
else if(hz > 25)
return BMI120_ACCEL_OUTPUT_DATA_RATE_50HZ;
else if(hz > 12)
return BMI120_ACCEL_OUTPUT_DATA_RATE_25HZ;
else if(hz > 6)
return BMI120_ACCEL_OUTPUT_DATA_RATE_12_5HZ;
else if(hz > 3)
return BMI120_ACCEL_OUTPUT_DATA_RATE_6_25HZ;
else if(hz >= 1)
return BMI120_ACCEL_OUTPUT_DATA_RATE_3_12HZ;
else
return BMI120_ACCEL_OUTPUT_DATA_RATE_1_56HZ;
}
/**
* This function sets the acc ODR
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the frequency required
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi120_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_bosch_bmi120_hz2odr(hz);
ret = sensor_i2c_read(drv, BMI120_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE__REG,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return ret;
}
value = BMI120_SET_BITSLICE(value, BMI120_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE,
odr);
ret = sensor_i2c_write(drv, BMI120_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE__REG,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
return 0;
}
/**
* This function sets the acc range
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the range required
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi120_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, BMI120_USER_ACCEL_RANGE__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return ret;
}
switch(range) {
case ACC_RANGE_2G: {
tmp = BMI120_ACCEL_RANGE_2G;
}
break;
case ACC_RANGE_4G: {
tmp = BMI120_ACCEL_RANGE_4G;
}
break;
case ACC_RANGE_8G: {
tmp = BMI120_ACCEL_RANGE_8G;
}
break;
case ACC_RANGE_16G: {
tmp = BMI120_ACCEL_RANGE_16G;
}
break;
default:
break;
}
value = BMI120_SET_BITSLICE(value, BMI120_USER_ACCEL_RANGE, tmp);
ret = sensor_i2c_write(drv, BMI120_USER_ACCEL_RANGE__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)) {
g_cur_acc_factor = g_bmi120_acc_factor[range];
}
return 0;
}
/**
* This function is the ISR
*
* @return
*/
static void drv_acc_bosch_bmi120_irq_handle(void)
{
/* no handle so far */
}
/**
* This function opens the acc
*
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi120_open(void)
{
int ret = 0;
ret = drv_acc_bosch_bmi120_set_power_mode(&bmi120_ctx, DEV_POWER_ON);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_acc_bosch_bmi120_set_range(&bmi120_ctx, ACC_RANGE_8G);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_acc_bosch_bmi120_set_odr(&bmi120_ctx, BMI120_ACC_DEFAULT_ODR_25HZ);
if(unlikely(ret) != 0) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
/**
* This function closes the acc
*
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi120_close(void)
{
int ret = 0;
ret = drv_acc_bosch_bmi120_set_power_mode(&bmi120_ctx, DEV_POWER_OFF);
if(unlikely(ret) != 0) {
return -1;
}
return 0;
}
/**
* This function reads the acc data and reports the data
*
* @param[in out] buf buffer for acc data
* @param[in out] len length of data
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi120_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if(len < size) {
return -1;
}
ret = sensor_i2c_read(&bmi120_ctx, BMI120_USER_DATA_14_ACCEL_X_LSB__REG,
®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi120_ctx, BMI120_USER_DATA_15_ACCEL_X_MSB__REG,
®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi120_ctx, BMI120_USER_DATA_16_ACCEL_Y_LSB__REG,
®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi120_ctx, BMI120_USER_DATA_17_ACCEL_Y_MSB__REG,
®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi120_ctx, BMI120_USER_DATA_18_ACCEL_Z_LSB__REG,
®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi120_ctx, BMI120_USER_DATA_19_ACCEL_Z_MSB__REG,
®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)reg[1])) <<
BMI120_SHIFT_BIT_POSITION_BY_08_BITS) | (reg[0]));
accel->data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)reg[3])) <<
BMI120_SHIFT_BIT_POSITION_BY_08_BITS) | (reg[2]));
accel->data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)reg[5])) <<
BMI120_SHIFT_BIT_POSITION_BY_08_BITS) | (reg[4]));
if(g_cur_acc_factor != 0) {
/* the unit of acc is mg, 1000 mg = 1 g */
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)g_cur_acc_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)g_cur_acc_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)g_cur_acc_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
/**
* This function is for the acc ioctl
*
* @param[in] cmd the ioctl command
* @param[in] arg the correspondding parameter
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi120_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_acc_bosch_bmi120_set_odr(&bmi120_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_acc_bosch_bmi120_set_range(&bmi120_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_bosch_bmi120_set_power_mode(&bmi120_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t*)arg;
info->model = "BMI120";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}
break;
default:
break;
}
return 0;
}
/**
* This function is for the acc initialization
*
* @return the operation status, 0 is OK, others is error
*/
int drv_acc_bosch_bmi120_init(void) {
printf("drv_acc_bosch_bmi120_init started \n");
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_bosch_bmi120_open;
sensor.close = drv_acc_bosch_bmi120_close;
sensor.read = drv_acc_bosch_bmi120_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_bosch_bmi120_ioctl;
sensor.irq_handle = drv_acc_bosch_bmi120_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret) != 0) {
printf("sensor_create_obj failed \n");
return -1;
}
ret = drv_acc_gyro_bosch_bmi120_validate_id(&bmi120_ctx, BMI120_CHIP_ID_VALUE);
if(unlikely(ret) != 0) {
printf("drv_acc_gyro_bosch_bmi120_validate_id failed \n");
return -1;
}
if(0 == g_bmi120flag) {
ret = drv_acc_gyro_bosch_bmi120_soft_reset(&bmi120_ctx);
if(unlikely(ret) != 0) {
printf("drv_acc_gyro_bosch_bmi120_soft_reset failed \n");
return -1;
}
ret = drv_acc_bosch_bmi120_set_power_mode(&bmi120_ctx, DEV_POWER_OFF);
if(unlikely(ret) != 0) {
printf("drv_acc_bosch_bmi120_set_power_mode failed \n");
return -1;
}
g_bmi120flag = 1;
} else {
LOG("%s %s acc do not need reset\n", SENSOR_STR, __func__);
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
printf("drv_acc_bosch_bmi120_init failed \n");
return 0;
}
/**
* This function sets the gyro powermode
*
* @param[in] drv pointer to the i2c dev
* @param[in] mode the powermode to be setted
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi120_set_power_mode(i2c_dev_t* drv,
dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
switch(mode) {
case DEV_POWER_ON: {
value = GYRO_MODE_NORMAL;
ret = sensor_i2c_write(drv, BMI120_CMD_COMMANDS__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
}
break;
case DEV_POWER_OFF:
case DEV_SLEEP: {
value = GYRO_MODE_SUSPEND;
ret = sensor_i2c_write(drv, BMI120_CMD_COMMANDS__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
}
break;
default:
break;
}
return 0;
}
/**
* This function gets the gyro ODR according to HZ
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the frequency required
* @return the conrresponding gyro ODR
*/
static uint8_t drv_gyro_bosch_bmi120_hz2odr(uint32_t hz)
{
if(hz > 1600)
return BMI120_GYRO_OUTPUT_DATA_RATE_3200HZ;
else if(hz > 800)
return BMI120_GYRO_OUTPUT_DATA_RATE_1600HZ;
else if(hz > 400)
return BMI120_GYRO_OUTPUT_DATA_RATE_800HZ;
else if(hz > 200)
return BMI120_GYRO_OUTPUT_DATA_RATE_400HZ;
else if(hz > 100)
return BMI120_GYRO_OUTPUT_DATA_RATE_200HZ;
else if(hz > 50)
return BMI120_GYRO_OUTPUT_DATA_RATE_100HZ;
else if(hz > 25)
return BMI120_GYRO_OUTPUT_DATA_RATE_50HZ;
else
return BMI120_GYRO_OUTPUT_DATA_RATE_25HZ;
}
/**
* This function sets the gyro ODR
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the frequency required
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi120_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_gyro_bosch_bmi120_hz2odr(hz);
ret = sensor_i2c_read(drv, BMI120_USER_GYRO_CONFIG_OUTPUT_DATA_RATE__REG,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return ret;
}
value = BMI120_SET_BITSLICE(value, BMI120_USER_GYRO_CONFIG_OUTPUT_DATA_RATE,
odr);
ret = sensor_i2c_write(drv, BMI120_USER_GYRO_CONFIG_OUTPUT_DATA_RATE__REG,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
return 0;
}
/**
* This function sets the gyro range
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the range required
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi120_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, BMI120_USER_GYRO_RANGE__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return ret;
}
switch(range) {
case GYRO_RANGE_125DPS: {
tmp = BMI120_GYRO_RANGE_125_DEG_SEC;
}
break;
case GYRO_RANGE_250DPS: {
tmp = BMI120_GYRO_RANGE_250_DEG_SEC;
}
break;
case GYRO_RANGE_500DPS: {
tmp = BMI120_GYRO_RANGE_500_DEG_SEC;
}
break;
case GYRO_RANGE_1000DPS: {
tmp = BMI120_GYRO_RANGE_1000_DEG_SEC;
}
break;
case GYRO_RANGE_2000DPS: {
tmp = BMI120_GYRO_RANGE_2000_DEG_SEC;
}
break;
default:
break;
}
value = BMI120_SET_BITSLICE(value, BMI120_USER_GYRO_RANGE, tmp);
ret = sensor_i2c_write(drv, BMI120_USER_GYRO_RANGE__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
if((range >= GYRO_RANGE_250DPS)&&(range <= GYRO_RANGE_2000DPS)) {
g_cur_gyro_factor = g_bmi120_gyro_factor[range];
}
return 0;
}
/**
* This function is ISR
*
* @return
*/
static void drv_gyro_bosch_bmi120_irq_handle(void)
{
/* no handle so far */
}
/**
* This function opens the acc
*
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi120_open(void)
{
int ret = 0;
ret = drv_gyro_bosch_bmi120_set_power_mode(&bmi120_ctx, DEV_POWER_ON);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_gyro_bosch_bmi120_set_range(&bmi120_ctx, GYRO_RANGE_1000DPS);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_gyro_bosch_bmi120_set_odr(&bmi120_ctx, BMI120_GYRO_DEFAULT_ODR_25HZ);
if(unlikely(ret) != 0) {
return -1;
}
return 0;
}
/**
* This function closes the gyro
*
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi120_close(void)
{
int ret = 0;
ret = drv_gyro_bosch_bmi120_set_power_mode(&bmi120_ctx, DEV_POWER_OFF);
if(unlikely(ret) != 0) {
return -1;
}
return 0;
}
/**
* This function reads the gyro data and reports the data
*
* @param[in out] buf buffer for gyro data
* @param[in out] len length of data
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi120_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
gyro_data_t *gyro = (gyro_data_t *)buf;
if(buf == NULL) {
return -1;
}
size = sizeof(gyro_data_t);
if(len < size) {
return -1;
}
ret = sensor_i2c_read(&bmi120_ctx, BMI120_USER_DATA_8_GYRO_X_LSB__REG,
®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi120_ctx, BMI120_USER_DATA_9_GYRO_X_MSB__REG,
®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi120_ctx, BMI120_USER_DATA_10_GYRO_Y_LSB__REG,
®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi120_ctx, BMI120_USER_DATA_11_GYRO_Y_MSB__REG,
®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi120_ctx, BMI120_USER_DATA_12_GYRO_Z_LSB__REG,
®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi120_ctx, BMI120_USER_DATA_13_GYRO_Z_MSB__REG,
®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return -1;
}
gyro->data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)reg[1])) <<
BMI120_SHIFT_BIT_POSITION_BY_08_BITS) | (reg[0]));
gyro->data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)reg[3])) <<
BMI120_SHIFT_BIT_POSITION_BY_08_BITS) | (reg[2]));
gyro->data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)reg[5])) <<
BMI120_SHIFT_BIT_POSITION_BY_08_BITS) | (reg[4]));
if(g_cur_gyro_factor != 0) {
gyro->data[DATA_AXIS_X] = gyro->data[DATA_AXIS_X] * GYROSCOPE_UNIT_FACTOR /
g_cur_gyro_factor;
gyro->data[DATA_AXIS_Y] = gyro->data[DATA_AXIS_Y] * GYROSCOPE_UNIT_FACTOR /
g_cur_gyro_factor;
gyro->data[DATA_AXIS_Z] = gyro->data[DATA_AXIS_Z] * GYROSCOPE_UNIT_FACTOR /
g_cur_gyro_factor;
}
gyro->timestamp = aos_now_ms();
return (int)size;
}
/**
* This function is for the gyro ioctl
*
* @param[in] cmd the ioctl command
* @param[in] arg the correspondding parameter
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi120_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_gyro_bosch_bmi120_set_odr(&bmi120_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_gyro_bosch_bmi120_set_range(&bmi120_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_gyro_bosch_bmi120_set_power_mode(&bmi120_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMI120";
info->range_max = 2000;
info->range_min = 125;
info->unit = udps;
}
break;
default:
break;
}
return 0;
}
/**
* This function is for the gyro initialization
*
* @return the operation status, 0 is OK, others is error
*/
int drv_gyro_bosch_bmi120_init(void) {
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_GYRO;
sensor.path = dev_gyro_path;
sensor.open = drv_gyro_bosch_bmi120_open;
sensor.close = drv_gyro_bosch_bmi120_close;
sensor.read = drv_gyro_bosch_bmi120_read;
sensor.write = NULL;
sensor.ioctl = drv_gyro_bosch_bmi120_ioctl;
sensor.irq_handle = drv_gyro_bosch_bmi120_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_acc_gyro_bosch_bmi120_validate_id(&bmi120_ctx, BMI120_CHIP_ID_VALUE);
if(unlikely(ret) != 0) {
return -1;
}
if(0 == g_bmi120flag) {
ret = drv_acc_gyro_bosch_bmi120_soft_reset(&bmi120_ctx);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_gyro_bosch_bmi120_set_power_mode(&bmi120_ctx, DEV_POWER_OFF);
if(unlikely(ret) != 0) {
return -1;
}
g_bmi120flag = 1;
} else {
LOG("%s %s gyro do not need reset\n", SENSOR_STR, __func__);
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_bosch_bmi120_init);
SENSOR_DRV_ADD(drv_gyro_bosch_bmi120_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_gyro_bosch_bmi120.c
|
C
|
apache-2.0
| 40,642
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
/*********************************************************************************************
*
*Copyright (C) 2016 - 2020 Bosch Sensortec GmbH
*Redistribution and use in source and binary forms, with or without
*modification, are permitted provided that the following conditions are met:
*Redistributions of source code must retain the above copyright
*notice, this list of conditions and the following disclaimer.
*Redistributions in binary form must reproduce the above copyright
*notice, this list of conditions and the following disclaimer in the
*documentation and/or other materials provided with the distribution.
*Neither the name of the copyright holder nor the names of the
*contributors may be used to endorse or promote products derived from
*this software without specific prior written permission.
*THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
*CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
*IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
*WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
*DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
*OR CONTRIBUTORS BE LIABLE FOR ANY
*DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
*OR CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED TO,
*PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
*LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
*HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
*WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
*(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
*ANY WAY OUT OF THE USE OF THIS
*SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
*The information provided is believed to be accurate and reliable.
*The copyright holder assumes no responsibility
*for the consequences of use
*of such information nor for any infringement of patents or
*other rights of third parties which may result from its use.
*No license is granted by implication or otherwise under any patent or
*patent rights of the copyright holder.
*
*
*******************************************************************************************/
#include "aos/kernel.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define BMI160_I2C_ADDR_TRANS(n) ((n)<<1)
#define BMI160_I2C_SLAVE_ADDR_LOW 0x68
#define BMI160_I2C_ADDR BMI160_I2C_ADDR_TRANS(BMI160_I2C_SLAVE_ADDR_LOW)
/* COMMAND REGISTER */
#define BMI160_CMD_COMMANDS_ADDR (0X7E)
/* CHIP ID */
#define BMI160_USER_CHIP_ID_ADDR (0x00)
/* ACCEL CONFIG REGISTERS FOR ODR, BANDWIDTH AND UNDERSAMPLING */
#define BMI160_USER_ACCEL_CONFIG_ADDR (0X40)
/* ACCEL RANGE */
#define BMI160_USER_ACCEL_RANGE_ADDR (0X41)
/* ACCEL DATA REGISTERS */
#define BMI160_USER_DATA_14_ADDR (0X12)
#define BMI160_USER_DATA_15_ADDR (0X13)
#define BMI160_USER_DATA_16_ADDR (0X14)
#define BMI160_USER_DATA_17_ADDR (0X15)
#define BMI160_USER_DATA_18_ADDR (0X16)
#define BMI160_USER_DATA_19_ADDR (0X17)
/* GYRO DATA REGISTERS */
#define BMI160_USER_DATA_8_ADDR (0X0C)
#define BMI160_USER_DATA_9_ADDR (0X0D)
#define BMI160_USER_DATA_10_ADDR (0X0E)
#define BMI160_USER_DATA_11_ADDR (0X0F)
#define BMI160_USER_DATA_12_ADDR (0X10)
#define BMI160_USER_DATA_13_ADDR (0X11)
#define BMI160_MODE_SWITCHING_DELAY (30)
/* GYRO CONFIG REGISTERS FOR ODR AND BANDWIDTH */
#define BMI160_USER_GYRO_CONFIG_ADDR (0X42)
/* GYRO RANGE */
#define BMI160_USER_GYRO_RANGE_ADDR (0X43)
/* BMI160 CHIPID */
#define BMI160_CHIP_ID_VALUE (0xD1)
/* CMD REGISTERS DEFINITION START */
/* COMMAND REGISTER LENGTH, POSITION AND MASK */
/* Command description address - Reg Addr --> 0x7E, Bit --> 0....7 */
#define BMI160_CMD_COMMANDS__POS (0)
#define BMI160_CMD_COMMANDS__LEN (8)
#define BMI160_CMD_COMMANDS__MSK (0xFF)
#define BMI160_CMD_COMMANDS__REG (BMI160_CMD_COMMANDS_ADDR)
/* CMD */
#define BMI160_CMD_SOFTRESET (0xB6)
/* name ACCEL POWER MODE */
#define ACCEL_MODE_NORMAL (0x11)
#define ACCEL_LOWPOWER (0X12)
#define ACCEL_SUSPEND (0X10)
/* BMI160 Accel power modes */
#define BMI160_ACCEL_SUSPEND 0
#define BMI160_ACCEL_NORMAL_MODE 1
#define BMI160_ACCEL_LOW_POWER 2
/* GYRO POWER MODE */
#define GYRO_MODE_SUSPEND (0x14)
#define GYRO_MODE_NORMAL (0x15)
#define GYRO_MODE_FASTSTARTUP (0x17)
/* CHIP ID LENGTH, POSITION AND MASK */
/* Chip ID Description - Reg Addr --> (0x00), Bit --> 0...7 */
#define BMI160_USER_CHIP_ID__POS (0)
#define BMI160_USER_CHIP_ID__MSK (0xFF)
#define BMI160_USER_CHIP_ID__LEN (8)
#define BMI160_USER_CHIP_ID__REG (BMI160_USER_CHIP_ID_ADDR)
/* ACCEL CONFIGURATION LENGTH, POSITION AND MASK */
/* Acc_Conf Description - Reg Addr --> (0x40), Bit --> 0...3 */
#define BMI160_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE__POS (0)
#define BMI160_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE__LEN (4)
#define BMI160_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE__MSK (0x0F)
#define BMI160_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE__REG \
(BMI160_USER_ACCEL_CONFIG_ADDR)
/* Acc_Conf Description - Reg Addr --> (0x40), Bit --> 4...6 */
#define BMI160_USER_ACCEL_CONFIG_ACCEL_BW__POS (4)
#define BMI160_USER_ACCEL_CONFIG_ACCEL_BW__LEN (3)
#define BMI160_USER_ACCEL_CONFIG_ACCEL_BW__MSK (0x70)
#define BMI160_USER_ACCEL_CONFIG_ACCEL_BW__REG (BMI160_USER_ACCEL_CONFIG_ADDR)
/* Acc_Conf Description - Reg Addr --> (0x40), Bit --> 7 */
#define BMI160_USER_ACCEL_CONFIG_ACCEL_UNDER_SAMPLING__POS (7)
#define BMI160_USER_ACCEL_CONFIG_ACCEL_UNDER_SAMPLING__LEN (1)
#define BMI160_USER_ACCEL_CONFIG_ACCEL_UNDER_SAMPLING__MSK (0x80)
#define BMI160_USER_ACCEL_CONFIG_ACCEL_UNDER_SAMPLING__REG \
(BMI160_USER_ACCEL_CONFIG_ADDR)
/* Acc_Range Description - Reg Addr --> 0x41, Bit --> 0...3 */
#define BMI160_USER_ACCEL_RANGE__POS (0)
#define BMI160_USER_ACCEL_RANGE__LEN (4)
#define BMI160_USER_ACCEL_RANGE__MSK (0x0F)
#define BMI160_USER_ACCEL_RANGE__REG \
(BMI160_USER_ACCEL_RANGE_ADDR)
/* GYRO CONFIGURATION LENGTH, POSITION AND MASK */
/* Gyro_Conf Description - Reg Addr --> (0x42), Bit --> 0...3 */
#define BMI160_USER_GYRO_CONFIG_OUTPUT_DATA_RATE__POS (0)
#define BMI160_USER_GYRO_CONFIG_OUTPUT_DATA_RATE__LEN (4)
#define BMI160_USER_GYRO_CONFIG_OUTPUT_DATA_RATE__MSK (0x0F)
#define BMI160_USER_GYRO_CONFIG_OUTPUT_DATA_RATE__REG \
(BMI160_USER_GYRO_CONFIG_ADDR)
/* Gyro_Conf Description - Reg Addr --> (0x42), Bit --> 4...5 */
#define BMI160_USER_GYRO_CONFIG_BW__POS (4)
#define BMI160_USER_GYRO_CONFIG_BW__LEN (2)
#define BMI160_USER_GYRO_CONFIG_BW__MSK (0x30)
#define BMI160_USER_GYRO_CONFIG_BW__REG \
(BMI160_USER_GYRO_CONFIG_ADDR)
/* Gyr_Range Description - Reg Addr --> 0x43, Bit --> 0...2 */
#define BMI160_USER_GYRO_RANGE__POS (0)
#define BMI160_USER_GYRO_RANGE__LEN (3)
#define BMI160_USER_GYRO_RANGE__MSK (0x07)
#define BMI160_USER_GYRO_RANGE__REG (BMI160_USER_GYRO_RANGE_ADDR)
/* ACCEL ODR */
#define BMI160_ACCEL_OUTPUT_DATA_RATE_RESERVED (0x00)
#define BMI160_ACCEL_OUTPUT_DATA_RATE_0_78HZ (0x01)
#define BMI160_ACCEL_OUTPUT_DATA_RATE_1_56HZ (0x02)
#define BMI160_ACCEL_OUTPUT_DATA_RATE_3_12HZ (0x03)
#define BMI160_ACCEL_OUTPUT_DATA_RATE_6_25HZ (0x04)
#define BMI160_ACCEL_OUTPUT_DATA_RATE_12_5HZ (0x05)
#define BMI160_ACCEL_OUTPUT_DATA_RATE_25HZ (0x06)
#define BMI160_ACCEL_OUTPUT_DATA_RATE_50HZ (0x07)
#define BMI160_ACCEL_OUTPUT_DATA_RATE_100HZ (0x08)
#define BMI160_ACCEL_OUTPUT_DATA_RATE_200HZ (0x09)
#define BMI160_ACCEL_OUTPUT_DATA_RATE_400HZ (0x0A)
#define BMI160_ACCEL_OUTPUT_DATA_RATE_800HZ (0x0B)
#define BMI160_ACCEL_OUTPUT_DATA_RATE_1600HZ (0x0C)
#define BMI160_ACCEL_OUTPUT_DATA_RATE_RESERVED0 (0x0D)
#define BMI160_ACCEL_OUTPUT_DATA_RATE_RESERVED1 (0x0E)
#define BMI160_ACCEL_OUTPUT_DATA_RATE_RESERVED2 (0x0F)
/* GYRO ODR */
#define BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED (0x00)
#define BMI160_GYRO_OUTPUT_DATA_RATE_25HZ (0x06)
#define BMI160_GYRO_OUTPUT_DATA_RATE_50HZ (0x07)
#define BMI160_GYRO_OUTPUT_DATA_RATE_100HZ (0x08)
#define BMI160_GYRO_OUTPUT_DATA_RATE_200HZ (0x09)
#define BMI160_GYRO_OUTPUT_DATA_RATE_400HZ (0x0A)
#define BMI160_GYRO_OUTPUT_DATA_RATE_800HZ (0x0B)
#define BMI160_GYRO_OUTPUT_DATA_RATE_1600HZ (0x0C)
#define BMI160_GYRO_OUTPUT_DATA_RATE_3200HZ (0x0D)
/* default HZ */
#define BMI160_ACC_DEFAULT_ODR_100HZ (100)
#define BMI160_ACC_DEFAULT_ODR_25HZ (25)
#define BMI160_GYRO_DEFAULT_ODR_100HZ (100)
#define BMI160_GYRO_DEFAULT_ODR_25HZ (25)
/* ACCEL RANGE */
#define BMI160_ACCEL_RANGE_2G (0X03)
#define BMI160_ACCEL_RANGE_4G (0X05)
#define BMI160_ACCEL_RANGE_8G (0X08)
#define BMI160_ACCEL_RANGE_16G (0X0C)
/* ACC sensitivity */
#define BMI160_ACC_SENSITIVITY_2G (16384)
#define BMI160_ACC_SENSITIVITY_4G (8192)
#define BMI160_ACC_SENSITIVITY_8G (4096)
#define BMI160_ACC_SENSITIVITY_16G (2048)
/* GYROSCOPE RANGE PARAMETER */
#define BMI160_GYRO_RANGE_2000_DEG_SEC (0x00)
#define BMI160_GYRO_RANGE_1000_DEG_SEC (0x01)
#define BMI160_GYRO_RANGE_500_DEG_SEC (0x02)
#define BMI160_GYRO_RANGE_250_DEG_SEC (0x03)
#define BMI160_GYRO_RANGE_125_DEG_SEC (0x04)
/* GYRO sensitivity */
#define BMI160_GYRO_SENSITIVITY_125DPS (262)
#define BMI160_GYRO_SENSITIVITY_250DPS (131)
#define BMI160_GYRO_SENSITIVITY_500DPS (66)
#define BMI160_GYRO_SENSITIVITY_1000DPS (33)
#define BMI160_GYRO_SENSITIVITY_2000DPS (16)
/* ACCEL DATA XYZ LENGTH, POSITION AND MASK */
/* ACC_X (LSB) Description - Reg Addr --> (0x12), Bit --> 0...7 */
#define BMI160_USER_DATA_14_ACCEL_X_LSB__POS (0)
#define BMI160_USER_DATA_14_ACCEL_X_LSB__LEN (8)
#define BMI160_USER_DATA_14_ACCEL_X_LSB__MSK (0xFF)
#define BMI160_USER_DATA_14_ACCEL_X_LSB__REG (BMI160_USER_DATA_14_ADDR)
/* ACC_X (MSB) Description - Reg Addr --> 0x13, Bit --> 0...7 */
#define BMI160_USER_DATA_15_ACCEL_X_MSB__POS (0)
#define BMI160_USER_DATA_15_ACCEL_X_MSB__LEN (8)
#define BMI160_USER_DATA_15_ACCEL_X_MSB__MSK (0xFF)
#define BMI160_USER_DATA_15_ACCEL_X_MSB__REG (BMI160_USER_DATA_15_ADDR)
/* ACC_Y (LSB) Description - Reg Addr --> (0x14), Bit --> 0...7 */
#define BMI160_USER_DATA_16_ACCEL_Y_LSB__POS (0)
#define BMI160_USER_DATA_16_ACCEL_Y_LSB__LEN (8)
#define BMI160_USER_DATA_16_ACCEL_Y_LSB__MSK (0xFF)
#define BMI160_USER_DATA_16_ACCEL_Y_LSB__REG (BMI160_USER_DATA_16_ADDR)
/* ACC_Y (MSB) Description - Reg Addr --> (0x15), Bit --> 0...7 */
#define BMI160_USER_DATA_17_ACCEL_Y_MSB__POS (0)
#define BMI160_USER_DATA_17_ACCEL_Y_MSB__LEN (8)
#define BMI160_USER_DATA_17_ACCEL_Y_MSB__MSK (0xFF)
#define BMI160_USER_DATA_17_ACCEL_Y_MSB__REG (BMI160_USER_DATA_17_ADDR)
/* ACC_Z (LSB) Description - Reg Addr --> 0x16, Bit --> 0...7 */
#define BMI160_USER_DATA_18_ACCEL_Z_LSB__POS (0)
#define BMI160_USER_DATA_18_ACCEL_Z_LSB__LEN (8)
#define BMI160_USER_DATA_18_ACCEL_Z_LSB__MSK (0xFF)
#define BMI160_USER_DATA_18_ACCEL_Z_LSB__REG (BMI160_USER_DATA_18_ADDR)
/* ACC_Z (MSB) Description - Reg Addr --> (0x17), Bit --> 0...7 */
#define BMI160_USER_DATA_19_ACCEL_Z_MSB__POS (0)
#define BMI160_USER_DATA_19_ACCEL_Z_MSB__LEN (8)
#define BMI160_USER_DATA_19_ACCEL_Z_MSB__MSK (0xFF)
#define BMI160_USER_DATA_19_ACCEL_Z_MSB__REG (BMI160_USER_DATA_19_ADDR)
/* GYRO DATA XYZ LENGTH, POSITION AND MASK */
/* GYR_X (LSB) Description - Reg Addr --> (0x0C), Bit --> 0...7 */
#define BMI160_USER_DATA_8_GYRO_X_LSB__POS (0)
#define BMI160_USER_DATA_8_GYRO_X_LSB__LEN (8)
#define BMI160_USER_DATA_8_GYRO_X_LSB__MSK (0xFF)
#define BMI160_USER_DATA_8_GYRO_X_LSB__REG (BMI160_USER_DATA_8_ADDR)
/* GYR_X (MSB) Description - Reg Addr --> (0x0D), Bit --> 0...7 */
#define BMI160_USER_DATA_9_GYRO_X_MSB__POS (0)
#define BMI160_USER_DATA_9_GYRO_X_MSB__LEN (8)
#define BMI160_USER_DATA_9_GYRO_X_MSB__MSK (0xFF)
#define BMI160_USER_DATA_9_GYRO_X_MSB__REG (BMI160_USER_DATA_9_ADDR)
/* GYR_Y (LSB) Description - Reg Addr --> 0x0E, Bit --> 0...7 */
#define BMI160_USER_DATA_10_GYRO_Y_LSB__POS (0)
#define BMI160_USER_DATA_10_GYRO_Y_LSB__LEN (8)
#define BMI160_USER_DATA_10_GYRO_Y_LSB__MSK (0xFF)
#define BMI160_USER_DATA_10_GYRO_Y_LSB__REG (BMI160_USER_DATA_10_ADDR)
/* GYR_Y (MSB) Description - Reg Addr --> (0x0F), Bit --> 0...7 */
#define BMI160_USER_DATA_11_GYRO_Y_MSB__POS (0)
#define BMI160_USER_DATA_11_GYRO_Y_MSB__LEN (8)
#define BMI160_USER_DATA_11_GYRO_Y_MSB__MSK (0xFF)
#define BMI160_USER_DATA_11_GYRO_Y_MSB__REG (BMI160_USER_DATA_11_ADDR)
/* GYR_Z (LSB) Description - Reg Addr --> (0x10), Bit --> 0...7 */
#define BMI160_USER_DATA_12_GYRO_Z_LSB__POS (0)
#define BMI160_USER_DATA_12_GYRO_Z_LSB__LEN (8)
#define BMI160_USER_DATA_12_GYRO_Z_LSB__MSK (0xFF)
#define BMI160_USER_DATA_12_GYRO_Z_LSB__REG (BMI160_USER_DATA_12_ADDR)
/* GYR_Z (MSB) Description - Reg Addr --> (0x11), Bit --> 0...7 */
#define BMI160_USER_DATA_13_GYRO_Z_MSB__POS (0)
#define BMI160_USER_DATA_13_GYRO_Z_MSB__LEN (8)
#define BMI160_USER_DATA_13_GYRO_Z_MSB__MSK (0xFF)
#define BMI160_USER_DATA_13_GYRO_Z_MSB__REG (BMI160_USER_DATA_13_ADDR)
/* SHIFT VALUE DEFINITION */
#define BMI160_SHIFT_BIT_POSITION_BY_01_BIT (1)
#define BMI160_SHIFT_BIT_POSITION_BY_02_BITS (2)
#define BMI160_SHIFT_BIT_POSITION_BY_03_BITS (3)
#define BMI160_SHIFT_BIT_POSITION_BY_04_BITS (4)
#define BMI160_SHIFT_BIT_POSITION_BY_05_BITS (5)
#define BMI160_SHIFT_BIT_POSITION_BY_06_BITS (6)
#define BMI160_SHIFT_BIT_POSITION_BY_07_BITS (7)
#define BMI160_SHIFT_BIT_POSITION_BY_08_BITS (8)
#define BMI160_SHIFT_BIT_POSITION_BY_09_BITS (9)
#define BMI160_SHIFT_BIT_POSITION_BY_12_BITS (12)
#define BMI160_SHIFT_BIT_POSITION_BY_13_BITS (13)
#define BMI160_SHIFT_BIT_POSITION_BY_14_BITS (14)
#define BMI160_SHIFT_BIT_POSITION_BY_15_BITS (15)
#define BMI160_SHIFT_BIT_POSITION_BY_16_BITS (16)
/* BIT SLICE GET AND SET FUNCTIONS */
#define BMI160_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##__MSK) >> bitname##__POS)
#define BMI160_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##__MSK) | \
((val<<bitname##__POS)&bitname##__MSK))
static int32_t g_bmi160_acc_factor[ACC_RANGE_MAX] = { BMI160_ACC_SENSITIVITY_2G, BMI160_ACC_SENSITIVITY_4G,
BMI160_ACC_SENSITIVITY_8G, BMI160_ACC_SENSITIVITY_16G
};
static int32_t g_bmi160_gyro_factor[GYRO_RANGE_MAX] = {BMI160_GYRO_SENSITIVITY_125DPS, BMI160_GYRO_SENSITIVITY_250DPS, BMI160_GYRO_SENSITIVITY_500DPS,
BMI160_GYRO_SENSITIVITY_1000DPS, BMI160_GYRO_SENSITIVITY_2000DPS
};
static int32_t g_cur_acc_factor = 0;
static int32_t g_cur_gyro_factor = 0;
static int32_t g_bmi160flag = 0;
i2c_dev_t bmi160_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = BMI160_I2C_ADDR,
};
/**
* This function does the soft reset
*
* @param[in] drv pointer to the i2c dev
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_gyro_bosch_bmi160_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = BMI160_CMD_SOFTRESET;
ret = sensor_i2c_write(drv, BMI160_CMD_COMMANDS__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return -1;
}
return 0;
}
/**
* This function validates the chip ID of device
*
* @param[in] drv pointer to the i2c dev
* @param[in] id_value the expected CHIPID
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_gyro_bosch_bmi160_validate_id(i2c_dev_t* drv,
uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, BMI160_USER_CHIP_ID__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read CHIPID failed \n");
return ret;
}
printf("read CHIPID %x\n", value);
if(id_value != value) {
printf("failed read CHIPID %x\n", value);
return -1;
}
return 0;
}
/**
* This function sets the acc powermode
*
* @param[in] drv pointer to the i2c dev
* @param[in] mode the powermode to be setted
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi160_set_power_mode(i2c_dev_t* drv,
dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
switch(mode) {
case DEV_POWER_ON: {
value = ACCEL_MODE_NORMAL;
ret = sensor_i2c_write(drv, BMI160_CMD_COMMANDS__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
}
break;
case DEV_POWER_OFF:
case DEV_SLEEP: {
value = ACCEL_SUSPEND;
ret = sensor_i2c_write(drv, BMI160_CMD_COMMANDS__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
}
break;
default:
break;
}
return 0;
}
/**
* This function gets the acc ODR according to HZ
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the frequency required
* @return the conrresponding acc ODR
*/
static uint8_t drv_acc_bosch_bmi160_hz2odr(uint32_t hz)
{
if(hz > 800)
return BMI160_ACCEL_OUTPUT_DATA_RATE_1600HZ;
else if(hz > 400)
return BMI160_ACCEL_OUTPUT_DATA_RATE_800HZ;
else if(hz > 200)
return BMI160_ACCEL_OUTPUT_DATA_RATE_400HZ;
else if(hz > 100)
return BMI160_ACCEL_OUTPUT_DATA_RATE_200HZ;
else if(hz > 50)
return BMI160_ACCEL_OUTPUT_DATA_RATE_100HZ;
else if(hz > 25)
return BMI160_ACCEL_OUTPUT_DATA_RATE_50HZ;
else if(hz > 12)
return BMI160_ACCEL_OUTPUT_DATA_RATE_25HZ;
else if(hz > 6)
return BMI160_ACCEL_OUTPUT_DATA_RATE_12_5HZ;
else if(hz > 3)
return BMI160_ACCEL_OUTPUT_DATA_RATE_6_25HZ;
else if(hz >= 1)
return BMI160_ACCEL_OUTPUT_DATA_RATE_3_12HZ;
else
return BMI160_ACCEL_OUTPUT_DATA_RATE_1_56HZ;
}
/**
* This function sets the acc ODR
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the frequency required
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi160_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_bosch_bmi160_hz2odr(hz);
ret = sensor_i2c_read(drv, BMI160_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE__REG,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return ret;
}
value = BMI160_SET_BITSLICE(value, BMI160_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE,
odr);
ret = sensor_i2c_write(drv, BMI160_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE__REG,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
return 0;
}
/**
* This function sets the acc range
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the range required
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi160_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, BMI160_USER_ACCEL_RANGE__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return ret;
}
switch(range) {
case ACC_RANGE_2G: {
tmp = BMI160_ACCEL_RANGE_2G;
}
break;
case ACC_RANGE_4G: {
tmp = BMI160_ACCEL_RANGE_4G;
}
break;
case ACC_RANGE_8G: {
tmp = BMI160_ACCEL_RANGE_8G;
}
break;
case ACC_RANGE_16G: {
tmp = BMI160_ACCEL_RANGE_16G;
}
break;
default:
break;
}
value = BMI160_SET_BITSLICE(value, BMI160_USER_ACCEL_RANGE, tmp);
ret = sensor_i2c_write(drv, BMI160_USER_ACCEL_RANGE__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)) {
g_cur_acc_factor = g_bmi160_acc_factor[range];
}
return 0;
}
/**
* This function is the ISR
*
* @return
*/
static void drv_acc_bosch_bmi160_irq_handle(void)
{
/* no handle so far */
}
/**
* This function opens the acc
*
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi160_open(void)
{
int ret = 0;
ret = drv_acc_bosch_bmi160_set_power_mode(&bmi160_ctx, DEV_POWER_ON);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_acc_bosch_bmi160_set_range(&bmi160_ctx, ACC_RANGE_8G);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_acc_bosch_bmi160_set_odr(&bmi160_ctx, BMI160_ACC_DEFAULT_ODR_25HZ);
if(unlikely(ret) != 0) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
/**
* This function closes the acc
*
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi160_close(void)
{
int ret = 0;
ret = drv_acc_bosch_bmi160_set_power_mode(&bmi160_ctx, DEV_POWER_OFF);
if(unlikely(ret) != 0) {
return -1;
}
return 0;
}
/**
* This function reads the acc data and reports the data
*
* @param[in out] buf buffer for acc data
* @param[in out] len length of data
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi160_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if(len < size) {
return -1;
}
ret = sensor_i2c_read(&bmi160_ctx, BMI160_USER_DATA_14_ACCEL_X_LSB__REG,
®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi160_ctx, BMI160_USER_DATA_15_ACCEL_X_MSB__REG,
®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi160_ctx, BMI160_USER_DATA_16_ACCEL_Y_LSB__REG,
®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi160_ctx, BMI160_USER_DATA_17_ACCEL_Y_MSB__REG,
®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi160_ctx, BMI160_USER_DATA_18_ACCEL_Z_LSB__REG,
®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi160_ctx, BMI160_USER_DATA_19_ACCEL_Z_MSB__REG,
®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)reg[1])) <<
BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (reg[0]));
accel->data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)reg[3])) <<
BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (reg[2]));
accel->data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)reg[5])) <<
BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (reg[4]));
if(g_cur_acc_factor != 0) {
/* the unit of acc is mg, 1000 mg = 1 g */
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)g_cur_acc_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)g_cur_acc_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] *
ACCELEROMETER_UNIT_FACTOR / (int32_t)g_cur_acc_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
/**
* This function is for the acc ioctl
*
* @param[in] cmd the ioctl command
* @param[in] arg the correspondding parameter
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi160_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_acc_bosch_bmi160_set_odr(&bmi160_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_acc_bosch_bmi160_set_range(&bmi160_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_bosch_bmi160_set_power_mode(&bmi160_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t*)arg;
info->model = "BMI160";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}
break;
default:
break;
}
return 0;
}
/**
* This function is for the acc initialization
*
* @return the operation status, 0 is OK, others is error
*/
int drv_acc_bosch_bmi160_init(void) {
printf("drv_acc_bosch_bmi160_init started \n");
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_bosch_bmi160_open;
sensor.close = drv_acc_bosch_bmi160_close;
sensor.read = drv_acc_bosch_bmi160_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_bosch_bmi160_ioctl;
sensor.irq_handle = drv_acc_bosch_bmi160_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret) != 0) {
printf("sensor_create_obj failed \n");
return -1;
}
ret = drv_acc_gyro_bosch_bmi160_validate_id(&bmi160_ctx, BMI160_CHIP_ID_VALUE);
if(unlikely(ret) != 0) {
printf("drv_acc_gyro_bosch_bmi160_validate_id failed \n");
return -1;
}
if(0 == g_bmi160flag) {
ret = drv_acc_gyro_bosch_bmi160_soft_reset(&bmi160_ctx);
if(unlikely(ret) != 0) {
printf("drv_acc_gyro_bosch_bmi160_soft_reset failed \n");
return -1;
}
ret = drv_acc_bosch_bmi160_set_power_mode(&bmi160_ctx, DEV_POWER_OFF);
if(unlikely(ret) != 0) {
printf("drv_acc_bosch_bmi160_set_power_mode failed \n");
return -1;
}
g_bmi160flag = 1;
} else {
LOG("%s %s acc do not need reset\n", SENSOR_STR, __func__);
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
printf("drv_acc_bosch_bmi160_init failed \n");
return 0;
}
/**
* This function sets the gyro powermode
*
* @param[in] drv pointer to the i2c dev
* @param[in] mode the powermode to be setted
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi160_set_power_mode(i2c_dev_t* drv,
dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
switch(mode) {
case DEV_POWER_ON: {
value = GYRO_MODE_NORMAL;
ret = sensor_i2c_write(drv, BMI160_CMD_COMMANDS__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
}
break;
case DEV_POWER_OFF:
case DEV_SLEEP: {
value = GYRO_MODE_SUSPEND;
ret = sensor_i2c_write(drv, BMI160_CMD_COMMANDS__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
}
break;
default:
break;
}
return 0;
}
/**
* This function gets the gyro ODR according to HZ
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the frequency required
* @return the conrresponding gyro ODR
*/
static uint8_t drv_gyro_bosch_bmi160_hz2odr(uint32_t hz)
{
if(hz > 1600)
return BMI160_GYRO_OUTPUT_DATA_RATE_3200HZ;
else if(hz > 800)
return BMI160_GYRO_OUTPUT_DATA_RATE_1600HZ;
else if(hz > 400)
return BMI160_GYRO_OUTPUT_DATA_RATE_800HZ;
else if(hz > 200)
return BMI160_GYRO_OUTPUT_DATA_RATE_400HZ;
else if(hz > 100)
return BMI160_GYRO_OUTPUT_DATA_RATE_200HZ;
else if(hz > 50)
return BMI160_GYRO_OUTPUT_DATA_RATE_100HZ;
else if(hz > 25)
return BMI160_GYRO_OUTPUT_DATA_RATE_50HZ;
else
return BMI160_GYRO_OUTPUT_DATA_RATE_25HZ;
}
/**
* This function sets the gyro ODR
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the frequency required
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi160_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_gyro_bosch_bmi160_hz2odr(hz);
ret = sensor_i2c_read(drv, BMI160_USER_GYRO_CONFIG_OUTPUT_DATA_RATE__REG,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return ret;
}
value = BMI160_SET_BITSLICE(value, BMI160_USER_GYRO_CONFIG_OUTPUT_DATA_RATE,
odr);
ret = sensor_i2c_write(drv, BMI160_USER_GYRO_CONFIG_OUTPUT_DATA_RATE__REG,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
return 0;
}
/**
* This function sets the gyro range
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the range required
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi160_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, BMI160_USER_GYRO_RANGE__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return ret;
}
switch(range) {
case GYRO_RANGE_125DPS: {
tmp = BMI160_GYRO_RANGE_125_DEG_SEC;
}
break;
case GYRO_RANGE_250DPS: {
tmp = BMI160_GYRO_RANGE_250_DEG_SEC;
}
break;
case GYRO_RANGE_500DPS: {
tmp = BMI160_GYRO_RANGE_500_DEG_SEC;
}
break;
case GYRO_RANGE_1000DPS: {
tmp = BMI160_GYRO_RANGE_1000_DEG_SEC;
}
break;
case GYRO_RANGE_2000DPS: {
tmp = BMI160_GYRO_RANGE_2000_DEG_SEC;
}
break;
default:
break;
}
value = BMI160_SET_BITSLICE(value, BMI160_USER_GYRO_RANGE, tmp);
ret = sensor_i2c_write(drv, BMI160_USER_GYRO_RANGE__REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
}
if((range >= GYRO_RANGE_125DPS)&&(range <= GYRO_RANGE_2000DPS)) {
g_cur_gyro_factor = g_bmi160_gyro_factor[range];
}
return 0;
}
/**
* This function is ISR
*
* @return
*/
static void drv_gyro_bosch_bmi160_irq_handle(void)
{
/* no handle so far */
}
/**
* This function opens the acc
*
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi160_open(void)
{
int ret = 0;
ret = drv_gyro_bosch_bmi160_set_power_mode(&bmi160_ctx, DEV_POWER_ON);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_gyro_bosch_bmi160_set_range(&bmi160_ctx, GYRO_RANGE_125DPS);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_gyro_bosch_bmi160_set_odr(&bmi160_ctx, BMI160_GYRO_DEFAULT_ODR_25HZ);
if(unlikely(ret) != 0) {
return -1;
}
return 0;
}
/**
* This function closes the gyro
*
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi160_close(void)
{
int ret = 0;
ret = drv_gyro_bosch_bmi160_set_power_mode(&bmi160_ctx, DEV_POWER_OFF);
if(unlikely(ret) != 0) {
return -1;
}
return 0;
}
/**
* This function reads the gyro data and reports the data
*
* @param[in out] buf buffer for gyro data
* @param[in out] len length of data
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi160_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
gyro_data_t *gyro = (gyro_data_t *)buf;
if(buf == NULL) {
return -1;
}
size = sizeof(gyro_data_t);
if(len < size) {
return -1;
}
ret = sensor_i2c_read(&bmi160_ctx, BMI160_USER_DATA_8_GYRO_X_LSB__REG,
®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi160_ctx, BMI160_USER_DATA_9_GYRO_X_MSB__REG,
®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi160_ctx, BMI160_USER_DATA_10_GYRO_Y_LSB__REG,
®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi160_ctx, BMI160_USER_DATA_11_GYRO_Y_MSB__REG,
®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi160_ctx, BMI160_USER_DATA_12_GYRO_Z_LSB__REG,
®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bmi160_ctx, BMI160_USER_DATA_13_GYRO_Z_MSB__REG,
®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
return -1;
}
gyro->data[DATA_AXIS_X] = (int32_t)((((int16_t)((int8_t)reg[1])) <<
BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (reg[0]));
gyro->data[DATA_AXIS_Y] = (int32_t)((((int16_t)((int8_t)reg[3])) <<
BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (reg[2]));
gyro->data[DATA_AXIS_Z] = (int32_t)((((int16_t)((int8_t)reg[5])) <<
BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (reg[4]));
if(g_cur_gyro_factor != 0) {
gyro->data[DATA_AXIS_X] = (int32_t)((int64_t)gyro->data[DATA_AXIS_X] * GYROSCOPE_UNIT_FACTOR /
g_cur_gyro_factor);
gyro->data[DATA_AXIS_Y] = (int32_t)((int64_t)gyro->data[DATA_AXIS_Y] * GYROSCOPE_UNIT_FACTOR /
g_cur_gyro_factor);
gyro->data[DATA_AXIS_Z] = (int32_t)((int64_t)gyro->data[DATA_AXIS_Z] * GYROSCOPE_UNIT_FACTOR /
g_cur_gyro_factor);
}
gyro->timestamp = aos_now_ms();
return (int)size;
}
/**
* This function is for the gyro ioctl
*
* @param[in] cmd the ioctl command
* @param[in] arg the correspondding parameter
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi160_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_gyro_bosch_bmi160_set_odr(&bmi160_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_gyro_bosch_bmi160_set_range(&bmi160_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_gyro_bosch_bmi160_set_power_mode(&bmi160_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMI160";
info->range_max = 2000;
info->range_min = 125;
info->unit = udps;
}
break;
default:
break;
}
return 0;
}
/**
* This function is for the gyro initialization
*
* @return the operation status, 0 is OK, others is error
*/
int drv_gyro_bosch_bmi160_init(void) {
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_GYRO;
sensor.path = dev_gyro_path;
sensor.open = drv_gyro_bosch_bmi160_open;
sensor.close = drv_gyro_bosch_bmi160_close;
sensor.read = drv_gyro_bosch_bmi160_read;
sensor.write = NULL;
sensor.ioctl = drv_gyro_bosch_bmi160_ioctl;
sensor.irq_handle = drv_gyro_bosch_bmi160_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_acc_gyro_bosch_bmi160_validate_id(&bmi160_ctx, BMI160_CHIP_ID_VALUE);
if(unlikely(ret) != 0) {
return -1;
}
if(0 == g_bmi160flag) {
ret = drv_acc_gyro_bosch_bmi160_soft_reset(&bmi160_ctx);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_gyro_bosch_bmi160_set_power_mode(&bmi160_ctx, DEV_POWER_OFF);
if(unlikely(ret) != 0) {
return -1;
}
g_bmi160flag = 1;
} else {
LOG("%s %s gyro do not need reset\n", SENSOR_STR, __func__);
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_bosch_bmi160_init);
SENSOR_DRV_ADD(drv_gyro_bosch_bmi160_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_gyro_bosch_bmi160.c
|
C
|
apache-2.0
| 40,700
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
/*********************************************************************************************
*
*Copyright (C) 2016 - 2020 Bosch Sensortec GmbH
*Redistribution and use in source and binary forms, with or without
*modification, are permitted provided that the following conditions are met:
*Redistributions of source code must retain the above copyright
*notice, this list of conditions and the following disclaimer.
*Redistributions in binary form must reproduce the above copyright
*notice, this list of conditions and the following disclaimer in the
*documentation and/or other materials provided with the distribution.
*Neither the name of the copyright holder nor the names of the
*contributors may be used to endorse or promote products derived from
*this software without specific prior written permission.
*THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
*CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
*IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
*WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
*DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
*OR CONTRIBUTORS BE LIABLE FOR ANY
*DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
*OR CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED TO,
*PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
*LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
*HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
*WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
*(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
*ANY WAY OUT OF THE USE OF THIS
*SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
*The information provided is believed to be accurate and reliable.
*The copyright holder assumes no responsibility
*for the consequences of use
*of such information nor for any infringement of patents or
*other rights of third parties which may result from its use.
*No license is granted by implication or otherwise under any patent or
*patent rights of the copyright holder.
*
*
*******************************************************************************************/
#include "aos/kernel.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define BMI260_I2C_ADDR_TRANS(n) ((n)<<1)
#define BMI260_I2C_SLAVE_ADDR_LOW 0x68
#define BMI260_I2C_ADDR BMI260_I2C_ADDR_TRANS(BMI260_I2C_SLAVE_ADDR_LOW)
/* Utility macros */
#define BMI2_SET_BITS(reg_data, bitname, data) \
((reg_data & ~(bitname##_MASK)) | \
((data << bitname##_POS) & bitname##_MASK))
#define BMI2_GET_BITS(reg_data, bitname) \
((reg_data & (bitname##_MASK)) >> \
(bitname##_POS))
#define BMI2_SET_BIT_POS0(reg_data, bitname, data) \
((reg_data & ~(bitname##_MASK)) | \
(data & bitname##_MASK))
#define BMI2_GET_BIT_POS0(reg_data, bitname) (reg_data & (bitname##_MASK))
#define BMI2_SET_BIT_VAL0(reg_data, bitname) (reg_data & ~(bitname##_MASK))
/* For getting LSB and MSB */
#define BMI2_GET_LSB(var) (uint8_t)(var & BMI2_SET_LOW_BYTE)
#define BMI2_GET_MSB(var) (uint8_t)((var & BMI2_SET_HIGH_BYTE) >> 8)
/* BMI2 register addresses */
#define BMI2_CHIP_ID_ADDR UINT8_C(0x00)
#define BMI260_CHIP_ID UINT8_C(0x20)
#define BMI2_STATUS_ADDR UINT8_C(0x03)
#define BMI2_AUX_X_LSB_ADDR UINT8_C(0x04)
#define BMI2_ACC_X_LSB_ADDR UINT8_C(0x0C)
#define BMI2_GYR_X_LSB_ADDR UINT8_C(0x12)
#define BMI2_EVENT_ADDR UINT8_C(0x1B)
#define BMI2_INT_STATUS_0_ADDR UINT8_C(0x1C)
#define BMI2_INT_STATUS_1_ADDR UINT8_C(0x1D)
#define BMI2_SYNC_COMMAND_ADDR UINT8_C(0x1E)
#define BMI2_CONF_STATUS_ADDR UINT8_C(0x21)
#define BMI2_FIFO_LENGTH_0_ADDR UINT8_C(0X24)
#define BMI2_FIFO_DATA_ADDR UINT8_C(0X26)
#define BMI2_PAGE_REG_ADDR UINT8_C(0x2F)
#define BMI2_FEAT_START_ADDR UINT8_C(0x30)
#define BMI2_ACC_CONF_ADDR UINT8_C(0x40)
#define BMI2_ACC_CONF1_ADDR UINT8_C(0x41)
#define BMI2_GYR_CONF_ADDR UINT8_C(0x42)
#define BMI2_GYR_CONF1_ADDR UINT8_C(0x43)
#define BMI2_AUX_CONF_ADDR UINT8_C(0x44)
#define BMI2_FIFO_DOWN_ADDR UINT8_C(0X45)
#define BMI2_FIFO_WTM_0_ADDR UINT8_C(0X46)
#define BMI2_FIFO_WTM_1_ADDR UINT8_C(0X47)
#define BMI2_FIFO_CONFIG_0_ADDR UINT8_C(0X48)
#define BMI2_FIFO_CONFIG_1_ADDR UINT8_C(0X49)
#define BMI2_AUX_DEV_ID_ADDR UINT8_C(0x4B)
#define BMI2_AUX_IF_CONF_ADDR UINT8_C(0x4C)
#define BMI2_AUX_RD_ADDR UINT8_C(0x4D)
#define BMI2_AUX_WR_ADDR UINT8_C(0x4E)
#define BMI2_AUX_WR_DATA_ADDR UINT8_C(0x4F)
#define BMI2_INT1_IO_CTRL_ADDR UINT8_C(0x53)
#define BMI2_INT2_IO_CTRL_ADDR UINT8_C(0x54)
#define BMI2_INT1_MAP_ADDR UINT8_C(0x56)
#define BMI2_INT2_MAP_ADDR UINT8_C(0x57)
#define BMI2_INT_MAP_HW_ADDR UINT8_C(0x58)
#define BMI2_CONF_CTRL_ADDR UINT8_C(0x59)
#define BMI2_NEXT_LSB_ADDR UINT8_C(0x5B)
#define BMI2_NEXT_MSB_ADDR UINT8_C(0x5C)
#define BMI2_CONF_LOAD_ADDR UINT8_C(0x5E)
#define BMI2_IF_CONF_ADDR UINT8_C(0X6B)
#define BMI2_ACC_SELF_TEST_ADDR UINT8_C(0X6D)
#define BMI2_GYR_OFF_COMP_3_ADDR UINT8_C(0X74)
#define BMI2_GYR_OFF_COMP_EN_ADDR UINT8_C(0X77)
#define BMI2_GYR_USR_GAIN_0_ADDR UINT8_C(0X78)
#define BMI2_PWR_CONF_ADDR UINT8_C(0x7C)
#define BMI2_PWR_CTRL_ADDR UINT8_C(0x7D)
#define BMI2_CMD_REG_ADDR UINT8_C(0x7E)
/* BMI2 Commands */
#define BMI2_USER_DEF_CMD_0 UINT8_C(0x03)
#define BMI2_SOFT_RESET_CMD UINT8_C(0xB6)
#define BMI2_FIFO_FLUSH_CMD UINT8_C(0xB0)
/* Accelerometer Macro Definitions */
/* Accelerometer Bandwidth parameters */
#define BMI2_ACC_OSR4_AVG1 UINT8_C(0x00)
#define BMI2_ACC_OSR2_AVG2 UINT8_C(0x01)
#define BMI2_ACC_NORMAL_AVG4 UINT8_C(0x02)
#define BMI2_ACC_CIC_AVG8 UINT8_C(0x03)
#define BMI2_ACC_RES_AVG16 UINT8_C(0x04)
#define BMI2_ACC_RES_AVG32 UINT8_C(0x05)
#define BMI2_ACC_RES_AVG64 UINT8_C(0x06)
#define BMI2_ACC_RES_AVG128 UINT8_C(0x07)
/* Accelerometer Output Data Rate */
#define BMI2_ACC_ODR_0_78HZ UINT8_C(0x01)
#define BMI2_ACC_ODR_1_56HZ UINT8_C(0x02)
#define BMI2_ACC_ODR_3_12HZ UINT8_C(0x03)
#define BMI2_ACC_ODR_6_25HZ UINT8_C(0x04)
#define BMI2_ACC_ODR_12_5HZ UINT8_C(0x05)
#define BMI2_ACC_ODR_25HZ UINT8_C(0x06)
#define BMI2_ACC_ODR_50HZ UINT8_C(0x07)
#define BMI2_ACC_ODR_100HZ UINT8_C(0x08)
#define BMI2_ACC_ODR_200HZ UINT8_C(0x09)
#define BMI2_ACC_ODR_400HZ UINT8_C(0x0A)
#define BMI2_ACC_ODR_800HZ UINT8_C(0x0B)
#define BMI2_ACC_ODR_1600HZ UINT8_C(0x0C)
/* Accelerometer G Range */
#define BMI2_ACC_RANGE_2G UINT8_C(0x00)
#define BMI2_ACC_RANGE_4G UINT8_C(0x01)
#define BMI2_ACC_RANGE_8G UINT8_C(0x02)
#define BMI2_ACC_RANGE_16G UINT8_C(0x03)
/* Mask definitions for accelerometer configuration register */
#define BMI2_ACC_RANGE_MASK UINT8_C(0x03)
#define BMI2_ACC_ODR_MASK UINT8_C(0x0F)
#define BMI2_ACC_BW_PARAM_MASK UINT8_C(0x70)
#define BMI2_ACC_PERF_MODE_MASK UINT8_C(0x80)
/* Bit position definitions for accelerometer configuration register */
#define BMI2_ACC_BW_PARAM_POS UINT8_C(0x04)
#define BMI2_ACC_PERF_MODE_POS UINT8_C(0x07)
/* Self test macro to show resulting minimum difference signal in mg */
#define BMI2_ST_ACC_X_AXIS_SIGNAL_DIFF UINT16_C(1800)
#define BMI2_ST_ACC_Y_AXIS_SIGNAL_DIFF UINT16_C(1800)
#define BMI2_ST_ACC_Z_AXIS_SIGNAL_DIFF UINT16_C(1800)
/* Mask definitions for accelerometer self-test */
#define BMI2_ACC_SELF_TEST_EN_MASK UINT8_C(0x01)
#define BMI2_ACC_SELF_TEST_SIGN_MASK UINT8_C(0x04)
#define BMI2_ACC_SELF_TEST_AMP_MASK UINT8_C(0x08)
/* Bit Positions for accelerometer self-test */
#define BMI2_ACC_SELF_TEST_SIGN_POS UINT8_C(0x02)
#define BMI2_ACC_SELF_TEST_AMP_POS UINT8_C(0x03)
/* Gyroscope Macro Definitions */
/* Gyroscope sense drive and low power mode */
/* Senses low power mode */
#define BMI2_GYR_LOW_POWER_MODE UINT8_C(0x00)
/* Select drive */
#define BMI2_GYR_HIGH_PERF_MODE UINT8_C(0x01)
/* Gyroscope Bandwidth parameters */
#define BMI2_GYR_OSR4_MODE UINT8_C(0x00)
#define BMI2_GYR_OSR2_MODE UINT8_C(0x01)
#define BMI2_GYR_NORMAL_MODE UINT8_C(0x02)
#define BMI2_GYR_CIC_MODE UINT8_C(0x03)
/* Gyroscope Output Data Rate */
#define BMI2_GYR_ODR_25HZ UINT8_C(0x06)
#define BMI2_GYR_ODR_50HZ UINT8_C(0x07)
#define BMI2_GYR_ODR_100HZ UINT8_C(0x08)
#define BMI2_GYR_ODR_200HZ UINT8_C(0x09)
#define BMI2_GYR_ODR_400HZ UINT8_C(0x0A)
#define BMI2_GYR_ODR_800HZ UINT8_C(0x0B)
#define BMI2_GYR_ODR_1600HZ UINT8_C(0x0C)
#define BMI2_GYR_ODR_3200HZ UINT8_C(0x0D)
/* Gyroscope OIS Range */
#define BMI2_GYR_OIS_125 UINT8_C(0x00)
#define BMI2_GYR_OIS_2000 UINT8_C(0x01)
/* Gyroscope Angular Rate Measurement Range */
#define BMI2_GYR_RANGE_2000 UINT8_C(0x00)
#define BMI2_GYR_RANGE_1000 UINT8_C(0x01)
#define BMI2_GYR_RANGE_500 UINT8_C(0x02)
#define BMI2_GYR_RANGE_250 UINT8_C(0x03)
#define BMI2_GYR_RANGE_125 UINT8_C(0x04)
/* Mask definitions for gyroscope configuration register */
#define BMI2_GYR_RANGE_MASK UINT8_C(0x07)
#define BMI2_GYR_OIS_RANGE_MASK UINT8_C(0x08)
#define BMI2_GYR_ODR_MASK UINT8_C(0x0F)
#define BMI2_GYR_BW_PARAM_MASK UINT8_C(0x30)
#define BMI2_GYR_DSLP_MASK UINT8_C(0x40)
#define BMI2_GYR_PERF_MODE_MASK UINT8_C(0x80)
/* Bit position definitions for gyroscope configuration register */
#define BMI2_GYR_OIS_RANGE_POS UINT8_C(0x03)
#define BMI2_GYR_BW_PARAM_POS UINT8_C(0x04)
#define BMI2_GYR_DSLP_POS UINT8_C(0x06)
#define BMI2_GYR_PERF_MODE_POS UINT8_C(0x07)
/* default HZ */
#define BMI260_ACC_DEFAULT_ODR_100HZ (100)
#define BMI260_ACC_DEFAULT_ODR_25HZ (25)
#define BMI260_GYRO_DEFAULT_ODR_100HZ (100)
#define BMI260_GYRO_DEFAULT_ODR_25HZ (25)
/* Mask definitions for power control register */
#define BMI2_AUX_EN_MASK UINT8_C(0x01)
#define BMI2_GYR_EN_MASK UINT8_C(0x02)
#define BMI2_ACC_EN_MASK UINT8_C(0x04)
#define BMI2_TEMP_EN_MASK UINT8_C(0x08)
/* Bit position definitions for power control register */
#define BMI2_GYR_EN_POS UINT8_C(0x01)
#define BMI2_ACC_EN_POS UINT8_C(0x02)
#define BMI2_TEMP_EN_POS UINT8_C(0x03)
/* Mask definitions for power configuration register */
#define BMI2_ADV_POW_EN_MASK UINT8_C(0x01)
/* Mask definitions for sensor event flags */
#define BMI2_EVENT_FLAG_MASK UINT8_C(0x1C)
/* Bit position definitions for sensor event flags */
#define BMI2_EVENT_FLAG_POS UINT8_C(0x02)
/* BMI2 sensor data bytes */
#define BMI2_ACC_GYR_NUM_BYTES UINT8_C(6)
#define BMI2_AUX_NUM_BYTES UINT8_C(8)
/* For enable and disable */
#define BMI2_ENABLE UINT8_C(1)
#define BMI2_DISABLE UINT8_C(0)
/* To define success code */
#define BMI2_OK INT8_C(0)
/* To define error codes */
#define BMI2_E_NULL_PTR INT8_C(-1)
#define BMI2_E_COM_FAIL INT8_C(-2)
#define BMI2_E_DEV_NOT_FOUND INT8_C(-3)
#define BMI2_E_OUT_OF_RANGE INT8_C(-4)
#define BMI2_E_ACC_INVALID_CFG INT8_C(-5)
#define BMI2_E_GYRO_INVALID_CFG INT8_C(-6)
#define BMI2_E_ACC_GYR_INVALID_CFG INT8_C(-7)
#define BMI2_E_INVALID_SENSOR INT8_C(-8)
#define BMI2_E_CONFIG_LOAD INT8_C(-9)
#define BMI2_E_INVALID_PAGE INT8_C(-11)
#define BMI2_E_INVALID_FEAT_INT INT8_C(-12)
#define BMI2_E_INVALID_INT_PIN INT8_C(-13)
#define BMI2_E_SET_APS_FAIL INT8_C(-14)
#define BMI2_E_AUX_INVALID_CFG INT8_C(-15)
#define BMI2_E_AUX_BUSY INT8_C(-16)
#define BMI2_E_SELF_TEST_FAIL INT8_C(-17)
#define BMI2_E_REMAP_ERROR INT8_C(-18)
#define BMI2_E_GYR_USER_GAIN_UPD_FAIL INT8_C(-19)
enum bmi2_sensor_config_error_e {
BMI2_NO_ERROR,
BMI2_ACC_ERROR,
BMI2_GYR_ERROR,
BMI2_ACC_GYR_ERROR
};
i2c_dev_t bmi260_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = BMI260_I2C_ADDR,
};
static int g_gyro_active_count = 0;
static int g_acc_active_count = 0;
static int32_t g_bmi260_acc_factor[ACC_RANGE_MAX] = { 16384, 8192, 4096, 2048 };
static int32_t g_bmi260_gyro_factor[GYRO_RANGE_MAX] = {262, 131, 65, 33, 16 };
static int32_t g_cur_acc_factor = 0;
static int32_t g_cur_gyro_factor = 0;
static int32_t g_bmi260flag = 0;
/**
* This function shows the error status when illegal sensor
* configuration is set.
* @param[in] drv pointer to the i2c dev
* @return the operation status, 0 is OK, others is error
*/
static int8_t cfg_error_status(i2c_dev_t* drv)
{
int8_t rslt = 0; /* Variable to define error */
int ret;
uint8_t reg_data; /* Variable to store data */
/* Get error status of the set sensor configuration */
ret = sensor_i2c_read(drv, BMI2_EVENT_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read CHIPID failed \n");
rslt = BMI2_E_COM_FAIL;
return rslt;
}
reg_data = BMI2_GET_BITS(reg_data, BMI2_EVENT_FLAG);
switch(reg_data) {
case BMI2_NO_ERROR:
rslt = BMI2_OK;
break;
case BMI2_ACC_ERROR:
rslt = BMI2_E_ACC_INVALID_CFG;
break;
case BMI2_GYR_ERROR:
rslt = BMI2_E_GYRO_INVALID_CFG;
break;
case BMI2_ACC_GYR_ERROR:
rslt = BMI2_E_ACC_GYR_INVALID_CFG;
break;
default:
break;
}
return rslt;
}
/**
* This function does the soft reset
*
* @param[in] drv pointer to the i2c dev
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_gyro_bosch_bmi260_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = BMI2_SOFT_RESET_CMD;
ret = sensor_i2c_write(drv, BMI2_CMD_REG_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(2);
if(unlikely(ret) != 0) {
return -1;
}
return 0;
}
/**
* This function validates the chip ID of device
*
* @param[in] drv pointer to the i2c dev
* @param[in] id_value the expected CHIPID
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_gyro_bosch_bmi260_validate_id(i2c_dev_t* drv,
uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, BMI2_CHIP_ID_ADDR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read CHIPID failed \n");
return ret;
}
printf("!!!!!!read CHIPID %x\n", value);
if(id_value != (value & 0x20)) {
printf("!!!!!failed read CHIPID %x\n", value);
return -1;
}
return 0;
}
/**
* This function enables the acc and gyro
*
* @param[in] drv pointer to the i2c dev
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_gyro_bosch_bmi260_enable(i2c_dev_t* drv)
{
int ret = 0;
uint8_t reg_data = 0; /* Variable to store register values */
uint8_t aps_status = 0; /* Variable to store adv power status */
int8_t rslt = 0; /* Variable to define error */
if(drv == NULL) {
return -1;
}
/* first enable ACC and GYRO */
ret = sensor_i2c_read(drv, BMI2_PWR_CTRL_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CTRL failed \n");
return ret;
}
/* enable ACC */
reg_data = BMI2_SET_BITS(reg_data, BMI2_ACC_EN, BMI2_ENABLE);
/* enable GYRO */
reg_data = BMI2_SET_BITS(reg_data, BMI2_GYR_EN, BMI2_ENABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CTRL_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CTRL failed \n");
return ret;
}
/* Get status of advance power save mode */
ret = sensor_i2c_read(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
aps_status = BMI2_GET_BIT_POS0(reg_data, BMI2_ADV_POW_EN);
if((aps_status == BMI2_ENABLE)) {
/* Disable advance power save if enabled */
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_DISABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
/* get ACC_CONFIG */
ret = sensor_i2c_read(drv, BMI2_ACC_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read BMI2_ACC_CONF_ADDR failed \n");
return ret;
}
/* enable accelerometer performance mode */
reg_data = BMI2_SET_BITS(reg_data, BMI2_ACC_PERF_MODE, BMI2_ENABLE);
/* Write accelerometer configuration to ACC_CONF */
ret = sensor_i2c_write(drv, BMI2_ACC_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write BMI2_ACC_CONF_ADDR failed \n");
return ret;
}
/* Get error status to check for invalid configurations */
rslt = cfg_error_status(drv);
if(rslt != BMI2_OK) {
printf("setting ACC failed, rslt = %d\n", rslt);
ret = -1;
return ret;
}
/* get GYRO_CONFIG */
ret = sensor_i2c_read(drv, BMI2_GYR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read BMI2_GYR_CONF_ADDR failed \n");
return ret;
}
/* enable gyroscope performance mode */
reg_data = BMI2_SET_BITS(reg_data, BMI2_GYR_PERF_MODE, BMI2_ENABLE);
/* disable gyroscope high performance/low-power mode */
reg_data = BMI2_SET_BITS(reg_data, BMI2_GYR_DSLP, BMI2_DISABLE);
/* Write accelerometer configuration to GYR_CONF */
ret = sensor_i2c_write(drv, BMI2_GYR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write BMI2_GYR_CONF_ADDR failed \n");
return ret;
}
/* Get error status to check for invalid configurations */
rslt = cfg_error_status(drv);
if(rslt != BMI2_OK) {
printf("setting GYRO failed, rslt = %d\n", rslt);
ret = -1;
return ret;
}
/* enable advance power save if needed */
if(aps_status == BMI2_ENABLE) {
/* Get status of advance power save mode */
ret = sensor_i2c_read(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_ENABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
return 0;
}
/**
* This function disables the acc and gyro
*
* @param[in] drv pointer to the i2c dev
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_gyro_bosch_bmi260_disable(i2c_dev_t* drv)
{
int ret = 0;
uint8_t reg_data = 0; /* Variable to store register values */
uint8_t aps_status = 0; /* Variable to store adv power status */
if(drv == NULL) {
return -1;
}
/* first disable ACC and GYRO */
ret = sensor_i2c_read(drv, BMI2_PWR_CTRL_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CTRL failed \n");
return ret;
}
/* disable ACC */
reg_data = BMI2_SET_BIT_VAL0(reg_data, BMI2_ACC_EN);
/* disable GYRO */
reg_data = BMI2_SET_BIT_VAL0(reg_data, BMI2_GYR_EN);
ret = sensor_i2c_write(drv, BMI2_PWR_CTRL_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CTRL failed \n");
return ret;
}
/* Get status of advance power save mode */
ret = sensor_i2c_read(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
aps_status = BMI2_GET_BIT_POS0(reg_data, BMI2_ADV_POW_EN);
if((aps_status == BMI2_DISABLE)) {
/* enable advance power save if disabled */
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_ENABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
return 0;
}
/**
* This function enables the acc
*
* @param[in] drv pointer to the i2c dev
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi260_enable(i2c_dev_t* drv)
{
int ret = 0;
uint8_t reg_data = 0; /* Variable to store register values */
uint8_t aps_status = 0; /* Variable to store adv power status */
int8_t rslt = 0; /* Variable to define error */
if(drv == NULL) {
return -1;
}
/* first enable ACC and GYRO */
ret = sensor_i2c_read(drv, BMI2_PWR_CTRL_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CTRL failed \n");
return ret;
}
/* enable ACC */
reg_data = BMI2_SET_BITS(reg_data, BMI2_ACC_EN, BMI2_ENABLE);
/* enable GYRO */
reg_data = BMI2_SET_BITS(reg_data, BMI2_GYR_EN, BMI2_DISABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CTRL_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CTRL failed \n");
return ret;
}
/* Get status of advance power save mode */
ret = sensor_i2c_read(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
aps_status = BMI2_GET_BIT_POS0(reg_data, BMI2_ADV_POW_EN);
if((aps_status == BMI2_ENABLE)) {
/* Disable advance power save if enabled */
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_DISABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
/* get ACC_CONFIG */
ret = sensor_i2c_read(drv, BMI2_ACC_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read BMI2_ACC_CONF_ADDR failed \n");
return ret;
}
/* enable accelerometer performance mode */
reg_data = BMI2_SET_BITS(reg_data, BMI2_ACC_PERF_MODE, BMI2_ENABLE);
/* Write accelerometer configuration to ACC_CONF */
ret = sensor_i2c_write(drv, BMI2_ACC_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write BMI2_ACC_CONF_ADDR failed \n");
return ret;
}
/* Get error status to check for invalid configurations */
rslt = cfg_error_status(drv);
if(rslt != BMI2_OK) {
printf("setting ACC failed, rslt = %d\n", rslt);
ret = -1;
return ret;
}
/* enable advance power save if needed */
if(aps_status == BMI2_ENABLE) {
/* Get status of advance power save mode */
ret = sensor_i2c_read(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_ENABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
return 0;
}
/**
* This function sets the acc powermode
*
* @param[in] drv pointer to the i2c dev
* @param[in] mode the powermode to be setted
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi260_set_power_mode(i2c_dev_t* drv,
dev_power_mode_e mode)
{
int ret = 0;
switch(mode) {
case DEV_POWER_ON: {
if(g_gyro_active_count > 0) {
/* use IMU setting */
ret = drv_acc_gyro_bosch_bmi260_enable(drv);
} else if(g_gyro_active_count == 0) {
/* use ACC only setting */
ret = drv_acc_bosch_bmi260_enable(drv);
} else {
printf("g_gyro_active_count error gyro_active_count %d\n",
g_gyro_active_count);
ret = -1;
}
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
} else {
if(g_acc_active_count == 0)
g_acc_active_count++;
}
}
break;
case DEV_POWER_OFF:
case DEV_SLEEP: {
if(g_gyro_active_count >= 0) {
ret = drv_acc_gyro_bosch_bmi260_disable(drv);
} else {
printf("g_gyro_active_count error g_gyro_active_count %d\n",
g_gyro_active_count);
ret = -1;
}
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
} else {
if(g_acc_active_count > 0)
g_acc_active_count = 0;
}
}
break;
default:
break;
}
return 0;
}
/**
* This function gets the XYZ data of acc
*
* @param[in] drv pointer to the i2c dev
* @param[in out] x pointer to the acc x data
* @param[in out] y pointer to the acc y data
* @param[in out] z pointer to the acc z data
* @return the operation status, 0 is OK, others is error
*/
static uint8_t drv_acc_bosch_bmi260_getXYZ(i2c_dev_t* drv, int16_t* x,
int16_t* y, int16_t* z)
{
int ret = 0;
uint8_t msb; /* Variables to store msb value */
uint8_t lsb; /* Variables to store lsb value */
uint16_t msb_lsb; /* Variables to store both msb and lsb value */
uint8_t index = 0; /* Variables to define index */
uint8_t reg_data[BMI2_ACC_GYR_NUM_BYTES] = {0}; /* Array to define data stored in register */
ret = sensor_i2c_read(drv, BMI2_ACC_X_LSB_ADDR, ®_data[0],
BMI2_ACC_GYR_NUM_BYTES, I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read BMI2_GYR_CONF_ADDR failed \n");
return ret;
}
/* Read x-axis data */
lsb = reg_data[index++];
msb = reg_data[index++];
msb_lsb = ((uint16_t)msb << 8) | (uint16_t)lsb;
*x = (int16_t)msb_lsb;
/* Read y-axis data */
lsb = reg_data[index++];
msb = reg_data[index++];
msb_lsb = ((uint16_t)msb << 8) | (uint16_t)lsb;
*y = (int16_t)msb_lsb;
/* Read z-axis data */
lsb = reg_data[index++];
msb = reg_data[index++];
msb_lsb = ((uint16_t)msb << 8) | (uint16_t)lsb;
*z = (int16_t)msb_lsb;
return 0;
}
/**
* This function gets the acc ODR according to HZ
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the frequency required
* @return the conrresponding acc ODR
*/
static uint8_t drv_acc_bosch_bmi260_hz2odr(uint32_t hz)
{
if(hz > 800)
return BMI2_ACC_ODR_1600HZ;
else if(hz > 400)
return BMI2_ACC_ODR_800HZ;
else if(hz > 200)
return BMI2_ACC_ODR_400HZ;
else if(hz > 100)
return BMI2_ACC_ODR_200HZ;
else if(hz > 50)
return BMI2_ACC_ODR_100HZ;
else if(hz > 25)
return BMI2_ACC_ODR_50HZ;
else if(hz > 12)
return BMI2_ACC_ODR_25HZ;
else if(hz > 6)
return BMI2_ACC_ODR_12_5HZ;
else if(hz > 3)
return BMI2_ACC_ODR_6_25HZ;
else if(hz >= 1)
return BMI2_ACC_ODR_3_12HZ;
else
return BMI2_ACC_ODR_1_56HZ;
}
/**
* This function sets the acc ODR
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the frequency required
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi260_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t odr = drv_acc_bosch_bmi260_hz2odr(hz);
uint8_t reg_data = 0; /* Variable to store register values */
uint8_t aps_status = 0; /* Variable to store adv power status */
int8_t rslt = 0; /* Variable to define error */
/* Get status of advance power save mode */
ret = sensor_i2c_read(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
aps_status = BMI2_GET_BIT_POS0(reg_data, BMI2_ADV_POW_EN);
if((aps_status == BMI2_ENABLE)) {
/* Disable advance power save if enabled */
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_DISABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
/* set odr nomatter what working mode */
/* get ACC_CONFIG */
ret = sensor_i2c_read(drv, BMI2_ACC_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read BMI2_ACC_CONF_ADDR failed \n");
return ret;
}
/* Set accelerometer ODR */
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ACC_ODR, odr);
/* Write accelerometer configuration to ACC_CONF */
ret = sensor_i2c_write(drv, BMI2_ACC_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write BMI2_ACC_CONF_ADDR failed \n");
return ret;
}
/* Get error status to check for invalid configurations */
rslt = cfg_error_status(drv);
if(rslt != BMI2_OK) {
printf("setting ACC failed, rslt = %d\n", rslt);
ret = -1;
return ret;
}
/* enable advance power save if needed */
if(aps_status == BMI2_ENABLE) {
/* Get status of advance power save mode */
ret = sensor_i2c_read(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_ENABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
return 0;
}
/**
* This function sets the acc range
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the range required
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi260_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t tmp = 0;
uint8_t reg_data = 0; /* Variable to store register values */
uint8_t aps_status = 0; /* Variable to store adv power status */
int8_t rslt = 0; /* Variable to define error */
if(unlikely(ret) != 0) {
return ret;
}
switch(range) {
case ACC_RANGE_2G: {
tmp = BMI2_ACC_RANGE_2G;
}
break;
case ACC_RANGE_4G: {
tmp = BMI2_ACC_RANGE_4G;
}
break;
case ACC_RANGE_8G: {
tmp = BMI2_ACC_RANGE_8G;
}
break;
case ACC_RANGE_16G: {
tmp = BMI2_ACC_RANGE_16G;
}
break;
default:
break;
}
/* Get status of advance power save mode */
ret = sensor_i2c_read(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
aps_status = BMI2_GET_BIT_POS0(reg_data, BMI2_ADV_POW_EN);
if((aps_status == BMI2_ENABLE)) {
/* Disable advance power save if enabled */
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_DISABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
/* set range nomatter what working mode */
/* get ACC_CONFIG1 */
ret = sensor_i2c_read(drv, BMI2_ACC_CONF1_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read BMI2_ACC_CONF1_ADDR failed \n");
return ret;
}
/* Set accelerometer range */
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ACC_RANGE, tmp);
/* Write accelerometer configuration to ACC_CONF1 */
ret = sensor_i2c_write(drv, BMI2_ACC_CONF1_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write BMI2_ACC_CONF_ADDR failed \n");
return ret;
}
/* Get error status to check for invalid configurations */
rslt = cfg_error_status(drv);
if(rslt != BMI2_OK) {
printf("setting ACC failed, rslt = %d\n", rslt);
ret = -1;
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)) {
g_cur_acc_factor = g_bmi260_acc_factor[range];
}
/* enable advance power save if needed */
if(aps_status == BMI2_ENABLE) {
/* Get status of advance power save mode */
ret = sensor_i2c_read(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_ENABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
return 0;
}
/**
* This function is the ISR
*
* @return
*/
static void drv_acc_bosch_bmi260_irq_handle(void)
{
/* no handle so far */
}
/**
* This function opens the acc
*
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi260_open(void)
{
int ret = 0;
ret = drv_acc_bosch_bmi260_set_power_mode(&bmi260_ctx, DEV_POWER_ON);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_acc_bosch_bmi260_set_range(&bmi260_ctx, ACC_RANGE_8G);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_acc_bosch_bmi260_set_odr(&bmi260_ctx, BMI260_ACC_DEFAULT_ODR_25HZ);
if(unlikely(ret) != 0) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
/**
* This function closes the acc
*
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi260_close(void)
{
int ret = 0;
ret = drv_acc_bosch_bmi260_set_power_mode(&bmi260_ctx, DEV_POWER_OFF);
if(unlikely(ret) != 0) {
return -1;
}
return 0;
}
/**
* This function reads the acc data and reports the data
*
* @param[in out] buf buffer for acc data
* @param[in out] len length of data
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi260_read(void *buf, size_t len)
{
int ret = 0;
int ret_getXYZ = 0;
size_t size;
uint8_t reg_data = 0; /* Variable to store register values */
uint8_t aps_status = 0; /* Variable to store adv power status */
int16_t x = 0;
int16_t y = 0;
int16_t z = 0;
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if(len < size) {
return -1;
}
/* Get status of advance power save mode */
ret = sensor_i2c_read(&bmi260_ctx, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
aps_status = BMI2_GET_BIT_POS0(reg_data, BMI2_ADV_POW_EN);
if((aps_status == BMI2_ENABLE)) {
/* Disable advance power save if enabled */
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_DISABLE);
ret = sensor_i2c_write(&bmi260_ctx, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
ret = drv_acc_bosch_bmi260_getXYZ(&bmi260_ctx, &x, &y, &z);
if(unlikely(ret)) {
printf("read ACC XYZ failed \n");
ret_getXYZ = ret;
}
/* enable advance power save if needed */
if(aps_status == BMI2_ENABLE) {
/* Get status of advance power save mode */
ret = sensor_i2c_read(&bmi260_ctx, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_ENABLE);
ret = sensor_i2c_write(&bmi260_ctx, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
if(unlikely(ret_getXYZ)) {
return -1;
}
if(g_cur_acc_factor != 0) {
/* the unit of acc is mg, 1000 mg = 1 g */
accel->data[DATA_AXIS_X] = x * ACCELEROMETER_UNIT_FACTOR /
(int32_t)g_cur_acc_factor;
accel->data[DATA_AXIS_Y] = y * ACCELEROMETER_UNIT_FACTOR /
(int32_t)g_cur_acc_factor;
accel->data[DATA_AXIS_Z] = z * ACCELEROMETER_UNIT_FACTOR /
(int32_t)g_cur_acc_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
/**
* This function is for the acc ioctl
*
* @param[in] cmd the ioctl command
* @param[in] arg the correspondding parameter
* @return the operation status, 0 is OK, others is error
*/
static int drv_acc_bosch_bmi260_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_acc_bosch_bmi260_set_odr(&bmi260_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_acc_bosch_bmi260_set_range(&bmi260_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_bosch_bmi260_set_power_mode(&bmi260_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t*)arg;
info->model = "BMI260";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}
break;
default:
break;
}
return 0;
}
/**
* This function is for the acc initialization
*
* @return the operation status, 0 is OK, others is error
*/
int drv_acc_bosch_bmi260_init(void) {
printf("drv_acc_bosch_bmi260_init started \n");
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_bosch_bmi260_open;
sensor.close = drv_acc_bosch_bmi260_close;
sensor.read = drv_acc_bosch_bmi260_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_bosch_bmi260_ioctl;
sensor.irq_handle = drv_acc_bosch_bmi260_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret) != 0) {
printf("sensor_create_obj failed \n");
return -1;
}
ret = drv_acc_gyro_bosch_bmi260_validate_id(&bmi260_ctx, BMI260_CHIP_ID);
if(unlikely(ret) != 0) {
printf("drv_acc_gyro_bosch_bmi260_validate_id failed \n");
return -1;
}
if(0 == g_bmi260flag) {
ret = drv_acc_gyro_bosch_bmi260_soft_reset(&bmi260_ctx);
if(unlikely(ret) != 0) {
printf("drv_acc_gyro_bosch_bmi260_soft_reset failed \n");
return -1;
}
ret = drv_acc_bosch_bmi260_set_power_mode(&bmi260_ctx, DEV_POWER_OFF);
if(unlikely(ret) != 0) {
printf("drv_acc_bosch_bmi260_set_power_mode failed \n");
return -1;
}
g_bmi260flag = 1;
} else {
LOG("%s %s acc do not need reset\n", SENSOR_STR, __func__);
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
/**
* This function enables the gyro
*
* @param[in] drv pointer to the i2c dev
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi260_enable(i2c_dev_t* drv)
{
int ret = 0;
uint8_t reg_data = 0; /* Variable to store register values */
uint8_t aps_status = 0; /* Variable to store adv power status */
int8_t rslt = 0; /* Variable to define error */
if(drv == NULL) {
return -1;
}
/* first enable ACC and GYRO */
ret = sensor_i2c_read(drv, BMI2_PWR_CTRL_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CTRL failed \n");
return ret;
}
/* enable ACC */
reg_data = BMI2_SET_BITS(reg_data, BMI2_ACC_EN, BMI2_DISABLE);
/* enable GYRO */
reg_data = BMI2_SET_BITS(reg_data, BMI2_GYR_EN, BMI2_ENABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CTRL_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CTRL failed \n");
return ret;
}
/* Get status of advance power save mode */
ret = sensor_i2c_read(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
aps_status = BMI2_GET_BIT_POS0(reg_data, BMI2_ADV_POW_EN);
if((aps_status == BMI2_ENABLE)) {
/* Disable advance power save if enabled */
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_DISABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
/* get GYRO_CONFIG */
ret = sensor_i2c_read(drv, BMI2_GYR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read BMI2_GYR_CONF_ADDR failed \n");
return ret;
}
/* enable gyroscope performance mode */
reg_data = BMI2_SET_BITS(reg_data, BMI2_GYR_PERF_MODE, BMI2_ENABLE);
/* disable gyroscope high performance/low-power mode */
reg_data = BMI2_SET_BITS(reg_data, BMI2_GYR_DSLP, BMI2_DISABLE);
/* Write accelerometer configuration to GYR_CONF */
ret = sensor_i2c_write(drv, BMI2_GYR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write BMI2_GYR_CONF_ADDR failed \n");
return ret;
}
/* Get error status to check for invalid configurations */
rslt = cfg_error_status(drv);
if(rslt != BMI2_OK) {
printf("setting GYRO failed, rslt = %d\n", rslt);
ret = -1;
return ret;
}
/* enable advance power save if needed */
if(aps_status == BMI2_ENABLE) {
/* Get status of advance power save mode */
ret = sensor_i2c_read(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_ENABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
return 0;
}
/**
* This function sets the gyro powermode
*
* @param[in] drv pointer to the i2c dev
* @param[in] mode the powermode to be setted
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi260_set_power_mode(i2c_dev_t* drv,
dev_power_mode_e mode)
{
int ret = 0;
switch(mode) {
case DEV_POWER_ON: {
if(g_acc_active_count > 0) {
/*use IMU setting*/
ret = drv_acc_gyro_bosch_bmi260_enable(drv);
} else if(g_acc_active_count == 0) {
/*use gyro only setting*/
ret = drv_gyro_bosch_bmi260_enable(drv);
} else {
printf("g_acc_active_count error g_acc_active_count %d\n", g_acc_active_count);
ret = -1;
}
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
} else {
if(g_gyro_active_count == 0)
g_gyro_active_count++;
}
}
break;
case DEV_POWER_OFF:
case DEV_SLEEP: {
if(g_acc_active_count >= 0) {
ret = drv_acc_gyro_bosch_bmi260_disable(drv);
} else {
printf("g_acc_active_count error g_acc_active_count %d\n", g_acc_active_count);
ret = -1;
}
aos_msleep(2);
if(unlikely(ret) != 0) {
return ret;
} else {
if(g_gyro_active_count > 0)
g_gyro_active_count = 0;
}
}
break;
default:
break;
}
return 0;
}
/**
* This function gets the XYZ data of gyro
*
* @param[in] drv pointer to the i2c dev
* @param[in out] x pointer to the gyro x data
* @param[in out] y pointer to the gyro y data
* @param[in out] z pointer to the gyro z data
* @return the operation status, 0 is OK, others is error
*/
static uint8_t drv_gyro_bosch_bmi260_getXYZ(i2c_dev_t* drv, int16_t* x,
int16_t* y, int16_t* z)
{
int ret = 0;
uint8_t msb; /* Variables to store msb value */
uint8_t lsb; /* Variables to store lsb value */
uint16_t msb_lsb; /* Variables to store both msb and lsb value */
uint8_t index = 0; /* Variables to define index */
uint8_t reg_data[BMI2_ACC_GYR_NUM_BYTES] = {0}; /* Array to define data stored in register */
ret = sensor_i2c_read(drv, BMI2_GYR_X_LSB_ADDR, ®_data[0],
BMI2_ACC_GYR_NUM_BYTES, I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read BMI2_GYR_CONF_ADDR failed \n");
return ret;
}
/* Read x-axis data */
lsb = reg_data[index++];
msb = reg_data[index++];
msb_lsb = ((uint16_t)msb << 8) | (uint16_t)lsb;
*x = (int16_t)msb_lsb;
/* Read y-axis data */
lsb = reg_data[index++];
msb = reg_data[index++];
msb_lsb = ((uint16_t)msb << 8) | (uint16_t)lsb;
*y = (int16_t)msb_lsb;
/* Read z-axis data */
lsb = reg_data[index++];
msb = reg_data[index++];
msb_lsb = ((uint16_t)msb << 8) | (uint16_t)lsb;
*z = (int16_t)msb_lsb;
return 0;
}
/**
* This function gets the gyro ODR according to HZ
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the frequency required
* @return the conrresponding gyro ODR
*/
static uint8_t drv_gyro_bosch_bmi260_hz2odr(uint32_t hz)
{
if(hz > 1600)
return BMI2_GYR_ODR_3200HZ ;
else if(hz > 800)
return BMI2_GYR_ODR_1600HZ;
else if(hz > 400)
return BMI2_GYR_ODR_800HZ;
else if(hz > 200)
return BMI2_GYR_ODR_400HZ;
else if(hz > 100)
return BMI2_GYR_ODR_200HZ;
else if(hz > 50)
return BMI2_GYR_ODR_100HZ;
else if(hz > 25)
return BMI2_GYR_ODR_50HZ;
else
return BMI2_GYR_ODR_25HZ;
}
/**
* This function sets the gyro ODR
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the frequency required
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi260_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t odr = drv_gyro_bosch_bmi260_hz2odr(hz);
uint8_t reg_data = 0; /* Variable to store register values */
uint8_t aps_status = 0; /* Variable to store adv power status */
int8_t rslt = 0; /* Variable to define error */
/* Get status of advance power save mode */
ret = sensor_i2c_read(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
aps_status = BMI2_GET_BIT_POS0(reg_data, BMI2_ADV_POW_EN);
if((aps_status == BMI2_ENABLE)) {
/* Disable advance power save if enabled */
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_DISABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
/* set gyro ODR setting */
/*get GYRO_CONFIG*/
ret = sensor_i2c_read(drv, BMI2_GYR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read BMI2_GYR_CONF_ADDR failed \n");
return ret;
}
/* Set gyroscope ODR */
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_GYR_ODR, odr);
/* Write configuration to GYR_CONF */
ret = sensor_i2c_write(drv, BMI2_GYR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write BMI2_GYR_CONF_ADDR failed \n");
return ret;
}
/* Get error status to check for invalid configurations */
rslt = cfg_error_status(drv);
if(rslt != BMI2_OK) {
printf("setting GYRO failed, rslt = %d\n", rslt);
ret = -1;
return ret;
}
/* enable advance power save if needed */
if(aps_status == BMI2_ENABLE) {
/* Get status of advance power save mode */
ret = sensor_i2c_read(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_ENABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
return 0;
}
/**
* This function sets the gyro range
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the range required
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi260_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t tmp = 0;
uint8_t reg_data = 0; /* Variable to store register values */
uint8_t aps_status = 0; /* Variable to store adv power status */
int8_t rslt = 0; /* Variable to define error */
switch(range) {
case GYRO_RANGE_125DPS: {
tmp = BMI2_GYR_RANGE_125;
}
break;
case GYRO_RANGE_250DPS: {
tmp = BMI2_GYR_RANGE_250;
}
break;
case GYRO_RANGE_500DPS: {
tmp = BMI2_GYR_RANGE_500;
}
break;
case GYRO_RANGE_1000DPS: {
tmp = BMI2_GYR_RANGE_1000;
}
break;
case GYRO_RANGE_2000DPS: {
tmp = BMI2_GYR_RANGE_2000;
}
break;
default:
break;
}
/* Get status of advance power save mode */
ret = sensor_i2c_read(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
aps_status = BMI2_GET_BIT_POS0(reg_data, BMI2_ADV_POW_EN);
if((aps_status == BMI2_ENABLE)) {
/* Disable advance power save if enabled */
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_DISABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
/* set gyro range setting */
/* get GYRO_CONFIG1 */
ret = sensor_i2c_read(drv, BMI2_GYR_CONF1_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read BMI2_GYR_CONF1_ADDR failed \n");
return ret;
}
/* Set gyroscope range */
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_GYR_RANGE, tmp);
/* Write configuration to GYR_CONF1 */
ret = sensor_i2c_write(drv, BMI2_GYR_CONF1_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write BMI2_GYR_CONF1_ADDR failed \n");
return ret;
}
/* Get error status to check for invalid configurations */
rslt = cfg_error_status(drv);
if(rslt != BMI2_OK) {
printf("setting GYRO failed, rslt = %d\n", rslt);
ret = -1;
return ret;
}
if((range >= GYRO_RANGE_250DPS)&&(range <= GYRO_RANGE_2000DPS)) {
g_cur_gyro_factor = g_bmi260_gyro_factor[range];
}
/* enable advance power save if needed */
if(aps_status == BMI2_ENABLE) {
/* Get status of advance power save mode */
ret = sensor_i2c_read(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_ENABLE);
ret = sensor_i2c_write(drv, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
return 0;
}
/**
* This function is ISR
*
* @return
*/
static void drv_gyro_bosch_bmi260_irq_handle(void)
{
/* no handle so far */
}
/**
* This function opens the acc
*
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi260_open(void)
{
int ret = 0;
ret = drv_gyro_bosch_bmi260_set_power_mode(&bmi260_ctx, DEV_POWER_ON);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_gyro_bosch_bmi260_set_range(&bmi260_ctx, GYRO_RANGE_1000DPS);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_gyro_bosch_bmi260_set_odr(&bmi260_ctx, BMI260_GYRO_DEFAULT_ODR_25HZ);
if(unlikely(ret) != 0) {
return -1;
}
return 0;
}
/**
* This function closes the gyro
*
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi260_close(void)
{
int ret = 0;
ret = drv_gyro_bosch_bmi260_set_power_mode(&bmi260_ctx, DEV_POWER_OFF);
if(unlikely(ret) != 0) {
return -1;
}
return 0;
}
/**
* This function reads the gyro data and reports the data
*
* @param[in out] buf buffer for gyro data
* @param[in out] len length of data
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi260_read(void *buf, size_t len)
{
int ret = 0;
int ret_getXYZ = 0;
size_t size;
int16_t x = 0;
int16_t y = 0;
int16_t z = 0;
uint8_t reg_data = 0; /* Variable to store register values */
uint8_t aps_status = 0; /* Variable to store adv power status */
gyro_data_t *gyro = (gyro_data_t *)buf;
if(buf == NULL) {
return -1;
}
size = sizeof(gyro_data_t);
if(len < size) {
return -1;
}
/* Get status of advance power save mode */
ret = sensor_i2c_read(&bmi260_ctx, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("read PWR_CONF_ADDR failed \n");
return ret;
}
aps_status = BMI2_GET_BIT_POS0(reg_data, BMI2_ADV_POW_EN);
if((aps_status == BMI2_ENABLE)) {
/* Disable advance power save if enabled */
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_DISABLE);
ret = sensor_i2c_write(&bmi260_ctx, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("write PWR_CONF_ADDR failed \n");
return ret;
}
}
ret = drv_gyro_bosch_bmi260_getXYZ(&bmi260_ctx, &x, &y, &z);
if(unlikely(ret)) {
printf("!!!!read gyro XYZ failed \n");
ret_getXYZ = ret;
}
/* enable advance power save if needed */
if(aps_status == BMI2_ENABLE) {
/* Get status of advance power save mode */
ret = sensor_i2c_read(&bmi260_ctx, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
if(unlikely(ret) != 0) {
printf("!!!!read PWR_CONF_ADDR failed \n");
return ret;
}
reg_data = BMI2_SET_BIT_POS0(reg_data, BMI2_ADV_POW_EN, BMI2_ENABLE);
ret = sensor_i2c_write(&bmi260_ctx, BMI2_PWR_CONF_ADDR, ®_data, I2C_DATA_LEN,
I2C_OP_RETRIES);
aos_msleep(3);
if(unlikely(ret) != 0) {
printf("!!!!!write PWR_CONF_ADDR failed \n");
return ret;
}
}
if(unlikely(ret_getXYZ)) {
return -1;
}
if(g_cur_gyro_factor != 0) {
gyro->data[DATA_AXIS_X] = (int32_t)((int64_t)x * GYROSCOPE_UNIT_FACTOR / (int64_t)g_cur_gyro_factor);
gyro->data[DATA_AXIS_Y] = (int32_t)((int64_t)y * GYROSCOPE_UNIT_FACTOR / (int64_t)g_cur_gyro_factor);
gyro->data[DATA_AXIS_Z] = (int32_t)((int64_t)z * GYROSCOPE_UNIT_FACTOR / (int64_t)g_cur_gyro_factor);
//printf("cur_gyro_factor = %d \n", g_cur_gyro_factor);
//printf("x = %d, y = %d, z = %d \n", gyro->data[DATA_AXIS_X], gyro->data[DATA_AXIS_Y], gyro->data[DATA_AXIS_Z]);
} else
printf("g_cur_gyro_factor == 0 \n");
gyro->timestamp = aos_now_ms();
return (int)size;
}
/**
* This function is for the gyro ioctl
*
* @param[in] cmd the ioctl command
* @param[in] arg the correspondding parameter
* @return the operation status, 0 is OK, others is error
*/
static int drv_gyro_bosch_bmi260_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_gyro_bosch_bmi260_set_odr(&bmi260_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_gyro_bosch_bmi260_set_range(&bmi260_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_gyro_bosch_bmi260_set_power_mode(&bmi260_ctx, arg);
if(unlikely(ret) != 0) {
return -1;
}
}
break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMI260";
info->range_max = 2000;
info->range_min = 125;
info->unit = udps;
}
break;
default:
break;
}
return 0;
}
/**
* This function is for the gyro initialization
*
* @return the operation status, 0 is OK, others is error
*/
int drv_gyro_bosch_bmi260_init(void) {
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_GYRO;
sensor.path = dev_gyro_path;
sensor.open = drv_gyro_bosch_bmi260_open;
sensor.close = drv_gyro_bosch_bmi260_close;
sensor.read = drv_gyro_bosch_bmi260_read;
sensor.write = NULL;
sensor.ioctl = drv_gyro_bosch_bmi260_ioctl;
sensor.irq_handle = drv_gyro_bosch_bmi260_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_acc_gyro_bosch_bmi260_validate_id(&bmi260_ctx, BMI260_CHIP_ID);
if(unlikely(ret) != 0) {
return -1;
}
if(0 == g_bmi260flag) {
ret = drv_acc_gyro_bosch_bmi260_soft_reset(&bmi260_ctx);
if(unlikely(ret) != 0) {
return -1;
}
ret = drv_gyro_bosch_bmi260_set_power_mode(&bmi260_ctx, DEV_POWER_OFF);
if(unlikely(ret) != 0) {
return -1;
}
g_bmi260flag = 1;
}
else {
LOG("%s %s gyro do not need reset\n", SENSOR_STR, __func__);
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_bosch_bmi260_init);
SENSOR_DRV_ADD(drv_gyro_bosch_bmi260_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_gyro_bosch_bmi260.c
|
C
|
apache-2.0
| 65,350
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
/*#define SH200L_DEBUG*/
#ifdef SH200L_DEBUG
#define SH200L_LOG LOG
#else
#define SH200L_LOG
#endif
#define SH200L_I2C_ADDR1 (0x6C)
#define SH200L_I2C_ADDR2 (0x6D)
#define SH200L_I2C_ADDR_TRANS(n) ((n)<<1)
#define SH200L_I2C_ADDR SH200L_I2C_ADDR_TRANS(SH200L_I2C_ADDR2)
#define SH200L_ACC_GYRO_WHO_AM_I_REG 0x30
#define SH200L_CHIP_ID_VALUE (0x18)
#define SH200L_ACC_CONFIG 0x0E
#define SH200L_GYRO_CONFIG 0x0F
#define SH200L_GYRO_DLPF 0x11
#define SH200L_FIFO_CONFIG 0x12
#define SH200L_ACC_RANGE 0x16
#define SH200L_GYRO_RANGE 0x2B
#define SH200L_OUTPUT_ACC_X 0x00
#define SH200L_OUTPUT_GYRO_X 0x06
#define SH200L_OUTPUT_TEMP 0x0C
#define SH200L_REG_SET1 0xBA
#define SH200L_REG_SET2 0xCA
#define SH200L_ADC_RESET 0xC2
#define SH200L_SOFT_RESET 0x7F
#define SH200L_RESET 0x75
#define SH200L_ACC_RANGE_2G (0x0)
#define SH200L_ACC_RANGE_4G (0x0)
#define SH200L_ACC_RANGE_8G (0x1)
#define SH200L_ACC_RANGE_16G (0x2)
#define SH200L_ACC_RANGE_MSK (0X3)
#define SH200L_ACC_RANGE_POS (0)
#define SH200L_ACC_SENSITIVITY_2G (61)
#define SH200L_ACC_SENSITIVITY_4G (122)
#define SH200L_ACC_SENSITIVITY_8G (244)
#define SH200L_ACC_SENSITIVITY_16G (488)
#define SH200L_ACC_ODR_16_HZ (0X03)
#define SH200L_ACC_ODR_32_HZ (0x02)
#define SH200L_ACC_ODR_64_HZ (0x01)
#define SH200L_ACC_ODR_128_LP_HZ (0x00)
#define SH200L_ACC_ODR_128_HZ (0x03)
#define SH200L_ACC_ODR_256_HZ (0x02)
#define SH200L_ACC_ODR_512_HZ (0x01)
#define SH200L_ACC_ODR_1024_HZ (0x00)
#define SH200L_ACC_ODR_MSK (0X18)
#define SH200L_ACC_ODR_POS (3)
#define SH200L_GYRO_ODR_31_HZ (0x03)
#define SH200L_GYRO_ODR_250_HZ (0x02)
#define SH200L_GYRO_ODR_500_HZ (0x01)
#define SH200L_GYRO_ODR_1000_HZ (0x00)
#define SH200L_GYRO_ODR_8K_HZ (0x04)
#define SH200L_GYRO_ODR_16K_HZ (0x05)
#define SH200L_GYRO_ODR_32K_HZ (0x06)
#define SH200L_GYRO_ODR_MSK (0X0E)
#define SH200L_GYRO_ODR_POS (1)
//#define SH200L_GYRO_RANGE_125 (0x4)
#define SH200L_GYRO_RANGE_245 (0x3)
#define SH200L_GYRO_RANGE_500 (0x2)
#define SH200L_GYRO_RANGE_1000 (0x1)
#define SH200L_GYRO_RANGE_2000 (0x0)
#define SH200L_GYRO_RANGE_MSK (0X7)
#define SH200L_GYRO_RANGE_POS (0)
#define SH200L_GYRO_SENSITIVITY_245DPS (7633)
#define SH200L_GYRO_SENSITIVITY_500DPS (15267)
#define SH200L_GYRO_SENSITIVITY_1000DPS (30487)
#define SH200L_GYRO_SENSITIVITY_2000DPS (60975)
#define SH200L_SHIFT_EIGHT_BITS (8)
#define SH200L_16_BIT_SHIFT (0xFF)
#define SH200L_ACC_MUL (1000)
#define SH200L_GYRO_MUL (1)
#define SH200L_ACC_DEFAULT_ODR_100HZ (100)
#define SH200L_GYRO_DEFAULT_ODR_100HZ (100)
#define SH200L_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define SH200L_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t sh200l_acc_factor[ACC_RANGE_MAX] = { SH200L_ACC_SENSITIVITY_2G, SH200L_ACC_SENSITIVITY_4G,
SH200L_ACC_SENSITIVITY_8G, SH200L_ACC_SENSITIVITY_16G };
static int32_t sh200l_gyro_factor[GYRO_RANGE_MAX] = {0, SH200L_GYRO_SENSITIVITY_245DPS, SH200L_GYRO_SENSITIVITY_500DPS,
SH200L_GYRO_SENSITIVITY_1000DPS, SH200L_GYRO_SENSITIVITY_2000DPS };
static int32_t cur_acc_factor = 0;
static int32_t cur_gyro_factor = 0;
static int32_t g_sh200lflag = 0;
static int32_t g_sleep = 0;
static int32_t g_powerdown = 0;
static int32_t g_low_odr = 0;
i2c_dev_t sh200l_ctx = {
.port = 4,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = SH200L_I2C_ADDR,
};
UNUSED static void drv_acc_senodia_sh200l_dump_reg(void)
{
uint8_t rw_buffer[32] = {0};
uint8_t reg_map[] = {
0xc2,
0x0E,
0x0F,
0x11,
0x12,
0x16,
0x2B,
0xba,
};
uint8_t i = 0;
uint16_t n = sizeof(reg_map)/sizeof(reg_map[0]);
int ret = 0;
for(i=0; i<n;i++) {
ret = sensor_i2c_read(&sh200l_ctx, reg_map[i], &rw_buffer[i],I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return;
}
}
}
static int drv_acc_gyro_senodia_sh200l_hw_init(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
/*set acc odr 256hz*/
value = 0x91;
ret = sensor_i2c_write(drv, SH200L_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
/*set gyro odr 500hz*/
value = 0x13;
ret = sensor_i2c_write(drv, SH200L_GYRO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
/*set gyro dlpf 50hz*/
value = 0x03;
ret = sensor_i2c_write(drv, SH200L_GYRO_DLPF, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
/*set no buffer mode*/
value = 0x00;
ret = sensor_i2c_write(drv, SH200L_FIFO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
/*set acc range +-8G*/
value = 0x01;
ret = sensor_i2c_write(drv, SH200L_ACC_RANGE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
/*set gyro range +-2000/s*/
value = 0x00;
ret = sensor_i2c_write(drv, SH200L_GYRO_RANGE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
value = 0xC0;
ret = sensor_i2c_write(drv, SH200L_REG_SET1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
value = 0x10;
ret = sensor_i2c_write(drv, SH200L_REG_SET2, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
aos_msleep(1);
value = 0x00;
ret = sensor_i2c_write(drv, SH200L_REG_SET2, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
aos_msleep(10);
return 0;
}
static int drv_acc_gyro_senodia_sh200l_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0x00;
/*soft reset*/
value = 0x00;
sensor_i2c_write(drv, SH200L_SOFT_RESET, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
aos_msleep(1);
/*ADC Reset*/
value = 0x0E;
ret = sensor_i2c_write(drv, SH200L_ADC_RESET, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
aos_msleep(1);
value = 0x0A;
ret = sensor_i2c_write(drv, SH200L_ADC_RESET, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_gyro_senodia_sh200l_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0, i = 3;
(void)ret;
if(drv == NULL){
return -1;
}
do{
ret = sensor_i2c_read(drv, SH200L_ACC_GYRO_WHO_AM_I_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
}while((value != 0x18) && (i-- > 0));
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_senodia_sh200l_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, SH200L_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
/*1. bit2 ==>0; bit0 ==>1 normal mode && filter enable*/
value &= (~(1<<2));
value |= (1<<0);
/*2. set odr*/
value = SH200L_SET_BITSLICE(value,SH200L_ACC_ODR, SH200L_ACC_ODR_128_HZ);
ret = sensor_i2c_write(drv, SH200L_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
g_sleep = 0;
g_powerdown = 0;
}break;
case DEV_POWER_OFF:{
/*1. filter disable*/
value &= (~(1<<0));
ret = sensor_i2c_write(drv, SH200L_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
/*2. low power mode*/
value |= (1<<2);
ret = sensor_i2c_write(drv, SH200L_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
g_powerdown = 1;
}break;
case DEV_SLEEP:{
/*1. filter disable */
value &= (~(1<<0));
ret = sensor_i2c_write(drv, SH200L_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
/*2. lower power mode*/
value |= (1<<2);
ret = sensor_i2c_write(drv, SH200L_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
/*3. bit2==>1; bit0 ==> 1 set odr && filter enable*/
value |= (1<<0);
value = SH200L_SET_BITSLICE(value,SH200L_ACC_ODR, SH200L_ACC_ODR_16_HZ);
ret = sensor_i2c_write(drv, SH200L_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
g_sleep = 1;
}break;
default:break;
}
return 0;
}
static uint8_t drv_acc_senodia_sh200l_hz2odr(uint32_t hz)
{
if(hz > 512)
return SH200L_ACC_ODR_1024_HZ;
else if(hz > 256)
return SH200L_ACC_ODR_512_HZ;
else if(hz > 128)
return SH200L_ACC_ODR_256_HZ;
else if(hz > 64){
if(g_sleep == 0){
g_low_odr = 0;
return SH200L_ACC_ODR_128_HZ;
}
else{
g_low_odr = 1;
return SH200L_ACC_ODR_128_LP_HZ;
}
}
else if(hz > 32)
return SH200L_ACC_ODR_64_HZ;
else if(hz > 16)
return SH200L_ACC_ODR_32_HZ;
else if(hz > 8)
return SH200L_ACC_ODR_16_HZ;
else
return SH200L_ACC_ODR_16_HZ;
if(hz > 128)
g_low_odr = 0;
else if(hz < 64)
g_low_odr = 1;
}
static int drv_acc_senodia_sh200l_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_senodia_sh200l_hz2odr(hz);
ret = sensor_i2c_read(drv, SH200L_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if(1 == g_low_odr){
value &= (~(1<<0));
ret = sensor_i2c_write(drv, SH200L_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= (1<<2);
ret = sensor_i2c_write(drv, SH200L_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= (1<<0);
ret = sensor_i2c_write(drv, SH200L_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}
value = SH200L_SET_BITSLICE(value,SH200L_ACC_ODR,odr);
ret = sensor_i2c_write(drv, SH200L_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_senodia_sh200l_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, SH200L_ACC_RANGE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_4G:{
tmp = SH200L_ACC_RANGE_4G;
}break;
case ACC_RANGE_8G:{
tmp = SH200L_ACC_RANGE_8G;
}break;
case ACC_RANGE_16G:{
tmp = SH200L_ACC_RANGE_16G;
}break;
default:break;
}
value = SH200L_SET_BITSLICE(value,SH200L_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, SH200L_ACC_RANGE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)){
cur_acc_factor = sh200l_acc_factor[range];
}
return 0;
}
static void drv_acc_senodia_sh200l_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_senodia_sh200l_open(void)
{
int ret = 0;
drv_acc_gyro_senodia_sh200l_hw_init(&sh200l_ctx);
ret = drv_acc_senodia_sh200l_set_range(&sh200l_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_senodia_sh200l_set_power_mode(&sh200l_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_senodia_sh200l_set_odr(&sh200l_ctx, SH200L_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_senodia_sh200l_close(void)
{
int ret = 0;
ret = drv_acc_senodia_sh200l_set_power_mode(&sh200l_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_senodia_sh200l_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&sh200l_ctx, SH200L_OUTPUT_ACC_X, ®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200l_ctx, SH200L_OUTPUT_ACC_X + 1, ®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200l_ctx, SH200L_OUTPUT_ACC_X + 2, ®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200l_ctx, SH200L_OUTPUT_ACC_X + 3, ®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200l_ctx, SH200L_OUTPUT_ACC_X + 4, ®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200l_ctx, SH200L_OUTPUT_ACC_X + 5, ®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< SH200L_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< SH200L_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< SH200L_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = (accel->data[DATA_AXIS_X] * cur_acc_factor)/SH200L_ACC_MUL;
accel->data[DATA_AXIS_Y] = (accel->data[DATA_AXIS_Y] * cur_acc_factor)/SH200L_ACC_MUL;
accel->data[DATA_AXIS_Z] = (accel->data[DATA_AXIS_Z] * cur_acc_factor)/SH200L_ACC_MUL;
}
/*SH200L_LOG("acc x = %d, y = %d, z = %d , cur_acc_factor = %d\n", accel->data[DATA_AXIS_X], accel->data[DATA_AXIS_Y], accel->data[DATA_AXIS_Z], cur_acc_factor);*/
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_senodia_sh200l_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_senodia_sh200l_set_odr(&sh200l_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_senodia_sh200l_set_range(&sh200l_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_senodia_sh200l_set_power_mode(&sh200l_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t*)arg;
info->model = "SH200L";
info->range_max = 16;
info->range_min = 4;
info->unit = mg;
}break;
default:break;
}
return 0;
}
int drv_acc_senodia_sh200l_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_senodia_sh200l_open;
sensor.close = drv_acc_senodia_sh200l_close;
sensor.read = drv_acc_senodia_sh200l_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_senodia_sh200l_ioctl;
sensor.irq_handle = drv_acc_senodia_sh200l_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_senodia_sh200l_validate_id(&sh200l_ctx, SH200L_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
if(0 == g_sh200lflag){
ret = drv_acc_gyro_senodia_sh200l_soft_reset(&sh200l_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_senodia_sh200l_set_power_mode(&sh200l_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
#if 0
ret = drv_acc_gyro_senodia_sh200l_hw_init(&sh200l_ctx);
if(unlikely(ret)){
return -1;
}
#endif
g_sh200lflag = 1;
}
else{
}
return 0;
}
static int drv_gyro_senodia_sh200l_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, SH200L_GYRO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = SH200L_SET_BITSLICE(value,SH200L_GYRO_ODR,SH200L_GYRO_ODR_31_HZ);
ret = sensor_i2c_write(drv, SH200L_GYRO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value &= (~(1<<0));
ret = sensor_i2c_write(drv, SH200L_GYRO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = SH200L_SET_BITSLICE(value,SH200L_GYRO_ODR,SH200L_GYRO_ODR_31_HZ);
ret = sensor_i2c_write(drv, SH200L_GYRO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_gyro_senodia_sh200l_hz2odr(uint32_t hz)
{
if(hz > 1660)
return SH200L_GYRO_ODR_32K_HZ;
else if(hz > 833)
return SH200L_GYRO_ODR_16K_HZ;
else if(hz > 416)
return SH200L_GYRO_ODR_8K_HZ;
else if(hz > 208)
return SH200L_GYRO_ODR_1000_HZ;
else if(hz > 104)
return SH200L_GYRO_ODR_500_HZ;
else if(hz > 52)
return SH200L_GYRO_ODR_250_HZ;
else if(hz > 26)
return SH200L_GYRO_ODR_31_HZ;
else
return SH200L_GYRO_ODR_31_HZ;
}
static int drv_gyro_senodia_sh200l_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_gyro_senodia_sh200l_hz2odr(hz);
ret = sensor_i2c_read(drv, SH200L_GYRO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = SH200L_SET_BITSLICE(value,SH200L_GYRO_ODR,odr);
ret = sensor_i2c_write(drv, SH200L_GYRO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_gyro_senodia_sh200l_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, SH200L_GYRO_RANGE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case GYRO_RANGE_250DPS:{
tmp = SH200L_GYRO_RANGE_245;
}break;
case GYRO_RANGE_500DPS:{
tmp = SH200L_GYRO_RANGE_500;
}break;
case GYRO_RANGE_1000DPS:{
tmp = SH200L_GYRO_RANGE_1000;
}break;
case GYRO_RANGE_2000DPS:{
tmp = SH200L_GYRO_RANGE_2000;
}break;
default:break;
}
value = SH200L_SET_BITSLICE(value,SH200L_GYRO_RANGE,tmp);
ret = sensor_i2c_write(drv, SH200L_GYRO_RANGE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= GYRO_RANGE_250DPS)&&(range <= GYRO_RANGE_2000DPS)){
cur_gyro_factor = sh200l_gyro_factor[range];
}
return 0;
}
static void drv_gyro_senodia_sh200l_irq_handle(void)
{
/* no handle so far */
}
static int drv_gyro_senodia_sh200l_open(void)
{
int ret = 0;
drv_acc_gyro_senodia_sh200l_hw_init(&sh200l_ctx);
ret = drv_gyro_senodia_sh200l_set_power_mode(&sh200l_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_senodia_sh200l_set_range(&sh200l_ctx, GYRO_RANGE_2000DPS);
if(unlikely(ret)){
return -1;
}
#ifdef FASTMODE_TEST
ret = drv_gyro_senodia_sh200l_set_odr(&sh200l_ctx, 200);
if(unlikely(ret)){
return -1;
}
#else
ret = drv_gyro_senodia_sh200l_set_odr(&sh200l_ctx, SH200L_GYRO_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
#endif
return 0;
}
static int drv_gyro_senodia_sh200l_close(void)
{
int ret = 0;
ret = drv_gyro_senodia_sh200l_set_power_mode(&sh200l_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_gyro_senodia_sh200l_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
gyro_data_t *gyro = (gyro_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(gyro_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&sh200l_ctx, SH200L_OUTPUT_GYRO_X, ®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200l_ctx, SH200L_OUTPUT_GYRO_X + 1, ®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200l_ctx, SH200L_OUTPUT_GYRO_X + 2, ®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200l_ctx, SH200L_OUTPUT_GYRO_X + 3, ®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200l_ctx, SH200L_OUTPUT_GYRO_X + 4, ®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200l_ctx, SH200L_OUTPUT_GYRO_X + 5, ®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
gyro->data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)reg[1]))<< SH200L_SHIFT_EIGHT_BITS)|(reg[0]));
gyro->data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)reg[3]))<< SH200L_SHIFT_EIGHT_BITS)|(reg[2]));
gyro->data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)reg[5]))<< SH200L_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_gyro_factor != 0){
gyro->data[DATA_AXIS_X] = (gyro->data[DATA_AXIS_X] * cur_gyro_factor)/SH200L_GYRO_MUL;
gyro->data[DATA_AXIS_Y] = (gyro->data[DATA_AXIS_Y] * cur_gyro_factor)/SH200L_GYRO_MUL;
gyro->data[DATA_AXIS_Z] = (gyro->data[DATA_AXIS_Z] * cur_gyro_factor)/SH200L_GYRO_MUL;
}
gyro->timestamp = aos_now_ms();
/*SH200L_LOG("gyro x = %d, y = %d, z = %d , cur_gyro_factor = %d\n", gyro->data[DATA_AXIS_X], gyro->data[DATA_AXIS_Y], gyro->data[DATA_AXIS_Z], cur_gyro_factor);*/
return (int)size;
}
UNUSED static int drv_acc_gyro_senodia_sh200l_self_test(i2c_dev_t* drv, int32_t* diff)
{
uint8_t gainRegister[32] = {147, 148, 149, 153, 154, 155, 159, 160, 161, 187, 198, 199, 200, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 219, 220, 221, 222, 223, 224};
uint8_t gainData[26] = {0, 4, 0, 0, 4, 0, 0, 4, 0, 0x10,0xC0, 0x40, 0x40, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
uint8_t gainData1[3] = { 0xA0, 0x20, 0x20};
uint8_t i, reg, data;
int16_t c_gyro_self[3] = {0};
int sumGyroData[3] = {0};
int16_t avgGyroData[3] = {0};
int16_t GyroData[3] = {0};
int16_t avgGyroData1[3] = {0};
uint8_t self_gain_data[32] = {0};
uint8_t temp[6]= {0};
int ret = 0;
if(NULL == diff)
return -1;
for( i = 0 ; i < 32 ; i++ ){
reg = gainRegister[i];
ret = sensor_i2c_read(drv, reg, &(self_gain_data[i]), I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
aos_msleep(1);
}
c_gyro_self[0] = self_gain_data[26] + self_gain_data[27] * 256;
c_gyro_self[1] = self_gain_data[28] + self_gain_data[29] * 256;
c_gyro_self[2] = self_gain_data[30] + self_gain_data[31] * 256;
for( i = 0 ; i < 26 ; i++ ){
reg = gainRegister[i];
data = gainData[i];
ret = sensor_i2c_write(drv, reg, &data, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
aos_msleep(1);
}
for(i=0;i<3;i++){
sumGyroData[i] = 0;
avgGyroData[i] = 0;
}
aos_msleep(500);
for(i=30; i>0; i--){
aos_msleep(1);
ret = sensor_i2c_read(drv, SH200L_OUTPUT_GYRO_X,(uint8_t *) &temp, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
GyroData[0]=((int16_t)((temp[1]<<8)|temp[0]));//
GyroData[1]=((int16_t)((temp[3]<<8)|temp[2]));//
GyroData[2]=((int16_t)((temp[5]<<8)|temp[4]));//
sumGyroData[0] += GyroData[0];
sumGyroData[1] += GyroData[1];
sumGyroData[2] += GyroData[2];
}
for(i = 0; i < 3; i++){
avgGyroData[i] = sumGyroData[i] / 30;
}
for( i = 0 ; i < 3 ; i++ ){
reg = gainRegister[i + 10];
data = gainData1[i];
ret = sensor_i2c_write(drv, reg, &data, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
aos_msleep(1);
}
aos_msleep(500);
for(i=0;i<3;i++){
sumGyroData[i] = 0;
avgGyroData1[i] = 0;
}
for(i=30; i>0; i--){
aos_msleep(1);
ret = sensor_i2c_read(drv, SH200L_OUTPUT_GYRO_X, (uint8_t *)&temp, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
GyroData[0]=((int16_t)((temp[1]<<8)|temp[0]));//
GyroData[1]=((int16_t)((temp[3]<<8)|temp[2]));//
GyroData[2]=((int16_t)((temp[5]<<8)|temp[4]));//
sumGyroData[0] += GyroData[0];
sumGyroData[1] += GyroData[1];
sumGyroData[2] += GyroData[2];
}
for(i = 0; i < 3; i++){
avgGyroData1[i] = sumGyroData[i] / 30;
}
for(i = 0; i < 3; i++){
diff[i] = avgGyroData[i] - avgGyroData1[i];
if((diff[i] > (c_gyro_self[i] + c_gyro_self[i] / 3)) ||(diff[i] < (c_gyro_self[i] - c_gyro_self[i] / 3))){
ret = -1;
break;
}
}
return ret;
}
static int drv_gyro_senodia_sh200l_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_gyro_senodia_sh200l_set_odr(&sh200l_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_gyro_senodia_sh200l_set_range(&sh200l_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_gyro_senodia_sh200l_set_power_mode(&sh200l_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "SH200L";
info->range_max = 2000;
info->range_min = 125;
info->unit = udps;
}break;
#if 0
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_acc_gyro_senodia_sh200l_self_test(&sh200l_ctx, info->data);
SH200L_LOG("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
return ret;
}break;
#endif
default:break;
}
return 0;
}
int drv_gyro_senodia_sh200l_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_GYRO;
sensor.path = dev_gyro_path;
sensor.open = drv_gyro_senodia_sh200l_open;
sensor.close = drv_gyro_senodia_sh200l_close;
sensor.read = drv_gyro_senodia_sh200l_read;
sensor.write = NULL;
sensor.ioctl = drv_gyro_senodia_sh200l_ioctl;
sensor.irq_handle = drv_gyro_senodia_sh200l_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_senodia_sh200l_validate_id(&sh200l_ctx, SH200L_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
if(0 == g_sh200lflag){
ret = drv_acc_gyro_senodia_sh200l_soft_reset(&sh200l_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_senodia_sh200l_hw_init(&sh200l_ctx);
if(unlikely(ret)){
return -1;
}
g_sh200lflag = 1;
}
else{
}
/* update the phy sensor info to sensor hal */
return 0;
}
SENSOR_DRV_ADD(drv_acc_senodia_sh200l_init);
SENSOR_DRV_ADD(drv_gyro_senodia_sh200l_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_gyro_senodia_sh200l.c
|
C
|
apache-2.0
| 29,119
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
/*#define SH200Q_DEBUG*/
#ifdef SH200Q_DEBUG
#define SH200Q_LOG LOG
#else
#define SH200Q_LOG
#endif
#define SH200Q_I2C_ADDR1 (0x6C)
#define SH200Q_I2C_ADDR2 (0x6D)
#define SH200Q_I2C_ADDR_TRANS(n) ((n)<<1)
#define SH200Q_I2C_ADDR SH200Q_I2C_ADDR_TRANS(SH200Q_I2C_ADDR2)
#define SH200Q_ACC_GYRO_WHO_AM_I_REG 0x30
#define SH200Q_CHIP_ID_VALUE (0x18)
#define SH200Q_ACC_CONFIG 0x0E
#define SH200Q_GYRO_CONFIG 0x0F
#define SH200Q_GYRO_DLPF 0x11
#define SH200Q_FIFO_CONFIG 0x12
#define SH200Q_ACC_RANGE 0x16
#define SH200Q_GYRO_RANGE 0x2B
#define SH200Q_OUTPUT_ACC_X 0x00
#define SH200Q_OUTPUT_GYRO_X 0x06
#define SH200Q_OUTPUT_TEMP 0x0C
#define SH200Q_REG_SET1 0xBA
#define SH200Q_REG_SET2 0xCA
#define SH200Q_ADC_RESET 0xC2
#define SH200Q_SOFT_RESET 0x7F
#define SH200Q_RESET 0x75
#define SH200Q_ACC_RANGE_2G (0x0)
#define SH200Q_ACC_RANGE_4G (0x0)
#define SH200Q_ACC_RANGE_8G (0x1)
#define SH200Q_ACC_RANGE_16G (0x2)
#define SH200Q_ACC_RANGE_MSK (0X3)
#define SH200Q_ACC_RANGE_POS (0)
#define SH200Q_ACC_SENSITIVITY_2G (61)
#define SH200Q_ACC_SENSITIVITY_4G (122)
#define SH200Q_ACC_SENSITIVITY_8G (244)
#define SH200Q_ACC_SENSITIVITY_16G (488)
#define SH200Q_ACC_ODR_16_HZ (0X03)
#define SH200Q_ACC_ODR_32_HZ (0x02)
#define SH200Q_ACC_ODR_64_HZ (0x01)
#define SH200Q_ACC_ODR_128_LP_HZ (0x00)
#define SH200Q_ACC_ODR_128_HZ (0x03)
#define SH200Q_ACC_ODR_256_HZ (0x02)
#define SH200Q_ACC_ODR_512_HZ (0x01)
#define SH200Q_ACC_ODR_1024_HZ (0x00)
#define SH200Q_ACC_ODR_MSK (0X18)
#define SH200Q_ACC_ODR_POS (3)
#define SH200Q_GYRO_ODR_31_HZ (0x03)
#define SH200Q_GYRO_ODR_250_HZ (0x02)
#define SH200Q_GYRO_ODR_500_HZ (0x01)
#define SH200Q_GYRO_ODR_1000_HZ (0x00)
#define SH200Q_GYRO_ODR_8K_HZ (0x04)
#define SH200Q_GYRO_ODR_16K_HZ (0x05)
#define SH200Q_GYRO_ODR_32K_HZ (0x06)
#define SH200Q_GYRO_ODR_MSK (0X0E)
#define SH200Q_GYRO_ODR_POS (1)
//#define SH200Q_GYRO_RANGE_125 (0x4)
#define SH200Q_GYRO_RANGE_245 (0x3)
#define SH200Q_GYRO_RANGE_500 (0x2)
#define SH200Q_GYRO_RANGE_1000 (0x1)
#define SH200Q_GYRO_RANGE_2000 (0x0)
#define SH200Q_GYRO_RANGE_MSK (0X7)
#define SH200Q_GYRO_RANGE_POS (0)
#define SH200Q_GYRO_SENSITIVITY_245DPS (7633)
#define SH200Q_GYRO_SENSITIVITY_500DPS (15267)
#define SH200Q_GYRO_SENSITIVITY_1000DPS (30487)
#define SH200Q_GYRO_SENSITIVITY_2000DPS (60975)
#define SH200Q_SHIFT_EIGHT_BITS (8)
#define SH200Q_16_BIT_SHIFT (0xFF)
#define SH200Q_ACC_MUL (1000)
#define SH200Q_GYRO_MUL (1)
#define SH200Q_ACC_DEFAULT_ODR_100HZ (100)
#define SH200Q_GYRO_DEFAULT_ODR_100HZ (100)
#define SH200Q_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define SH200Q_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t sh200q_acc_factor[ACC_RANGE_MAX] = { SH200Q_ACC_SENSITIVITY_2G, SH200Q_ACC_SENSITIVITY_4G,
SH200Q_ACC_SENSITIVITY_8G, SH200Q_ACC_SENSITIVITY_16G };
static int32_t sh200q_gyro_factor[GYRO_RANGE_MAX] = {0, SH200Q_GYRO_SENSITIVITY_245DPS, SH200Q_GYRO_SENSITIVITY_500DPS,
SH200Q_GYRO_SENSITIVITY_1000DPS, SH200Q_GYRO_SENSITIVITY_2000DPS };
static int32_t cur_acc_factor = 0;
static int32_t cur_gyro_factor = 0;
static int32_t g_sh200qflag = 0;
static int32_t g_sleep = 0;
static int32_t g_powerdown = 0;
static int32_t g_low_odr = 0;
i2c_dev_t sh200q_ctx = {
.port = 4,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = SH200Q_I2C_ADDR,
};
UNUSED static void drv_acc_senodia_sh200q_dump_reg(void)
{
uint8_t rw_buffer[32] = {0};
uint8_t reg_map[] = {
0xc2,
0x0E,
0x0F,
0x11,
0x12,
0x16,
0x2B,
0xba,
};
uint8_t i = 0;
uint16_t n = sizeof(reg_map)/sizeof(reg_map[0]);
int ret = 0;
for(i=0; i<n;i++) {
ret = sensor_i2c_read(&sh200q_ctx, reg_map[i], &rw_buffer[i],I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return;
}
}
}
static int drv_acc_gyro_senodia_sh200q_hw_init(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
/*set acc odr 256hz*/
value = 0x91;
ret = sensor_i2c_write(drv, SH200Q_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
/*set gyro odr 500hz*/
value = 0x13;
ret = sensor_i2c_write(drv, SH200Q_GYRO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
/*set gyro dlpf 50hz*/
value = 0x03;
ret = sensor_i2c_write(drv, SH200Q_GYRO_DLPF, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
/*set no buffer mode*/
value = 0x00;
ret = sensor_i2c_write(drv, SH200Q_FIFO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
/*set acc range +-8G*/
value = 0x01;
ret = sensor_i2c_write(drv, SH200Q_ACC_RANGE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
/*set gyro range +-2000/s*/
value = 0x00;
ret = sensor_i2c_write(drv, SH200Q_GYRO_RANGE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
value = 0xC0;
ret = sensor_i2c_write(drv, SH200Q_REG_SET1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
value = 0x10;
ret = sensor_i2c_write(drv, SH200Q_REG_SET2, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
aos_msleep(1);
value = 0x00;
ret = sensor_i2c_write(drv, SH200Q_REG_SET2, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
aos_msleep(10);
return 0;
}
static int drv_acc_gyro_senodia_sh200q_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0x00;
/*soft reset*/
value = 0x00;
sensor_i2c_write(drv, SH200Q_SOFT_RESET, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
aos_msleep(1);
/*ADC Reset*/
value = 0x0E;
ret = sensor_i2c_write(drv, SH200Q_ADC_RESET, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
aos_msleep(1);
value = 0x0A;
ret = sensor_i2c_write(drv, SH200Q_ADC_RESET, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_gyro_senodia_sh200q_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0, i = 3;
(void)ret;
if(drv == NULL){
return -1;
}
do{
ret = sensor_i2c_read(drv, SH200Q_ACC_GYRO_WHO_AM_I_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
}while((value != 0x18) && (i-- > 0));
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_senodia_sh200q_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, SH200Q_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
/*1. bit2 ==>0; bit0 ==>1 normal mode && filter enable*/
value &= (~(1<<2));
value |= (1<<0);
/*2. set odr*/
value = SH200Q_SET_BITSLICE(value,SH200Q_ACC_ODR, SH200Q_ACC_ODR_128_HZ);
ret = sensor_i2c_write(drv, SH200Q_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
g_sleep = 0;
g_powerdown = 0;
}break;
case DEV_POWER_OFF:{
/*1. filter disable*/
value &= (~(1<<0));
ret = sensor_i2c_write(drv, SH200Q_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
/*2. low power mode*/
value |= (1<<2);
ret = sensor_i2c_write(drv, SH200Q_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
g_powerdown = 1;
}break;
case DEV_SLEEP:{
/*1. filter disable */
value &= (~(1<<0));
ret = sensor_i2c_write(drv, SH200Q_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
/*2. lower power mode*/
value |= (1<<2);
ret = sensor_i2c_write(drv, SH200Q_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
/*3. bit2==>1; bit0 ==> 1 set odr && filter enable*/
value |= (1<<0);
value = SH200Q_SET_BITSLICE(value,SH200Q_ACC_ODR, SH200Q_ACC_ODR_16_HZ);
ret = sensor_i2c_write(drv, SH200Q_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
g_sleep = 1;
}break;
default:break;
}
return 0;
}
static uint8_t drv_acc_senodia_sh200q_hz2odr(uint32_t hz)
{
if(hz > 512)
return SH200Q_ACC_ODR_1024_HZ;
else if(hz > 256)
return SH200Q_ACC_ODR_512_HZ;
else if(hz > 128)
return SH200Q_ACC_ODR_256_HZ;
else if(hz > 64){
if(g_sleep == 0){
g_low_odr = 0;
return SH200Q_ACC_ODR_128_HZ;
}
else{
g_low_odr = 1;
return SH200Q_ACC_ODR_128_LP_HZ;
}
}
else if(hz > 32)
return SH200Q_ACC_ODR_64_HZ;
else if(hz > 16)
return SH200Q_ACC_ODR_32_HZ;
else if(hz > 8)
return SH200Q_ACC_ODR_16_HZ;
else
return SH200Q_ACC_ODR_16_HZ;
if(hz > 128)
g_low_odr = 0;
else if(hz < 64)
g_low_odr = 1;
}
static int drv_acc_senodia_sh200q_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_senodia_sh200q_hz2odr(hz);
ret = sensor_i2c_read(drv, SH200Q_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if(1 == g_low_odr){
value &= (~(1<<0));
ret = sensor_i2c_write(drv, SH200Q_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= (1<<2);
ret = sensor_i2c_write(drv, SH200Q_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= (1<<0);
ret = sensor_i2c_write(drv, SH200Q_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}
value = SH200Q_SET_BITSLICE(value,SH200Q_ACC_ODR,odr);
ret = sensor_i2c_write(drv, SH200Q_ACC_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_senodia_sh200q_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, SH200Q_ACC_RANGE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_4G:{
tmp = SH200Q_ACC_RANGE_4G;
}break;
case ACC_RANGE_8G:{
tmp = SH200Q_ACC_RANGE_8G;
}break;
case ACC_RANGE_16G:{
tmp = SH200Q_ACC_RANGE_16G;
}break;
default:break;
}
value = SH200Q_SET_BITSLICE(value,SH200Q_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, SH200Q_ACC_RANGE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)){
cur_acc_factor = sh200q_acc_factor[range];
}
return 0;
}
static void drv_acc_senodia_sh200q_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_senodia_sh200q_open(void)
{
int ret = 0;
drv_acc_gyro_senodia_sh200q_hw_init(&sh200q_ctx);
ret = drv_acc_senodia_sh200q_set_range(&sh200q_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_senodia_sh200q_set_power_mode(&sh200q_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_senodia_sh200q_set_odr(&sh200q_ctx, SH200Q_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_senodia_sh200q_close(void)
{
int ret = 0;
ret = drv_acc_senodia_sh200q_set_power_mode(&sh200q_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_senodia_sh200q_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&sh200q_ctx, SH200Q_OUTPUT_ACC_X, ®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200q_ctx, SH200Q_OUTPUT_ACC_X + 1, ®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200q_ctx, SH200Q_OUTPUT_ACC_X + 2, ®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200q_ctx, SH200Q_OUTPUT_ACC_X + 3, ®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200q_ctx, SH200Q_OUTPUT_ACC_X + 4, ®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200q_ctx, SH200Q_OUTPUT_ACC_X + 5, ®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< SH200Q_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< SH200Q_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< SH200Q_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = (accel->data[DATA_AXIS_X] * cur_acc_factor)/SH200Q_ACC_MUL;
accel->data[DATA_AXIS_Y] = (accel->data[DATA_AXIS_Y] * cur_acc_factor)/SH200Q_ACC_MUL;
accel->data[DATA_AXIS_Z] = (accel->data[DATA_AXIS_Z] * cur_acc_factor)/SH200Q_ACC_MUL;
}
/*SH200Q_LOG("acc x = %d, y = %d, z = %d , cur_acc_factor = %d\n", accel->data[DATA_AXIS_X], accel->data[DATA_AXIS_Y], accel->data[DATA_AXIS_Z], cur_acc_factor);*/
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_senodia_sh200q_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_senodia_sh200q_set_odr(&sh200q_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_senodia_sh200q_set_range(&sh200q_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_senodia_sh200q_set_power_mode(&sh200q_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t*)arg;
info->model = "SH200Q";
info->range_max = 16;
info->range_min = 4;
info->unit = mg;
}break;
default:break;
}
return 0;
}
int drv_acc_senodia_sh200q_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_senodia_sh200q_open;
sensor.close = drv_acc_senodia_sh200q_close;
sensor.read = drv_acc_senodia_sh200q_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_senodia_sh200q_ioctl;
sensor.irq_handle = drv_acc_senodia_sh200q_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_senodia_sh200q_validate_id(&sh200q_ctx, SH200Q_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
if(0 == g_sh200qflag){
ret = drv_acc_gyro_senodia_sh200q_soft_reset(&sh200q_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_senodia_sh200q_set_power_mode(&sh200q_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
#if 0
ret = drv_acc_gyro_senodia_sh200q_hw_init(&sh200q_ctx);
if(unlikely(ret)){
return -1;
}
#endif
g_sh200qflag = 1;
}
else{
}
return 0;
}
static int drv_gyro_senodia_sh200q_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, SH200Q_GYRO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = SH200Q_SET_BITSLICE(value,SH200Q_GYRO_ODR,SH200Q_GYRO_ODR_31_HZ);
ret = sensor_i2c_write(drv, SH200Q_GYRO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value &= (~(1<<0));
ret = sensor_i2c_write(drv, SH200Q_GYRO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = SH200Q_SET_BITSLICE(value,SH200Q_GYRO_ODR,SH200Q_GYRO_ODR_31_HZ);
ret = sensor_i2c_write(drv, SH200Q_GYRO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_gyro_senodia_sh200q_hz2odr(uint32_t hz)
{
if(hz > 1660)
return SH200Q_GYRO_ODR_32K_HZ;
else if(hz > 833)
return SH200Q_GYRO_ODR_16K_HZ;
else if(hz > 416)
return SH200Q_GYRO_ODR_8K_HZ;
else if(hz > 208)
return SH200Q_GYRO_ODR_1000_HZ;
else if(hz > 104)
return SH200Q_GYRO_ODR_500_HZ;
else if(hz > 52)
return SH200Q_GYRO_ODR_250_HZ;
else if(hz > 26)
return SH200Q_GYRO_ODR_31_HZ;
else
return SH200Q_GYRO_ODR_31_HZ;
}
static int drv_gyro_senodia_sh200q_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_gyro_senodia_sh200q_hz2odr(hz);
ret = sensor_i2c_read(drv, SH200Q_GYRO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = SH200Q_SET_BITSLICE(value,SH200Q_GYRO_ODR,odr);
ret = sensor_i2c_write(drv, SH200Q_GYRO_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_gyro_senodia_sh200q_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, SH200Q_GYRO_RANGE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case GYRO_RANGE_250DPS:{
tmp = SH200Q_GYRO_RANGE_245;
}break;
case GYRO_RANGE_500DPS:{
tmp = SH200Q_GYRO_RANGE_500;
}break;
case GYRO_RANGE_1000DPS:{
tmp = SH200Q_GYRO_RANGE_1000;
}break;
case GYRO_RANGE_2000DPS:{
tmp = SH200Q_GYRO_RANGE_2000;
}break;
default:break;
}
value = SH200Q_SET_BITSLICE(value,SH200Q_GYRO_RANGE,tmp);
ret = sensor_i2c_write(drv, SH200Q_GYRO_RANGE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= GYRO_RANGE_250DPS)&&(range <= GYRO_RANGE_2000DPS)){
cur_gyro_factor = sh200q_gyro_factor[range];
}
return 0;
}
static void drv_gyro_senodia_sh200q_irq_handle(void)
{
/* no handle so far */
}
static int drv_gyro_senodia_sh200q_open(void)
{
int ret = 0;
drv_acc_gyro_senodia_sh200q_hw_init(&sh200q_ctx);
ret = drv_gyro_senodia_sh200q_set_power_mode(&sh200q_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_senodia_sh200q_set_range(&sh200q_ctx, GYRO_RANGE_2000DPS);
if(unlikely(ret)){
return -1;
}
#ifdef FASTMODE_TEST
ret = drv_gyro_senodia_sh200q_set_odr(&sh200q_ctx, 200);
if(unlikely(ret)){
return -1;
}
#else
ret = drv_gyro_senodia_sh200q_set_odr(&sh200q_ctx, SH200Q_GYRO_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
#endif
return 0;
}
static int drv_gyro_senodia_sh200q_close(void)
{
int ret = 0;
ret = drv_gyro_senodia_sh200q_set_power_mode(&sh200q_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_gyro_senodia_sh200q_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
gyro_data_t *gyro = (gyro_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(gyro_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&sh200q_ctx, SH200Q_OUTPUT_GYRO_X, ®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200q_ctx, SH200Q_OUTPUT_GYRO_X + 1, ®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200q_ctx, SH200Q_OUTPUT_GYRO_X + 2, ®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200q_ctx, SH200Q_OUTPUT_GYRO_X + 3, ®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200q_ctx, SH200Q_OUTPUT_GYRO_X + 4, ®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&sh200q_ctx, SH200Q_OUTPUT_GYRO_X + 5, ®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
gyro->data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)reg[1]))<< SH200Q_SHIFT_EIGHT_BITS)|(reg[0]));
gyro->data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)reg[3]))<< SH200Q_SHIFT_EIGHT_BITS)|(reg[2]));
gyro->data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)reg[5]))<< SH200Q_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_gyro_factor != 0){
gyro->data[DATA_AXIS_X] = (gyro->data[DATA_AXIS_X] * cur_gyro_factor)/SH200Q_GYRO_MUL;
gyro->data[DATA_AXIS_Y] = (gyro->data[DATA_AXIS_Y] * cur_gyro_factor)/SH200Q_GYRO_MUL;
gyro->data[DATA_AXIS_Z] = (gyro->data[DATA_AXIS_Z] * cur_gyro_factor)/SH200Q_GYRO_MUL;
}
gyro->timestamp = aos_now_ms();
/*SH200Q_LOG("gyro x = %d, y = %d, z = %d , cur_gyro_factor = %d\n", gyro->data[DATA_AXIS_X], gyro->data[DATA_AXIS_Y], gyro->data[DATA_AXIS_Z], cur_gyro_factor);*/
return (int)size;
}
UNUSED static int drv_acc_gyro_senodia_sh200q_self_test(i2c_dev_t* drv, int32_t* diff)
{
uint8_t gainRegister[32] = {147, 148, 149, 153, 154, 155, 159, 160, 161, 187, 198, 199, 200, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 219, 220, 221, 222, 223, 224};
uint8_t gainData[26] = {0, 4, 0, 0, 4, 0, 0, 4, 0, 0x10,0xC0, 0x40, 0x40, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
uint8_t gainData1[3] = { 0xA0, 0x20, 0x20};
uint8_t i, reg, data;
int16_t c_gyro_self[3] = {0};
int sumGyroData[3] = {0};
int16_t avgGyroData[3] = {0};
int16_t GyroData[3] = {0};
int16_t avgGyroData1[3] = {0};
uint8_t self_gain_data[32] = {0};
uint8_t temp[6]= {0};
int ret = 0;
if(NULL == diff)
return -1;
for( i = 0 ; i < 32 ; i++ ){
reg = gainRegister[i];
ret = sensor_i2c_read(drv, reg, &(self_gain_data[i]), I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
aos_msleep(1);
}
c_gyro_self[0] = self_gain_data[26] + self_gain_data[27] * 256;
c_gyro_self[1] = self_gain_data[28] + self_gain_data[29] * 256;
c_gyro_self[2] = self_gain_data[30] + self_gain_data[31] * 256;
for( i = 0 ; i < 26 ; i++ ){
reg = gainRegister[i];
data = gainData[i];
ret = sensor_i2c_write(drv, reg, &data, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
aos_msleep(1);
}
for(i=0;i<3;i++){
sumGyroData[i] = 0;
avgGyroData[i] = 0;
}
aos_msleep(500);
for(i=30; i>0; i--){
aos_msleep(1);
ret = sensor_i2c_read(drv, SH200Q_OUTPUT_GYRO_X, &temp[0], 6, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
GyroData[0]=((int16_t)((temp[1]<<8)|temp[0]));//
GyroData[1]=((int16_t)((temp[3]<<8)|temp[2]));//
GyroData[2]=((int16_t)((temp[5]<<8)|temp[4]));//
sumGyroData[0] += GyroData[0];
sumGyroData[1] += GyroData[1];
sumGyroData[2] += GyroData[2];
}
for(i = 0; i < 3; i++){
avgGyroData[i] = sumGyroData[i] / 30;
}
for( i = 0 ; i < 3 ; i++ ){
reg = gainRegister[i + 10];
data = gainData1[i];
ret = sensor_i2c_write(drv, reg, &data, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
aos_msleep(1);
}
aos_msleep(500);
for(i=0;i<3;i++){
sumGyroData[i] = 0;
avgGyroData1[i] = 0;
}
for(i=30; i>0; i--){
aos_msleep(1);
ret = sensor_i2c_read(drv, SH200Q_OUTPUT_GYRO_X, &temp[0], 6, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
GyroData[0]=((int16_t)((temp[1]<<8)|temp[0]));//
GyroData[1]=((int16_t)((temp[3]<<8)|temp[2]));//
GyroData[2]=((int16_t)((temp[5]<<8)|temp[4]));//
sumGyroData[0] += GyroData[0];
sumGyroData[1] += GyroData[1];
sumGyroData[2] += GyroData[2];
}
for(i = 0; i < 3; i++){
avgGyroData1[i] = sumGyroData[i] / 30;
}
for(i = 0; i < 3; i++){
diff[i] = avgGyroData[i] - avgGyroData1[i];
if((diff[i] > (c_gyro_self[i] + c_gyro_self[i] / 3)) ||(diff[i] < (c_gyro_self[i] - c_gyro_self[i] / 3))){
ret = -1;
break;
}
}
return ret;
}
static int drv_gyro_senodia_sh200q_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_gyro_senodia_sh200q_set_odr(&sh200q_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_gyro_senodia_sh200q_set_range(&sh200q_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_gyro_senodia_sh200q_set_power_mode(&sh200q_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "SH200Q";
info->range_max = 2000;
info->range_min = 125;
info->unit = udps;
}break;
#if 0
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_acc_gyro_senodia_sh200q_self_test(&sh200q_ctx, info->data);
SH200Q_LOG("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
return ret;
}break;
#endif
default:break;
}
return 0;
}
int drv_gyro_senodia_sh200q_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_GYRO;
sensor.path = dev_gyro_path;
sensor.open = drv_gyro_senodia_sh200q_open;
sensor.close = drv_gyro_senodia_sh200q_close;
sensor.read = drv_gyro_senodia_sh200q_read;
sensor.write = NULL;
sensor.ioctl = drv_gyro_senodia_sh200q_ioctl;
sensor.irq_handle = drv_gyro_senodia_sh200q_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_senodia_sh200q_validate_id(&sh200q_ctx, SH200Q_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
if(0 == g_sh200qflag){
ret = drv_acc_gyro_senodia_sh200q_soft_reset(&sh200q_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_senodia_sh200q_hw_init(&sh200q_ctx);
if(unlikely(ret)){
return -1;
}
g_sh200qflag = 1;
}
else{
}
/* update the phy sensor info to sensor hal */
return 0;
}
SENSOR_DRV_ADD(drv_acc_senodia_sh200q_init);
SENSOR_DRV_ADD(drv_gyro_senodia_sh200q_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_gyro_senodia_sh200q.c
|
C
|
apache-2.0
| 29,106
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LSM6DS3_I2C_ADDR1 (0x6A)
#define LSM6DS3_I2C_ADDR2 (0x6B)
#define LSM6DS3_I2C_ADDR_TRANS(n) ((n)<<1)
#define LSM6DS3_I2C_ADDR LSM6DS3_I2C_ADDR_TRANS(LSM6DS3_I2C_ADDR2)
#define LSM6DS3_ACC_GYRO_FUNC_CFG_ACCESS 0x01
#define LSM6DS3_ACC_GYRO_SENSOR_SYNC_TIME 0x04
#define LSM6DS3_ACC_GYRO_SENSOR_RES_RATIO 0x05
#define LSM6DS3_ACC_GYRO_FIFO_CTRL1 0x06
#define LSM6DS3_ACC_GYRO_FIFO_CTRL2 0x07
#define LSM6DS3_ACC_GYRO_FIFO_CTRL3 0x08
#define LSM6DS3_ACC_GYRO_FIFO_CTRL4 0x09
#define LSM6DS3_ACC_GYRO_FIFO_CTRL5 0x0A
#define LSM6DS3_ACC_GYRO_DRDY_PULSE_CFG_G 0x0B
#define LSM6DS3_ACC_GYRO_INT1_CTRL 0x0D
#define LSM6DS3_ACC_GYRO_INT2_CTRL 0x0E
#define LSM6DS3_ACC_GYRO_WHO_AM_I_REG 0x0F
#define LSM6DS3_ACC_GYRO_CTRL1_XL 0x10
#define LSM6DS3_ACC_GYRO_CTRL2_G 0x11
#define LSM6DS3_ACC_GYRO_CTRL3_C 0x12
#define LSM6DS3_ACC_GYRO_CTRL4_C 0x13
#define LSM6DS3_ACC_GYRO_CTRL5_C 0x14
#define LSM6DS3_ACC_GYRO_CTRL6_C 0x15
#define LSM6DS3_ACC_GYRO_CTRL7_G 0x16
#define LSM6DS3_ACC_GYRO_CTRL8_XL 0x17
#define LSM6DS3_ACC_GYRO_CTRL9_XL 0x18
#define LSM6DS3_ACC_GYRO_CTRL10_C 0x19
#define LSM6DS3_ACC_GYRO_MASTER_CONFIG 0x1A
#define LSM6DS3_ACC_GYRO_WAKE_UP_SRC 0x1B
#define LSM6DS3_ACC_GYRO_TAP_SRC 0x1C
#define LSM6DS3_ACC_GYRO_D6D_SRC 0x1D
#define LSM6DS3_ACC_GYRO_STATUS_REG 0x1E
#define LSM6DS3_ACC_GYRO_OUT_TEMP_L 0x20
#define LSM6DS3_ACC_GYRO_OUT_TEMP_H 0x21
#define LSM6DS3_ACC_GYRO_OUTX_L_G 0x22
#define LSM6DS3_ACC_GYRO_OUTX_H_G 0x23
#define LSM6DS3_ACC_GYRO_OUTY_L_G 0x24
#define LSM6DS3_ACC_GYRO_OUTY_H_G 0x25
#define LSM6DS3_ACC_GYRO_OUTZ_L_G 0x26
#define LSM6DS3_ACC_GYRO_OUTZ_H_G 0x27
#define LSM6DS3_ACC_GYRO_OUTX_L_XL 0x28
#define LSM6DS3_ACC_GYRO_OUTX_H_XL 0x29
#define LSM6DS3_ACC_GYRO_OUTY_L_XL 0x2A
#define LSM6DS3_ACC_GYRO_OUTY_H_XL 0x2B
#define LSM6DS3_ACC_GYRO_OUTZ_L_XL 0x2C
#define LSM6DS3_ACC_GYRO_OUTZ_H_XL 0x2D
#define LSM6DS3_ACC_GYRO_SENSORHUB1_REG 0x2E
#define LSM6DS3_ACC_GYRO_SENSORHUB2_REG 0x2F
#define LSM6DS3_ACC_GYRO_SENSORHUB3_REG 0x30
#define LSM6DS3_ACC_GYRO_SENSORHUB4_REG 0x31
#define LSM6DS3_ACC_GYRO_SENSORHUB5_REG 0x32
#define LSM6DS3_ACC_GYRO_SENSORHUB6_REG 0x33
#define LSM6DS3_ACC_GYRO_SENSORHUB7_REG 0x34
#define LSM6DS3_ACC_GYRO_SENSORHUB8_REG 0x35
#define LSM6DS3_ACC_GYRO_SENSORHUB9_REG 0x36
#define LSM6DS3_ACC_GYRO_SENSORHUB10_REG 0x37
#define LSM6DS3_ACC_GYRO_SENSORHUB11_REG 0x38
#define LSM6DS3_ACC_GYRO_SENSORHUB12_REG 0x39
#define LSM6DS3_ACC_GYRO_FIFO_STATUS1 0x3A
#define LSM6DS3_ACC_GYRO_FIFO_STATUS2 0x3B
#define LSM6DS3_ACC_GYRO_FIFO_STATUS3 0x3C
#define LSM6DS3_ACC_GYRO_FIFO_STATUS4 0x3D
#define LSM6DS3_ACC_GYRO_FIFO_DATA_OUT_L 0x3E
#define LSM6DS3_ACC_GYRO_FIFO_DATA_OUT_H 0x3F
#define LSM6DS3_ACC_GYRO_TIMESTAMP0_REG 0x40
#define LSM6DS3_ACC_GYRO_TIMESTAMP1_REG 0x41
#define LSM6DS3_ACC_GYRO_TIMESTAMP2_REG 0x42
#define LSM6DS3_ACC_GYRO_TIMESTAMP_L 0x49
#define LSM6DS3_ACC_GYRO_TIMESTAMP_H 0x4A
#define LSM6DS3_ACC_GYRO_STEP_COUNTER_L 0x4B
#define LSM6DS3_ACC_GYRO_STEP_COUNTER_H 0x4C
#define LSM6DS3_ACC_GYRO_SENSORHUB13_REG 0x4D
#define LSM6DS3_ACC_GYRO_SENSORHUB14_REG 0x4E
#define LSM6DS3_ACC_GYRO_SENSORHUB15_REG 0x4F
#define LSM6DS3_ACC_GYRO_SENSORHUB16_REG 0x50
#define LSM6DS3_ACC_GYRO_SENSORHUB17_REG 0x51
#define LSM6DS3_ACC_GYRO_SENSORHUB18_REG 0x52
#define LSM6DS3_ACC_GYRO_FUNC_SRC 0x53
#define LSM6DS3_ACC_GYRO_TAP_CFG1 0x58
#define LSM6DS3_ACC_GYRO_TAP_THS_6D 0x59
#define LSM6DS3_ACC_GYRO_INT_DUR2 0x5A
#define LSM6DS3_ACC_GYRO_WAKE_UP_THS 0x5B
#define LSM6DS3_ACC_GYRO_WAKE_UP_DUR 0x5C
#define LSM6DS3_ACC_GYRO_FREE_FALL 0x5D
#define LSM6DS3_ACC_GYRO_MD1_CFG 0x5E
#define LSM6DS3_ACC_GYRO_MD2_CFG 0x5F
#define LSM6DS3_ACC_GYRO_OUT_MAG_RAW_X_L 0x66
#define LSM6DS3_ACC_GYRO_OUT_MAG_RAW_X_H 0x67
#define LSM6DS3_ACC_GYRO_OUT_MAG_RAW_Y_L 0x68
#define LSM6DS3_ACC_GYRO_OUT_MAG_RAW_Y_H 0x69
#define LSM6DS3_ACC_GYRO_OUT_MAG_RAW_Z_L 0x6A
#define LSM6DS3_ACC_GYRO_OUT_MAG_RAW_Z_H 0x6B
#define LSM6DS3_CHIP_ID_VALUE (0x69)
#define LSM6DS3_RESET_VALUE (0x1)
#define LSM6DS3_RESET_MSK (0X1)
#define LSM6DS3_RESET_POS (0)
#define LSM6DS3_BDU_VALUE (0x40)
#define LSM6DS3_BDU_MSK (0X40)
#define LSM6DS3_BDU_POS (6)
#define LSM6DS3_ACC_ODR_POWER_DOWN (0X00)
#define LSM6DS3_ACC_ODR_1_6_HZ (0X0B)
#define LSM6DS3_ACC_ODR_12_5_HZ (0x01)
#define LSM6DS3_ACC_ODR_26_HZ (0x02)
#define LSM6DS3_ACC_ODR_52_HZ (0x03)
#define LSM6DS3_ACC_ODR_104_HZ (0x04)
#define LSM6DS3_ACC_ODR_208_HZ (0x05)
#define LSM6DS3_ACC_ODR_416_HZ (0x06)
#define LSM6DS3_ACC_ODR_833_HZ (0x07)
#define LSM6DS3_ACC_ODR_1_66_KHZ (0x08)
#define LSM6DS3_ACC_ODR_3_33_KHZ (0x09)
#define LSM6DS3_ACC_ODR_6_66_KHZ (0x0A)
#define LSM6DS3_ACC_ODR_MSK (0XF0)
#define LSM6DS3_ACC_ODR_POS (4)
#define LSM6DS3_GYRO_ODR_POWER_DOWN (0X00)
#define LSM6DS3_GYRO_ODR_12_5_HZ (0x01)
#define LSM6DS3_GYRO_ODR_26_HZ (0x02)
#define LSM6DS3_GYRO_ODR_52_HZ (0x03)
#define LSM6DS3_GYRO_ODR_104_HZ (0x04)
#define LSM6DS3_GYRO_ODR_208_HZ (0x05)
#define LSM6DS3_GYRO_ODR_416_HZ (0x06)
#define LSM6DS3_GYRO_ODR_833_HZ (0x07)
#define LSM6DS3_GYRO_ODR_1_66_KHZ (0x08)
#define LSM6DS3_GYRO_ODR_3_33_KHZ (0x09)
#define LSM6DS3_GYRO_ODR_6_66_KHZ (0x0A)
#define LSM6DS3_GYRO_ODR_MSK (0XF0)
#define LSM6DS3_GYRO_ODR_POS (4)
#define LSM6DS3_ACC_RANGE_2G (0x0)
#define LSM6DS3_ACC_RANGE_4G (0x2)
#define LSM6DS3_ACC_RANGE_8G (0x3)
#define LSM6DS3_ACC_RANGE_16G (0x1)
#define LSM6DS3_ACC_RANGE_MSK (0X0C)
#define LSM6DS3_ACC_RANGE_POS (2)
#define LSM6DS3_ACC_SENSITIVITY_2G (61)
#define LSM6DS3_ACC_SENSITIVITY_4G (122)
#define LSM6DS3_ACC_SENSITIVITY_8G (244)
#define LSM6DS3_ACC_SENSITIVITY_16G (488)
#define LSM6DS3_GYRO_RANGE_245 (0x0)
#define LSM6DS3_GYRO_RANGE_500 (0x1)
#define LSM6DS3_GYRO_RANGE_1000 (0x2)
#define LSM6DS3_GYRO_RANGE_2000 (0x3)
#define LSM6DS3_GYRO_RANGE_MSK (0X0C)
#define LSM6DS3_GYRO_RANGE_POS (2)
#define LSM6DS3_GYRO_SENSITIVITY_245DPS (8750)
#define LSM6DS3_GYRO_SENSITIVITY_500DPS (17500)
#define LSM6DS3_GYRO_SENSITIVITY_1000DPS (35000)
#define LSM6DS3_GYRO_SENSITIVITY_2000DPS (70000)
#define LSM6DS3_SHIFT_EIGHT_BITS (8)
#define LSM6DS3_16_BIT_SHIFT (0xFF)
#define LSM6DS3_ACC_MUL (1000)
#define LSM6DS3_GYRO_MUL (1)
#define LSM6DS3_ACC_DEFAULT_ODR_100HZ (100)
#define LSM6DS3_GYRO_DEFAULT_ODR_100HZ (100)
#define LSM6DS3_ACC_SELF_TEST_MIN_X (90) // 90mg
#define LSM6DS3_ACC_SELF_TEST_MIN_Y (90) // 90mg
#define LSM6DS3_ACC_SELF_TEST_MIN_Z (90) // 90mg
#define LSM6DS3_ACC_SELF_TEST_MAX_X (1700) // 1700mg
#define LSM6DS3_ACC_SELF_TEST_MAX_Y (1700) // 1700mg
#define LSM6DS3_ACC_SELF_TEST_MAX_Z (1700) // 1700mg
#define LSM6DS3_ACC_SELF_TEST_DRY_WAIT_CNT 5
#define LSM6DS3_ACC_SELF_TEST_AVG_SAMPLE_CNT 5
#define LSM6DS3_GYRO_SELF_TEST_MIN_X (150) // 150dps
#define LSM6DS3_GYRO_SELF_TEST_MIN_Y (150) // 150dps
#define LSM6DS3_GYRO_SELF_TEST_MIN_Z (150) // 150dps
#define LSM6DS3_GYRO_SELF_TEST_MAX_X (700) // 700dps
#define LSM6DS3_GYRO_SELF_TEST_MAX_Y (700) // 700dps
#define LSM6DS3_GYRO_SELF_TEST_MAX_Z (700) // 700dps
#define LSM6DS3_GYRO_SELF_TEST_DRY_WAIT_CNT 5
#define LSM6DS3_GYRO_SELF_TEST_AVG_SAMPLE_CNT 5
#define LSM6DS3_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define LSM6DS3_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t lsm6ds3_acc_factor[ACC_RANGE_MAX] = { LSM6DS3_ACC_SENSITIVITY_2G, LSM6DS3_ACC_SENSITIVITY_4G,
LSM6DS3_ACC_SENSITIVITY_8G, LSM6DS3_ACC_SENSITIVITY_16G };
static int32_t lsm6ds3_gyro_factor[GYRO_RANGE_MAX] = {0, LSM6DS3_GYRO_SENSITIVITY_245DPS, LSM6DS3_GYRO_SENSITIVITY_500DPS,
LSM6DS3_GYRO_SENSITIVITY_1000DPS, LSM6DS3_GYRO_SENSITIVITY_2000DPS };
static int32_t cur_acc_factor = 0;
static int32_t cur_gyro_factor = 0;
static int32_t g_lsm6ds3flag = 0;
static i2c_dev_t lsm6ds3_ctx = {
//.port = 4,
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LSM6DS3_I2C_ADDR,
};
static int drv_acc_gyro_st_lsm6ds3_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LSM6DS3_RESET_VALUE;
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_gyro_st_lsm6ds3_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_WHO_AM_I_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
//LOG("%s %s right id (0x%02x), read id(0x%02x)\n", SENSOR_STR, __func__, id_value, value);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6ds3_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LSM6DS3_SET_BITSLICE(value,LSM6DS3_ACC_ODR,LSM6DS3_ACC_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LSM6DS3_SET_BITSLICE(value,LSM6DS3_ACC_ODR,LSM6DS3_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LSM6DS3_SET_BITSLICE(value,LSM6DS3_ACC_ODR,LSM6DS3_ACC_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static int drv_acc_gyro_st_lsm6ds3_set_bdu(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (value & LSM6DS3_BDU_VALUE)
return 0;
value |= LSM6DS3_BDU_VALUE;
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static uint8_t drv_acc_st_lsm6ds3_hz2odr(uint32_t hz)
{
if(hz > 3330)
return LSM6DS3_ACC_ODR_6_66_KHZ;
else if(hz > 1660)
return LSM6DS3_ACC_ODR_3_33_KHZ;
else if(hz > 833)
return LSM6DS3_ACC_ODR_1_66_KHZ;
else if(hz > 416)
return LSM6DS3_ACC_ODR_833_HZ;
else if(hz > 208)
return LSM6DS3_ACC_ODR_416_HZ;
else if(hz > 104)
return LSM6DS3_ACC_ODR_208_HZ;
else if(hz > 52)
return LSM6DS3_ACC_ODR_104_HZ;
else if(hz > 26)
return LSM6DS3_ACC_ODR_52_HZ;
else if(hz > 13)
return LSM6DS3_ACC_ODR_26_HZ;
else if(hz >= 2)
return LSM6DS3_ACC_ODR_12_5_HZ;
else
return LSM6DS3_ACC_ODR_1_6_HZ;
}
static int drv_acc_st_lsm6ds3_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_lsm6ds3_hz2odr(hz);
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LSM6DS3_SET_BITSLICE(value,LSM6DS3_ACC_ODR,odr);
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lsm6ds3_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_2G:{
tmp = LSM6DS3_ACC_RANGE_2G;
}break;
case ACC_RANGE_4G:{
tmp = LSM6DS3_ACC_RANGE_4G;
}break;
case ACC_RANGE_8G:{
tmp = LSM6DS3_ACC_RANGE_8G;
}break;
case ACC_RANGE_16G:{
tmp = LSM6DS3_ACC_RANGE_16G;
}break;
default:break;
}
value = LSM6DS3_SET_BITSLICE(value,LSM6DS3_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)){
cur_acc_factor = lsm6ds3_acc_factor[range];
}
return 0;
}
static int drv_acc_st_lsm6ds3_st_discard(i2c_dev_t* drv)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
for (i = 0; i < LSM6DS3_ACC_SELF_TEST_DRY_WAIT_CNT; i ++) {
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x01)
break;
aos_msleep(20);
}
if (i >= LSM6DS3_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_OUTX_L_XL, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
return ret;
}
static int drv_acc_st_lsm6ds3_st_data(i2c_dev_t* drv,int32_t* data)
{
uint8_t i, j;
int16_t x_raw, y_raw, z_raw;
int32_t x_mg, y_mg, z_mg;
int32_t x_sum, y_sum, z_sum;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
x_sum = 0; y_sum = 0; z_sum = 0;
for (i = 0; i < LSM6DS3_ACC_SELF_TEST_AVG_SAMPLE_CNT; i ++) {
for (j = 0; j < LSM6DS3_ACC_SELF_TEST_DRY_WAIT_CNT; j ++) {
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x01)
break;
aos_msleep(20);
}
if (j >= LSM6DS3_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_OUTX_L_XL, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
x_raw = (buffer[1] << 8) + buffer[0];
y_raw = (buffer[3] << 8) + buffer[2];
z_raw = (buffer[5] << 8) + buffer[4];
//LOG("%s %s %d: i(%d), raw(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_raw, y_raw, z_raw);
x_mg = x_raw * LSM6DS3_ACC_SENSITIVITY_4G / 1000;
y_mg = y_raw * LSM6DS3_ACC_SENSITIVITY_4G / 1000;
z_mg = z_raw * LSM6DS3_ACC_SENSITIVITY_4G / 1000;
//LOG("%s %s %d: i(%d), mg(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_mg, y_mg, z_mg);
x_sum += x_mg;
y_sum += y_mg;
z_sum += z_mg;
}
data[0] = x_sum / LSM6DS3_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[1] = y_sum / LSM6DS3_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[2] = z_sum / LSM6DS3_ACC_SELF_TEST_AVG_SAMPLE_CNT;
return ret;
}
static int drv_acc_st_lsm6ds3_self_test(i2c_dev_t* drv,int32_t* data)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t ctrl_reg[10];
int32_t out_nost[3];
int32_t out_st[3];
int32_t out_diff[3];
const uint8_t ctrl_val[10] = { 0x38, 0, 0x44, 0, 0, 0, 0, 0, 0, 0 };
// Save cfg registers which will be modified during self-test
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
// Initialize Sensor, turn on sensor, enable X/Y/Z axes
// Set BDU=1, FS=4G, ODR = 52Hz
for (i = 0; i < 10; i ++) {
value = ctrl_val[i];
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL1_XL + i, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
}
aos_msleep(100);
// Discard the first sample
ret = drv_acc_st_lsm6ds3_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and averate them
ret = drv_acc_st_lsm6ds3_st_data(drv, out_nost);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Enable seft-test
value = 0x01;
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL5_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(100);
// Discard the first sample
ret = drv_acc_st_lsm6ds3_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and average them
ret = drv_acc_st_lsm6ds3_st_data(drv, out_st);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Check if the differences are between min and max
for (i = 0; i < 3; i ++) {
out_diff[i] = abs(out_st[i] - out_nost[i]);
data[i] = out_diff[i];
}
if ((LSM6DS3_ACC_SELF_TEST_MIN_X > out_diff[0]) || (out_diff[0] > LSM6DS3_ACC_SELF_TEST_MAX_X)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DS3_ACC_SELF_TEST_MIN_Y > out_diff[1]) || (out_diff[1] > LSM6DS3_ACC_SELF_TEST_MAX_Y)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DS3_ACC_SELF_TEST_MIN_Z > out_diff[2]) || (out_diff[2] > LSM6DS3_ACC_SELF_TEST_MAX_Z)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
restore:
ret += sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
return ret;
}
static void drv_acc_st_lsm6ds3_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_lsm6ds3_open(void)
{
int ret = 0;
ret = drv_acc_st_lsm6ds3_set_power_mode(&lsm6ds3_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6ds3_set_bdu(&lsm6ds3_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm6ds3_set_range(&lsm6ds3_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm6ds3_set_odr(&lsm6ds3_ctx, LSM6DS3_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6ds3_close(void)
{
int ret = 0;
ret = drv_acc_st_lsm6ds3_set_power_mode(&lsm6ds3_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6ds3_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lsm6ds3_ctx, LSM6DS3_ACC_GYRO_OUTX_L_XL, ®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3_ctx, LSM6DS3_ACC_GYRO_OUTX_H_XL, ®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3_ctx, LSM6DS3_ACC_GYRO_OUTY_L_XL, ®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3_ctx, LSM6DS3_ACC_GYRO_OUTY_H_XL, ®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3_ctx, LSM6DS3_ACC_GYRO_OUTZ_L_XL, ®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3_ctx, LSM6DS3_ACC_GYRO_OUTZ_H_XL, ®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< LSM6DS3_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< LSM6DS3_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< LSM6DS3_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = (accel->data[DATA_AXIS_X] * cur_acc_factor)/LSM6DS3_ACC_MUL;
accel->data[DATA_AXIS_Y] = (accel->data[DATA_AXIS_Y] * cur_acc_factor)/LSM6DS3_ACC_MUL;
accel->data[DATA_AXIS_Z] = (accel->data[DATA_AXIS_Z] * cur_acc_factor)/LSM6DS3_ACC_MUL;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_lsm6ds3_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_lsm6ds3_set_odr(&lsm6ds3_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_st_lsm6ds3_set_range(&lsm6ds3_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_lsm6ds3_set_power_mode(&lsm6ds3_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
//dev_sensor_info_t *info = (dev_sensor_info_t*)arg;
info->model = "LSM6DS3";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}break;
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_acc_st_lsm6ds3_self_test(&lsm6ds3_ctx, (int32_t*)info->data);
//printf("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
LOG("%s %s: %d, %d, %d\n", SENSOR_STR, __func__, info->data[0],info->data[1],info->data[2]);
return ret;
}
default:break;
}
return 0;
}
int drv_acc_st_lsm6ds3_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_lsm6ds3_open;
sensor.close = drv_acc_st_lsm6ds3_close;
sensor.read = drv_acc_st_lsm6ds3_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_lsm6ds3_ioctl;
sensor.irq_handle = drv_acc_st_lsm6ds3_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6ds3_validate_id(&lsm6ds3_ctx, LSM6DS3_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
if(0 == g_lsm6ds3flag)
{
ret = drv_acc_gyro_st_lsm6ds3_soft_reset(&lsm6ds3_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm6ds3_set_power_mode(&lsm6ds3_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
g_lsm6ds3flag = 1;
}
else
{
LOG("%s %s acc do not need reset\n", SENSOR_STR, __func__);
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_gyro_st_lsm6ds3_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LSM6DS3_SET_BITSLICE(value,LSM6DS3_GYRO_ODR,LSM6DS3_GYRO_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LSM6DS3_SET_BITSLICE(value,LSM6DS3_GYRO_ODR,LSM6DS3_GYRO_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LSM6DS3_SET_BITSLICE(value,LSM6DS3_GYRO_ODR,LSM6DS3_GYRO_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_gyro_st_lsm6ds3_hz2odr(uint32_t hz)
{
if(hz > 3330)
return LSM6DS3_GYRO_ODR_6_66_KHZ;
else if(hz > 1660)
return LSM6DS3_GYRO_ODR_3_33_KHZ;
else if(hz > 833)
return LSM6DS3_GYRO_ODR_1_66_KHZ;
else if(hz > 416)
return LSM6DS3_GYRO_ODR_833_HZ;
else if(hz > 208)
return LSM6DS3_GYRO_ODR_416_HZ;
else if(hz > 104)
return LSM6DS3_GYRO_ODR_208_HZ;
else if(hz > 52)
return LSM6DS3_GYRO_ODR_104_HZ;
else if(hz > 26)
return LSM6DS3_GYRO_ODR_52_HZ;
else if(hz > 13)
return LSM6DS3_GYRO_ODR_26_HZ;
else
return LSM6DS3_GYRO_ODR_12_5_HZ;
}
static int drv_gyro_st_lsm6ds3_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_gyro_st_lsm6ds3_hz2odr(hz);
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LSM6DS3_SET_BITSLICE(value,LSM6DS3_GYRO_ODR,odr);
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_gyro_st_lsm6ds3_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case GYRO_RANGE_250DPS:{
tmp = LSM6DS3_GYRO_RANGE_245;
}break;
case GYRO_RANGE_500DPS:{
tmp = LSM6DS3_GYRO_RANGE_500;
}break;
case GYRO_RANGE_1000DPS:{
tmp = LSM6DS3_GYRO_RANGE_1000;
}break;
case GYRO_RANGE_2000DPS:{
tmp = LSM6DS3_GYRO_RANGE_2000;
}break;
default:break;
}
value = LSM6DS3_SET_BITSLICE(value,LSM6DS3_GYRO_RANGE,tmp);
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= GYRO_RANGE_250DPS)&&(range <= GYRO_RANGE_2000DPS)){
cur_gyro_factor = lsm6ds3_gyro_factor[range];
}
return 0;
}
static int drv_gyro_st_lsm6ds3_st_discard(i2c_dev_t* drv)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
for (i = 0; i < LSM6DS3_GYRO_SELF_TEST_DRY_WAIT_CNT; i ++) {
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x02)
break;
aos_msleep(20);
}
if (i >= LSM6DS3_GYRO_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_OUTX_L_G, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
return ret;
}
static int drv_gyro_st_lsm6ds3_st_data(i2c_dev_t* drv,int32_t* data)
{
uint8_t i, j;
int16_t x_raw, y_raw, z_raw;
int32_t x_dps, y_dps, z_dps;
int32_t x_sum, y_sum, z_sum;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
x_sum = 0; y_sum = 0; z_sum = 0;
for (i = 0; i < LSM6DS3_GYRO_SELF_TEST_AVG_SAMPLE_CNT; i ++) {
for (j = 0; j < LSM6DS3_GYRO_SELF_TEST_DRY_WAIT_CNT; j ++) {
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x02)
break;
aos_msleep(5);
}
if (j >= LSM6DS3_GYRO_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_OUTX_L_G, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
x_raw = (buffer[1] << 8) + buffer[0];
y_raw = (buffer[3] << 8) + buffer[2];
z_raw = (buffer[5] << 8) + buffer[4];
//LOG("%s %s %d: i(%d), raw(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_raw, y_raw, z_raw);
x_dps = x_raw * LSM6DS3_GYRO_SENSITIVITY_2000DPS / 1000000;
y_dps = y_raw * LSM6DS3_GYRO_SENSITIVITY_2000DPS / 1000000;
z_dps = z_raw * LSM6DS3_GYRO_SENSITIVITY_2000DPS / 1000000;
//LOG("%s %s %d: i(%d), dps(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_dps, y_dps, z_dps);
x_sum += x_dps;
y_sum += y_dps;
z_sum += z_dps;
}
data[0] = x_sum / LSM6DS3_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[1] = y_sum / LSM6DS3_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[2] = z_sum / LSM6DS3_ACC_SELF_TEST_AVG_SAMPLE_CNT;
return ret;
}
static int drv_gyro_st_lsm6ds3_self_test(i2c_dev_t* drv,int32_t* data)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t ctrl_reg[10];
int32_t out_nost[3];
int32_t out_st[3];
int32_t out_diff[3];
const uint8_t ctrl_val[10] = { 0, 0x5c, 0x44, 0, 0, 0, 0, 0, 0, 0 };
// Save cfg registers which will be modified during self-test
ret = sensor_i2c_read(drv, LSM6DS3_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
// Initialize Sensor, turn on sensor, enable P/R/Y
// Set BDU=1, ODR = 208Hz, FS=2000dps
for (i = 0; i < 10; i ++) {
value = ctrl_val[i];
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL1_XL + i, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
}
aos_msleep(150);
// Discard the first sample
ret = drv_gyro_st_lsm6ds3_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and averate them
ret = drv_gyro_st_lsm6ds3_st_data(drv, out_nost);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Enable seft-test
value = 0x04;
ret = sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL5_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(50);
// Discard the first sample
ret = drv_gyro_st_lsm6ds3_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and average them
ret = drv_gyro_st_lsm6ds3_st_data(drv, out_st);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Check if the differences are between min and max
for (i = 0; i < 3; i ++) {
out_diff[i] = abs(out_st[i] - out_nost[i]);
data[i] = out_diff[i];
}
if ((LSM6DS3_GYRO_SELF_TEST_MIN_X > out_diff[0]) || (out_diff[0] > LSM6DS3_GYRO_SELF_TEST_MAX_X)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DS3_GYRO_SELF_TEST_MIN_Y > out_diff[1]) || (out_diff[1] > LSM6DS3_GYRO_SELF_TEST_MAX_Y)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DS3_GYRO_SELF_TEST_MIN_Z > out_diff[2]) || (out_diff[2] > LSM6DS3_GYRO_SELF_TEST_MAX_Z)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
restore:
ret += sensor_i2c_write(drv, LSM6DS3_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
return ret;
}
static void drv_gyro_st_lsm6ds3_irq_handle(void)
{
/* no handle so far */
}
static int drv_gyro_st_lsm6ds3_open(void)
{
int ret = 0;
ret = drv_gyro_st_lsm6ds3_set_power_mode(&lsm6ds3_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6ds3_set_bdu(&lsm6ds3_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_st_lsm6ds3_set_range(&lsm6ds3_ctx, GYRO_RANGE_1000DPS);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_st_lsm6ds3_set_odr(&lsm6ds3_ctx, LSM6DS3_GYRO_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_gyro_st_lsm6ds3_close(void)
{
int ret = 0;
ret = drv_gyro_st_lsm6ds3_set_power_mode(&lsm6ds3_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_gyro_st_lsm6ds3_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
gyro_data_t *gyro = (gyro_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(gyro_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lsm6ds3_ctx, LSM6DS3_ACC_GYRO_OUTX_L_G, ®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3_ctx, LSM6DS3_ACC_GYRO_OUTX_H_G, ®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3_ctx, LSM6DS3_ACC_GYRO_OUTY_L_G, ®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3_ctx, LSM6DS3_ACC_GYRO_OUTY_H_G, ®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3_ctx, LSM6DS3_ACC_GYRO_OUTZ_L_G, ®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3_ctx, LSM6DS3_ACC_GYRO_OUTZ_H_G, ®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
gyro->data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)reg[1]))<< LSM6DS3_SHIFT_EIGHT_BITS)|(reg[0]));
gyro->data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)reg[3]))<< LSM6DS3_SHIFT_EIGHT_BITS)|(reg[2]));
gyro->data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)reg[5]))<< LSM6DS3_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_gyro_factor != 0){
gyro->data[DATA_AXIS_X] = (gyro->data[DATA_AXIS_X] * cur_gyro_factor)/LSM6DS3_GYRO_MUL;
gyro->data[DATA_AXIS_Y] = (gyro->data[DATA_AXIS_Y] * cur_gyro_factor)/LSM6DS3_GYRO_MUL;
gyro->data[DATA_AXIS_Z] = (gyro->data[DATA_AXIS_Z] * cur_gyro_factor)/LSM6DS3_GYRO_MUL;
}
gyro->timestamp = aos_now_ms();
return (int)size;
}
static int drv_gyro_st_lsm6ds3_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_gyro_st_lsm6ds3_set_odr(&lsm6ds3_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_gyro_st_lsm6ds3_set_range(&lsm6ds3_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_gyro_st_lsm6ds3_set_power_mode(&lsm6ds3_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
//dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LSM6DS3";
info->range_max = 2000;
info->range_min = 125;
info->unit = udps;
}break;
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_gyro_st_lsm6ds3_self_test(&lsm6ds3_ctx, (int32_t*)info->data);
//printf("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
LOG("%s %s: %d, %d, %d\n", SENSOR_STR, __func__, info->data[0],info->data[1],info->data[2]);
return ret;
}
default:break;
}
return 0;
}
int drv_gyro_st_lsm6ds3_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_GYRO;
sensor.path = dev_gyro_path;
sensor.open = drv_gyro_st_lsm6ds3_open;
sensor.close = drv_gyro_st_lsm6ds3_close;
sensor.read = drv_gyro_st_lsm6ds3_read;
sensor.write = NULL;
sensor.ioctl = drv_gyro_st_lsm6ds3_ioctl;
sensor.irq_handle = drv_gyro_st_lsm6ds3_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6ds3_validate_id(&lsm6ds3_ctx, LSM6DS3_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
if(0 == g_lsm6ds3flag){
ret = drv_acc_gyro_st_lsm6ds3_soft_reset(&lsm6ds3_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_st_lsm6ds3_set_power_mode(&lsm6ds3_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
g_lsm6ds3flag = 1;
}
else{
LOG("%s %s gyro do not need reset\n", SENSOR_STR, __func__);
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_lsm6ds3_init);
SENSOR_DRV_ADD(drv_gyro_st_lsm6ds3_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_gyro_st_lsm6ds3.c
|
C
|
apache-2.0
| 40,823
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LSM6DS3TR_C_I2C_ADDR1 (0x6A)
#define LSM6DS3TR_C_I2C_ADDR2 (0x6B)
#define LSM6DS3TR_C_I2C_ADDR_TRANS(n) ((n)<<1)
#define LSM6DS3TR_C_I2C_ADDR LSM6DS3TR_C_I2C_ADDR_TRANS(LSM6DS3TR_C_I2C_ADDR2)
#define LSM6DS3TR_C_ACC_GYRO_FUNC_CFG_ACCESS 0x01
#define LSM6DS3TR_C_ACC_GYRO_SENSOR_SYNC_TIME 0x04
#define LSM6DS3TR_C_ACC_GYRO_SENSOR_RES_RATIO 0x05
#define LSM6DS3TR_C_ACC_GYRO_FIFO_CTRL1 0x06
#define LSM6DS3TR_C_ACC_GYRO_FIFO_CTRL2 0x07
#define LSM6DS3TR_C_ACC_GYRO_FIFO_CTRL3 0x08
#define LSM6DS3TR_C_ACC_GYRO_FIFO_CTRL4 0x09
#define LSM6DS3TR_C_ACC_GYRO_FIFO_CTRL5 0x0A
#define LSM6DS3TR_C_ACC_GYRO_DRDY_PULSE_CFG_G 0x0B
#define LSM6DS3TR_C_ACC_GYRO_INT1_CTRL 0x0D
#define LSM6DS3TR_C_ACC_GYRO_INT2_CTRL 0x0E
#define LSM6DS3TR_C_ACC_GYRO_WHO_AM_I_REG 0x0F
#define LSM6DS3TR_C_ACC_GYRO_CTRL1_XL 0x10
#define LSM6DS3TR_C_ACC_GYRO_CTRL2_G 0x11
#define LSM6DS3TR_C_ACC_GYRO_CTRL3_C 0x12
#define LSM6DS3TR_C_ACC_GYRO_CTRL4_C 0x13
#define LSM6DS3TR_C_ACC_GYRO_CTRL5_C 0x14
#define LSM6DS3TR_C_ACC_GYRO_CTRL6_C 0x15
#define LSM6DS3TR_C_ACC_GYRO_CTRL7_G 0x16
#define LSM6DS3TR_C_ACC_GYRO_CTRL8_XL 0x17
#define LSM6DS3TR_C_ACC_GYRO_CTRL9_XL 0x18
#define LSM6DS3TR_C_ACC_GYRO_CTRL10_C 0x19
#define LSM6DS3TR_C_ACC_GYRO_MASTER_CONFIG 0x1A
#define LSM6DS3TR_C_ACC_GYRO_WAKE_UP_SRC 0x1B
#define LSM6DS3TR_C_ACC_GYRO_TAP_SRC 0x1C
#define LSM6DS3TR_C_ACC_GYRO_D6D_SRC 0x1D
#define LSM6DS3TR_C_ACC_GYRO_STATUS_REG 0x1E
#define LSM6DS3TR_C_ACC_GYRO_OUT_TEMP_L 0x20
#define LSM6DS3TR_C_ACC_GYRO_OUT_TEMP_H 0x21
#define LSM6DS3TR_C_ACC_GYRO_OUTX_L_G 0x22
#define LSM6DS3TR_C_ACC_GYRO_OUTX_H_G 0x23
#define LSM6DS3TR_C_ACC_GYRO_OUTY_L_G 0x24
#define LSM6DS3TR_C_ACC_GYRO_OUTY_H_G 0x25
#define LSM6DS3TR_C_ACC_GYRO_OUTZ_L_G 0x26
#define LSM6DS3TR_C_ACC_GYRO_OUTZ_H_G 0x27
#define LSM6DS3TR_C_ACC_GYRO_OUTX_L_XL 0x28
#define LSM6DS3TR_C_ACC_GYRO_OUTX_H_XL 0x29
#define LSM6DS3TR_C_ACC_GYRO_OUTY_L_XL 0x2A
#define LSM6DS3TR_C_ACC_GYRO_OUTY_H_XL 0x2B
#define LSM6DS3TR_C_ACC_GYRO_OUTZ_L_XL 0x2C
#define LSM6DS3TR_C_ACC_GYRO_OUTZ_H_XL 0x2D
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB1_REG 0x2E
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB2_REG 0x2F
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB3_REG 0x30
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB4_REG 0x31
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB5_REG 0x32
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB6_REG 0x33
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB7_REG 0x34
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB8_REG 0x35
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB9_REG 0x36
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB10_REG 0x37
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB11_REG 0x38
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB12_REG 0x39
#define LSM6DS3TR_C_ACC_GYRO_FIFO_STATUS1 0x3A
#define LSM6DS3TR_C_ACC_GYRO_FIFO_STATUS2 0x3B
#define LSM6DS3TR_C_ACC_GYRO_FIFO_STATUS3 0x3C
#define LSM6DS3TR_C_ACC_GYRO_FIFO_STATUS4 0x3D
#define LSM6DS3TR_C_ACC_GYRO_FIFO_DATA_OUT_L 0x3E
#define LSM6DS3TR_C_ACC_GYRO_FIFO_DATA_OUT_H 0x3F
#define LSM6DS3TR_C_ACC_GYRO_TIMESTAMP0_REG 0x40
#define LSM6DS3TR_C_ACC_GYRO_TIMESTAMP1_REG 0x41
#define LSM6DS3TR_C_ACC_GYRO_TIMESTAMP2_REG 0x42
#define LSM6DS3TR_C_ACC_GYRO_TIMESTAMP_L 0x49
#define LSM6DS3TR_C_ACC_GYRO_TIMESTAMP_H 0x4A
#define LSM6DS3TR_C_ACC_GYRO_STEP_COUNTER_L 0x4B
#define LSM6DS3TR_C_ACC_GYRO_STEP_COUNTER_H 0x4C
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB13_REG 0x4D
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB14_REG 0x4E
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB15_REG 0x4F
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB16_REG 0x50
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB17_REG 0x51
#define LSM6DS3TR_C_ACC_GYRO_SENSORHUB18_REG 0x52
#define LSM6DS3TR_C_ACC_GYRO_FUNC_SRC 0x53
#define LSM6DS3TR_C_ACC_GYRO_TAP_CFG1 0x58
#define LSM6DS3TR_C_ACC_GYRO_TAP_THS_6D 0x59
#define LSM6DS3TR_C_ACC_GYRO_INT_DUR2 0x5A
#define LSM6DS3TR_C_ACC_GYRO_WAKE_UP_THS 0x5B
#define LSM6DS3TR_C_ACC_GYRO_WAKE_UP_DUR 0x5C
#define LSM6DS3TR_C_ACC_GYRO_FREE_FALL 0x5D
#define LSM6DS3TR_C_ACC_GYRO_MD1_CFG 0x5E
#define LSM6DS3TR_C_ACC_GYRO_MD2_CFG 0x5F
#define LSM6DS3TR_C_ACC_GYRO_OUT_MAG_RAW_X_L 0x66
#define LSM6DS3TR_C_ACC_GYRO_OUT_MAG_RAW_X_H 0x67
#define LSM6DS3TR_C_ACC_GYRO_OUT_MAG_RAW_Y_L 0x68
#define LSM6DS3TR_C_ACC_GYRO_OUT_MAG_RAW_Y_H 0x69
#define LSM6DS3TR_C_ACC_GYRO_OUT_MAG_RAW_Z_L 0x6A
#define LSM6DS3TR_C_ACC_GYRO_OUT_MAG_RAW_Z_H 0x6B
#define LSM6DS3TR_C_ACC_GYRO_X_OFS_USR 0x73
#define LSM6DS3TR_C_ACC_GYRO_Y_OFS_USR 0x74
#define LSM6DS3TR_C_ACC_GYRO_Z_OFS_USR 0x75
#define LSM6DS3TR_C_CHIP_ID_VALUE (0x6A)
#define LSM6DS3TR_C_RESET_VALUE (0x1)
#define LSM6DS3TR_C_RESET_MSK (0X1)
#define LSM6DS3TR_C_RESET_POS (0)
#define LSM6DS3TR_C_BDU_VALUE (0x40)
#define LSM6DS3TR_C_BDU_MSK (0X40)
#define LSM6DS3TR_C_BDU_POS (6)
#define LSM6DS3TR_C_ACC_ODR_POWER_DOWN (0X00)
#define LSM6DS3TR_C_ACC_ODR_1_6_HZ (0X0B)
#define LSM6DS3TR_C_ACC_ODR_12_5_HZ (0x01)
#define LSM6DS3TR_C_ACC_ODR_26_HZ (0x02)
#define LSM6DS3TR_C_ACC_ODR_52_HZ (0x03)
#define LSM6DS3TR_C_ACC_ODR_104_HZ (0x04)
#define LSM6DS3TR_C_ACC_ODR_208_HZ (0x05)
#define LSM6DS3TR_C_ACC_ODR_416_HZ (0x06)
#define LSM6DS3TR_C_ACC_ODR_833_HZ (0x07)
#define LSM6DS3TR_C_ACC_ODR_1_66_KHZ (0x08)
#define LSM6DS3TR_C_ACC_ODR_3_33_KHZ (0x09)
#define LSM6DS3TR_C_ACC_ODR_6_66_KHZ (0x0A)
#define LSM6DS3TR_C_ACC_ODR_MSK (0XF0)
#define LSM6DS3TR_C_ACC_ODR_POS (4)
#define LSM6DS3TR_C_GYRO_ODR_POWER_DOWN (0X00)
#define LSM6DS3TR_C_GYRO_ODR_12_5_HZ (0x01)
#define LSM6DS3TR_C_GYRO_ODR_26_HZ (0x02)
#define LSM6DS3TR_C_GYRO_ODR_52_HZ (0x03)
#define LSM6DS3TR_C_GYRO_ODR_104_HZ (0x04)
#define LSM6DS3TR_C_GYRO_ODR_208_HZ (0x05)
#define LSM6DS3TR_C_GYRO_ODR_416_HZ (0x06)
#define LSM6DS3TR_C_GYRO_ODR_833_HZ (0x07)
#define LSM6DS3TR_C_GYRO_ODR_1_66_KHZ (0x08)
#define LSM6DS3TR_C_GYRO_ODR_3_33_KHZ (0x09)
#define LSM6DS3TR_C_GYRO_ODR_6_66_KHZ (0x0A)
#define LSM6DS3TR_C_GYRO_ODR_MSK (0XF0)
#define LSM6DS3TR_C_GYRO_ODR_POS (4)
#define LSM6DS3TR_C_ACC_RANGE_2G (0x0)
#define LSM6DS3TR_C_ACC_RANGE_4G (0x2)
#define LSM6DS3TR_C_ACC_RANGE_8G (0x3)
#define LSM6DS3TR_C_ACC_RANGE_16G (0x1)
#define LSM6DS3TR_C_ACC_RANGE_MSK (0X0C)
#define LSM6DS3TR_C_ACC_RANGE_POS (2)
#define LSM6DS3TR_C_ACC_SENSITIVITY_2G (61)
#define LSM6DS3TR_C_ACC_SENSITIVITY_4G (122)
#define LSM6DS3TR_C_ACC_SENSITIVITY_8G (244)
#define LSM6DS3TR_C_ACC_SENSITIVITY_16G (488)
#define LSM6DS3TR_C_GYRO_RANGE_245 (0x0)
#define LSM6DS3TR_C_GYRO_RANGE_500 (0x1)
#define LSM6DS3TR_C_GYRO_RANGE_1000 (0x2)
#define LSM6DS3TR_C_GYRO_RANGE_2000 (0x3)
#define LSM6DS3TR_C_GYRO_RANGE_MSK (0X0C)
#define LSM6DS3TR_C_GYRO_RANGE_POS (2)
#define LSM6DS3TR_C_GYRO_SENSITIVITY_245DPS (8750)
#define LSM6DS3TR_C_GYRO_SENSITIVITY_500DPS (17500)
#define LSM6DS3TR_C_GYRO_SENSITIVITY_1000DPS (35000)
#define LSM6DS3TR_C_GYRO_SENSITIVITY_2000DPS (70000)
#define LSM6DS3TR_C_SHIFT_EIGHT_BITS (8)
#define LSM6DS3TR_C_16_BIT_SHIFT (0xFF)
#define LSM6DS3TR_C_ACC_MUL (1000)
#define LSM6DS3TR_C_GYRO_MUL (1)
#define LSM6DS3TR_C_ACC_DEFAULT_ODR_100HZ (100)
#define LSM6DS3TR_C_GYRO_DEFAULT_ODR_100HZ (100)
#define LSM6DS3TR_C_ACC_SELF_TEST_MIN_X (90) // 90mg
#define LSM6DS3TR_C_ACC_SELF_TEST_MIN_Y (90) // 90mg
#define LSM6DS3TR_C_ACC_SELF_TEST_MIN_Z (90) // 90mg
#define LSM6DS3TR_C_ACC_SELF_TEST_MAX_X (1700) // 1700mg
#define LSM6DS3TR_C_ACC_SELF_TEST_MAX_Y (1700) // 1700mg
#define LSM6DS3TR_C_ACC_SELF_TEST_MAX_Z (1700) // 1700mg
#define LSM6DS3TR_C_ACC_SELF_TEST_DRY_WAIT_CNT 5
#define LSM6DS3TR_C_ACC_SELF_TEST_AVG_SAMPLE_CNT 5
#define LSM6DS3TR_C_GYRO_SELF_TEST_MIN_X (150) // 150dps
#define LSM6DS3TR_C_GYRO_SELF_TEST_MIN_Y (150) // 150dps
#define LSM6DS3TR_C_GYRO_SELF_TEST_MIN_Z (150) // 150dps
#define LSM6DS3TR_C_GYRO_SELF_TEST_MAX_X (700) // 700dps
#define LSM6DS3TR_C_GYRO_SELF_TEST_MAX_Y (700) // 700dps
#define LSM6DS3TR_C_GYRO_SELF_TEST_MAX_Z (700) // 700dps
#define LSM6DS3TR_C_GYRO_SELF_TEST_DRY_WAIT_CNT 5
#define LSM6DS3TR_C_GYRO_SELF_TEST_AVG_SAMPLE_CNT 5
#define LSM6DS3TR_C_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define LSM6DS3TR_C_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t lsm6ds3tr_c_acc_factor[ACC_RANGE_MAX] = { LSM6DS3TR_C_ACC_SENSITIVITY_2G, LSM6DS3TR_C_ACC_SENSITIVITY_4G,
LSM6DS3TR_C_ACC_SENSITIVITY_8G, LSM6DS3TR_C_ACC_SENSITIVITY_16G };
static int32_t lsm6ds3tr_c_gyro_factor[GYRO_RANGE_MAX] = {0, LSM6DS3TR_C_GYRO_SENSITIVITY_245DPS, LSM6DS3TR_C_GYRO_SENSITIVITY_500DPS,
LSM6DS3TR_C_GYRO_SENSITIVITY_1000DPS, LSM6DS3TR_C_GYRO_SENSITIVITY_2000DPS };
static int32_t cur_acc_factor = 0;
static int32_t cur_gyro_factor = 0;
static int32_t g_lsm6ds3tr_cflag = 0;
static i2c_dev_t lsm6ds3tr_c_ctx = {
//.port = 4,
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LSM6DS3TR_C_I2C_ADDR,
};
static int drv_acc_gyro_st_lsm6ds3tr_c_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LSM6DS3TR_C_RESET_VALUE;
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_gyro_st_lsm6ds3tr_c_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_WHO_AM_I_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
LOG("%s %s right id (0x%02x), read id(0x%02x)\n", SENSOR_STR, __func__, id_value, value);
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6ds3tr_c_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LSM6DS3TR_C_SET_BITSLICE(value,LSM6DS3TR_C_ACC_ODR,LSM6DS3TR_C_ACC_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LSM6DS3TR_C_SET_BITSLICE(value,LSM6DS3TR_C_ACC_ODR,LSM6DS3TR_C_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LSM6DS3TR_C_SET_BITSLICE(value,LSM6DS3TR_C_ACC_ODR,LSM6DS3TR_C_ACC_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static int drv_acc_gyro_st_lsm6ds3tr_c_set_bdu(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (value & LSM6DS3TR_C_BDU_VALUE)
return 0;
value |= LSM6DS3TR_C_BDU_VALUE;
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static uint8_t drv_acc_st_lsm6ds3tr_c_hz2odr(uint32_t hz)
{
if(hz > 3330)
return LSM6DS3TR_C_ACC_ODR_6_66_KHZ;
else if(hz > 1660)
return LSM6DS3TR_C_ACC_ODR_3_33_KHZ;
else if(hz > 833)
return LSM6DS3TR_C_ACC_ODR_1_66_KHZ;
else if(hz > 416)
return LSM6DS3TR_C_ACC_ODR_833_HZ;
else if(hz > 208)
return LSM6DS3TR_C_ACC_ODR_416_HZ;
else if(hz > 104)
return LSM6DS3TR_C_ACC_ODR_208_HZ;
else if(hz > 52)
return LSM6DS3TR_C_ACC_ODR_104_HZ;
else if(hz > 26)
return LSM6DS3TR_C_ACC_ODR_52_HZ;
else if(hz > 13)
return LSM6DS3TR_C_ACC_ODR_26_HZ;
else if(hz >= 2)
return LSM6DS3TR_C_ACC_ODR_12_5_HZ;
else
return LSM6DS3TR_C_ACC_ODR_1_6_HZ;
}
static int drv_acc_st_lsm6ds3tr_c_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_lsm6ds3tr_c_hz2odr(hz);
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LSM6DS3TR_C_SET_BITSLICE(value,LSM6DS3TR_C_ACC_ODR,odr);
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lsm6ds3tr_c_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_2G:{
tmp = LSM6DS3TR_C_ACC_RANGE_2G;
}break;
case ACC_RANGE_4G:{
tmp = LSM6DS3TR_C_ACC_RANGE_4G;
}break;
case ACC_RANGE_8G:{
tmp = LSM6DS3TR_C_ACC_RANGE_8G;
}break;
case ACC_RANGE_16G:{
tmp = LSM6DS3TR_C_ACC_RANGE_16G;
}break;
default:break;
}
value = LSM6DS3TR_C_SET_BITSLICE(value,LSM6DS3TR_C_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)){
cur_acc_factor = lsm6ds3tr_c_acc_factor[range];
}
return 0;
}
static int drv_acc_st_lsm6ds3tr_c_st_discard(i2c_dev_t* drv)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
for (i = 0; i < LSM6DS3TR_C_ACC_SELF_TEST_DRY_WAIT_CNT; i ++) {
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x01)
break;
aos_msleep(20);
}
if (i >= LSM6DS3TR_C_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_OUTX_L_XL, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
return ret;
}
static int drv_acc_st_lsm6ds3tr_c_st_data(i2c_dev_t* drv,int32_t* data)
{
uint8_t i, j;
int16_t x_raw, y_raw, z_raw;
int32_t x_mg, y_mg, z_mg;
int32_t x_sum, y_sum, z_sum;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
x_sum = 0; y_sum = 0; z_sum = 0;
for (i = 0; i < LSM6DS3TR_C_ACC_SELF_TEST_AVG_SAMPLE_CNT; i ++) {
for (j = 0; j < LSM6DS3TR_C_ACC_SELF_TEST_DRY_WAIT_CNT; j ++) {
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x01)
break;
aos_msleep(20);
}
if (j >= LSM6DS3TR_C_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_OUTX_L_XL, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
x_raw = (buffer[1] << 8) + buffer[0];
y_raw = (buffer[3] << 8) + buffer[2];
z_raw = (buffer[5] << 8) + buffer[4];
//LOG("%s %s %d: i(%d), raw(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_raw, y_raw, z_raw);
x_mg = x_raw * LSM6DS3TR_C_ACC_SENSITIVITY_4G / 1000;
y_mg = y_raw * LSM6DS3TR_C_ACC_SENSITIVITY_4G / 1000;
z_mg = z_raw * LSM6DS3TR_C_ACC_SENSITIVITY_4G / 1000;
//LOG("%s %s %d: i(%d), mg(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_mg, y_mg, z_mg);
x_sum += x_mg;
y_sum += y_mg;
z_sum += z_mg;
}
data[0] = x_sum / LSM6DS3TR_C_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[1] = y_sum / LSM6DS3TR_C_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[2] = z_sum / LSM6DS3TR_C_ACC_SELF_TEST_AVG_SAMPLE_CNT;
return ret;
}
static int drv_acc_st_lsm6ds3tr_c_self_test(i2c_dev_t* drv,int32_t* data)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t ctrl_reg[10];
int32_t out_nost[3];
int32_t out_st[3];
int32_t out_diff[3];
const uint8_t ctrl_val[10] = { 0x38, 0, 0x44, 0, 0, 0, 0, 0, 0, 0 };
// Save cfg registers which will be modified during self-test
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
// Initialize Sensor, turn on sensor, enable X/Y/Z axes
// Set BDU=1, FS=4G, ODR = 52Hz
for (i = 0; i < 10; i ++) {
value = ctrl_val[i];
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL1_XL + i, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
}
aos_msleep(100);
// Discard the first sample
ret = drv_acc_st_lsm6ds3tr_c_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and averate them
ret = drv_acc_st_lsm6ds3tr_c_st_data(drv, out_nost);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Enable seft-test
value = 0x01;
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL5_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(100);
// Discard the first sample
ret = drv_acc_st_lsm6ds3tr_c_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and average them
ret = drv_acc_st_lsm6ds3tr_c_st_data(drv, out_st);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Check if the differences are between min and max
for (i = 0; i < 3; i ++) {
out_diff[i] = abs(out_st[i] - out_nost[i]);
data[i] = out_diff[i];
}
if ((LSM6DS3TR_C_ACC_SELF_TEST_MIN_X > out_diff[0]) || (out_diff[0] > LSM6DS3TR_C_ACC_SELF_TEST_MAX_X)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DS3TR_C_ACC_SELF_TEST_MIN_Y > out_diff[1]) || (out_diff[1] > LSM6DS3TR_C_ACC_SELF_TEST_MAX_Y)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DS3TR_C_ACC_SELF_TEST_MIN_Z > out_diff[2]) || (out_diff[2] > LSM6DS3TR_C_ACC_SELF_TEST_MAX_Z)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
restore:
ret += sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
return ret;
}
static void drv_acc_st_lsm6ds3tr_c_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_lsm6ds3tr_c_open(void)
{
int ret = 0;
ret = drv_acc_st_lsm6ds3tr_c_set_power_mode(&lsm6ds3tr_c_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6ds3tr_c_set_bdu(&lsm6ds3tr_c_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm6ds3tr_c_set_range(&lsm6ds3tr_c_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm6ds3tr_c_set_odr(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6ds3tr_c_close(void)
{
int ret = 0;
ret = drv_acc_st_lsm6ds3tr_c_set_power_mode(&lsm6ds3tr_c_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6ds3tr_c_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_ACC_GYRO_OUTX_L_XL, ®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_ACC_GYRO_OUTX_H_XL, ®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_ACC_GYRO_OUTY_L_XL, ®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_ACC_GYRO_OUTY_H_XL, ®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_ACC_GYRO_OUTZ_L_XL, ®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_ACC_GYRO_OUTZ_H_XL, ®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< LSM6DS3TR_C_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< LSM6DS3TR_C_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< LSM6DS3TR_C_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = (accel->data[DATA_AXIS_X] * cur_acc_factor)/LSM6DS3TR_C_ACC_MUL;
accel->data[DATA_AXIS_Y] = (accel->data[DATA_AXIS_Y] * cur_acc_factor)/LSM6DS3TR_C_ACC_MUL;
accel->data[DATA_AXIS_Z] = (accel->data[DATA_AXIS_Z] * cur_acc_factor)/LSM6DS3TR_C_ACC_MUL;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_lsm6ds3tr_c_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_lsm6ds3tr_c_set_odr(&lsm6ds3tr_c_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_st_lsm6ds3tr_c_set_range(&lsm6ds3tr_c_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_lsm6ds3tr_c_set_power_mode(&lsm6ds3tr_c_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
//dev_sensor_info_t *info = (dev_sensor_info_t*)arg;
info->model = "LSM6DS3TR_C";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}break;
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_acc_st_lsm6ds3tr_c_self_test(&lsm6ds3tr_c_ctx, (int32_t*)info->data);
//printf("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
LOG("%s %s: %d, %d, %d\n", SENSOR_STR, __func__, info->data[0],info->data[1],info->data[2]);
return ret;
}
default:break;
}
return 0;
}
int drv_acc_st_lsm6ds3tr_c_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_lsm6ds3tr_c_open;
sensor.close = drv_acc_st_lsm6ds3tr_c_close;
sensor.read = drv_acc_st_lsm6ds3tr_c_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_lsm6ds3tr_c_ioctl;
sensor.irq_handle = drv_acc_st_lsm6ds3tr_c_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6ds3tr_c_validate_id(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
if(0 == g_lsm6ds3tr_cflag)
{
ret = drv_acc_gyro_st_lsm6ds3tr_c_soft_reset(&lsm6ds3tr_c_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm6ds3tr_c_set_power_mode(&lsm6ds3tr_c_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
g_lsm6ds3tr_cflag = 1;
}
else
{
LOG("%s %s acc do not need reset\n", SENSOR_STR, __func__);
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_gyro_st_lsm6ds3tr_c_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LSM6DS3TR_C_SET_BITSLICE(value,LSM6DS3TR_C_GYRO_ODR,LSM6DS3TR_C_GYRO_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LSM6DS3TR_C_SET_BITSLICE(value,LSM6DS3TR_C_GYRO_ODR,LSM6DS3TR_C_GYRO_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LSM6DS3TR_C_SET_BITSLICE(value,LSM6DS3TR_C_GYRO_ODR,LSM6DS3TR_C_GYRO_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_gyro_st_lsm6ds3tr_c_hz2odr(uint32_t hz)
{
if(hz > 3330)
return LSM6DS3TR_C_GYRO_ODR_6_66_KHZ;
else if(hz > 1660)
return LSM6DS3TR_C_GYRO_ODR_3_33_KHZ;
else if(hz > 833)
return LSM6DS3TR_C_GYRO_ODR_1_66_KHZ;
else if(hz > 416)
return LSM6DS3TR_C_GYRO_ODR_833_HZ;
else if(hz > 208)
return LSM6DS3TR_C_GYRO_ODR_416_HZ;
else if(hz > 104)
return LSM6DS3TR_C_GYRO_ODR_208_HZ;
else if(hz > 52)
return LSM6DS3TR_C_GYRO_ODR_104_HZ;
else if(hz > 26)
return LSM6DS3TR_C_GYRO_ODR_52_HZ;
else if(hz > 13)
return LSM6DS3TR_C_GYRO_ODR_26_HZ;
else
return LSM6DS3TR_C_GYRO_ODR_12_5_HZ;
}
static int drv_gyro_st_lsm6ds3tr_c_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_gyro_st_lsm6ds3tr_c_hz2odr(hz);
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LSM6DS3TR_C_SET_BITSLICE(value,LSM6DS3TR_C_GYRO_ODR,odr);
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_gyro_st_lsm6ds3tr_c_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case GYRO_RANGE_250DPS:{
tmp = LSM6DS3TR_C_GYRO_RANGE_245;
}break;
case GYRO_RANGE_500DPS:{
tmp = LSM6DS3TR_C_GYRO_RANGE_500;
}break;
case GYRO_RANGE_1000DPS:{
tmp = LSM6DS3TR_C_GYRO_RANGE_1000;
}break;
case GYRO_RANGE_2000DPS:{
tmp = LSM6DS3TR_C_GYRO_RANGE_2000;
}break;
default:break;
}
value = LSM6DS3TR_C_SET_BITSLICE(value,LSM6DS3TR_C_GYRO_RANGE,tmp);
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= GYRO_RANGE_250DPS)&&(range <= GYRO_RANGE_2000DPS)){
cur_gyro_factor = lsm6ds3tr_c_gyro_factor[range];
}
return 0;
}
static int drv_gyro_st_lsm6ds3tr_c_st_discard(i2c_dev_t* drv)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
for (i = 0; i < LSM6DS3TR_C_GYRO_SELF_TEST_DRY_WAIT_CNT; i ++) {
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x02)
break;
aos_msleep(20);
}
if (i >= LSM6DS3TR_C_GYRO_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_OUTX_L_G, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
return ret;
}
static int drv_gyro_st_lsm6ds3tr_c_st_data(i2c_dev_t* drv,int32_t* data)
{
uint8_t i, j;
int16_t x_raw, y_raw, z_raw;
int32_t x_dps, y_dps, z_dps;
int32_t x_sum, y_sum, z_sum;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
x_sum = 0; y_sum = 0; z_sum = 0;
for (i = 0; i < LSM6DS3TR_C_GYRO_SELF_TEST_AVG_SAMPLE_CNT; i ++) {
for (j = 0; j < LSM6DS3TR_C_GYRO_SELF_TEST_DRY_WAIT_CNT; j ++) {
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x02)
break;
aos_msleep(5);
}
if (j >= LSM6DS3TR_C_GYRO_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_OUTX_L_G, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
x_raw = (buffer[1] << 8) + buffer[0];
y_raw = (buffer[3] << 8) + buffer[2];
z_raw = (buffer[5] << 8) + buffer[4];
//LOG("%s %s %d: i(%d), raw(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_raw, y_raw, z_raw);
x_dps = x_raw * LSM6DS3TR_C_GYRO_SENSITIVITY_2000DPS / 1000000;
y_dps = y_raw * LSM6DS3TR_C_GYRO_SENSITIVITY_2000DPS / 1000000;
z_dps = z_raw * LSM6DS3TR_C_GYRO_SENSITIVITY_2000DPS / 1000000;
//LOG("%s %s %d: i(%d), dps(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_dps, y_dps, z_dps);
x_sum += x_dps;
y_sum += y_dps;
z_sum += z_dps;
}
data[0] = x_sum / LSM6DS3TR_C_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[1] = y_sum / LSM6DS3TR_C_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[2] = z_sum / LSM6DS3TR_C_ACC_SELF_TEST_AVG_SAMPLE_CNT;
return ret;
}
static int drv_gyro_st_lsm6ds3tr_c_self_test(i2c_dev_t* drv,int32_t* data)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t ctrl_reg[10];
int32_t out_nost[3];
int32_t out_st[3];
int32_t out_diff[3];
const uint8_t ctrl_val[10] = { 0, 0x5c, 0x44, 0, 0, 0, 0, 0, 0, 0 };
// Save cfg registers which will be modified during self-test
ret = sensor_i2c_read(drv, LSM6DS3TR_C_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
// Initialize Sensor, turn on sensor, enable P/R/Y
// Set BDU=1, ODR = 208Hz, FS=2000dps
for (i = 0; i < 10; i ++) {
value = ctrl_val[i];
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL1_XL + i, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
}
aos_msleep(150);
// Discard the first sample
ret = drv_gyro_st_lsm6ds3tr_c_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and averate them
ret = drv_gyro_st_lsm6ds3tr_c_st_data(drv, out_nost);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Enable seft-test
value = 0x04;
ret = sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL5_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(50);
// Discard the first sample
ret = drv_gyro_st_lsm6ds3tr_c_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and average them
ret = drv_gyro_st_lsm6ds3tr_c_st_data(drv, out_st);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Check if the differences are between min and max
for (i = 0; i < 3; i ++) {
out_diff[i] = abs(out_st[i] - out_nost[i]);
data[i] = out_diff[i];
}
if ((LSM6DS3TR_C_GYRO_SELF_TEST_MIN_X > out_diff[0]) || (out_diff[0] > LSM6DS3TR_C_GYRO_SELF_TEST_MAX_X)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DS3TR_C_GYRO_SELF_TEST_MIN_Y > out_diff[1]) || (out_diff[1] > LSM6DS3TR_C_GYRO_SELF_TEST_MAX_Y)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DS3TR_C_GYRO_SELF_TEST_MIN_Z > out_diff[2]) || (out_diff[2] > LSM6DS3TR_C_GYRO_SELF_TEST_MAX_Z)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
restore:
ret += sensor_i2c_write(drv, LSM6DS3TR_C_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
return ret;
}
static void drv_gyro_st_lsm6ds3tr_c_irq_handle(void)
{
/* no handle so far */
}
static int drv_gyro_st_lsm6ds3tr_c_open(void)
{
int ret = 0;
ret = drv_gyro_st_lsm6ds3tr_c_set_power_mode(&lsm6ds3tr_c_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6ds3tr_c_set_bdu(&lsm6ds3tr_c_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_st_lsm6ds3tr_c_set_range(&lsm6ds3tr_c_ctx, GYRO_RANGE_1000DPS);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_st_lsm6ds3tr_c_set_odr(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_GYRO_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_gyro_st_lsm6ds3tr_c_close(void)
{
int ret = 0;
ret = drv_gyro_st_lsm6ds3tr_c_set_power_mode(&lsm6ds3tr_c_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_gyro_st_lsm6ds3tr_c_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
gyro_data_t *gyro = (gyro_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(gyro_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_ACC_GYRO_OUTX_L_G, ®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_ACC_GYRO_OUTX_H_G, ®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_ACC_GYRO_OUTY_L_G, ®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_ACC_GYRO_OUTY_H_G, ®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_ACC_GYRO_OUTZ_L_G, ®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_ACC_GYRO_OUTZ_H_G, ®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
gyro->data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)reg[1]))<< LSM6DS3TR_C_SHIFT_EIGHT_BITS)|(reg[0]));
gyro->data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)reg[3]))<< LSM6DS3TR_C_SHIFT_EIGHT_BITS)|(reg[2]));
gyro->data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)reg[5]))<< LSM6DS3TR_C_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_gyro_factor != 0){
gyro->data[DATA_AXIS_X] = (gyro->data[DATA_AXIS_X] * cur_gyro_factor)/LSM6DS3TR_C_GYRO_MUL;
gyro->data[DATA_AXIS_Y] = (gyro->data[DATA_AXIS_Y] * cur_gyro_factor)/LSM6DS3TR_C_GYRO_MUL;
gyro->data[DATA_AXIS_Z] = (gyro->data[DATA_AXIS_Z] * cur_gyro_factor)/LSM6DS3TR_C_GYRO_MUL;
}
gyro->timestamp = aos_now_ms();
return (int)size;
}
static int drv_gyro_st_lsm6ds3tr_c_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_gyro_st_lsm6ds3tr_c_set_odr(&lsm6ds3tr_c_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_gyro_st_lsm6ds3tr_c_set_range(&lsm6ds3tr_c_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_gyro_st_lsm6ds3tr_c_set_power_mode(&lsm6ds3tr_c_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
//dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LSM6DS3TR_C";
info->range_max = 2000;
info->range_min = 125;
info->unit = udps;
}break;
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_gyro_st_lsm6ds3tr_c_self_test(&lsm6ds3tr_c_ctx, (int32_t*)info->data);
//printf("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
LOG("%s %s: %d, %d, %d\n", SENSOR_STR, __func__, info->data[0],info->data[1],info->data[2]);
return ret;
}
default:break;
}
return 0;
}
int drv_gyro_st_lsm6ds3tr_c_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_GYRO;
sensor.path = dev_gyro_path;
sensor.open = drv_gyro_st_lsm6ds3tr_c_open;
sensor.close = drv_gyro_st_lsm6ds3tr_c_close;
sensor.read = drv_gyro_st_lsm6ds3tr_c_read;
sensor.write = NULL;
sensor.ioctl = drv_gyro_st_lsm6ds3tr_c_ioctl;
sensor.irq_handle = drv_gyro_st_lsm6ds3tr_c_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6ds3tr_c_validate_id(&lsm6ds3tr_c_ctx, LSM6DS3TR_C_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
if(0 == g_lsm6ds3tr_cflag){
ret = drv_acc_gyro_st_lsm6ds3tr_c_soft_reset(&lsm6ds3tr_c_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_st_lsm6ds3tr_c_set_power_mode(&lsm6ds3tr_c_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
g_lsm6ds3tr_cflag = 1;
}
else{
LOG("%s %s gyro do not need reset\n", SENSOR_STR, __func__);
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_lsm6ds3tr_c_init);
SENSOR_DRV_ADD(drv_gyro_st_lsm6ds3tr_c_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_gyro_st_lsm6ds3tr_c.c
|
C
|
apache-2.0
| 42,819
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "ulog/ulog.h"
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LSM6DSL_I2C_ADDR1 (0x6A)
#define LSM6DSL_I2C_ADDR2 (0x6B)
#define LSM6DSL_I2C_ADDR_TRANS(n) ((n) << 1)
#define LSM6DSL_I2C_ADDR LSM6DSL_I2C_ADDR_TRANS(LSM6DSL_I2C_ADDR2)
#define LSM6DSL_ACC_GYRO_FUNC_CFG_ACCESS 0x01
#define LSM6DSL_ACC_GYRO_SENSOR_SYNC_TIME 0x04
#define LSM6DSL_ACC_GYRO_SENSOR_RES_RATIO 0x05
#define LSM6DSL_ACC_GYRO_FIFO_CTRL1 0x06
#define LSM6DSL_ACC_GYRO_FIFO_CTRL2 0x07
#define LSM6DSL_ACC_GYRO_FIFO_CTRL3 0x08
#define LSM6DSL_ACC_GYRO_FIFO_CTRL4 0x09
#define LSM6DSL_ACC_GYRO_FIFO_CTRL5 0x0A
#define LSM6DSL_ACC_GYRO_DRDY_PULSE_CFG_G 0x0B
#define LSM6DSL_ACC_GYRO_INT1_CTRL 0x0D
#define LSM6DSL_ACC_GYRO_INT2_CTRL 0x0E
#define LSM6DSL_ACC_GYRO_WHO_AM_I_REG 0x0F
#define LSM6DSL_ACC_GYRO_CTRL1_XL 0x10
#define LSM6DSL_ACC_GYRO_CTRL2_G 0x11
#define LSM6DSL_ACC_GYRO_CTRL3_C 0x12
#define LSM6DSL_ACC_GYRO_CTRL4_C 0x13
#define LSM6DSL_ACC_GYRO_CTRL5_C 0x14
#define LSM6DSL_ACC_GYRO_CTRL6_C 0x15
#define LSM6DSL_ACC_GYRO_CTRL7_G 0x16
#define LSM6DSL_ACC_GYRO_CTRL8_XL 0x17
#define LSM6DSL_ACC_GYRO_CTRL9_XL 0x18
#define LSM6DSL_ACC_GYRO_CTRL10_C 0x19
#define LSM6DSL_ACC_GYRO_MASTER_CONFIG 0x1A
#define LSM6DSL_ACC_GYRO_WAKE_UP_SRC 0x1B
#define LSM6DSL_ACC_GYRO_TAP_SRC 0x1C
#define LSM6DSL_ACC_GYRO_D6D_SRC 0x1D
#define LSM6DSL_ACC_GYRO_STATUS_REG 0x1E
#define LSM6DSL_ACC_GYRO_OUT_TEMP_L 0x20
#define LSM6DSL_ACC_GYRO_OUT_TEMP_H 0x21
#define LSM6DSL_ACC_GYRO_OUTX_L_G 0x22
#define LSM6DSL_ACC_GYRO_OUTX_H_G 0x23
#define LSM6DSL_ACC_GYRO_OUTY_L_G 0x24
#define LSM6DSL_ACC_GYRO_OUTY_H_G 0x25
#define LSM6DSL_ACC_GYRO_OUTZ_L_G 0x26
#define LSM6DSL_ACC_GYRO_OUTZ_H_G 0x27
#define LSM6DSL_ACC_GYRO_OUTX_L_XL 0x28
#define LSM6DSL_ACC_GYRO_OUTX_H_XL 0x29
#define LSM6DSL_ACC_GYRO_OUTY_L_XL 0x2A
#define LSM6DSL_ACC_GYRO_OUTY_H_XL 0x2B
#define LSM6DSL_ACC_GYRO_OUTZ_L_XL 0x2C
#define LSM6DSL_ACC_GYRO_OUTZ_H_XL 0x2D
#define LSM6DSL_ACC_GYRO_SENSORHUB1_REG 0x2E
#define LSM6DSL_ACC_GYRO_SENSORHUB2_REG 0x2F
#define LSM6DSL_ACC_GYRO_SENSORHUB3_REG 0x30
#define LSM6DSL_ACC_GYRO_SENSORHUB4_REG 0x31
#define LSM6DSL_ACC_GYRO_SENSORHUB5_REG 0x32
#define LSM6DSL_ACC_GYRO_SENSORHUB6_REG 0x33
#define LSM6DSL_ACC_GYRO_SENSORHUB7_REG 0x34
#define LSM6DSL_ACC_GYRO_SENSORHUB8_REG 0x35
#define LSM6DSL_ACC_GYRO_SENSORHUB9_REG 0x36
#define LSM6DSL_ACC_GYRO_SENSORHUB10_REG 0x37
#define LSM6DSL_ACC_GYRO_SENSORHUB11_REG 0x38
#define LSM6DSL_ACC_GYRO_SENSORHUB12_REG 0x39
#define LSM6DSL_ACC_GYRO_FIFO_STATUS1 0x3A
#define LSM6DSL_ACC_GYRO_FIFO_STATUS2 0x3B
#define LSM6DSL_ACC_GYRO_FIFO_STATUS3 0x3C
#define LSM6DSL_ACC_GYRO_FIFO_STATUS4 0x3D
#define LSM6DSL_ACC_GYRO_FIFO_DATA_OUT_L 0x3E
#define LSM6DSL_ACC_GYRO_FIFO_DATA_OUT_H 0x3F
#define LSM6DSL_ACC_GYRO_TIMESTAMP0_REG 0x40
#define LSM6DSL_ACC_GYRO_TIMESTAMP1_REG 0x41
#define LSM6DSL_ACC_GYRO_TIMESTAMP2_REG 0x42
#define LSM6DSL_ACC_GYRO_TIMESTAMP_L 0x49
#define LSM6DSL_ACC_GYRO_TIMESTAMP_H 0x4A
#define LSM6DSL_ACC_GYRO_STEP_COUNTER_L 0x4B
#define LSM6DSL_ACC_GYRO_STEP_COUNTER_H 0x4C
#define LSM6DSL_ACC_GYRO_SENSORHUB13_REG 0x4D
#define LSM6DSL_ACC_GYRO_SENSORHUB14_REG 0x4E
#define LSM6DSL_ACC_GYRO_SENSORHUB15_REG 0x4F
#define LSM6DSL_ACC_GYRO_SENSORHUB16_REG 0x50
#define LSM6DSL_ACC_GYRO_SENSORHUB17_REG 0x51
#define LSM6DSL_ACC_GYRO_SENSORHUB18_REG 0x52
#define LSM6DSL_ACC_GYRO_FUNC_SRC 0x53
#define LSM6DSL_ACC_GYRO_TAP_CFG1 0x58
#define LSM6DSL_ACC_GYRO_TAP_THS_6D 0x59
#define LSM6DSL_ACC_GYRO_INT_DUR2 0x5A
#define LSM6DSL_ACC_GYRO_WAKE_UP_THS 0x5B
#define LSM6DSL_ACC_GYRO_WAKE_UP_DUR 0x5C
#define LSM6DSL_ACC_GYRO_FREE_FALL 0x5D
#define LSM6DSL_ACC_GYRO_MD1_CFG 0x5E
#define LSM6DSL_ACC_GYRO_MD2_CFG 0x5F
#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_X_L 0x66
#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_X_H 0x67
#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Y_L 0x68
#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Y_H 0x69
#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Z_L 0x6A
#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Z_H 0x6B
#define LSM6DSL_ACC_GYRO_X_OFS_USR 0x73
#define LSM6DSL_ACC_GYRO_Y_OFS_USR 0x74
#define LSM6DSL_ACC_GYRO_Z_OFS_USR 0x75
#define LSM6DSL_CHIP_ID_VALUE (0x6A)
#define LSM6DSL_RESET_VALUE (0x1)
#define LSM6DSL_RESET_MSK (0X1)
#define LSM6DSL_RESET_POS (0)
#define LSM6DSL_ACC_ODR_POWER_DOWN (0X00)
#define LSM6DSL_ACC_ODR_1_6_HZ (0X0B)
#define LSM6DSL_ACC_ODR_12_5_HZ (0x01)
#define LSM6DSL_ACC_ODR_26_HZ (0x02)
#define LSM6DSL_ACC_ODR_52_HZ (0x03)
#define LSM6DSL_ACC_ODR_104_HZ (0x04)
#define LSM6DSL_ACC_ODR_208_HZ (0x05)
#define LSM6DSL_ACC_ODR_416_HZ (0x06)
#define LSM6DSL_ACC_ODR_833_HZ (0x07)
#define LSM6DSL_ACC_ODR_1_66_KHZ (0x08)
#define LSM6DSL_ACC_ODR_3_33_KHZ (0x09)
#define LSM6DSL_ACC_ODR_6_66_KHZ (0x0A)
#define LSM6DSL_ACC_ODR_MSK (0XF0)
#define LSM6DSL_ACC_ODR_POS (4)
#define LSM6DSL_GYRO_ODR_POWER_DOWN (0X00)
#define LSM6DSL_GYRO_ODR_12_5_HZ (0x01)
#define LSM6DSL_GYRO_ODR_26_HZ (0x02)
#define LSM6DSL_GYRO_ODR_52_HZ (0x03)
#define LSM6DSL_GYRO_ODR_104_HZ (0x04)
#define LSM6DSL_GYRO_ODR_208_HZ (0x05)
#define LSM6DSL_GYRO_ODR_416_HZ (0x06)
#define LSM6DSL_GYRO_ODR_833_HZ (0x07)
#define LSM6DSL_GYRO_ODR_1_66_KHZ (0x08)
#define LSM6DSL_GYRO_ODR_3_33_KHZ (0x09)
#define LSM6DSL_GYRO_ODR_6_66_KHZ (0x0A)
#define LSM6DSL_GYRO_ODR_MSK (0XF0)
#define LSM6DSL_GYRO_ODR_POS (4)
#define LSM6DSL_ACC_RANGE_2G (0x0)
#define LSM6DSL_ACC_RANGE_4G (0x2)
#define LSM6DSL_ACC_RANGE_8G (0x3)
#define LSM6DSL_ACC_RANGE_16G (0x1)
#define LSM6DSL_ACC_RANGE_MSK (0X0C)
#define LSM6DSL_ACC_RANGE_POS (2)
#define LSM6DSL_ACC_SENSITIVITY_2G (61)
#define LSM6DSL_ACC_SENSITIVITY_4G (122)
#define LSM6DSL_ACC_SENSITIVITY_8G (244)
#define LSM6DSL_ACC_SENSITIVITY_16G (488)
#define LSM6DSL_GYRO_RANGE_245 (0x0)
#define LSM6DSL_GYRO_RANGE_500 (0x1)
#define LSM6DSL_GYRO_RANGE_1000 (0x2)
#define LSM6DSL_GYRO_RANGE_2000 (0x3)
#define LSM6DSL_GYRO_RANGE_MSK (0X0C)
#define LSM6DSL_GYRO_RANGE_POS (2)
#define LSM6DSL_GYRO_SENSITIVITY_245DPS (8750)
#define LSM6DSL_GYRO_SENSITIVITY_500DPS (17500)
#define LSM6DSL_GYRO_SENSITIVITY_1000DPS (35000)
#define LSM6DSL_GYRO_SENSITIVITY_2000DPS (70000)
#define LSM6DSL_SHIFT_EIGHT_BITS (8)
#define LSM6DSL_16_BIT_SHIFT (0xFF)
#define LSM6DSL_ACC_MUL (1000)
#define LSM6DSL_GYRO_MUL (1)
#define LSM6DSL_ACC_DEFAULT_ODR_100HZ (100)
#define LSM6DSL_GYRO_DEFAULT_ODR_100HZ (100)
#define LSM6DSL_GET_BITSLICE(regvar, bitname) \
((regvar & bitname##_MSK) >> bitname##_POS)
#define LSM6DSL_SET_BITSLICE(regvar, bitname, val) \
((regvar & ~bitname##_MSK) | ((val << bitname##_POS) & bitname##_MSK))
static int32_t lsm6dsl_acc_factor[ACC_RANGE_MAX] = {
LSM6DSL_ACC_SENSITIVITY_2G, LSM6DSL_ACC_SENSITIVITY_4G,
LSM6DSL_ACC_SENSITIVITY_8G, LSM6DSL_ACC_SENSITIVITY_16G
};
static int32_t lsm6dsl_gyro_factor[GYRO_RANGE_MAX] = {
0, LSM6DSL_GYRO_SENSITIVITY_245DPS, LSM6DSL_GYRO_SENSITIVITY_500DPS,
LSM6DSL_GYRO_SENSITIVITY_1000DPS, LSM6DSL_GYRO_SENSITIVITY_2000DPS
};
static int32_t cur_acc_factor = 0;
static int32_t cur_gyro_factor = 0;
static int32_t g_lsm6dslflag = 0;
i2c_dev_t lsm6dsl_ctx = {
.port = 4,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LSM6DSL_I2C_ADDR,
};
static int drv_acc_gyro_st_lsm6dsl_soft_reset(i2c_dev_t *drv)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value |= LSM6DSL_RESET_VALUE;
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_acc_gyro_st_lsm6dsl_validate_id(i2c_dev_t *drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_WHO_AM_I_REG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (id_value != value) {
return -1;
}
return 0;
}
static int drv_acc_st_lsm6dsl_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_ON: {
value = LSM6DSL_SET_BITSLICE(value, LSM6DSL_ACC_ODR,
LSM6DSL_ACC_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_POWER_OFF: {
value = LSM6DSL_SET_BITSLICE(value, LSM6DSL_ACC_ODR,
LSM6DSL_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_SLEEP: {
value = LSM6DSL_SET_BITSLICE(value, LSM6DSL_ACC_ODR,
LSM6DSL_ACC_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
default:
break;
}
return 0;
}
static uint8_t drv_acc_st_lsm6dsl_hz2odr(uint32_t hz)
{
if (hz > 3330)
return LSM6DSL_ACC_ODR_6_66_KHZ;
else if (hz > 1660)
return LSM6DSL_ACC_ODR_3_33_KHZ;
else if (hz > 833)
return LSM6DSL_ACC_ODR_1_66_KHZ;
else if (hz > 416)
return LSM6DSL_ACC_ODR_833_HZ;
else if (hz > 208)
return LSM6DSL_ACC_ODR_416_HZ;
else if (hz > 104)
return LSM6DSL_ACC_ODR_208_HZ;
else if (hz > 52)
return LSM6DSL_ACC_ODR_104_HZ;
else if (hz > 26)
return LSM6DSL_ACC_ODR_52_HZ;
else if (hz > 13)
return LSM6DSL_ACC_ODR_26_HZ;
else if (hz >= 2)
return LSM6DSL_ACC_ODR_12_5_HZ;
else
return LSM6DSL_ACC_ODR_1_6_HZ;
}
static int drv_acc_st_lsm6dsl_set_odr(i2c_dev_t *drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_lsm6dsl_hz2odr(hz);
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = LSM6DSL_SET_BITSLICE(value, LSM6DSL_ACC_ODR, odr);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_st_lsm6dsl_set_range(i2c_dev_t *drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (range) {
case ACC_RANGE_2G: {
tmp = LSM6DSL_ACC_RANGE_2G;
} break;
case ACC_RANGE_4G: {
tmp = LSM6DSL_ACC_RANGE_4G;
} break;
case ACC_RANGE_8G: {
tmp = LSM6DSL_ACC_RANGE_8G;
} break;
case ACC_RANGE_16G: {
tmp = LSM6DSL_ACC_RANGE_16G;
} break;
default:
break;
}
value = LSM6DSL_SET_BITSLICE(value, LSM6DSL_ACC_RANGE, tmp);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (range <= ACC_RANGE_16G) {
cur_acc_factor = lsm6dsl_acc_factor[range];
}
return 0;
}
static void drv_acc_st_lsm6dsl_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_lsm6dsl_open(void)
{
int ret = 0;
ret = drv_acc_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_st_lsm6dsl_set_range(&lsm6dsl_ctx, ACC_RANGE_8G);
if (unlikely(ret)) {
return -1;
}
ret =
drv_acc_st_lsm6dsl_set_odr(&lsm6dsl_ctx, LSM6DSL_ACC_DEFAULT_ODR_100HZ);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_acc_st_lsm6dsl_close(void)
{
int ret = 0;
ret = drv_acc_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_acc_st_lsm6dsl_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTX_L_XL, ®[0],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTX_H_XL, ®[1],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTY_L_XL, ®[2],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTY_H_XL, ®[3],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTZ_L_XL, ®[4],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTZ_H_XL, ®[5],
I2C_REG_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)(
(((int16_t)((int8_t)reg[1])) << LSM6DSL_SHIFT_EIGHT_BITS) | (reg[0]));
accel->data[DATA_AXIS_Y] = (int16_t)(
(((int16_t)((int8_t)reg[3])) << LSM6DSL_SHIFT_EIGHT_BITS) | (reg[2]));
accel->data[DATA_AXIS_Z] = (int16_t)(
(((int16_t)((int8_t)reg[5])) << LSM6DSL_SHIFT_EIGHT_BITS) | (reg[4]));
if (cur_acc_factor != 0) {
accel->data[DATA_AXIS_X] =
(accel->data[DATA_AXIS_X] * cur_acc_factor) / LSM6DSL_ACC_MUL;
accel->data[DATA_AXIS_Y] =
(accel->data[DATA_AXIS_Y] * cur_acc_factor) / LSM6DSL_ACC_MUL;
accel->data[DATA_AXIS_Z] =
(accel->data[DATA_AXIS_Z] * cur_acc_factor) / LSM6DSL_ACC_MUL;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_lsm6dsl_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_acc_st_lsm6dsl_set_odr(&lsm6dsl_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_acc_st_lsm6dsl_set_range(&lsm6dsl_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LSM6DSL";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
} break;
default:
break;
}
return 0;
}
int drv_acc_st_lsm6dsl_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_lsm6dsl_open;
sensor.close = drv_acc_st_lsm6dsl_close;
sensor.read = drv_acc_st_lsm6dsl_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_lsm6dsl_ioctl;
sensor.irq_handle = drv_acc_st_lsm6dsl_irq_handle;
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
ret =
drv_acc_gyro_st_lsm6dsl_validate_id(&lsm6dsl_ctx, LSM6DSL_CHIP_ID_VALUE);
if (unlikely(ret)) {
return -1;
}
if (0 == g_lsm6dslflag) {
ret = drv_acc_gyro_st_lsm6dsl_soft_reset(&lsm6dsl_ctx);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
g_lsm6dslflag = 1;
} else {
LOG("%s %s acc do not need reset\n", SENSOR_STR, __func__);
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_gyro_st_lsm6dsl_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_ON: {
value = LSM6DSL_SET_BITSLICE(value, LSM6DSL_GYRO_ODR,
LSM6DSL_GYRO_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_POWER_OFF: {
value = LSM6DSL_SET_BITSLICE(value, LSM6DSL_GYRO_ODR,
LSM6DSL_GYRO_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_SLEEP: {
value = LSM6DSL_SET_BITSLICE(value, LSM6DSL_GYRO_ODR,
LSM6DSL_GYRO_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
default:
break;
}
return 0;
}
static uint8_t drv_gyro_st_lsm6dsl_hz2odr(uint32_t hz)
{
if (hz > 3330)
return LSM6DSL_GYRO_ODR_6_66_KHZ;
else if (hz > 1660)
return LSM6DSL_GYRO_ODR_3_33_KHZ;
else if (hz > 833)
return LSM6DSL_GYRO_ODR_1_66_KHZ;
else if (hz > 416)
return LSM6DSL_GYRO_ODR_833_HZ;
else if (hz > 208)
return LSM6DSL_GYRO_ODR_416_HZ;
else if (hz > 104)
return LSM6DSL_GYRO_ODR_208_HZ;
else if (hz > 52)
return LSM6DSL_GYRO_ODR_104_HZ;
else if (hz > 26)
return LSM6DSL_GYRO_ODR_52_HZ;
else if (hz > 13)
return LSM6DSL_GYRO_ODR_26_HZ;
else
return LSM6DSL_GYRO_ODR_12_5_HZ;
}
static int drv_gyro_st_lsm6dsl_set_odr(i2c_dev_t *drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_gyro_st_lsm6dsl_hz2odr(hz);
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = LSM6DSL_SET_BITSLICE(value, LSM6DSL_GYRO_ODR, odr);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_gyro_st_lsm6dsl_set_range(i2c_dev_t *drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (range) {
case GYRO_RANGE_250DPS: {
tmp = LSM6DSL_GYRO_RANGE_245;
} break;
case GYRO_RANGE_500DPS: {
tmp = LSM6DSL_GYRO_RANGE_500;
} break;
case GYRO_RANGE_1000DPS: {
tmp = LSM6DSL_GYRO_RANGE_1000;
} break;
case GYRO_RANGE_2000DPS: {
tmp = LSM6DSL_GYRO_RANGE_2000;
} break;
default:
break;
}
value = LSM6DSL_SET_BITSLICE(value, LSM6DSL_GYRO_RANGE, tmp);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if ((range >= GYRO_RANGE_250DPS) && (range <= GYRO_RANGE_2000DPS)) {
cur_gyro_factor = lsm6dsl_gyro_factor[range];
}
return 0;
}
static void drv_gyro_st_lsm6dsl_irq_handle(void)
{
/* no handle so far */
}
static int drv_gyro_st_lsm6dsl_open(void)
{
int ret = 0;
ret = drv_gyro_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
ret = drv_gyro_st_lsm6dsl_set_range(&lsm6dsl_ctx, GYRO_RANGE_1000DPS);
if (unlikely(ret)) {
return -1;
}
ret =
drv_gyro_st_lsm6dsl_set_odr(&lsm6dsl_ctx, LSM6DSL_GYRO_DEFAULT_ODR_100HZ);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_gyro_st_lsm6dsl_close(void)
{
int ret = 0;
ret = drv_gyro_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_gyro_st_lsm6dsl_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
gyro_data_t *gyro = (gyro_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(gyro_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTX_L_G, ®[0],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTX_H_G, ®[1],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTY_L_G, ®[2],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTY_H_G, ®[3],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTZ_L_G, ®[4],
I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTZ_H_G, ®[5],
I2C_REG_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
gyro->data[DATA_AXIS_X] = (int16_t)(
(((int32_t)((int8_t)reg[1])) << LSM6DSL_SHIFT_EIGHT_BITS) | (reg[0]));
gyro->data[DATA_AXIS_Y] = (int16_t)(
(((int32_t)((int8_t)reg[3])) << LSM6DSL_SHIFT_EIGHT_BITS) | (reg[2]));
gyro->data[DATA_AXIS_Z] = (int16_t)(
(((int32_t)((int8_t)reg[5])) << LSM6DSL_SHIFT_EIGHT_BITS) | (reg[4]));
if (cur_gyro_factor != 0) {
gyro->data[DATA_AXIS_X] =
(gyro->data[DATA_AXIS_X] * cur_gyro_factor) / LSM6DSL_GYRO_MUL;
gyro->data[DATA_AXIS_Y] =
(gyro->data[DATA_AXIS_Y] * cur_gyro_factor) / LSM6DSL_GYRO_MUL;
gyro->data[DATA_AXIS_Z] =
(gyro->data[DATA_AXIS_Z] * cur_gyro_factor) / LSM6DSL_GYRO_MUL;
}
gyro->timestamp = aos_now_ms();
return (int)size;
}
static int drv_gyro_st_lsm6dsl_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_ODR_SET: {
ret = drv_gyro_st_lsm6dsl_set_odr(&lsm6dsl_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_RANGE_SET: {
ret = drv_gyro_st_lsm6dsl_set_range(&lsm6dsl_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_gyro_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LSM6DSL";
info->range_max = 2000;
info->range_min = 125;
info->unit = udps;
} break;
default:
break;
}
return 0;
}
int drv_gyro_st_lsm6dsl_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_GYRO;
sensor.path = dev_gyro_path;
sensor.open = drv_gyro_st_lsm6dsl_open;
sensor.close = drv_gyro_st_lsm6dsl_close;
sensor.read = drv_gyro_st_lsm6dsl_read;
sensor.write = NULL;
sensor.ioctl = drv_gyro_st_lsm6dsl_ioctl;
sensor.irq_handle = drv_gyro_st_lsm6dsl_irq_handle;
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
ret =
drv_acc_gyro_st_lsm6dsl_validate_id(&lsm6dsl_ctx, LSM6DSL_CHIP_ID_VALUE);
if (unlikely(ret)) {
return -1;
}
if (0 == g_lsm6dslflag) {
ret = drv_acc_gyro_st_lsm6dsl_soft_reset(&lsm6dsl_ctx);
if (unlikely(ret)) {
return -1;
}
ret = drv_gyro_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
g_lsm6dslflag = 1;
} else {
LOG("%s %s gyro do not need reset\n", SENSOR_STR, __func__);
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_lsm6dsl_init);
SENSOR_DRV_ADD(drv_gyro_st_lsm6dsl_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_gyro_st_lsm6dsl.c
|
C
|
apache-2.0
| 26,685
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LSM6DSM_I2C_ADDR1 (0x6A)
#define LSM6DSM_I2C_ADDR2 (0x6B)
#define LSM6DSM_I2C_ADDR_TRANS(n) ((n)<<1)
//#define LSM6DSM_I2C_ADDR LSM6DSM_I2C_ADDR_TRANS(LSM6DSM_I2C_ADDR2)
#define LSM6DSM_I2C_ADDR LSM6DSM_I2C_ADDR_TRANS(LSM6DSM_I2C_ADDR1)
#define LSM6DSM_ACC_GYRO_FUNC_CFG_ACCESS 0x01
#define LSM6DSM_ACC_GYRO_SENSOR_SYNC_TIME 0x04
#define LSM6DSM_ACC_GYRO_SENSOR_RES_RATIO 0x05
#define LSM6DSM_ACC_GYRO_FIFO_CTRL1 0x06
#define LSM6DSM_ACC_GYRO_FIFO_CTRL2 0x07
#define LSM6DSM_ACC_GYRO_FIFO_CTRL3 0x08
#define LSM6DSM_ACC_GYRO_FIFO_CTRL4 0x09
#define LSM6DSM_ACC_GYRO_FIFO_CTRL5 0x0A
#define LSM6DSM_ACC_GYRO_DRDY_PULSE_CFG_G 0x0B
#define LSM6DSM_ACC_GYRO_INT1_CTRL 0x0D
#define LSM6DSM_ACC_GYRO_INT2_CTRL 0x0E
#define LSM6DSM_ACC_GYRO_WHO_AM_I_REG 0x0F
#define LSM6DSM_ACC_GYRO_CTRL1_XL 0x10
#define LSM6DSM_ACC_GYRO_CTRL2_G 0x11
#define LSM6DSM_ACC_GYRO_CTRL3_C 0x12
#define LSM6DSM_ACC_GYRO_CTRL4_C 0x13
#define LSM6DSM_ACC_GYRO_CTRL5_C 0x14
#define LSM6DSM_ACC_GYRO_CTRL6_C 0x15
#define LSM6DSM_ACC_GYRO_CTRL7_G 0x16
#define LSM6DSM_ACC_GYRO_CTRL8_XL 0x17
#define LSM6DSM_ACC_GYRO_CTRL9_XL 0x18
#define LSM6DSM_ACC_GYRO_CTRL10_C 0x19
#define LSM6DSM_ACC_GYRO_MASTER_CONFIG 0x1A
#define LSM6DSM_ACC_GYRO_WAKE_UP_SRC 0x1B
#define LSM6DSM_ACC_GYRO_TAP_SRC 0x1C
#define LSM6DSM_ACC_GYRO_D6D_SRC 0x1D
#define LSM6DSM_ACC_GYRO_STATUS_REG 0x1E
#define LSM6DSM_ACC_GYRO_OUT_TEMP_L 0x20
#define LSM6DSM_ACC_GYRO_OUT_TEMP_H 0x21
#define LSM6DSM_ACC_GYRO_OUTX_L_G 0x22
#define LSM6DSM_ACC_GYRO_OUTX_H_G 0x23
#define LSM6DSM_ACC_GYRO_OUTY_L_G 0x24
#define LSM6DSM_ACC_GYRO_OUTY_H_G 0x25
#define LSM6DSM_ACC_GYRO_OUTZ_L_G 0x26
#define LSM6DSM_ACC_GYRO_OUTZ_H_G 0x27
#define LSM6DSM_ACC_GYRO_OUTX_L_XL 0x28
#define LSM6DSM_ACC_GYRO_OUTX_H_XL 0x29
#define LSM6DSM_ACC_GYRO_OUTY_L_XL 0x2A
#define LSM6DSM_ACC_GYRO_OUTY_H_XL 0x2B
#define LSM6DSM_ACC_GYRO_OUTZ_L_XL 0x2C
#define LSM6DSM_ACC_GYRO_OUTZ_H_XL 0x2D
#define LSM6DSM_ACC_GYRO_SENSORHUB1_REG 0x2E
#define LSM6DSM_ACC_GYRO_SENSORHUB2_REG 0x2F
#define LSM6DSM_ACC_GYRO_SENSORHUB3_REG 0x30
#define LSM6DSM_ACC_GYRO_SENSORHUB4_REG 0x31
#define LSM6DSM_ACC_GYRO_SENSORHUB5_REG 0x32
#define LSM6DSM_ACC_GYRO_SENSORHUB6_REG 0x33
#define LSM6DSM_ACC_GYRO_SENSORHUB7_REG 0x34
#define LSM6DSM_ACC_GYRO_SENSORHUB8_REG 0x35
#define LSM6DSM_ACC_GYRO_SENSORHUB9_REG 0x36
#define LSM6DSM_ACC_GYRO_SENSORHUB10_REG 0x37
#define LSM6DSM_ACC_GYRO_SENSORHUB11_REG 0x38
#define LSM6DSM_ACC_GYRO_SENSORHUB12_REG 0x39
#define LSM6DSM_ACC_GYRO_FIFO_STATUS1 0x3A
#define LSM6DSM_ACC_GYRO_FIFO_STATUS2 0x3B
#define LSM6DSM_ACC_GYRO_FIFO_STATUS3 0x3C
#define LSM6DSM_ACC_GYRO_FIFO_STATUS4 0x3D
#define LSM6DSM_ACC_GYRO_FIFO_DATA_OUT_L 0x3E
#define LSM6DSM_ACC_GYRO_FIFO_DATA_OUT_H 0x3F
#define LSM6DSM_ACC_GYRO_TIMESTAMP0_REG 0x40
#define LSM6DSM_ACC_GYRO_TIMESTAMP1_REG 0x41
#define LSM6DSM_ACC_GYRO_TIMESTAMP2_REG 0x42
#define LSM6DSM_ACC_GYRO_TIMESTAMP_L 0x49
#define LSM6DSM_ACC_GYRO_TIMESTAMP_H 0x4A
#define LSM6DSM_ACC_GYRO_STEP_COUNTER_L 0x4B
#define LSM6DSM_ACC_GYRO_STEP_COUNTER_H 0x4C
#define LSM6DSM_ACC_GYRO_SENSORHUB13_REG 0x4D
#define LSM6DSM_ACC_GYRO_SENSORHUB14_REG 0x4E
#define LSM6DSM_ACC_GYRO_SENSORHUB15_REG 0x4F
#define LSM6DSM_ACC_GYRO_SENSORHUB16_REG 0x50
#define LSM6DSM_ACC_GYRO_SENSORHUB17_REG 0x51
#define LSM6DSM_ACC_GYRO_SENSORHUB18_REG 0x52
#define LSM6DSM_ACC_GYRO_FUNC_SRC1 0x53
#define LSM6DSM_ACC_GYRO_FUNC_SRC2 0x54
#define LSM6DSM_ACC_GYRO_TAP_CFG1 0x58
#define LSM6DSM_ACC_GYRO_TAP_THS_6D 0x59
#define LSM6DSM_ACC_GYRO_INT_DUR2 0x5A
#define LSM6DSM_ACC_GYRO_WAKE_UP_THS 0x5B
#define LSM6DSM_ACC_GYRO_WAKE_UP_DUR 0x5C
#define LSM6DSM_ACC_GYRO_FREE_FALL 0x5D
#define LSM6DSM_ACC_GYRO_MD1_CFG 0x5E
#define LSM6DSM_ACC_GYRO_MD2_CFG 0x5F
#define LSM6DSM_ACC_GYRO_OUT_MAG_RAW_X_L 0x66
#define LSM6DSM_ACC_GYRO_OUT_MAG_RAW_X_H 0x67
#define LSM6DSM_ACC_GYRO_OUT_MAG_RAW_Y_L 0x68
#define LSM6DSM_ACC_GYRO_OUT_MAG_RAW_Y_H 0x69
#define LSM6DSM_ACC_GYRO_OUT_MAG_RAW_Z_L 0x6A
#define LSM6DSM_ACC_GYRO_OUT_MAG_RAW_Z_H 0x6B
#define LSM6DSM_ACC_GYRO_X_OFS_USR 0x73
#define LSM6DSM_ACC_GYRO_Y_OFS_USR 0x74
#define LSM6DSM_ACC_GYRO_Z_OFS_USR 0x75
#define LSM6DSM_CHIP_ID_VALUE (0x6A)
#define LSM6DSM_RESET_VALUE (0x1)
#define LSM6DSM_RESET_MSK (0X1)
#define LSM6DSM_RESET_POS (0)
#define LSM6DSM_BDU_VALUE (0x40)
#define LSM6DSM_BDU_MSK (0X40)
#define LSM6DSM_BDU_POS (6)
#define LSM6DSM_ACC_ODR_POWER_DOWN (0X00)
#define LSM6DSM_ACC_ODR_1_6_HZ (0X0B)
#define LSM6DSM_ACC_ODR_12_5_HZ (0x01)
#define LSM6DSM_ACC_ODR_26_HZ (0x02)
#define LSM6DSM_ACC_ODR_52_HZ (0x03)
#define LSM6DSM_ACC_ODR_104_HZ (0x04)
#define LSM6DSM_ACC_ODR_208_HZ (0x05)
#define LSM6DSM_ACC_ODR_416_HZ (0x06)
#define LSM6DSM_ACC_ODR_833_HZ (0x07)
#define LSM6DSM_ACC_ODR_1_66_KHZ (0x08)
#define LSM6DSM_ACC_ODR_3_33_KHZ (0x09)
#define LSM6DSM_ACC_ODR_6_66_KHZ (0x0A)
#define LSM6DSM_ACC_ODR_MSK (0XF0)
#define LSM6DSM_ACC_ODR_POS (4)
#define LSM6DSM_GYRO_ODR_POWER_DOWN (0X00)
#define LSM6DSM_GYRO_ODR_12_5_HZ (0x01)
#define LSM6DSM_GYRO_ODR_26_HZ (0x02)
#define LSM6DSM_GYRO_ODR_52_HZ (0x03)
#define LSM6DSM_GYRO_ODR_104_HZ (0x04)
#define LSM6DSM_GYRO_ODR_208_HZ (0x05)
#define LSM6DSM_GYRO_ODR_416_HZ (0x06)
#define LSM6DSM_GYRO_ODR_833_HZ (0x07)
#define LSM6DSM_GYRO_ODR_1_66_KHZ (0x08)
#define LSM6DSM_GYRO_ODR_3_33_KHZ (0x09)
#define LSM6DSM_GYRO_ODR_6_66_KHZ (0x0A)
#define LSM6DSM_GYRO_ODR_MSK (0XF0)
#define LSM6DSM_GYRO_ODR_POS (4)
#define LSM6DSM_ACC_RANGE_2G (0x0)
#define LSM6DSM_ACC_RANGE_4G (0x2)
#define LSM6DSM_ACC_RANGE_8G (0x3)
#define LSM6DSM_ACC_RANGE_16G (0x1)
#define LSM6DSM_ACC_RANGE_MSK (0X0C)
#define LSM6DSM_ACC_RANGE_POS (2)
#define LSM6DSM_ACC_SENSITIVITY_2G (61)
#define LSM6DSM_ACC_SENSITIVITY_4G (122)
#define LSM6DSM_ACC_SENSITIVITY_8G (244)
#define LSM6DSM_ACC_SENSITIVITY_16G (488)
#define LSM6DSM_GYRO_RANGE_245 (0x0)
#define LSM6DSM_GYRO_RANGE_500 (0x1)
#define LSM6DSM_GYRO_RANGE_1000 (0x2)
#define LSM6DSM_GYRO_RANGE_2000 (0x3)
#define LSM6DSM_GYRO_RANGE_MSK (0X0C)
#define LSM6DSM_GYRO_RANGE_POS (2)
#define LSM6DSM_GYRO_SENSITIVITY_245DPS (8750)
#define LSM6DSM_GYRO_SENSITIVITY_500DPS (17500)
#define LSM6DSM_GYRO_SENSITIVITY_1000DPS (35000)
#define LSM6DSM_GYRO_SENSITIVITY_2000DPS (70000)
#define LSM6DSM_SHIFT_EIGHT_BITS (8)
#define LSM6DSM_16_BIT_SHIFT (0xFF)
#define LSM6DSM_ACC_MUL (1000)
#define LSM6DSM_GYRO_MUL (1)
#define LSM6DSM_ACC_DEFAULT_ODR_100HZ (100)
#define LSM6DSM_GYRO_DEFAULT_ODR_100HZ (100)
#define LSM6DSM_ACC_SELF_TEST_MIN_X (90) // 90mg
#define LSM6DSM_ACC_SELF_TEST_MIN_Y (90) // 90mg
#define LSM6DSM_ACC_SELF_TEST_MIN_Z (90) // 90mg
#define LSM6DSM_ACC_SELF_TEST_MAX_X (1700) // 1700mg
#define LSM6DSM_ACC_SELF_TEST_MAX_Y (1700) // 1700mg
#define LSM6DSM_ACC_SELF_TEST_MAX_Z (1700) // 1700mg
#define LSM6DSM_ACC_SELF_TEST_DRY_WAIT_CNT 5
#define LSM6DSM_ACC_SELF_TEST_AVG_SAMPLE_CNT 5
#define LSM6DSM_GYRO_SELF_TEST_MIN_X (150) // 150dps
#define LSM6DSM_GYRO_SELF_TEST_MIN_Y (150) // 150dps
#define LSM6DSM_GYRO_SELF_TEST_MIN_Z (150) // 150dps
#define LSM6DSM_GYRO_SELF_TEST_MAX_X (700) // 700dps
#define LSM6DSM_GYRO_SELF_TEST_MAX_Y (700) // 700dps
#define LSM6DSM_GYRO_SELF_TEST_MAX_Z (700) // 700dps
#define LSM6DSM_GYRO_SELF_TEST_DRY_WAIT_CNT 5
#define LSM6DSM_GYRO_SELF_TEST_AVG_SAMPLE_CNT 5
#define LSM6DSM_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define LSM6DSM_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t lsm6dsm_acc_factor[ACC_RANGE_MAX] = { LSM6DSM_ACC_SENSITIVITY_2G, LSM6DSM_ACC_SENSITIVITY_4G,
LSM6DSM_ACC_SENSITIVITY_8G, LSM6DSM_ACC_SENSITIVITY_16G };
static int32_t lsm6dsm_gyro_factor[GYRO_RANGE_MAX] = {0, LSM6DSM_GYRO_SENSITIVITY_245DPS, LSM6DSM_GYRO_SENSITIVITY_500DPS,
LSM6DSM_GYRO_SENSITIVITY_1000DPS, LSM6DSM_GYRO_SENSITIVITY_2000DPS };
static int32_t cur_acc_factor = 0;
static int32_t cur_gyro_factor = 0;
static int32_t g_lsm6dsmflag = 0;
i2c_dev_t lsm6dsm_ctx = {
//.port = 4,
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LSM6DSM_I2C_ADDR,
};
static int drv_acc_gyro_st_lsm6dsm_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LSM6DSM_RESET_VALUE;
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_gyro_st_lsm6dsm_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_WHO_AM_I_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
LOG("%s %s right id (0x%02x), read id(0x%02x)\n", SENSOR_STR, __func__, id_value, value);
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6dsm_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LSM6DSM_SET_BITSLICE(value,LSM6DSM_ACC_ODR,LSM6DSM_ACC_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LSM6DSM_SET_BITSLICE(value,LSM6DSM_ACC_ODR,LSM6DSM_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LSM6DSM_SET_BITSLICE(value,LSM6DSM_ACC_ODR,LSM6DSM_ACC_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static int drv_acc_gyro_st_lsm6dsm_set_bdu(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (value & LSM6DSM_BDU_VALUE)
return 0;
value |= LSM6DSM_BDU_VALUE;
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static uint8_t drv_acc_st_lsm6dsm_hz2odr(uint32_t hz)
{
if(hz > 3330)
return LSM6DSM_ACC_ODR_6_66_KHZ;
else if(hz > 1660)
return LSM6DSM_ACC_ODR_3_33_KHZ;
else if(hz > 833)
return LSM6DSM_ACC_ODR_1_66_KHZ;
else if(hz > 416)
return LSM6DSM_ACC_ODR_833_HZ;
else if(hz > 208)
return LSM6DSM_ACC_ODR_416_HZ;
else if(hz > 104)
return LSM6DSM_ACC_ODR_208_HZ;
else if(hz > 52)
return LSM6DSM_ACC_ODR_104_HZ;
else if(hz > 26)
return LSM6DSM_ACC_ODR_52_HZ;
else if(hz > 13)
return LSM6DSM_ACC_ODR_26_HZ;
else if(hz >= 2)
return LSM6DSM_ACC_ODR_12_5_HZ;
else
return LSM6DSM_ACC_ODR_1_6_HZ;
}
static int drv_acc_st_lsm6dsm_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_lsm6dsm_hz2odr(hz);
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LSM6DSM_SET_BITSLICE(value,LSM6DSM_ACC_ODR,odr);
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lsm6dsm_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_2G:{
tmp = LSM6DSM_ACC_RANGE_2G;
}break;
case ACC_RANGE_4G:{
tmp = LSM6DSM_ACC_RANGE_4G;
}break;
case ACC_RANGE_8G:{
tmp = LSM6DSM_ACC_RANGE_8G;
}break;
case ACC_RANGE_16G:{
tmp = LSM6DSM_ACC_RANGE_16G;
}break;
default:break;
}
value = LSM6DSM_SET_BITSLICE(value,LSM6DSM_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)){
cur_acc_factor = lsm6dsm_acc_factor[range];
}
return 0;
}
static int drv_acc_st_lsm6dsm_st_discard(i2c_dev_t* drv)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
for (i = 0; i < LSM6DSM_ACC_SELF_TEST_DRY_WAIT_CNT; i ++) {
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x01)
break;
aos_msleep(20);
}
if (i >= LSM6DSM_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_OUTX_L_XL, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
return ret;
}
static int drv_acc_st_lsm6dsm_st_data(i2c_dev_t* drv,int32_t* data)
{
uint8_t i, j;
int16_t x_raw, y_raw, z_raw;
int32_t x_mg, y_mg, z_mg;
int32_t x_sum, y_sum, z_sum;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
x_sum = 0; y_sum = 0; z_sum = 0;
for (i = 0; i < LSM6DSM_ACC_SELF_TEST_AVG_SAMPLE_CNT; i ++) {
for (j = 0; j < LSM6DSM_ACC_SELF_TEST_DRY_WAIT_CNT; j ++) {
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x01)
break;
aos_msleep(20);
}
if (j >= LSM6DSM_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_OUTX_L_XL, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
x_raw = (buffer[1] << 8) + buffer[0];
y_raw = (buffer[3] << 8) + buffer[2];
z_raw = (buffer[5] << 8) + buffer[4];
//LOG("%s %s %d: i(%d), raw(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_raw, y_raw, z_raw);
x_mg = x_raw * LSM6DSM_ACC_SENSITIVITY_4G / 1000;
y_mg = y_raw * LSM6DSM_ACC_SENSITIVITY_4G / 1000;
z_mg = z_raw * LSM6DSM_ACC_SENSITIVITY_4G / 1000;
//LOG("%s %s %d: i(%d), mg(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_mg, y_mg, z_mg);
x_sum += x_mg;
y_sum += y_mg;
z_sum += z_mg;
}
data[0] = x_sum / LSM6DSM_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[1] = y_sum / LSM6DSM_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[2] = z_sum / LSM6DSM_ACC_SELF_TEST_AVG_SAMPLE_CNT;
return ret;
}
static int drv_acc_st_lsm6dsm_self_test(i2c_dev_t* drv,int32_t* data)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t ctrl_reg[10];
int32_t out_nost[3];
int32_t out_st[3];
int32_t out_diff[3];
const uint8_t ctrl_val[10] = { 0x38, 0, 0x44, 0, 0, 0, 0, 0, 0, 0 };
// Save cfg registers which will be modified during self-test
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
// Initialize Sensor, turn on sensor, enable X/Y/Z axes
// Set BDU=1, FS=4G, ODR = 52Hz
for (i = 0; i < 10; i ++) {
value = ctrl_val[i];
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL1_XL + i, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
}
aos_msleep(100);
// Discard the first sample
ret = drv_acc_st_lsm6dsm_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and averate them
ret = drv_acc_st_lsm6dsm_st_data(drv, out_nost);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Enable seft-test
value = 0x01;
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL5_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(100);
// Discard the first sample
ret = drv_acc_st_lsm6dsm_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and average them
ret = drv_acc_st_lsm6dsm_st_data(drv, out_st);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Check if the differences are between min and max
for (i = 0; i < 3; i ++) {
out_diff[i] = abs(out_st[i] - out_nost[i]);
data[i] = out_diff[i];
}
if ((LSM6DSM_ACC_SELF_TEST_MIN_X > out_diff[0]) || (out_diff[0] > LSM6DSM_ACC_SELF_TEST_MAX_X)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DSM_ACC_SELF_TEST_MIN_Y > out_diff[1]) || (out_diff[1] > LSM6DSM_ACC_SELF_TEST_MAX_Y)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DSM_ACC_SELF_TEST_MIN_Z > out_diff[2]) || (out_diff[2] > LSM6DSM_ACC_SELF_TEST_MAX_Z)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
restore:
ret += sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
return ret;
}
static void drv_acc_st_lsm6dsm_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_lsm6dsm_open(void)
{
int ret = 0;
ret = drv_acc_st_lsm6dsm_set_power_mode(&lsm6dsm_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6dsm_set_bdu(&lsm6dsm_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm6dsm_set_range(&lsm6dsm_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm6dsm_set_odr(&lsm6dsm_ctx, LSM6DSM_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6dsm_close(void)
{
int ret = 0;
ret = drv_acc_st_lsm6dsm_set_power_mode(&lsm6dsm_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6dsm_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lsm6dsm_ctx, LSM6DSM_ACC_GYRO_OUTX_L_XL, ®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsm_ctx, LSM6DSM_ACC_GYRO_OUTX_H_XL, ®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsm_ctx, LSM6DSM_ACC_GYRO_OUTY_L_XL, ®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsm_ctx, LSM6DSM_ACC_GYRO_OUTY_H_XL, ®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsm_ctx, LSM6DSM_ACC_GYRO_OUTZ_L_XL, ®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsm_ctx, LSM6DSM_ACC_GYRO_OUTZ_H_XL, ®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< LSM6DSM_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< LSM6DSM_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< LSM6DSM_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = (accel->data[DATA_AXIS_X] * cur_acc_factor)/LSM6DSM_ACC_MUL;
accel->data[DATA_AXIS_Y] = (accel->data[DATA_AXIS_Y] * cur_acc_factor)/LSM6DSM_ACC_MUL;
accel->data[DATA_AXIS_Z] = (accel->data[DATA_AXIS_Z] * cur_acc_factor)/LSM6DSM_ACC_MUL;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_lsm6dsm_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_lsm6dsm_set_odr(&lsm6dsm_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_st_lsm6dsm_set_range(&lsm6dsm_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_lsm6dsm_set_power_mode(&lsm6dsm_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
//dev_sensor_info_t *info = (dev_sensor_info_t*)arg;
info->model = "LSM6DSM";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}break;
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_acc_st_lsm6dsm_self_test(&lsm6dsm_ctx, (int32_t*)info->data);
//printf("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
LOG("%s %s: %d, %d, %d\n", SENSOR_STR, __func__, info->data[0],info->data[1],info->data[2]);
return ret;
}
default:break;
}
return 0;
}
int drv_acc_st_lsm6dsm_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_lsm6dsm_open;
sensor.close = drv_acc_st_lsm6dsm_close;
sensor.read = drv_acc_st_lsm6dsm_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_lsm6dsm_ioctl;
sensor.irq_handle = drv_acc_st_lsm6dsm_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_acc_gyro_st_lsm6dsm_validate_id(&lsm6dsm_ctx, LSM6DSM_CHIP_ID_VALUE);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
if(0 == g_lsm6dsmflag)
{
ret = drv_acc_gyro_st_lsm6dsm_soft_reset(&lsm6dsm_ctx);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_acc_st_lsm6dsm_set_power_mode(&lsm6dsm_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
g_lsm6dsmflag = 1;
}
else
{
LOG("%s %s acc do not need reset\n", SENSOR_STR, __func__);
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_gyro_st_lsm6dsm_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LSM6DSM_SET_BITSLICE(value,LSM6DSM_GYRO_ODR,LSM6DSM_GYRO_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LSM6DSM_SET_BITSLICE(value,LSM6DSM_GYRO_ODR,LSM6DSM_GYRO_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LSM6DSM_SET_BITSLICE(value,LSM6DSM_GYRO_ODR,LSM6DSM_GYRO_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_gyro_st_lsm6dsm_hz2odr(uint32_t hz)
{
if(hz > 3330)
return LSM6DSM_GYRO_ODR_6_66_KHZ;
else if(hz > 1660)
return LSM6DSM_GYRO_ODR_3_33_KHZ;
else if(hz > 833)
return LSM6DSM_GYRO_ODR_1_66_KHZ;
else if(hz > 416)
return LSM6DSM_GYRO_ODR_833_HZ;
else if(hz > 208)
return LSM6DSM_GYRO_ODR_416_HZ;
else if(hz > 104)
return LSM6DSM_GYRO_ODR_208_HZ;
else if(hz > 52)
return LSM6DSM_GYRO_ODR_104_HZ;
else if(hz > 26)
return LSM6DSM_GYRO_ODR_52_HZ;
else if(hz > 13)
return LSM6DSM_GYRO_ODR_26_HZ;
else
return LSM6DSM_GYRO_ODR_12_5_HZ;
}
static int drv_gyro_st_lsm6dsm_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_gyro_st_lsm6dsm_hz2odr(hz);
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LSM6DSM_SET_BITSLICE(value,LSM6DSM_GYRO_ODR,odr);
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_gyro_st_lsm6dsm_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case GYRO_RANGE_250DPS:{
tmp = LSM6DSM_GYRO_RANGE_245;
}break;
case GYRO_RANGE_500DPS:{
tmp = LSM6DSM_GYRO_RANGE_500;
}break;
case GYRO_RANGE_1000DPS:{
tmp = LSM6DSM_GYRO_RANGE_1000;
}break;
case GYRO_RANGE_2000DPS:{
tmp = LSM6DSM_GYRO_RANGE_2000;
}break;
default:break;
}
value = LSM6DSM_SET_BITSLICE(value,LSM6DSM_GYRO_RANGE,tmp);
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= GYRO_RANGE_250DPS)&&(range <= GYRO_RANGE_2000DPS)){
cur_gyro_factor = lsm6dsm_gyro_factor[range];
}
return 0;
}
static int drv_gyro_st_lsm6dsm_st_discard(i2c_dev_t* drv)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
for (i = 0; i < LSM6DSM_GYRO_SELF_TEST_DRY_WAIT_CNT; i ++) {
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x02)
break;
aos_msleep(20);
}
if (i >= LSM6DSM_GYRO_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_OUTX_L_G, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
return ret;
}
static int drv_gyro_st_lsm6dsm_st_data(i2c_dev_t* drv,int32_t* data)
{
uint8_t i, j;
int16_t x_raw, y_raw, z_raw;
int32_t x_dps, y_dps, z_dps;
int32_t x_sum, y_sum, z_sum;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
x_sum = 0; y_sum = 0; z_sum = 0;
for (i = 0; i < LSM6DSM_GYRO_SELF_TEST_AVG_SAMPLE_CNT; i ++) {
for (j = 0; j < LSM6DSM_GYRO_SELF_TEST_DRY_WAIT_CNT; j ++) {
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x02)
break;
aos_msleep(5);
}
if (j >= LSM6DSM_GYRO_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_OUTX_L_G, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
x_raw = (buffer[1] << 8) + buffer[0];
y_raw = (buffer[3] << 8) + buffer[2];
z_raw = (buffer[5] << 8) + buffer[4];
//LOG("%s %s %d: i(%d), raw(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_raw, y_raw, z_raw);
x_dps = x_raw * LSM6DSM_GYRO_SENSITIVITY_2000DPS / 1000000;
y_dps = y_raw * LSM6DSM_GYRO_SENSITIVITY_2000DPS / 1000000;
z_dps = z_raw * LSM6DSM_GYRO_SENSITIVITY_2000DPS / 1000000;
//LOG("%s %s %d: i(%d), dps(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_dps, y_dps, z_dps);
x_sum += x_dps;
y_sum += y_dps;
z_sum += z_dps;
}
data[0] = x_sum / LSM6DSM_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[1] = y_sum / LSM6DSM_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[2] = z_sum / LSM6DSM_ACC_SELF_TEST_AVG_SAMPLE_CNT;
return ret;
}
static int drv_gyro_st_lsm6dsm_self_test(i2c_dev_t* drv,int32_t* data)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t ctrl_reg[10];
int32_t out_nost[3];
int32_t out_st[3];
int32_t out_diff[3];
const uint8_t ctrl_val[10] = { 0, 0x5c, 0x44, 0, 0, 0, 0, 0, 0, 0 };
// Save cfg registers which will be modified during self-test
ret = sensor_i2c_read(drv, LSM6DSM_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
// Initialize Sensor, turn on sensor, enable P/R/Y
// Set BDU=1, ODR = 208Hz, FS=2000dps
for (i = 0; i < 10; i ++) {
value = ctrl_val[i];
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL1_XL + i, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
}
aos_msleep(150);
// Discard the first sample
ret = drv_gyro_st_lsm6dsm_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and averate them
ret = drv_gyro_st_lsm6dsm_st_data(drv, out_nost);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Enable seft-test
value = 0x04;
ret = sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL5_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(50);
// Discard the first sample
ret = drv_gyro_st_lsm6dsm_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and average them
ret = drv_gyro_st_lsm6dsm_st_data(drv, out_st);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Check if the differences are between min and max
for (i = 0; i < 3; i ++) {
out_diff[i] = abs(out_st[i] - out_nost[i]);
data[i] = out_diff[i];
}
if ((LSM6DSM_GYRO_SELF_TEST_MIN_X > out_diff[0]) || (out_diff[0] > LSM6DSM_GYRO_SELF_TEST_MAX_X)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DSM_GYRO_SELF_TEST_MIN_Y > out_diff[1]) || (out_diff[1] > LSM6DSM_GYRO_SELF_TEST_MAX_Y)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DSM_GYRO_SELF_TEST_MIN_Z > out_diff[2]) || (out_diff[2] > LSM6DSM_GYRO_SELF_TEST_MAX_Z)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
restore:
ret += sensor_i2c_write(drv, LSM6DSM_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
return ret;
}
static void drv_gyro_st_lsm6dsm_irq_handle(void)
{
/* no handle so far */
}
static int drv_gyro_st_lsm6dsm_open(void)
{
int ret = 0;
ret = drv_gyro_st_lsm6dsm_set_power_mode(&lsm6dsm_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6dsm_set_bdu(&lsm6dsm_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_st_lsm6dsm_set_range(&lsm6dsm_ctx, GYRO_RANGE_1000DPS);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_st_lsm6dsm_set_odr(&lsm6dsm_ctx, LSM6DSM_GYRO_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_gyro_st_lsm6dsm_close(void)
{
int ret = 0;
ret = drv_gyro_st_lsm6dsm_set_power_mode(&lsm6dsm_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_gyro_st_lsm6dsm_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
gyro_data_t *gyro = (gyro_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(gyro_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lsm6dsm_ctx, LSM6DSM_ACC_GYRO_OUTX_L_G, ®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsm_ctx, LSM6DSM_ACC_GYRO_OUTX_H_G, ®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsm_ctx, LSM6DSM_ACC_GYRO_OUTY_L_G, ®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsm_ctx, LSM6DSM_ACC_GYRO_OUTY_H_G, ®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsm_ctx, LSM6DSM_ACC_GYRO_OUTZ_L_G, ®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsm_ctx, LSM6DSM_ACC_GYRO_OUTZ_H_G, ®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
gyro->data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)reg[1]))<< LSM6DSM_SHIFT_EIGHT_BITS)|(reg[0]));
gyro->data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)reg[3]))<< LSM6DSM_SHIFT_EIGHT_BITS)|(reg[2]));
gyro->data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)reg[5]))<< LSM6DSM_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_gyro_factor != 0){
gyro->data[DATA_AXIS_X] = (gyro->data[DATA_AXIS_X] * cur_gyro_factor)/LSM6DSM_GYRO_MUL;
gyro->data[DATA_AXIS_Y] = (gyro->data[DATA_AXIS_Y] * cur_gyro_factor)/LSM6DSM_GYRO_MUL;
gyro->data[DATA_AXIS_Z] = (gyro->data[DATA_AXIS_Z] * cur_gyro_factor)/LSM6DSM_GYRO_MUL;
}
gyro->timestamp = aos_now_ms();
return (int)size;
}
static int drv_gyro_st_lsm6dsm_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_gyro_st_lsm6dsm_set_odr(&lsm6dsm_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_gyro_st_lsm6dsm_set_range(&lsm6dsm_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_gyro_st_lsm6dsm_set_power_mode(&lsm6dsm_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
//dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LSM6DSM";
info->range_max = 2000;
info->range_min = 125;
info->unit = udps;
}break;
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_gyro_st_lsm6dsm_self_test(&lsm6dsm_ctx, (int32_t*)info->data);
//printf("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
LOG("%s %s: %d, %d, %d\n", SENSOR_STR, __func__, info->data[0],info->data[1],info->data[2]);
return ret;
}
default:break;
}
return 0;
}
int drv_gyro_st_lsm6dsm_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_GYRO;
sensor.path = dev_gyro_path;
sensor.open = drv_gyro_st_lsm6dsm_open;
sensor.close = drv_gyro_st_lsm6dsm_close;
sensor.read = drv_gyro_st_lsm6dsm_read;
sensor.write = NULL;
sensor.ioctl = drv_gyro_st_lsm6dsm_ioctl;
sensor.irq_handle = drv_gyro_st_lsm6dsm_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_acc_gyro_st_lsm6dsm_validate_id(&lsm6dsm_ctx, LSM6DSM_CHIP_ID_VALUE);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
if(0 == g_lsm6dsmflag){
ret = drv_acc_gyro_st_lsm6dsm_soft_reset(&lsm6dsm_ctx);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_gyro_st_lsm6dsm_set_power_mode(&lsm6dsm_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
g_lsm6dsmflag = 1;
}
else{
LOG("%s %s gyro do not need reset\n", SENSOR_STR, __func__);
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_lsm6dsm_init);
SENSOR_DRV_ADD(drv_gyro_st_lsm6dsm_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_gyro_st_lsm6dsm.c
|
C
|
apache-2.0
| 41,679
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LSM6DSOQ_I2C_ADDR1 (0x6A)
#define LSM6DSOQ_I2C_ADDR2 (0x6B)
#define LSM6DSOQ_I2C_ADDR_TRANS(n) ((n)<<1)
//#define LSM6DSOQ_I2C_ADDR LSM6DSOQ_I2C_ADDR_TRANS(LSM6DSOQ_I2C_ADDR2)
#define LSM6DSOQ_I2C_ADDR LSM6DSOQ_I2C_ADDR_TRANS(LSM6DSOQ_I2C_ADDR1)
#define LSM6DSOQ_ACC_GYRO_FUNC_CFG_ACCESS 0x01
#define LSM6DSOQ_ACC_GYRO_SENSOR_SYNC_TIME 0x04
#define LSM6DSOQ_ACC_GYRO_SENSOR_RES_RATIO 0x05
#define LSM6DSOQ_ACC_GYRO_FIFO_CTRL1 0x06
#define LSM6DSOQ_ACC_GYRO_FIFO_CTRL2 0x07
#define LSM6DSOQ_ACC_GYRO_FIFO_CTRL3 0x08
#define LSM6DSOQ_ACC_GYRO_FIFO_CTRL4 0x09
#define LSM6DSOQ_ACC_GYRO_DRDY_PULSE_CFG_G 0x0B
#define LSM6DSOQ_ACC_GYRO_INT1_CTRL 0x0D
#define LSM6DSOQ_ACC_GYRO_INT2_CTRL 0x0E
#define LSM6DSOQ_ACC_GYRO_WHO_AM_I_REG 0x0F
#define LSM6DSOQ_ACC_GYRO_CTRL1_XL 0x10
#define LSM6DSOQ_ACC_GYRO_CTRL2_G 0x11
#define LSM6DSOQ_ACC_GYRO_CTRL3_C 0x12
#define LSM6DSOQ_ACC_GYRO_CTRL4_C 0x13
#define LSM6DSOQ_ACC_GYRO_CTRL5_C 0x14
#define LSM6DSOQ_ACC_GYRO_CTRL6_C 0x15
#define LSM6DSOQ_ACC_GYRO_CTRL7_G 0x16
#define LSM6DSOQ_ACC_GYRO_CTRL8_XL 0x17
#define LSM6DSOQ_ACC_GYRO_CTRL9_XL 0x18
#define LSM6DSOQ_ACC_GYRO_CTRL10_C 0x19
#define LSM6DSOQ_ACC_GYRO_ALL_INT_SRC 0x1A
#define LSM6DSOQ_ACC_GYRO_WAKE_UP_SRC 0x1B
#define LSM6DSOQ_ACC_GYRO_TAP_SRC 0x1C
#define LSM6DSOQ_ACC_GYRO_D6D_SRC 0x1D
#define LSM6DSOQ_ACC_GYRO_STATUS_REG 0x1E
#define LSM6DSOQ_ACC_GYRO_OUT_TEMP_L 0x20
#define LSM6DSOQ_ACC_GYRO_OUT_TEMP_H 0x21
#define LSM6DSOQ_ACC_GYRO_OUTX_L_G 0x22
#define LSM6DSOQ_ACC_GYRO_OUTX_H_G 0x23
#define LSM6DSOQ_ACC_GYRO_OUTY_L_G 0x24
#define LSM6DSOQ_ACC_GYRO_OUTY_H_G 0x25
#define LSM6DSOQ_ACC_GYRO_OUTZ_L_G 0x26
#define LSM6DSOQ_ACC_GYRO_OUTZ_H_G 0x27
#define LSM6DSOQ_ACC_GYRO_OUTX_L_XL 0x28
#define LSM6DSOQ_ACC_GYRO_OUTX_H_XL 0x29
#define LSM6DSOQ_ACC_GYRO_OUTY_L_XL 0x2A
#define LSM6DSOQ_ACC_GYRO_OUTY_H_XL 0x2B
#define LSM6DSOQ_ACC_GYRO_OUTZ_L_XL 0x2C
#define LSM6DSOQ_ACC_GYRO_OUTZ_H_XL 0x2D
#define LSM6DSOQ_ACC_GYRO_EMB_FUNC_STATUS_MAINPAGE 0x35
#define LSM6DSOQ_ACC_GYRO_FSM_STATUS_A_MAINPAGE 0x36
#define LSM6DSOQ_ACC_GYRO_FSM_STATUS_B_MAINPAGE 0x37
#define LSM6DSOQ_ACC_GYRO_MASTER_MAINPAGE 0x39
#define LSM6DSOQ_ACC_GYRO_FIFO_STATUS1 0x3A
#define LSM6DSOQ_ACC_GYRO_FIFO_STATUS2 0x3B
#define LSM6DSOQ_ACC_GYRO_TIMESTAMP0_REG 0x40
#define LSM6DSOQ_ACC_GYRO_TIMESTAMP1_REG 0x41
#define LSM6DSOQ_ACC_GYRO_TIMESTAMP2_REG 0x42
#define LSM6DSOQ_ACC_GYRO_X_OFS_USR 0x73
#define LSM6DSOQ_ACC_GYRO_Y_OFS_USR 0x74
#define LSM6DSOQ_ACC_GYRO_Z_OFS_USR 0x75
#define LSM6DSOQ_CHIP_ID_VALUE (0x6C)
#define LSM6DSOQ_RESET_VALUE (0x1)
#define LSM6DSOQ_RESET_MSK (0X1)
#define LSM6DSOQ_RESET_POS (0)
#define LSM6DSOQ_BDU_VALUE (0x40)
#define LSM6DSOQ_BDU_MSK (0X40)
#define LSM6DSOQ_BDU_POS (6)
#define LSM6DSOQ_ACC_ODR_POWER_DOWN (0X00)
#define LSM6DSOQ_ACC_ODR_1_6_HZ (0X0B)
#define LSM6DSOQ_ACC_ODR_12_5_HZ (0x01)
#define LSM6DSOQ_ACC_ODR_26_HZ (0x02)
#define LSM6DSOQ_ACC_ODR_52_HZ (0x03)
#define LSM6DSOQ_ACC_ODR_104_HZ (0x04)
#define LSM6DSOQ_ACC_ODR_208_HZ (0x05)
#define LSM6DSOQ_ACC_ODR_416_HZ (0x06)
#define LSM6DSOQ_ACC_ODR_833_HZ (0x07)
#define LSM6DSOQ_ACC_ODR_1_66_KHZ (0x08)
#define LSM6DSOQ_ACC_ODR_3_33_KHZ (0x09)
#define LSM6DSOQ_ACC_ODR_6_66_KHZ (0x0A)
#define LSM6DSOQ_ACC_ODR_MSK (0XF0)
#define LSM6DSOQ_ACC_ODR_POS (4)
#define LSM6DSOQ_GYRO_ODR_POWER_DOWN (0X00)
#define LSM6DSOQ_GYRO_ODR_12_5_HZ (0x01)
#define LSM6DSOQ_GYRO_ODR_26_HZ (0x02)
#define LSM6DSOQ_GYRO_ODR_52_HZ (0x03)
#define LSM6DSOQ_GYRO_ODR_104_HZ (0x04)
#define LSM6DSOQ_GYRO_ODR_208_HZ (0x05)
#define LSM6DSOQ_GYRO_ODR_416_HZ (0x06)
#define LSM6DSOQ_GYRO_ODR_833_HZ (0x07)
#define LSM6DSOQ_GYRO_ODR_1_66_KHZ (0x08)
#define LSM6DSOQ_GYRO_ODR_3_33_KHZ (0x09)
#define LSM6DSOQ_GYRO_ODR_6_66_KHZ (0x0A)
#define LSM6DSOQ_GYRO_ODR_MSK (0XF0)
#define LSM6DSOQ_GYRO_ODR_POS (4)
#define LSM6DSOQ_ACC_RANGE_2G (0x0)
#define LSM6DSOQ_ACC_RANGE_4G (0x2)
#define LSM6DSOQ_ACC_RANGE_8G (0x3)
#define LSM6DSOQ_ACC_RANGE_16G (0x1)
#define LSM6DSOQ_ACC_RANGE_MSK (0X0C)
#define LSM6DSOQ_ACC_RANGE_POS (2)
#define LSM6DSOQ_ACC_SENSITIVITY_2G (61)
#define LSM6DSOQ_ACC_SENSITIVITY_4G (122)
#define LSM6DSOQ_ACC_SENSITIVITY_8G (244)
#define LSM6DSOQ_ACC_SENSITIVITY_16G (488)
#define LSM6DSOQ_GYRO_RANGE_245 (0x0)
#define LSM6DSOQ_GYRO_RANGE_500 (0x1)
#define LSM6DSOQ_GYRO_RANGE_1000 (0x2)
#define LSM6DSOQ_GYRO_RANGE_2000 (0x3)
#define LSM6DSOQ_GYRO_RANGE_MSK (0X0C)
#define LSM6DSOQ_GYRO_RANGE_POS (2)
#define LSM6DSOQ_GYRO_SENSITIVITY_245DPS (8750)
#define LSM6DSOQ_GYRO_SENSITIVITY_500DPS (17500)
#define LSM6DSOQ_GYRO_SENSITIVITY_1000DPS (35000)
#define LSM6DSOQ_GYRO_SENSITIVITY_2000DPS (70000)
#define LSM6DSOQ_SHIFT_EIGHT_BITS (8)
#define LSM6DSOQ_16_BIT_SHIFT (0xFF)
#define LSM6DSOQ_ACC_MUL (1000)
#define LSM6DSOQ_GYRO_MUL (1)
#define LSM6DSOQ_ACC_DEFAULT_ODR_100HZ (100)
#define LSM6DSOQ_GYRO_DEFAULT_ODR_100HZ (100)
#define LSM6DSOQ_ACC_SELF_TEST_MIN_X (90) // 90mg
#define LSM6DSOQ_ACC_SELF_TEST_MIN_Y (90) // 90mg
#define LSM6DSOQ_ACC_SELF_TEST_MIN_Z (90) // 90mg
#define LSM6DSOQ_ACC_SELF_TEST_MAX_X (1700) // 1700mg
#define LSM6DSOQ_ACC_SELF_TEST_MAX_Y (1700) // 1700mg
#define LSM6DSOQ_ACC_SELF_TEST_MAX_Z (1700) // 1700mg
#define LSM6DSOQ_ACC_SELF_TEST_DRY_WAIT_CNT 5
#define LSM6DSOQ_ACC_SELF_TEST_AVG_SAMPLE_CNT 5
#define LSM6DSOQ_GYRO_SELF_TEST_MIN_X (150) // 150dps
#define LSM6DSOQ_GYRO_SELF_TEST_MIN_Y (150) // 150dps
#define LSM6DSOQ_GYRO_SELF_TEST_MIN_Z (150) // 150dps
#define LSM6DSOQ_GYRO_SELF_TEST_MAX_X (700) // 700dps
#define LSM6DSOQ_GYRO_SELF_TEST_MAX_Y (700) // 700dps
#define LSM6DSOQ_GYRO_SELF_TEST_MAX_Z (700) // 700dps
#define LSM6DSOQ_GYRO_SELF_TEST_DRY_WAIT_CNT 5
#define LSM6DSOQ_GYRO_SELF_TEST_AVG_SAMPLE_CNT 5
#define LSM6DSOQ_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define LSM6DSOQ_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t lsm6dsoq_acc_factor[ACC_RANGE_MAX] = { LSM6DSOQ_ACC_SENSITIVITY_2G, LSM6DSOQ_ACC_SENSITIVITY_4G,
LSM6DSOQ_ACC_SENSITIVITY_8G, LSM6DSOQ_ACC_SENSITIVITY_16G };
static int32_t lsm6dsoq_gyro_factor[GYRO_RANGE_MAX] = {0, LSM6DSOQ_GYRO_SENSITIVITY_245DPS, LSM6DSOQ_GYRO_SENSITIVITY_500DPS,
LSM6DSOQ_GYRO_SENSITIVITY_1000DPS, LSM6DSOQ_GYRO_SENSITIVITY_2000DPS };
static int32_t cur_acc_factor = 0;
static int32_t cur_gyro_factor = 0;
static int32_t g_lsm6dsoqflag = 0;
static i2c_dev_t lsm6dsoq_ctx = {
//.port = 4,
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LSM6DSOQ_I2C_ADDR,
};
static int drv_acc_gyro_st_lsm6dsoq_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LSM6DSOQ_RESET_VALUE;
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_gyro_st_lsm6dsoq_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_WHO_AM_I_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
LOG("%s %s right id (0x%02x), read id(0x%02x)\n", SENSOR_STR, __func__, id_value, value);
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6dsoq_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LSM6DSOQ_SET_BITSLICE(value,LSM6DSOQ_ACC_ODR,LSM6DSOQ_ACC_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LSM6DSOQ_SET_BITSLICE(value,LSM6DSOQ_ACC_ODR,LSM6DSOQ_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LSM6DSOQ_SET_BITSLICE(value,LSM6DSOQ_ACC_ODR,LSM6DSOQ_ACC_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static int drv_acc_gyro_st_lsm6dsoq_set_bdu(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (value & LSM6DSOQ_BDU_VALUE)
return 0;
value |= LSM6DSOQ_BDU_VALUE;
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static uint8_t drv_acc_st_lsm6dsoq_hz2odr(uint32_t hz)
{
if(hz > 3330)
return LSM6DSOQ_ACC_ODR_6_66_KHZ;
else if(hz > 1660)
return LSM6DSOQ_ACC_ODR_3_33_KHZ;
else if(hz > 833)
return LSM6DSOQ_ACC_ODR_1_66_KHZ;
else if(hz > 416)
return LSM6DSOQ_ACC_ODR_833_HZ;
else if(hz > 208)
return LSM6DSOQ_ACC_ODR_416_HZ;
else if(hz > 104)
return LSM6DSOQ_ACC_ODR_208_HZ;
else if(hz > 52)
return LSM6DSOQ_ACC_ODR_104_HZ;
else if(hz > 26)
return LSM6DSOQ_ACC_ODR_52_HZ;
else if(hz > 13)
return LSM6DSOQ_ACC_ODR_26_HZ;
else if(hz >= 2)
return LSM6DSOQ_ACC_ODR_12_5_HZ;
else
return LSM6DSOQ_ACC_ODR_1_6_HZ;
}
static int drv_acc_st_lsm6dsoq_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_lsm6dsoq_hz2odr(hz);
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LSM6DSOQ_SET_BITSLICE(value,LSM6DSOQ_ACC_ODR,odr);
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lsm6dsoq_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_2G:{
tmp = LSM6DSOQ_ACC_RANGE_2G;
}break;
case ACC_RANGE_4G:{
tmp = LSM6DSOQ_ACC_RANGE_4G;
}break;
case ACC_RANGE_8G:{
tmp = LSM6DSOQ_ACC_RANGE_8G;
}break;
case ACC_RANGE_16G:{
tmp = LSM6DSOQ_ACC_RANGE_16G;
}break;
default:break;
}
value = LSM6DSOQ_SET_BITSLICE(value,LSM6DSOQ_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)){
cur_acc_factor = lsm6dsoq_acc_factor[range];
}
return 0;
}
static int drv_acc_st_lsm6dsoq_st_discard(i2c_dev_t* drv)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
for (i = 0; i < LSM6DSOQ_ACC_SELF_TEST_DRY_WAIT_CNT; i ++) {
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x01)
break;
aos_msleep(20);
}
if (i >= LSM6DSOQ_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_OUTX_L_XL, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
return ret;
}
static int drv_acc_st_lsm6dsoq_st_data(i2c_dev_t* drv,int32_t* data)
{
uint8_t i, j;
int16_t x_raw, y_raw, z_raw;
int32_t x_mg, y_mg, z_mg;
int32_t x_sum, y_sum, z_sum;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
x_sum = 0; y_sum = 0; z_sum = 0;
for (i = 0; i < LSM6DSOQ_ACC_SELF_TEST_AVG_SAMPLE_CNT; i ++) {
for (j = 0; j < LSM6DSOQ_ACC_SELF_TEST_DRY_WAIT_CNT; j ++) {
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x01)
break;
aos_msleep(20);
}
if (j >= LSM6DSOQ_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_OUTX_L_XL, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
x_raw = (buffer[1] << 8) + buffer[0];
y_raw = (buffer[3] << 8) + buffer[2];
z_raw = (buffer[5] << 8) + buffer[4];
//LOG("%s %s %d: i(%d), raw(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_raw, y_raw, z_raw);
x_mg = x_raw * LSM6DSOQ_ACC_SENSITIVITY_4G / 1000;
y_mg = y_raw * LSM6DSOQ_ACC_SENSITIVITY_4G / 1000;
z_mg = z_raw * LSM6DSOQ_ACC_SENSITIVITY_4G / 1000;
//LOG("%s %s %d: i(%d), mg(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_mg, y_mg, z_mg);
x_sum += x_mg;
y_sum += y_mg;
z_sum += z_mg;
}
data[0] = x_sum / LSM6DSOQ_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[1] = y_sum / LSM6DSOQ_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[2] = z_sum / LSM6DSOQ_ACC_SELF_TEST_AVG_SAMPLE_CNT;
return ret;
}
static int drv_acc_st_lsm6dsoq_self_test(i2c_dev_t* drv,int32_t* data)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t ctrl_reg[10];
int32_t out_nost[3];
int32_t out_st[3];
int32_t out_diff[3];
const uint8_t ctrl_val[10] = { 0x38, 0, 0x44, 0, 0, 0, 0, 0, 0, 0 };
// Save cfg registers which will be modified during self-test
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
// Initialize Sensor, turn on sensor, enable X/Y/Z axes
// Set BDU=1, FS=4G, ODR = 52Hz
for (i = 0; i < 10; i ++) {
value = ctrl_val[i];
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL1_XL + i, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
}
aos_msleep(100);
// Discard the first sample
ret = drv_acc_st_lsm6dsoq_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and averate them
ret = drv_acc_st_lsm6dsoq_st_data(drv, out_nost);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Enable seft-test
value = 0x01;
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL5_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(100);
// Discard the first sample
ret = drv_acc_st_lsm6dsoq_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and average them
ret = drv_acc_st_lsm6dsoq_st_data(drv, out_st);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Check if the differences are between min and max
for (i = 0; i < 3; i ++) {
out_diff[i] = abs(out_st[i] - out_nost[i]);
data[i] = out_diff[i];
}
if ((LSM6DSOQ_ACC_SELF_TEST_MIN_X > out_diff[0]) || (out_diff[0] > LSM6DSOQ_ACC_SELF_TEST_MAX_X)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DSOQ_ACC_SELF_TEST_MIN_Y > out_diff[1]) || (out_diff[1] > LSM6DSOQ_ACC_SELF_TEST_MAX_Y)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DSOQ_ACC_SELF_TEST_MIN_Z > out_diff[2]) || (out_diff[2] > LSM6DSOQ_ACC_SELF_TEST_MAX_Z)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
restore:
ret += sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
return ret;
}
static void drv_acc_st_lsm6dsoq_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_lsm6dsoq_open(void)
{
int ret = 0;
ret = drv_acc_st_lsm6dsoq_set_power_mode(&lsm6dsoq_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6dsoq_set_bdu(&lsm6dsoq_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm6dsoq_set_range(&lsm6dsoq_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm6dsoq_set_odr(&lsm6dsoq_ctx, LSM6DSOQ_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6dsoq_close(void)
{
int ret = 0;
ret = drv_acc_st_lsm6dsoq_set_power_mode(&lsm6dsoq_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6dsoq_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lsm6dsoq_ctx, LSM6DSOQ_ACC_GYRO_OUTX_L_XL, ®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsoq_ctx, LSM6DSOQ_ACC_GYRO_OUTX_H_XL, ®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsoq_ctx, LSM6DSOQ_ACC_GYRO_OUTY_L_XL, ®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsoq_ctx, LSM6DSOQ_ACC_GYRO_OUTY_H_XL, ®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsoq_ctx, LSM6DSOQ_ACC_GYRO_OUTZ_L_XL, ®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsoq_ctx, LSM6DSOQ_ACC_GYRO_OUTZ_H_XL, ®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< LSM6DSOQ_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< LSM6DSOQ_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< LSM6DSOQ_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = (accel->data[DATA_AXIS_X] * cur_acc_factor)/LSM6DSOQ_ACC_MUL;
accel->data[DATA_AXIS_Y] = (accel->data[DATA_AXIS_Y] * cur_acc_factor)/LSM6DSOQ_ACC_MUL;
accel->data[DATA_AXIS_Z] = (accel->data[DATA_AXIS_Z] * cur_acc_factor)/LSM6DSOQ_ACC_MUL;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_lsm6dsoq_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_lsm6dsoq_set_odr(&lsm6dsoq_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_st_lsm6dsoq_set_range(&lsm6dsoq_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_lsm6dsoq_set_power_mode(&lsm6dsoq_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
//dev_sensor_info_t *info = (dev_sensor_info_t*)arg;
info->model = "LSM6DSOQ";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}break;
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_acc_st_lsm6dsoq_self_test(&lsm6dsoq_ctx, (int32_t*)info->data);
//printf("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
LOG("%s %s: %d, %d, %d\n", SENSOR_STR, __func__, info->data[0],info->data[1],info->data[2]);
return ret;
}
default:break;
}
return 0;
}
int drv_acc_st_lsm6dsoq_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_lsm6dsoq_open;
sensor.close = drv_acc_st_lsm6dsoq_close;
sensor.read = drv_acc_st_lsm6dsoq_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_lsm6dsoq_ioctl;
sensor.irq_handle = drv_acc_st_lsm6dsoq_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_acc_gyro_st_lsm6dsoq_validate_id(&lsm6dsoq_ctx, LSM6DSOQ_CHIP_ID_VALUE);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
if(0 == g_lsm6dsoqflag)
{
ret = drv_acc_gyro_st_lsm6dsoq_soft_reset(&lsm6dsoq_ctx);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_acc_st_lsm6dsoq_set_power_mode(&lsm6dsoq_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
g_lsm6dsoqflag = 1;
}
else
{
LOG("%s %s acc do not need reset\n", SENSOR_STR, __func__);
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_gyro_st_lsm6dsoq_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LSM6DSOQ_SET_BITSLICE(value,LSM6DSOQ_GYRO_ODR,LSM6DSOQ_GYRO_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LSM6DSOQ_SET_BITSLICE(value,LSM6DSOQ_GYRO_ODR,LSM6DSOQ_GYRO_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LSM6DSOQ_SET_BITSLICE(value,LSM6DSOQ_GYRO_ODR,LSM6DSOQ_GYRO_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_gyro_st_lsm6dsoq_hz2odr(uint32_t hz)
{
if(hz > 3330)
return LSM6DSOQ_GYRO_ODR_6_66_KHZ;
else if(hz > 1660)
return LSM6DSOQ_GYRO_ODR_3_33_KHZ;
else if(hz > 833)
return LSM6DSOQ_GYRO_ODR_1_66_KHZ;
else if(hz > 416)
return LSM6DSOQ_GYRO_ODR_833_HZ;
else if(hz > 208)
return LSM6DSOQ_GYRO_ODR_416_HZ;
else if(hz > 104)
return LSM6DSOQ_GYRO_ODR_208_HZ;
else if(hz > 52)
return LSM6DSOQ_GYRO_ODR_104_HZ;
else if(hz > 26)
return LSM6DSOQ_GYRO_ODR_52_HZ;
else if(hz > 13)
return LSM6DSOQ_GYRO_ODR_26_HZ;
else
return LSM6DSOQ_GYRO_ODR_12_5_HZ;
}
static int drv_gyro_st_lsm6dsoq_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_gyro_st_lsm6dsoq_hz2odr(hz);
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LSM6DSOQ_SET_BITSLICE(value,LSM6DSOQ_GYRO_ODR,odr);
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_gyro_st_lsm6dsoq_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case GYRO_RANGE_250DPS:{
tmp = LSM6DSOQ_GYRO_RANGE_245;
}break;
case GYRO_RANGE_500DPS:{
tmp = LSM6DSOQ_GYRO_RANGE_500;
}break;
case GYRO_RANGE_1000DPS:{
tmp = LSM6DSOQ_GYRO_RANGE_1000;
}break;
case GYRO_RANGE_2000DPS:{
tmp = LSM6DSOQ_GYRO_RANGE_2000;
}break;
default:break;
}
value = LSM6DSOQ_SET_BITSLICE(value,LSM6DSOQ_GYRO_RANGE,tmp);
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= GYRO_RANGE_250DPS)&&(range <= GYRO_RANGE_2000DPS)){
cur_gyro_factor = lsm6dsoq_gyro_factor[range];
}
return 0;
}
static int drv_gyro_st_lsm6dsoq_st_discard(i2c_dev_t* drv)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
for (i = 0; i < LSM6DSOQ_GYRO_SELF_TEST_DRY_WAIT_CNT; i ++) {
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x02)
break;
aos_msleep(20);
}
if (i >= LSM6DSOQ_GYRO_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_OUTX_L_G, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
return ret;
}
static int drv_gyro_st_lsm6dsoq_st_data(i2c_dev_t* drv,int32_t* data)
{
uint8_t i, j;
int16_t x_raw, y_raw, z_raw;
int32_t x_dps, y_dps, z_dps;
int32_t x_sum, y_sum, z_sum;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
x_sum = 0; y_sum = 0; z_sum = 0;
for (i = 0; i < LSM6DSOQ_GYRO_SELF_TEST_AVG_SAMPLE_CNT; i ++) {
for (j = 0; j < LSM6DSOQ_GYRO_SELF_TEST_DRY_WAIT_CNT; j ++) {
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x02)
break;
aos_msleep(5);
}
if (j >= LSM6DSOQ_GYRO_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_OUTX_L_G, buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
x_raw = (buffer[1] << 8) + buffer[0];
y_raw = (buffer[3] << 8) + buffer[2];
z_raw = (buffer[5] << 8) + buffer[4];
//LOG("%s %s %d: i(%d), raw(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_raw, y_raw, z_raw);
x_dps = x_raw * LSM6DSOQ_GYRO_SENSITIVITY_2000DPS / 1000000;
y_dps = y_raw * LSM6DSOQ_GYRO_SENSITIVITY_2000DPS / 1000000;
z_dps = z_raw * LSM6DSOQ_GYRO_SENSITIVITY_2000DPS / 1000000;
//LOG("%s %s %d: i(%d), dps(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_dps, y_dps, z_dps);
x_sum += x_dps;
y_sum += y_dps;
z_sum += z_dps;
}
data[0] = x_sum / LSM6DSOQ_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[1] = y_sum / LSM6DSOQ_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[2] = z_sum / LSM6DSOQ_ACC_SELF_TEST_AVG_SAMPLE_CNT;
return ret;
}
static int drv_gyro_st_lsm6dsoq_self_test(i2c_dev_t* drv,int32_t* data)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t ctrl_reg[10];
int32_t out_nost[3];
int32_t out_st[3];
int32_t out_diff[3];
const uint8_t ctrl_val[10] = { 0, 0x5c, 0x44, 0, 0, 0, 0, 0, 0, 0 };
// Save cfg registers which will be modified during self-test
ret = sensor_i2c_read(drv, LSM6DSOQ_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
// Initialize Sensor, turn on sensor, enable P/R/Y
// Set BDU=1, ODR = 208Hz, FS=2000dps
for (i = 0; i < 10; i ++) {
value = ctrl_val[i];
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL1_XL + i, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
}
aos_msleep(150);
// Discard the first sample
ret = drv_gyro_st_lsm6dsoq_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and averate them
ret = drv_gyro_st_lsm6dsoq_st_data(drv, out_nost);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Enable seft-test
value = 0x04;
ret = sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL5_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(50);
// Discard the first sample
ret = drv_gyro_st_lsm6dsoq_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and average them
ret = drv_gyro_st_lsm6dsoq_st_data(drv, out_st);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Check if the differences are between min and max
for (i = 0; i < 3; i ++) {
out_diff[i] = abs(out_st[i] - out_nost[i]);
data[i] = out_diff[i];
}
if ((LSM6DSOQ_GYRO_SELF_TEST_MIN_X > out_diff[0]) || (out_diff[0] > LSM6DSOQ_GYRO_SELF_TEST_MAX_X)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DSOQ_GYRO_SELF_TEST_MIN_Y > out_diff[1]) || (out_diff[1] > LSM6DSOQ_GYRO_SELF_TEST_MAX_Y)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM6DSOQ_GYRO_SELF_TEST_MIN_Z > out_diff[2]) || (out_diff[2] > LSM6DSOQ_GYRO_SELF_TEST_MAX_Z)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
restore:
ret += sensor_i2c_write(drv, LSM6DSOQ_ACC_GYRO_CTRL1_XL, ctrl_reg, 10, I2C_OP_RETRIES);
return ret;
}
static void drv_gyro_st_lsm6dsoq_irq_handle(void)
{
/* no handle so far */
}
static int drv_gyro_st_lsm6dsoq_open(void)
{
int ret = 0;
ret = drv_gyro_st_lsm6dsoq_set_power_mode(&lsm6dsoq_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6dsoq_set_bdu(&lsm6dsoq_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_st_lsm6dsoq_set_range(&lsm6dsoq_ctx, GYRO_RANGE_1000DPS);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_st_lsm6dsoq_set_odr(&lsm6dsoq_ctx, LSM6DSOQ_GYRO_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_gyro_st_lsm6dsoq_close(void)
{
int ret = 0;
ret = drv_gyro_st_lsm6dsoq_set_power_mode(&lsm6dsoq_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_gyro_st_lsm6dsoq_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
gyro_data_t *gyro = (gyro_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(gyro_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lsm6dsoq_ctx, LSM6DSOQ_ACC_GYRO_OUTX_L_G, ®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsoq_ctx, LSM6DSOQ_ACC_GYRO_OUTX_H_G, ®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsoq_ctx, LSM6DSOQ_ACC_GYRO_OUTY_L_G, ®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsoq_ctx, LSM6DSOQ_ACC_GYRO_OUTY_H_G, ®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsoq_ctx, LSM6DSOQ_ACC_GYRO_OUTZ_L_G, ®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsoq_ctx, LSM6DSOQ_ACC_GYRO_OUTZ_H_G, ®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
gyro->data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)reg[1]))<< LSM6DSOQ_SHIFT_EIGHT_BITS)|(reg[0]));
gyro->data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)reg[3]))<< LSM6DSOQ_SHIFT_EIGHT_BITS)|(reg[2]));
gyro->data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)reg[5]))<< LSM6DSOQ_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_gyro_factor != 0){
gyro->data[DATA_AXIS_X] = (gyro->data[DATA_AXIS_X] * cur_gyro_factor)/LSM6DSOQ_GYRO_MUL;
gyro->data[DATA_AXIS_Y] = (gyro->data[DATA_AXIS_Y] * cur_gyro_factor)/LSM6DSOQ_GYRO_MUL;
gyro->data[DATA_AXIS_Z] = (gyro->data[DATA_AXIS_Z] * cur_gyro_factor)/LSM6DSOQ_GYRO_MUL;
}
gyro->timestamp = aos_now_ms();
return (int)size;
}
static int drv_gyro_st_lsm6dsoq_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_gyro_st_lsm6dsoq_set_odr(&lsm6dsoq_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_gyro_st_lsm6dsoq_set_range(&lsm6dsoq_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_gyro_st_lsm6dsoq_set_power_mode(&lsm6dsoq_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LSM6DSOQ";
info->range_max = 2000;
info->range_min = 125;
info->unit = udps;
}break;
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_gyro_st_lsm6dsoq_self_test(&lsm6dsoq_ctx, (int32_t*)info->data);
//printf("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
LOG("%s %s: %d, %d, %d\n", SENSOR_STR, __func__, info->data[0],info->data[1],info->data[2]);
return ret;
}
default:break;
}
return 0;
}
int drv_gyro_st_lsm6dsoq_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_GYRO;
sensor.path = dev_gyro_path;
sensor.open = drv_gyro_st_lsm6dsoq_open;
sensor.close = drv_gyro_st_lsm6dsoq_close;
sensor.read = drv_gyro_st_lsm6dsoq_read;
sensor.write = NULL;
sensor.ioctl = drv_gyro_st_lsm6dsoq_ioctl;
sensor.irq_handle = drv_gyro_st_lsm6dsoq_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_acc_gyro_st_lsm6dsoq_validate_id(&lsm6dsoq_ctx, LSM6DSOQ_CHIP_ID_VALUE);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
if(0 == g_lsm6dsoqflag){
ret = drv_acc_gyro_st_lsm6dsoq_soft_reset(&lsm6dsoq_ctx);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_gyro_st_lsm6dsoq_set_power_mode(&lsm6dsoq_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
g_lsm6dsoqflag = 1;
}
else{
LOG("%s %s gyro do not need reset\n", SENSOR_STR, __func__);
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_lsm6dsoq_init);
SENSOR_DRV_ADD(drv_gyro_st_lsm6dsoq_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_gyro_st_lsm6dsoq.c
|
C
|
apache-2.0
| 40,218
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LSM6DSR_I2C_ADDR1 (0x6A)
#define LSM6DSR_I2C_ADDR2 (0x6B)
#define LSM6DSR_I2C_ADDR_TRANS(n) ((n)<<1)
#define LSM6DSR_I2C_ADDR LSM6DSR_I2C_ADDR_TRANS(LSM6DSR_I2C_ADDR2)
#define LSM6DSR_ACC_GYRO_FUNC_CFG_ACCESS 0x01
#define LSM6DSR_ACC_GYRO_PIN_CTRL 0x02
#define LSM6DSR_ACC_GYRO_FIFO_CTRL1 0x07
#define LSM6DSR_ACC_GYRO_FIFO_CTRL2 0x08
#define LSM6DSR_ACC_GYRO_FIFO_CTRL3 0x09
#define LSM6DSR_ACC_GYRO_FIFO_CTRL4 0x0A
#define LSM6DSR_ACC_GYRO_COUNTER_BDR_REG1 0x0B
#define LSM6DSR_ACC_GYRO_COUNTER_BDR_REG2 0x0C
#define LSM6DSR_ACC_GYRO_INT1_CTRL 0x0D
#define LSM6DSR_ACC_GYRO_INT2_CTRL 0x0E
#define LSM6DSR_ACC_GYRO_WHO_AM_I_REG 0x0F
#define LSM6DSR_ACC_GYRO_CTRL1_XL 0x10
#define LSM6DSR_ACC_GYRO_CTRL2_G 0x11
#define LSM6DSR_ACC_GYRO_CTRL3_C 0x12
#define LSM6DSR_ACC_GYRO_CTRL4_C 0x13
#define LSM6DSR_ACC_GYRO_CTRL5_C 0x14
#define LSM6DSR_ACC_GYRO_CTRL6_C 0x15
#define LSM6DSR_ACC_GYRO_CTRL7_G 0x16
#define LSM6DSR_ACC_GYRO_CTRL8_XL 0x17
#define LSM6DSR_ACC_GYRO_CTRL9_XL 0x18
#define LSM6DSR_ACC_GYRO_CTRL10_C 0x19
#define LSM6DSR_ACC_GYRO_ALL_INT_SRC 0x1A
#define LSM6DSR_ACC_GYRO_WAKE_UP_SRC 0x1B
#define LSM6DSR_ACC_GYRO_TAP_SRC 0x1C
#define LSM6DSR_ACC_GYRO_D6D_SRC 0x1D
#define LSM6DSR_ACC_GYRO_STATUS_REG 0x1E
#define LSM6DSR_ACC_GYRO_OUT_TEMP_L 0x20
#define LSM6DSR_ACC_GYRO_OUT_TEMP_H 0x21
#define LSM6DSR_ACC_GYRO_OUTX_L_G 0x22
#define LSM6DSR_ACC_GYRO_OUTX_H_G 0x23
#define LSM6DSR_ACC_GYRO_OUTY_L_G 0x24
#define LSM6DSR_ACC_GYRO_OUTY_H_G 0x25
#define LSM6DSR_ACC_GYRO_OUTZ_L_G 0x26
#define LSM6DSR_ACC_GYRO_OUTZ_H_G 0x27
#define LSM6DSR_ACC_GYRO_OUTX_L_XL 0x28
#define LSM6DSR_ACC_GYRO_OUTX_H_XL 0x29
#define LSM6DSR_ACC_GYRO_OUTY_L_XL 0x2A
#define LSM6DSR_ACC_GYRO_OUTY_H_XL 0x2B
#define LSM6DSR_ACC_GYRO_OUTZ_L_XL 0x2C
#define LSM6DSR_ACC_GYRO_OUTZ_H_XL 0x2D
#define LSM6DSR_ACC_GYRO_FIFO_STATUS1 0x3A
#define LSM6DSR_ACC_GYRO_FIFO_STATUS2 0x3B
#define LSM6DSR_ACC_GYRO_TIMESTAMP0_REG 0x40
#define LSM6DSR_ACC_GYRO_TIMESTAMP1_REG 0x41
#define LSM6DSR_ACC_GYRO_TIMESTAMP2_REG 0x42
#define LSM6DSR_ACC_GYRO_TIMESTAMP3_REG 0x43
#define LSM6DSR_ACC_GYRO_TAP_CFG0 0x56
#define LSM6DSR_ACC_GYRO_TAP_CFG1 0x57
#define LSM6DSR_ACC_GYRO_TAP_CFG2 0x58
#define LSM6DSR_ACC_GYRO_TAP_THS_6D 0x59
#define LSM6DSR_ACC_GYRO_INT_DUR2 0x5A
#define LSM6DSR_ACC_GYRO_WAKE_UP_THS 0x5B
#define LSM6DSR_ACC_GYRO_WAKE_UP_DUR 0x5C
#define LSM6DSR_ACC_GYRO_FREE_FALL 0x5D
#define LSM6DSR_ACC_GYRO_MD1_CFG 0x5E
#define LSM6DSR_ACC_GYRO_MD2_CFG 0x5F
#define LSM6DSR_ACC_GYRO_X_OFS_USR 0x73
#define LSM6DSR_ACC_GYRO_Y_OFS_USR 0x74
#define LSM6DSR_ACC_GYRO_Z_OFS_USR 0x75
#define LSM6DSR_CHIP_ID_VALUE (0x6B)
#define LSM6DSR_RESET_VALUE (0x1)
#define LSM6DSR_RESET_MSK (0X1)
#define LSM6DSR_RESET_POS (0)
#define LSM6DSR_BDU_VALUE (0x40)
#define LSM6DSR_BDU_MSK (0X40)
#define LSM6DSR_BDU_POS (6)
#define LSM6DSR_ACC_ODR_POWER_DOWN (0X00)
#define LSM6DSR_ACC_ODR_1_6_HZ (0X0B)
#define LSM6DSR_ACC_ODR_12_5_HZ (0x01)
#define LSM6DSR_ACC_ODR_26_HZ (0x02)
#define LSM6DSR_ACC_ODR_52_HZ (0x03)
#define LSM6DSR_ACC_ODR_104_HZ (0x04)
#define LSM6DSR_ACC_ODR_208_HZ (0x05)
#define LSM6DSR_ACC_ODR_416_HZ (0x06)
#define LSM6DSR_ACC_ODR_833_HZ (0x07)
#define LSM6DSR_ACC_ODR_1_66_KHZ (0x08)
#define LSM6DSR_ACC_ODR_3_33_KHZ (0x09)
#define LSM6DSR_ACC_ODR_6_66_KHZ (0x0A)
#define LSM6DSR_ACC_ODR_MSK (0XF0)
#define LSM6DSR_ACC_ODR_POS (4)
#define LSM6DSR_GYRO_ODR_POWER_DOWN (0X00)
#define LSM6DSR_GYRO_ODR_12_5_HZ (0x01)
#define LSM6DSR_GYRO_ODR_26_HZ (0x02)
#define LSM6DSR_GYRO_ODR_52_HZ (0x03)
#define LSM6DSR_GYRO_ODR_104_HZ (0x04)
#define LSM6DSR_GYRO_ODR_208_HZ (0x05)
#define LSM6DSR_GYRO_ODR_416_HZ (0x06)
#define LSM6DSR_GYRO_ODR_833_HZ (0x07)
#define LSM6DSR_GYRO_ODR_1_66_KHZ (0x08)
#define LSM6DSR_GYRO_ODR_3_33_KHZ (0x09)
#define LSM6DSR_GYRO_ODR_6_66_KHZ (0x0A)
#define LSM6DSR_GYRO_ODR_MSK (0XF0)
#define LSM6DSR_GYRO_ODR_POS (4)
#define LSM6DSR_ACC_RANGE_2G (0x0)
#define LSM6DSR_ACC_RANGE_4G (0x2)
#define LSM6DSR_ACC_RANGE_8G (0x3)
#define LSM6DSR_ACC_RANGE_16G (0x1)
#define LSM6DSR_ACC_RANGE_MSK (0X0C)
#define LSM6DSR_ACC_RANGE_POS (2)
#define LSM6DSR_ACC_SENSITIVITY_2G (61)
#define LSM6DSR_ACC_SENSITIVITY_4G (122)
#define LSM6DSR_ACC_SENSITIVITY_8G (244)
#define LSM6DSR_ACC_SENSITIVITY_16G (488)
#define LSM6DSR_GYRO_RANGE_245 (0x0)
#define LSM6DSR_GYRO_RANGE_500 (0x1)
#define LSM6DSR_GYRO_RANGE_1000 (0x2)
#define LSM6DSR_GYRO_RANGE_2000 (0x3)
#define LSM6DSR_GYRO_RANGE_MSK (0X0C)
#define LSM6DSR_GYRO_RANGE_POS (2)
#define LSM6DSR_GYRO_SENSITIVITY_245DPS (8750)
#define LSM6DSR_GYRO_SENSITIVITY_500DPS (17500)
#define LSM6DSR_GYRO_SENSITIVITY_1000DPS (35000)
#define LSM6DSR_GYRO_SENSITIVITY_2000DPS (70000)
#define LSM6DSR_SHIFT_EIGHT_BITS (8)
#define LSM6DSR_16_BIT_SHIFT (0xFF)
#define LSM6DSR_ACC_MUL (1000)
#define LSM6DSR_GYRO_MUL (1)
#define LSM6DSR_ACC_DEFAULT_ODR_100HZ (100)
#define LSM6DSR_GYRO_DEFAULT_ODR_100HZ (100)
#define LSM6DSR_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define LSM6DSR_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t lsm6dsr_acc_factor[ACC_RANGE_MAX] = { LSM6DSR_ACC_SENSITIVITY_2G, LSM6DSR_ACC_SENSITIVITY_4G,
LSM6DSR_ACC_SENSITIVITY_8G, LSM6DSR_ACC_SENSITIVITY_16G };
static int32_t lsm6dsr_gyro_factor[GYRO_RANGE_MAX] = {0, LSM6DSR_GYRO_SENSITIVITY_245DPS, LSM6DSR_GYRO_SENSITIVITY_500DPS,
LSM6DSR_GYRO_SENSITIVITY_1000DPS, LSM6DSR_GYRO_SENSITIVITY_2000DPS };
static int32_t cur_acc_factor = 0;
static int32_t cur_gyro_factor = 0;
static int32_t g_lsm6dsrflag = 0;
i2c_dev_t lsm6dsr_ctx = {
//.port = 4,
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LSM6DSR_I2C_ADDR,
};
static int drv_acc_gyro_st_lsm6dsr_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, LSM6DSR_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LSM6DSR_RESET_VALUE;
ret = sensor_i2c_write(drv, LSM6DSR_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_gyro_st_lsm6dsr_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, LSM6DSR_ACC_GYRO_WHO_AM_I_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
LOG("%s %s right id (0x%02x), read id(0x%02x)\n", SENSOR_STR, __func__, id_value, value);
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6dsr_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM6DSR_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LSM6DSR_SET_BITSLICE(value,LSM6DSR_ACC_ODR,LSM6DSR_ACC_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSR_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LSM6DSR_SET_BITSLICE(value,LSM6DSR_ACC_ODR,LSM6DSR_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LSM6DSR_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LSM6DSR_SET_BITSLICE(value,LSM6DSR_ACC_ODR,LSM6DSR_ACC_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSR_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static int drv_acc_gyro_st_lsm6dsr_set_bdu(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, LSM6DSR_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (value & LSM6DSR_BDU_VALUE)
return 0;
value |= LSM6DSR_BDU_VALUE;
ret = sensor_i2c_write(drv, LSM6DSR_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static uint8_t drv_acc_st_lsm6dsr_hz2odr(uint32_t hz)
{
if(hz > 3330)
return LSM6DSR_ACC_ODR_6_66_KHZ;
else if(hz > 1660)
return LSM6DSR_ACC_ODR_3_33_KHZ;
else if(hz > 833)
return LSM6DSR_ACC_ODR_1_66_KHZ;
else if(hz > 416)
return LSM6DSR_ACC_ODR_833_HZ;
else if(hz > 208)
return LSM6DSR_ACC_ODR_416_HZ;
else if(hz > 104)
return LSM6DSR_ACC_ODR_208_HZ;
else if(hz > 52)
return LSM6DSR_ACC_ODR_104_HZ;
else if(hz > 26)
return LSM6DSR_ACC_ODR_52_HZ;
else if(hz > 13)
return LSM6DSR_ACC_ODR_26_HZ;
else if(hz >= 2)
return LSM6DSR_ACC_ODR_12_5_HZ;
else
return LSM6DSR_ACC_ODR_1_6_HZ;
}
static int drv_acc_st_lsm6dsr_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_lsm6dsr_hz2odr(hz);
ret = sensor_i2c_read(drv, LSM6DSR_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LSM6DSR_SET_BITSLICE(value,LSM6DSR_ACC_ODR,odr);
ret = sensor_i2c_write(drv, LSM6DSR_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lsm6dsr_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LSM6DSR_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_2G:{
tmp = LSM6DSR_ACC_RANGE_2G;
}break;
case ACC_RANGE_4G:{
tmp = LSM6DSR_ACC_RANGE_4G;
}break;
case ACC_RANGE_8G:{
tmp = LSM6DSR_ACC_RANGE_8G;
}break;
case ACC_RANGE_16G:{
tmp = LSM6DSR_ACC_RANGE_16G;
}break;
default:break;
}
value = LSM6DSR_SET_BITSLICE(value,LSM6DSR_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, LSM6DSR_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)){
cur_acc_factor = lsm6dsr_acc_factor[range];
}
return 0;
}
static void drv_acc_st_lsm6dsr_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_lsm6dsr_open(void)
{
int ret = 0;
ret = drv_acc_st_lsm6dsr_set_power_mode(&lsm6dsr_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6dsr_set_bdu(&lsm6dsr_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm6dsr_set_range(&lsm6dsr_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm6dsr_set_odr(&lsm6dsr_ctx, LSM6DSR_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6dsr_close(void)
{
int ret = 0;
ret = drv_acc_st_lsm6dsr_set_power_mode(&lsm6dsr_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6dsr_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lsm6dsr_ctx, LSM6DSR_ACC_GYRO_OUTX_L_XL, ®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsr_ctx, LSM6DSR_ACC_GYRO_OUTX_H_XL, ®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsr_ctx, LSM6DSR_ACC_GYRO_OUTY_L_XL, ®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsr_ctx, LSM6DSR_ACC_GYRO_OUTY_H_XL, ®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsr_ctx, LSM6DSR_ACC_GYRO_OUTZ_L_XL, ®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsr_ctx, LSM6DSR_ACC_GYRO_OUTZ_H_XL, ®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< LSM6DSR_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< LSM6DSR_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< LSM6DSR_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = (accel->data[DATA_AXIS_X] * cur_acc_factor)/LSM6DSR_ACC_MUL;
accel->data[DATA_AXIS_Y] = (accel->data[DATA_AXIS_Y] * cur_acc_factor)/LSM6DSR_ACC_MUL;
accel->data[DATA_AXIS_Z] = (accel->data[DATA_AXIS_Z] * cur_acc_factor)/LSM6DSR_ACC_MUL;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_lsm6dsr_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_lsm6dsr_set_odr(&lsm6dsr_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_st_lsm6dsr_set_range(&lsm6dsr_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_lsm6dsr_set_power_mode(&lsm6dsr_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t*)arg;
info->model = "LSM6DSR";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}break;
default:break;
}
return 0;
}
int drv_acc_st_lsm6dsr_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_lsm6dsr_open;
sensor.close = drv_acc_st_lsm6dsr_close;
sensor.read = drv_acc_st_lsm6dsr_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_lsm6dsr_ioctl;
sensor.irq_handle = drv_acc_st_lsm6dsr_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_acc_gyro_st_lsm6dsr_validate_id(&lsm6dsr_ctx, LSM6DSR_CHIP_ID_VALUE);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
if(0 == g_lsm6dsrflag)
{
ret = drv_acc_gyro_st_lsm6dsr_soft_reset(&lsm6dsr_ctx);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_acc_st_lsm6dsr_set_power_mode(&lsm6dsr_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
g_lsm6dsrflag = 1;
}
else
{
LOG("%s %s acc do not need reset\n", SENSOR_STR, __func__);
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_gyro_st_lsm6dsr_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM6DSR_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LSM6DSR_SET_BITSLICE(value,LSM6DSR_GYRO_ODR,LSM6DSR_GYRO_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSR_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LSM6DSR_SET_BITSLICE(value,LSM6DSR_GYRO_ODR,LSM6DSR_GYRO_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LSM6DSR_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LSM6DSR_SET_BITSLICE(value,LSM6DSR_GYRO_ODR,LSM6DSR_GYRO_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSR_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_gyro_st_lsm6dsr_hz2odr(uint32_t hz)
{
if(hz > 3330)
return LSM6DSR_GYRO_ODR_6_66_KHZ;
else if(hz > 1660)
return LSM6DSR_GYRO_ODR_3_33_KHZ;
else if(hz > 833)
return LSM6DSR_GYRO_ODR_1_66_KHZ;
else if(hz > 416)
return LSM6DSR_GYRO_ODR_833_HZ;
else if(hz > 208)
return LSM6DSR_GYRO_ODR_416_HZ;
else if(hz > 104)
return LSM6DSR_GYRO_ODR_208_HZ;
else if(hz > 52)
return LSM6DSR_GYRO_ODR_104_HZ;
else if(hz > 26)
return LSM6DSR_GYRO_ODR_52_HZ;
else if(hz > 13)
return LSM6DSR_GYRO_ODR_26_HZ;
else
return LSM6DSR_GYRO_ODR_12_5_HZ;
}
static int drv_gyro_st_lsm6dsr_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_gyro_st_lsm6dsr_hz2odr(hz);
ret = sensor_i2c_read(drv, LSM6DSR_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LSM6DSR_SET_BITSLICE(value,LSM6DSR_GYRO_ODR,odr);
ret = sensor_i2c_write(drv, LSM6DSR_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_gyro_st_lsm6dsr_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LSM6DSR_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case GYRO_RANGE_250DPS:{
tmp = LSM6DSR_GYRO_RANGE_245;
}break;
case GYRO_RANGE_500DPS:{
tmp = LSM6DSR_GYRO_RANGE_500;
}break;
case GYRO_RANGE_1000DPS:{
tmp = LSM6DSR_GYRO_RANGE_1000;
}break;
case GYRO_RANGE_2000DPS:{
tmp = LSM6DSR_GYRO_RANGE_2000;
}break;
default:break;
}
value = LSM6DSR_SET_BITSLICE(value,LSM6DSR_GYRO_RANGE,tmp);
ret = sensor_i2c_write(drv, LSM6DSR_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= GYRO_RANGE_250DPS)&&(range <= GYRO_RANGE_2000DPS)){
cur_gyro_factor = lsm6dsr_gyro_factor[range];
}
return 0;
}
static void drv_gyro_st_lsm6dsr_irq_handle(void)
{
/* no handle so far */
}
static int drv_gyro_st_lsm6dsr_open(void)
{
int ret = 0;
ret = drv_gyro_st_lsm6dsr_set_power_mode(&lsm6dsr_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6dsr_set_bdu(&lsm6dsr_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_st_lsm6dsr_set_range(&lsm6dsr_ctx, GYRO_RANGE_1000DPS);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_st_lsm6dsr_set_odr(&lsm6dsr_ctx, LSM6DSR_GYRO_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_gyro_st_lsm6dsr_close(void)
{
int ret = 0;
ret = drv_gyro_st_lsm6dsr_set_power_mode(&lsm6dsr_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_gyro_st_lsm6dsr_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
gyro_data_t *gyro = (gyro_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(gyro_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lsm6dsr_ctx, LSM6DSR_ACC_GYRO_OUTX_L_G, ®[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsr_ctx, LSM6DSR_ACC_GYRO_OUTX_H_G, ®[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsr_ctx, LSM6DSR_ACC_GYRO_OUTY_L_G, ®[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsr_ctx, LSM6DSR_ACC_GYRO_OUTY_H_G, ®[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsr_ctx, LSM6DSR_ACC_GYRO_OUTZ_L_G, ®[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsr_ctx, LSM6DSR_ACC_GYRO_OUTZ_H_G, ®[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
gyro->data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)reg[1]))<< LSM6DSR_SHIFT_EIGHT_BITS)|(reg[0]));
gyro->data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)reg[3]))<< LSM6DSR_SHIFT_EIGHT_BITS)|(reg[2]));
gyro->data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)reg[5]))<< LSM6DSR_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_gyro_factor != 0){
gyro->data[DATA_AXIS_X] = (gyro->data[DATA_AXIS_X] * cur_gyro_factor)/LSM6DSR_GYRO_MUL;
gyro->data[DATA_AXIS_Y] = (gyro->data[DATA_AXIS_Y] * cur_gyro_factor)/LSM6DSR_GYRO_MUL;
gyro->data[DATA_AXIS_Z] = (gyro->data[DATA_AXIS_Z] * cur_gyro_factor)/LSM6DSR_GYRO_MUL;
}
gyro->timestamp = aos_now_ms();
return (int)size;
}
static int drv_gyro_st_lsm6dsr_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_gyro_st_lsm6dsr_set_odr(&lsm6dsr_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_gyro_st_lsm6dsr_set_range(&lsm6dsr_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_gyro_st_lsm6dsr_set_power_mode(&lsm6dsr_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LSM6DSR";
info->range_max = 2000;
info->range_min = 125;
info->unit = udps;
}break;
default:break;
}
return 0;
}
int drv_gyro_st_lsm6dsr_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_GYRO;
sensor.path = dev_gyro_path;
sensor.open = drv_gyro_st_lsm6dsr_open;
sensor.close = drv_gyro_st_lsm6dsr_close;
sensor.read = drv_gyro_st_lsm6dsr_read;
sensor.write = NULL;
sensor.ioctl = drv_gyro_st_lsm6dsr_ioctl;
sensor.irq_handle = drv_gyro_st_lsm6dsr_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_acc_gyro_st_lsm6dsr_validate_id(&lsm6dsr_ctx, LSM6DSR_CHIP_ID_VALUE);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
if(0 == g_lsm6dsrflag){
ret = drv_acc_gyro_st_lsm6dsr_soft_reset(&lsm6dsr_ctx);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_gyro_st_lsm6dsr_set_power_mode(&lsm6dsr_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
g_lsm6dsrflag = 1;
}
else{
LOG("%s %s gyro do not need reset\n", SENSOR_STR, __func__);
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_lsm6dsr_init);
SENSOR_DRV_ADD(drv_gyro_st_lsm6dsr_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_gyro_st_lsm6dsr.c
|
C
|
apache-2.0
| 26,222
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LSM303AGR_MAG_I2C_ADDR1 0x1E
#define LSM303AGR_MAG_I2C_ADDR_TRANS(n) ((n)<<1)
#define LSM303AGR_MAG_I2C_ADDR LSM303AGR_MAG_I2C_ADDR_TRANS(LSM303AGR_MAG_I2C_ADDR1)
#define LSM303AGR_MAG_BIT(x) (x)
#define LSM303AGR_ACC_I2C_ADDR1 (0x19)
#define LSM303AGR_ACC_I2C_ADDR_TRANS(n) ((n)<<1)
#define LSM303AGR_ACC_I2C_ADDR LSM303AGR_ACC_I2C_ADDR_TRANS(LSM303AGR_ACC_I2C_ADDR1)
#define LSM303AGR_ACC_STATUS_REG_AUX 0x07
#define LSM303AGR_ACC_OUT_TEMP_L 0x0C
#define LSM303AGR_ACC_OUT_TEMP_H 0x0D
#define LSM303AGR_ACC_WHO_AM_I 0x0F
#define LSM303AGR_ACC_CTRL_REG0 0x1E
#define LSM303AGR_ACC_TEMP_CFG_REG 0x1F
#define LSM303AGR_ACC_CTRL_REG1 0x20
#define LSM303AGR_ACC_CTRL_REG2 0x21
#define LSM303AGR_ACC_CTRL_REG3 0x22
#define LSM303AGR_ACC_CTRL_REG4 0x23
#define LSM303AGR_ACC_CTRL_REG5 0x24
#define LSM303AGR_ACC_CTRL_REG6 0x25
#define LSM303AGR_ACC_REFERENCE 0x26
#define LSM303AGR_ACC_STATUS_REG 0x27
#define LSM303AGR_ACC_OUT_X_L 0x28
#define LSM303AGR_ACC_OUT_X_H 0x29
#define LSM303AGR_ACC_OUT_Y_L 0x2A
#define LSM303AGR_ACC_OUT_Y_H 0x2B
#define LSM303AGR_ACC_OUT_Z_L 0x2C
#define LSM303AGR_ACC_OUT_Z_H 0x2D
#define LSM303AGR_ACC_FIFO_CTRL_REG 0x2E
#define LSM303AGR_ACC_FIFO_SRC_REG 0x2F
#define LSM303AGR_ACC_INT1_CFG 0x30
#define LSM303AGR_ACC_INT1_SRC 0x31
#define LSM303AGR_ACC_INT1_THS 0x32
#define LSM303AGR_ACC_INT1_DURATION 0x33
#define LSM303AGR_ACC_INT2_CFG 0x34
#define LSM303AGR_ACC_INT2_SRC 0x35
#define LSM303AGR_ACC_INT2_THS 0x36
#define LSM303AGR_ACC_INT2_DURATION 0x37
#define LSM303AGR_ACC_CLICK_CFG 0x38
#define LSM303AGR_ACC_CLICK_SRC 0x39
#define LSM303AGR_ACC_CLICK_THS 0x3A
#define LSM303AGR_ACC_TIME_LIMIT 0x3B
#define LSM303AGR_ACC_TIME_LATENCY 0x3C
#define LSM303AGR_ACC_TIME_WINDOW 0x3D
#define LSM303AGR_ACC_ACT_THS 0x3E
#define LSM303AGR_ACC_ACT_DUR 0x3F
#define LSM303AGR_ACC_SELFTESTDISABLE (0x0)
#define LSM303AGR_ACC_SELFTESTENABLE (0x2)
#define LSM303AGR_ACC_SELFTEST_MSK (0x06)
#define LSM303AGR_ACC_SELFTEST_POS (2)
#define LSM303AGR_ACC_RANGE_2G (0x0)
#define LSM303AGR_ACC_RANGE_4G (0x1)
#define LSM303AGR_ACC_RANGE_8G (0x2)
#define LSM303AGR_ACC_RANGE_16G (0x3)
#define LSM303AGR_ACC_RANGE_MSK (0X30)
#define LSM303AGR_ACC_RANGE_POS (4)
#define LSM303AGR_ACC_SENSITIVITY_2G (1)
#define LSM303AGR_ACC_SENSITIVITY_4G (2)
#define LSM303AGR_ACC_SENSITIVITY_8G (4)
#define LSM303AGR_ACC_SENSITIVITY_16G (12)
#define LSM303AGR_ACC_CHIP_ID_VALUE (0x33)
#define LSM303AGR_ACC_SHIFT_EIGHT_BITS (8)
#define LSM303AGR_ACC_SHIFT_FOUR_BITS (4)
#define LSM303AGR_ACC_16_BIT_SHIFT (0xFF)
#define LSM303AGR_ACC_MUL (1000)
#define LSM303AGR_ACC_ODR_POWER_DOWN (0x00)
#define LSM303AGR_ACC_ODR_1_HZ (0x01)
#define LSM303AGR_ACC_ODR_10_HZ (0x02)
#define LSM303AGR_ACC_ODR_25_HZ (0x03)
#define LSM303AGR_ACC_ODR_50_HZ (0x04)
#define LSM303AGR_ACC_ODR_100_HZ (0x05)
#define LSM303AGR_ACC_ODR_200_HZ (0x06)
#define LSM303AGR_ACC_ODR_400_HZ (0x07)
#define LSM303AGR_ACC_ODR_1_62_KHZ (0x08)
#define LSM303AGR_ACC_ODR_5_376_KHZ (0x09)
#define LSM303AGR_ACC_ODR_1_344_HZ (0x09)
#define LSM303AGR_ACC_ODR_MSK (0XF0)
#define LSM303AGR_ACC_ODR_POS (4)
#define LSM303AGR_ACC_DEFAULT_ODR_100HZ (100)
#define LSM303AGR_ACC_BDU_ENABLE (0x80)
#define LSM303AGR_ACC_STATUS_ZYXDA (0x08)
#define LSM303AGR_ACC_DEFAULT_ODR_100HZ (100)
#define LSM303AGR_ACC_SELF_TEST_MIN_X (17 * 4) // 17 counts, per count 4mg
#define LSM303AGR_ACC_SELF_TEST_MIN_Y (17 * 4) // 17 counts, per count 4mg
#define LSM303AGR_ACC_SELF_TEST_MIN_Z (17 * 4) // 17 counts, per count 4mg
#define LSM303AGR_ACC_SELF_TEST_MAX_X (360 * 4) // 360 counts, per count 4mg
#define LSM303AGR_ACC_SELF_TEST_MAX_Y (360 * 4) // 360 counts, per count 4mg
#define LSM303AGR_ACC_SELF_TEST_MAX_Z (360 * 4) // 360 counts, per count 4mg
#define LSM303AGR_ACC_SELF_TEST_DRY_WAIT_CNT 5
#define LSM303AGR_ACC_SELF_TEST_AVG_SAMPLE_CNT 5
#define LSM303AGR_ACC_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define LSM303AGR_ACC_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t lsm303agr_acc_factor[ACC_RANGE_MAX] = { LSM303AGR_ACC_SENSITIVITY_2G, LSM303AGR_ACC_SENSITIVITY_4G,
LSM303AGR_ACC_SENSITIVITY_8G, LSM303AGR_ACC_SENSITIVITY_16G };
static int32_t cur_acc_factor = 0;
#define LSM303AGR_BIT(x) (x)
#define LSM303AGR_MAG_OFFSET_X_REG_L 0x45
#define LSM303AGR_MAG_OFFSET_X_REG_H 0x46
#define LSM303AGR_MAG_OFFSET_Y_REG_L 0x47
#define LSM303AGR_MAG_OFFSET_Y_REG_H 0x48
#define LSM303AGR_MAG_OFFSET_Z_REG_L 0x49
#define LSM303AGR_MAG_OFFSET_Z_REG_H 0x4A
#define LSM303AGR_MAG_WHO_AM_I 0x4F
#define LSM303AGR_MAG_CFG_REG_A 0x60
#define LSM303AGR_MAG_CFG_REG_B 0x61
#define LSM303AGR_MAG_CFG_REG_C 0x62
#define LSM303AGR_MAG_INT_CRTL_REG 0x63
#define LSM303AGR_MAG_INT_SOURCE_REG 0x64
#define LSM303AGR_MAG_INT_THS_L_REG 0x65
#define LSM303AGR_MAG_INT_THS_H_REG 0x66
#define LSM303AGR_MAG_STATUS_REG 0x67
#define LSM303AGR_MAG_OUTX_L_REG 0x68
#define LSM303AGR_MAG_OUTX_H_REG 0x69
#define LSM303AGR_MAG_OUTY_L_REG 0x6A
#define LSM303AGR_MAG_OUTY_H_REG 0x6B
#define LSM303AGR_MAG_OUTZ_L_REG 0x6C
#define LSM303AGR_MAG_OUTZ_H_REG 0x6D
#define LSM303AGR_MAG_TEMP_OUT_L_REG 0x6E
#define LSM303AGR_MAG_TEMP_OUT_H_REG 0x6F
#define I_AM_LSM303AGR 0x40
#define LSM303AGR_MAG_ODR_BIT LSM303AGR_BIT(0x0C)
#define LSM303AGR_MAG_ODR_10_HZ 0x00
#define LSM303AGR_MAG_ODR_20_HZ 0x04
#define LSM303AGR_MAG_ODR_50_HZ 0x08
#define LSM303AGR_MAG_ODR_100_HZ 0x0C
#define LSM303AGR_MAG_SELFTEST_DISABLE 0x00
#define LSM303AGR_MAG_SELFTEST_ENABLE 0x02
#define LSM303AGR_MAG_FS_50_GA 0x00
#define LSM303AGR_MAG_REBOOT_DEFAULT 0x00
#define LSM303AGR_MAG_REBOOT_ENABLE 0x40
#define LSM303AGR_MAG_SOFT_RESET_DEFAULT 0x00
#define LSM303AGR_MAG_SOFT_RESET_ENABLE 0x02
#define LSM303AGR_MAG_CONFIG_LOWPOWER_BIT LSM303AGR_BIT(0x10)
#define LSM303AGR_MAG_CONFIG_NORMAL_MODE 0x00
#define LSM303AGR_MAG_CONFIG_LOWPOWER_MODE 0x10
#define LSM303AGR_MAG_POWERMODE_BIT LSM303AGR_BIT(0x03)
#define LSM303AGR_MAG_CONTINUOUS_MODE 0x00
#define LSM303AGR_MAG_SINGLE_MODE 0x01
#define LSM303AGR_MAG_POWERDOWN1_MODE 0x02
#define LSM303AGR_MAG_POWERDOWN2_MODE 0x03
#define LSM303AGR_MAG_COMP_TEMP_EN 0x80
#define LSM303AGR_MAG_OFF_CANC 0x02
#define LSM303AGR_MAG_BLE_BIT LSM303AGR_BIT(0x08)
#define LSM303AGR_MAG_BLE_LSB 0x00
#define LSM303AGR_MAG_BLE_MSB 0x08
#define LSM303AGR_MAG_BDU_BIT LSM303AGR_BIT(0x10)
#define LSM303AGR_MAG_BDU_CONTINUOUS 0x00
#define LSM303AGR_MAG_BDU_MSBLSB 0x10
//#define LSM303AGR_MAG_SENSITIVITY_FOR_FS_50GA 15/10
#define LSM303AGR_MAG_SENSITIVITY_FOR_FS_50GA 1500
#define LSM303AGR_MAG_SELF_TEST_MIN_X (15) // 15mGuass
#define LSM303AGR_MAG_SELF_TEST_MIN_Y (15) // 15mGuass
#define LSM303AGR_MAG_SELF_TEST_MIN_Z (15) // 15mGuass
#define LSM303AGR_MAG_SELF_TEST_MAX_X (500) // 500mGuass
#define LSM303AGR_MAG_SELF_TEST_MAX_Y (500) // 500mGuass
#define LSM303AGR_MAG_SELF_TEST_MAX_Z (500) // 500mGuass
#define LSM303AGR_MAG_SELF_TEST_DRY_WAIT_CNT 5
#define LSM303AGR_MAG_SELF_TEST_AVG_SAMPLE_CNT 50
i2c_dev_t lsm303agr_mag_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LSM303AGR_MAG_I2C_ADDR,
};
i2c_dev_t lsm303agr_acc_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LSM303AGR_ACC_I2C_ADDR,
};
static int drv_acc_st_lsm303agr_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, LSM303AGR_ACC_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_st_lsm303agr_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM303AGR_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LSM303AGR_ACC_SET_BITSLICE(value,LSM303AGR_ACC_ODR,LSM303AGR_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, LSM303AGR_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LSM303AGR_ACC_SET_BITSLICE(value,LSM303AGR_ACC_ODR,LSM303AGR_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LSM303AGR_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LSM303AGR_ACC_SET_BITSLICE(value,LSM303AGR_ACC_ODR,LSM303AGR_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, LSM303AGR_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_acc_st_lsm303agr_hz2odr(uint32_t hz)
{
if(hz > 1620)
return LSM303AGR_ACC_ODR_5_376_KHZ;
else if(hz > 1344)
return LSM303AGR_ACC_ODR_1_62_KHZ;
else if(hz > 400)
return LSM303AGR_ACC_ODR_1_344_HZ;
else if(hz > 200)
return LSM303AGR_ACC_ODR_400_HZ;
else if(hz > 100)
return LSM303AGR_ACC_ODR_200_HZ;
else if(hz > 50)
return LSM303AGR_ACC_ODR_100_HZ;
else if(hz > 25)
return LSM303AGR_ACC_ODR_50_HZ;
else if(hz > 10)
return LSM303AGR_ACC_ODR_25_HZ;
else if(hz >= 1)
return LSM303AGR_ACC_ODR_10_HZ;
else
return LSM303AGR_ACC_ODR_1_HZ;
}
static int drv_acc_st_lsm303agr_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_lsm303agr_hz2odr(hz);
ret = sensor_i2c_read(drv, LSM303AGR_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LSM303AGR_ACC_SET_BITSLICE(value,LSM303AGR_ACC_ODR,odr);
ret = sensor_i2c_write(drv, LSM303AGR_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lsm303agr_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LSM303AGR_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_2G:{
tmp = LSM303AGR_ACC_RANGE_2G;
}break;
case ACC_RANGE_4G:{
tmp = LSM303AGR_ACC_RANGE_4G;
}break;
case ACC_RANGE_8G:{
tmp = LSM303AGR_ACC_RANGE_8G;
}break;
case ACC_RANGE_16G:{
tmp = LSM303AGR_ACC_RANGE_16G;
}break;
default:break;
}
value = LSM303AGR_ACC_SET_BITSLICE(value,LSM303AGR_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, LSM303AGR_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)){
cur_acc_factor = lsm303agr_acc_factor[range];
}
return 0;
}
static int drv_acc_st_lsm303agr_set_bdu(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM303AGR_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LSM303AGR_ACC_BDU_ENABLE;
ret = sensor_i2c_write(drv, LSM303AGR_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lsm303agr_st_discard(i2c_dev_t* drv)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
for (i = 0; i < LSM303AGR_ACC_SELF_TEST_DRY_WAIT_CNT; i ++) {
ret = sensor_i2c_read(drv, LSM303AGR_ACC_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x08)
break;
aos_msleep(20);
}
if (i >= LSM303AGR_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, (LSM303AGR_ACC_OUT_X_L | 0x80), buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
return ret;
}
static int drv_acc_st_lsm303agr_st_data(i2c_dev_t* drv,int32_t* data)
{
uint8_t i, j;
int16_t x_raw, y_raw, z_raw;
int32_t x_mg, y_mg, z_mg;
int32_t x_sum, y_sum, z_sum;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
x_sum = 0; y_sum = 0; z_sum = 0;
for (i = 0; i < LSM303AGR_ACC_SELF_TEST_AVG_SAMPLE_CNT; i ++) {
for (j = 0; j < LSM303AGR_ACC_SELF_TEST_DRY_WAIT_CNT; j ++) {
ret = sensor_i2c_read(drv, LSM303AGR_ACC_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x08)
break;
aos_msleep(20);
}
if (j >= LSM303AGR_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, (LSM303AGR_ACC_OUT_X_L | 0x80), buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
x_raw = (buffer[1] << 8) + buffer[0];
y_raw = (buffer[3] << 8) + buffer[2];
z_raw = (buffer[5] << 8) + buffer[4];
//LOG("%s %s %d: i(%d), raw(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_raw, y_raw, z_raw);
x_mg = x_raw >> 4;
y_mg = y_raw >> 4;
z_mg = z_raw >> 4;
//LOG("%s %s %d: i(%d), mg(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_mg, y_mg, z_mg);
x_sum += x_mg;
y_sum += y_mg;
z_sum += z_mg;
}
data[0] = x_sum / LSM303AGR_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[1] = y_sum / LSM303AGR_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[2] = z_sum / LSM303AGR_ACC_SELF_TEST_AVG_SAMPLE_CNT;
return ret;
}
static int drv_acc_st_lsm303agr_self_test(i2c_dev_t* drv,int32_t* data)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t ctrl_reg[4];
int32_t out_nost[3];
int32_t out_st[3];
int32_t out_diff[3];
// Save cfg registers which will be modified during self-test
ret = sensor_i2c_read(drv, (LSM303AGR_ACC_CTRL_REG1 | 0x80), ctrl_reg, 4, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
// Initialize Sensor, turn on sensor, enable X/Y/Z axes
// Set BDU=1, FS=2G, Normal mode, ODR = 50Hz
value = 0;
ret = sensor_i2c_write(drv, LSM303AGR_ACC_CTRL_REG2, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0;
ret = sensor_i2c_write(drv, LSM303AGR_ACC_CTRL_REG3, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0x80;
ret = sensor_i2c_write(drv, LSM303AGR_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0x47;
ret = sensor_i2c_write(drv, LSM303AGR_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(90);
// Discard the first sample
ret = drv_acc_st_lsm303agr_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and averate them
ret = drv_acc_st_lsm303agr_st_data(drv, out_nost);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Enable seft-test
value = 0x82;
ret = sensor_i2c_write(drv, LSM303AGR_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(90);
// Discard the first sample
ret = drv_acc_st_lsm303agr_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and average them
ret = drv_acc_st_lsm303agr_st_data(drv, out_st);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Check if the differences are between min and max
for (i = 0; i < 3; i ++) {
out_diff[i] = abs(out_st[i] - out_nost[i]);
data[i] = out_diff[i];
}
if ((LSM303AGR_ACC_SELF_TEST_MIN_X > out_diff[0]) || (out_diff[0] > LSM303AGR_ACC_SELF_TEST_MAX_X)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM303AGR_ACC_SELF_TEST_MIN_Y > out_diff[1]) || (out_diff[1] > LSM303AGR_ACC_SELF_TEST_MAX_Y)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM303AGR_ACC_SELF_TEST_MIN_Z > out_diff[2]) || (out_diff[2] > LSM303AGR_ACC_SELF_TEST_MAX_Z)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
restore:
ret += sensor_i2c_write(drv, LSM303AGR_ACC_CTRL_REG1 | 0x80, ctrl_reg, 4, I2C_OP_RETRIES);
return ret;
}
static void drv_acc_st_lsm303agr_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_lsm303agr_open(void)
{
int ret = 0;
ret = drv_acc_st_lsm303agr_set_power_mode(&lsm303agr_acc_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm303agr_set_range(&lsm303agr_acc_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm303agr_set_odr(&lsm303agr_acc_ctx, LSM303AGR_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lsm303agr_close(void)
{
int ret = 0;
ret = drv_acc_st_lsm303agr_set_power_mode(&lsm303agr_acc_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lsm303agr_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lsm303agr_acc_ctx, (LSM303AGR_ACC_OUT_X_L | 0x80), reg, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< LSM303AGR_ACC_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] >> LSM303AGR_ACC_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< LSM303AGR_ACC_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] >> LSM303AGR_ACC_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< LSM303AGR_ACC_SHIFT_EIGHT_BITS)|(reg[4]));
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] >> LSM303AGR_ACC_SHIFT_FOUR_BITS;
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] * cur_acc_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] * cur_acc_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] * cur_acc_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_lsm303agr_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_lsm303agr_set_odr(&lsm303agr_acc_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_st_lsm303agr_set_range(&lsm303agr_acc_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_lsm303agr_set_power_mode(&lsm303agr_acc_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
info->model = "LSM303AGR_ACC";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}break;
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_acc_st_lsm303agr_self_test(&lsm303agr_acc_ctx, (int32_t*)info->data);
//printf("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
LOG("%s %s: %d, %d, %d\n", SENSOR_STR, __func__, info->data[0],info->data[1],info->data[2]);
return ret;
}
default:break;
}
return 0;
}
int drv_acc_st_lsm303agr_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_lsm303agr_open;
sensor.close = drv_acc_st_lsm303agr_close;
sensor.read = drv_acc_st_lsm303agr_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_lsm303agr_ioctl;
sensor.irq_handle = drv_acc_st_lsm303agr_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm303agr_validate_id(&lsm303agr_acc_ctx, LSM303AGR_ACC_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm303agr_set_range(&lsm303agr_acc_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
//set odr is 100hz, and will update
ret = drv_acc_st_lsm303agr_set_odr(&lsm303agr_acc_ctx, LSM303AGR_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
//set bdu
ret = drv_acc_st_lsm303agr_set_bdu(&lsm303agr_acc_ctx);
if(unlikely(ret)){
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_mag_st_lsm303agr_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = LSM303AGR_MAG_SOFT_RESET_ENABLE;
//ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_A, LSM303AGR_MAG_SOFT_RESET_ENABLE, I2C_DATA_LEN, I2C_OP_RETRIES);
ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
UNUSED static int drv_mag_st_lsm303agr_selftest(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = LSM303AGR_MAG_SELFTEST_ENABLE;
//ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_C, LSM303AGR_MAG_SELFTEST_ENABLE, I2C_DATA_LEN, I2C_OP_RETRIES);
ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
UNUSED static int drv_mag_st_lsm303agr_reboot(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = LSM303AGR_MAG_REBOOT_ENABLE;
//ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_A, LSM303AGR_MAG_REBOOT_ENABLE, I2C_DATA_LEN, I2C_OP_RETRIES);
ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_mag_st_lsm303agr_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, LSM303AGR_MAG_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
LOG("%s %s right id (0x%02x), read id(0x%02x)\n", SENSOR_STR, __func__, id_value, value);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_mag_st_lsm303agr_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM303AGR_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (mode == DEV_POWER_ON)
{
value &= ~LSM303AGR_MAG_POWERMODE_BIT;
value |= LSM303AGR_MAG_CONTINUOUS_MODE;
}
else{
value &= ~LSM303AGR_MAG_POWERMODE_BIT;
value |= LSM303AGR_MAG_POWERDOWN2_MODE;
}
ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_mag_st_lsm303agr_set_odr(i2c_dev_t* drv, uint8_t odr)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM303AGR_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value &= ~LSM303AGR_MAG_ODR_BIT;
value |= (uint8_t)odr;
ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_mag_st_lsm303agr_enable_off_canc(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM303AGR_MAG_CFG_REG_B, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LSM303AGR_MAG_OFF_CANC;
ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_B, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_mag_st_lsm303agr_enable_temp(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM303AGR_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LSM303AGR_MAG_COMP_TEMP_EN;
ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
UNUSED static int drv_mag_st_lsm303agr_lowpower_mode(i2c_dev_t* drv, uint8_t lowpower_mode)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, LSM303AGR_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (lowpower_mode == LSM303AGR_MAG_CONFIG_LOWPOWER_MODE)
{
value &= ~LSM303AGR_MAG_CONFIG_LOWPOWER_BIT;
value |= LSM303AGR_MAG_CONFIG_LOWPOWER_MODE;
}
else{
value &= ~LSM303AGR_MAG_CONFIG_LOWPOWER_BIT;
value |= LSM303AGR_MAG_CONFIG_NORMAL_MODE;
}
ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_mag_st_lsm303agr_set_range(i2c_dev_t* drv, uint32_t range)
{
// default FS +/-50Gauss
return 0;
}
static int drv_mag_st_lsm303agr_set_ble(i2c_dev_t* drv, uint8_t ble)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM303AGR_MAG_CFG_REG_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (ble == LSM303AGR_MAG_BLE_LSB)
{
value &= ~LSM303AGR_MAG_BLE_BIT;
value |= LSM303AGR_MAG_BLE_LSB;
}
else{
value &= ~LSM303AGR_MAG_BLE_BIT;
value |= LSM303AGR_MAG_BLE_MSB;
}
ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_mag_st_lsm303agr_set_bdu(i2c_dev_t* drv, uint8_t bdu)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM303AGR_MAG_CFG_REG_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (bdu == LSM303AGR_MAG_BDU_CONTINUOUS)
{
value &= ~LSM303AGR_MAG_BDU_BIT;
value |= LSM303AGR_MAG_BDU_CONTINUOUS;
}
else{
value &= ~LSM303AGR_MAG_BDU_BIT;
value |= LSM303AGR_MAG_BDU_MSBLSB;
}
ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_mag_st_lsm303agr_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
ret = drv_mag_st_lsm303agr_set_power_mode(drv, DEV_POWER_OFF);
if(unlikely(ret)){
return ret;
}
ret = drv_mag_st_lsm303agr_set_odr(drv, LSM303AGR_MAG_ODR_10_HZ);
if(unlikely(ret)){
return ret;
}
ret = drv_mag_st_lsm303agr_set_range(drv, LSM303AGR_MAG_FS_50_GA);
if(unlikely(ret)){
return -1;
}
ret = drv_mag_st_lsm303agr_set_ble(drv, LSM303AGR_MAG_BLE_LSB);
if(unlikely(ret)){
return -1;
}
ret = drv_mag_st_lsm303agr_set_bdu(drv, LSM303AGR_MAG_BDU_MSBLSB);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_mag_st_lsm303agr_st_discard(i2c_dev_t* drv)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
for (i = 0; i < LSM303AGR_MAG_SELF_TEST_DRY_WAIT_CNT; i ++) {
ret = sensor_i2c_read(drv, LSM303AGR_MAG_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x08)
break;
aos_msleep(10);
}
if (i >= LSM303AGR_MAG_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, (LSM303AGR_MAG_OUTX_L_REG | 0x80), buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
return ret;
}
static int drv_mag_st_lsm303agr_st_data(i2c_dev_t* drv,int32_t* data)
{
uint8_t i, j;
int16_t x_raw, y_raw, z_raw;
int32_t x_mg, y_mg, z_mg;
int32_t x_sum, y_sum, z_sum;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
x_sum = 0; y_sum = 0; z_sum = 0;
for (i = 0; i < LSM303AGR_MAG_SELF_TEST_AVG_SAMPLE_CNT; i ++) {
for (j = 0; j < LSM303AGR_MAG_SELF_TEST_DRY_WAIT_CNT; j ++) {
ret = sensor_i2c_read(drv, LSM303AGR_MAG_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x08)
break;
aos_msleep(10);
}
if (j >= LSM303AGR_MAG_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, (LSM303AGR_MAG_OUTX_L_REG | 0x80), buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
x_raw = (buffer[1] << 8) + buffer[0];
y_raw = (buffer[3] << 8) + buffer[2];
z_raw = (buffer[5] << 8) + buffer[4];
x_mg = x_raw * LSM303AGR_MAG_SENSITIVITY_FOR_FS_50GA / 1000;
y_mg = y_raw * LSM303AGR_MAG_SENSITIVITY_FOR_FS_50GA / 1000;
z_mg = z_raw * LSM303AGR_MAG_SENSITIVITY_FOR_FS_50GA / 1000;
x_sum += x_mg;
y_sum += y_mg;
z_sum += z_mg;
}
data[0] = x_sum / LSM303AGR_MAG_SELF_TEST_AVG_SAMPLE_CNT;
data[1] = y_sum / LSM303AGR_MAG_SELF_TEST_AVG_SAMPLE_CNT;
data[2] = z_sum / LSM303AGR_MAG_SELF_TEST_AVG_SAMPLE_CNT;
return ret;
}
static int drv_mag_st_lsm303agr_self_test(i2c_dev_t* drv,int32_t* data)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t cfg_reg[3];
int32_t out_nost[3];
int32_t out_st[3];
int32_t out_diff[3];
// Save cfg registers which will be modified during self-test
ret = sensor_i2c_read(drv, (LSM303AGR_MAG_CFG_REG_A | 0x80), cfg_reg, 3, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
// Initialize Sensor, turn on sensor, COMP_TEMP_EN, BDU, Continueous-Measurement,
// Enable offset concellation, ODR = 100Hz
value = 0x8c;
ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0x02;
ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_B, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0x10;
ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(20);
// Discard the first sample
ret = drv_mag_st_lsm303agr_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and averate them
ret = drv_mag_st_lsm303agr_st_data(drv, out_nost);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Enable seft-test
value = 0x12;
ret = sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(60);
// Discard the first sample
ret = drv_mag_st_lsm303agr_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and average them
ret = drv_mag_st_lsm303agr_st_data(drv, out_st);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Check if the differences are between min and max
for (i = 0; i < 3; i ++) {
out_diff[i] = abs(out_st[i] - out_nost[i]);
data[i] = out_diff[i];
}
if ((LSM303AGR_MAG_SELF_TEST_MIN_X > out_diff[0]) || (out_diff[0] > LSM303AGR_MAG_SELF_TEST_MAX_X)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM303AGR_MAG_SELF_TEST_MIN_Y > out_diff[1]) || (out_diff[1] > LSM303AGR_MAG_SELF_TEST_MAX_Y)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LSM303AGR_MAG_SELF_TEST_MIN_Z > out_diff[2]) || (out_diff[2] > LSM303AGR_MAG_SELF_TEST_MAX_Z)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
restore:
ret += sensor_i2c_write(drv, LSM303AGR_MAG_CFG_REG_A | 0x80, cfg_reg, 3, I2C_OP_RETRIES);
return ret;
}
static void drv_mag_st_lsm303agr_irq_handle(void)
{
/* no handle so far */
}
static int drv_mag_st_lsm303agr_open(void)
{
int ret = 0;
ret = drv_mag_st_lsm303agr_set_power_mode(&lsm303agr_mag_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_mag_st_lsm303agr_close(void)
{
int ret = 0;
ret = drv_mag_st_lsm303agr_set_power_mode(&lsm303agr_mag_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_mag_st_lsm303agr_read(void* buf, size_t len)
{
int ret = 0;
size_t size;
int16_t pnRawData[3];
uint8_t buffer[6];
uint8_t i = 0;
uint16_t sensitivity = 0;
mag_data_t* pdata = (mag_data_t*)buf;
if(buf == NULL){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
size = sizeof(mag_data_t);
if(len < size){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(&lsm303agr_mag_ctx, (LSM303AGR_MAG_OUTX_L_REG | 0x80), buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
for(i=0; i<3; i++)
{
pnRawData[i]=((((uint16_t)buffer[2*i+1]) << 8) | (uint16_t)buffer[2*i]);
}
//LOG("%s %s: %d, %d, %d \n", SENSOR_STR, __func__, pnRawData[0], pnRawData[1], pnRawData[2]);
sensitivity = LSM303AGR_MAG_SENSITIVITY_FOR_FS_50GA;
for(i=0; i<3; i++)
{
//pdata->data[i] = ( int16_t )(pnRawData[i] * sensitivity);
pdata->data[i] = pnRawData[i] * sensitivity / 1000;
}
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_mag_st_lsm303agr_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_mag_st_lsm303agr_set_odr(&lsm303agr_mag_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_mag_st_lsm303agr_set_range(&lsm303agr_mag_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_mag_st_lsm303agr_set_power_mode(&lsm303agr_mag_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
//dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LSM303AGR";
info->range_max = 50;
info->range_min = 50;
info->unit = mGauss;
}break;
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_mag_st_lsm303agr_self_test(&lsm303agr_mag_ctx, (int32_t*)info->data);
//printf("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
LOG("%s %s: %d, %d, %d\n", SENSOR_STR, __func__, info->data[0],info->data[1],info->data[2]);
return ret;
}
default:break;
}
return 0;
}
int drv_mag_st_lsm303agr_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_MAG;
sensor.path = dev_mag_path;
sensor.open = drv_mag_st_lsm303agr_open;
sensor.close = drv_mag_st_lsm303agr_close;
sensor.read = drv_mag_st_lsm303agr_read;
sensor.write = NULL;
sensor.ioctl = drv_mag_st_lsm303agr_ioctl;
sensor.irq_handle = drv_mag_st_lsm303agr_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_mag_st_lsm303agr_validate_id(&lsm303agr_mag_ctx, I_AM_LSM303AGR);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_mag_st_lsm303agr_soft_reset(&lsm303agr_mag_ctx);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_mag_st_lsm303agr_set_default_config(&lsm303agr_mag_ctx);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_mag_st_lsm303agr_enable_temp(&lsm303agr_mag_ctx);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = drv_mag_st_lsm303agr_enable_off_canc(&lsm303agr_mag_ctx);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_lsm303agr_init);
SENSOR_DRV_ADD(drv_mag_st_lsm303agr_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_mag_st_lsm303agr.c
|
C
|
apache-2.0
| 42,978
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define NSA_REG_SPI_I2C 0x00
#define NSA_REG_WHO_AM_I 0x01
#define NSA_REG_ACC_X_LSB 0x02
#define NSA_REG_ACC_X_MSB 0x03
#define NSA_REG_ACC_Y_LSB 0x04
#define NSA_REG_ACC_Y_MSB 0x05
#define NSA_REG_ACC_Z_LSB 0x06
#define NSA_REG_ACC_Z_MSB 0x07
#define NSA_REG_MOTION_FLAG 0x09
#define NSA_REG_NEWDATA_FLAG 0x0A
#define NSA_REG_G_RANGE 0x0f
#define NSA_REG_ODR_AXIS_DISABLE 0x10
#define NSA_REG_POWERMODE_BW 0x11
#define NSA_REG_SWAP_POLARITY 0x12
#define NSA_REG_INTERRUPT_SETTINGS0 0x15
#define NSA_REG_INTERRUPT_SETTINGS1 0x16
#define NSA_REG_INTERRUPT_SETTINGS2 0x17
#define NSA_REG_INTERRUPT_MAPPING1 0x19
#define NSA_REG_INTERRUPT_MAPPING2 0x1a
#define NSA_REG_INTERRUPT_MAPPING3 0x1b
#define NSA_REG_INT_PIN_CONFIG 0x20
#define NSA_REG_INT_LATCH 0x21
#define NSA_REG_ACTIVE_DURATION 0x27
#define NSA_REG_ACTIVE_THRESHOLD 0x28
#define NSA_REG_CUSTOM_OFFSET_X 0x38
#define NSA_REG_CUSTOM_OFFSET_Y 0x39
#define NSA_REG_CUSTOM_OFFSET_Z 0x3a
#define NSA_REG_ENGINEERING_MODE 0x7f
#define NSA_REG_SENSITIVITY_TRIM_X 0x80
#define NSA_REG_SENSITIVITY_TRIM_Y 0x81
#define NSA_REG_SENSITIVITY_TRIM_Z 0x82
#define NSA_REG_COARSE_OFFSET_TRIM_X 0x83
#define NSA_REG_COARSE_OFFSET_TRIM_Y 0x84
#define NSA_REG_COARSE_OFFSET_TRIM_Z 0x85
#define NSA_REG_FINE_OFFSET_TRIM_X 0x86
#define NSA_REG_FINE_OFFSET_TRIM_Y 0x87
#define NSA_REG_FINE_OFFSET_TRIM_Z 0x88
#define NSA_REG_SENS_COMP 0x8c
#define NSA_REG_SENS_COARSE_TRIM 0xd1
#define DA213B_NORMAL_MODE 0x00
#define DA213B_SUSPEND_MODE 0x01
#define DA213B_I2C_SLAVE_ADDR (0x27)
#define DA213B_ACC_DATA_SIZE 6
#define DA213B_CHIP_ID_VAL 0x13
#define DA213B_ADDR_TRANS(n) ((n) << 1)
#define DA213B_GET_BITSLICE(regvar, bitname) ((regvar & bitname##__MSK) >> bitname##__POS)
#define DA213B_SET_BITSLICE(regvar, bitname, val) ((regvar & ~bitname##__MSK) | ((val<<bitname##__POS)&bitname##__MSK))
i2c_dev_t da213B_ctx = {
.port = 2,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr = DA213B_ADDR_TRANS(DA213B_I2C_SLAVE_ADDR)
};
static int drv_acc_mir3_da213B_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
int ret = 0;
uint8_t value = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, NSA_REG_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_mir3_da213B_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode;
switch(mode){
case DEV_POWER_OFF:
case DEV_SLEEP:{
dev_mode = (uint8_t)0x80;
break;
}
case DEV_POWER_ON:{
dev_mode = (uint8_t)0x34;
break;
}
default:return -1;
}
ret = sensor_i2c_write(drv, NSA_REG_POWERMODE_BW, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_mir3_da213B_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = 0x83;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x69;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0xbd;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, 0x8e, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (value == 0) {
value = 0x50;
ret = sensor_i2c_write(drv, 0x8e, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
}
value = 0x40;
ret = sensor_i2c_write(drv, NSA_REG_G_RANGE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x00;
ret = sensor_i2c_write(drv, NSA_REG_INT_PIN_CONFIG,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = drv_acc_mir3_da213B_set_power_mode(drv, DEV_SLEEP);
if (unlikely(ret)) {
return ret;
}
value = 0x07;
ret = sensor_i2c_write(drv, NSA_REG_ODR_AXIS_DISABLE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x04;
ret = sensor_i2c_write(drv, NSA_REG_INTERRUPT_MAPPING2,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x04;
ret = sensor_i2c_write(drv, NSA_REG_INTERRUPT_SETTINGS0,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static void drv_acc_mir3_da213B_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_mir3_da213B_open(void)
{
int ret = 0;
ret = drv_acc_mir3_da213B_set_power_mode(&da213B_ctx, DEV_POWER_ON);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_acc_mir3_da213B_close(void)
{
int ret = 0;
ret = drv_acc_mir3_da213B_set_power_mode(&da213B_ctx, DEV_POWER_OFF);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_acc_mir3_da213B_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t acc_raw[DA213B_ACC_DATA_SIZE] = {0};
accel_data_t* pdata = (accel_data_t*)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&da213B_ctx, NSA_REG_ACC_X_LSB, acc_raw, DA213B_ACC_DATA_SIZE, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->data[0] = (int32_t)((int16_t)(acc_raw[1] << 8 | acc_raw[0]) >> 4);
pdata->data[1] = (int32_t)((int16_t)(acc_raw[3] << 8 | acc_raw[2]) >> 4);
pdata->data[2] = (int32_t)((int16_t)(acc_raw[5] << 8 | acc_raw[4]) >> 4);
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_mir3_da213B_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_acc_mir3_da213B_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_mir3_da213B_set_power_mode(&da213B_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "DA213B";
info->unit = mg;
}break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_acc_mir3_da213B_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_acc_mir3_da213B_open;
sensor.close = drv_acc_mir3_da213B_close;
sensor.read = drv_acc_mir3_da213B_read;
sensor.write = drv_acc_mir3_da213B_write;
sensor.ioctl = drv_acc_mir3_da213B_ioctl;
sensor.irq_handle = drv_acc_mir3_da213B_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da213B_validate_id(&da213B_ctx, DA213B_CHIP_ID_VAL);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da213B_set_default_config(&da213B_ctx);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_mir3_da213B_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_mir3_da213B.c
|
C
|
apache-2.0
| 9,549
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define NSA_REG_SPI_I2C 0x00
#define NSA_REG_WHO_AM_I 0x01
#define NSA_REG_ACC_X_LSB 0x02
#define NSA_REG_ACC_X_MSB 0x03
#define NSA_REG_ACC_Y_LSB 0x04
#define NSA_REG_ACC_Y_MSB 0x05
#define NSA_REG_ACC_Z_LSB 0x06
#define NSA_REG_ACC_Z_MSB 0x07
#define NSA_REG_MOTION_FLAG 0x09
#define NSA_REG_NEWDATA_FLAG 0x0A
#define NSA_REG_G_RANGE 0x0f
#define NSA_REG_ODR_AXIS_DISABLE 0x10
#define NSA_REG_POWERMODE_BW 0x11
#define NSA_REG_SWAP_POLARITY 0x12
#define NSA_REG_INTERRUPT_SETTINGS0 0x15
#define NSA_REG_INTERRUPT_SETTINGS1 0x16
#define NSA_REG_INTERRUPT_SETTINGS2 0x17
#define NSA_REG_INTERRUPT_MAPPING1 0x19
#define NSA_REG_INTERRUPT_MAPPING2 0x1a
#define NSA_REG_INTERRUPT_MAPPING3 0x1b
#define NSA_REG_INT_PIN_CONFIG 0x20
#define NSA_REG_INT_LATCH 0x21
#define NSA_REG_ACTIVE_DURATION 0x27
#define NSA_REG_ACTIVE_THRESHOLD 0x28
#define NSA_REG_CUSTOM_OFFSET_X 0x38
#define NSA_REG_CUSTOM_OFFSET_Y 0x39
#define NSA_REG_CUSTOM_OFFSET_Z 0x3a
#define NSA_REG_ENGINEERING_MODE 0x7f
#define NSA_REG_SENSITIVITY_TRIM_X 0x80
#define NSA_REG_SENSITIVITY_TRIM_Y 0x81
#define NSA_REG_SENSITIVITY_TRIM_Z 0x82
#define NSA_REG_COARSE_OFFSET_TRIM_X 0x83
#define NSA_REG_COARSE_OFFSET_TRIM_Y 0x84
#define NSA_REG_COARSE_OFFSET_TRIM_Z 0x85
#define NSA_REG_FINE_OFFSET_TRIM_X 0x86
#define NSA_REG_FINE_OFFSET_TRIM_Y 0x87
#define NSA_REG_FINE_OFFSET_TRIM_Z 0x88
#define NSA_REG_SENS_COMP 0x8c
#define NSA_REG_SENS_COARSE_TRIM 0xd1
#define DA215_NORMAL_MODE 0x00
#define DA215_SUSPEND_MODE 0x01
#define DA215_I2C_SLAVE_ADDR (0x27)
#define DA215_ACC_DATA_SIZE 6
#define DA215_CHIP_ID_VAL 0x13
#define DA215_ADDR_TRANS(n) ((n) << 1)
#define DA215_GET_BITSLICE(regvar, bitname) ((regvar & bitname##__MSK) >> bitname##__POS)
#define DA215_SET_BITSLICE(regvar, bitname, val) ((regvar & ~bitname##__MSK) | ((val<<bitname##__POS)&bitname##__MSK))
i2c_dev_t da215_ctx = {
.port = 2,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = DA215_ADDR_TRANS(DA215_I2C_SLAVE_ADDR)
};
static int drv_acc_mir3_da215_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
int ret = 0;
uint8_t value = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, NSA_REG_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_mir3_da215_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode;
switch(mode){
case DEV_POWER_OFF:
case DEV_SLEEP:{
dev_mode = (uint8_t)0x80;
break;
}
case DEV_POWER_ON:{
dev_mode = (uint8_t)0x34;
break;
}
default:return -1;
}
ret = sensor_i2c_write(drv, NSA_REG_POWERMODE_BW, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
dev_mode = 0;
ret = sensor_i2c_read(drv, NSA_REG_POWERMODE_BW, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
LOG("sensor_i2c_read:0x%x \n", dev_mode);
return 0;
}
static int drv_acc_mir3_da215_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = 0x83;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x69;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0xbd;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, 0x8e, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (value == 0) {
value = 0x50;
ret = sensor_i2c_write(drv, 0x8e, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
}
value = 0x40;
ret = sensor_i2c_write(drv, NSA_REG_G_RANGE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x00;
ret = sensor_i2c_write(drv, NSA_REG_INT_PIN_CONFIG,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = drv_acc_mir3_da215_set_power_mode(drv, DEV_SLEEP);
if (unlikely(ret)) {
return ret;
}
value = 0x07;
ret = sensor_i2c_write(drv, NSA_REG_ODR_AXIS_DISABLE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x04;
ret = sensor_i2c_write(drv, NSA_REG_INTERRUPT_MAPPING2,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x04;
ret = sensor_i2c_write(drv, NSA_REG_INTERRUPT_SETTINGS0,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static void drv_acc_mir3_da215_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_mir3_da215_open(void)
{
int ret = 0;
ret = drv_acc_mir3_da215_set_power_mode(&da215_ctx, DEV_POWER_ON);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_acc_mir3_da215_close(void)
{
int ret = 0;
ret = drv_acc_mir3_da215_set_power_mode(&da215_ctx, DEV_POWER_OFF);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_acc_mir3_da215_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t acc_raw[DA215_ACC_DATA_SIZE] = {0};
accel_data_t* pdata = (accel_data_t*)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&da215_ctx, NSA_REG_ACC_X_LSB, acc_raw, DA215_ACC_DATA_SIZE, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->data[0] = (int32_t)((int16_t)(acc_raw[1] << 8 | acc_raw[0]) >> 4);
pdata->data[1] = (int32_t)((int16_t)(acc_raw[3] << 8 | acc_raw[2]) >> 4);
pdata->data[2] = (int32_t)((int16_t)(acc_raw[5] << 8 | acc_raw[4]) >> 4);
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_mir3_da215_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_acc_mir3_da215_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_mir3_da215_set_power_mode(&da215_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "DA215";
info->unit = mg;
}break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_acc_mir3_da215_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_acc_mir3_da215_open;
sensor.close = drv_acc_mir3_da215_close;
sensor.read = drv_acc_mir3_da215_read;
sensor.write = drv_acc_mir3_da215_write;
sensor.ioctl = drv_acc_mir3_da215_ioctl;
sensor.irq_handle = drv_acc_mir3_da215_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da215_validate_id(&da215_ctx, DA215_CHIP_ID_VAL);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da215_set_default_config(&da215_ctx);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_mir3_da215_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_mir3_da215.c
|
C
|
apache-2.0
| 9,665
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "ulog/ulog.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define NSA_REG_SPI_I2C 0x00
#define NSA_REG_WHO_AM_I 0x01
#define NSA_REG_ACC_X_LSB 0x02
#define NSA_REG_ACC_X_MSB 0x03
#define NSA_REG_ACC_Y_LSB 0x04
#define NSA_REG_ACC_Y_MSB 0x05
#define NSA_REG_ACC_Z_LSB 0x06
#define NSA_REG_ACC_Z_MSB 0x07
#define NSA_REG_MOTION_FLAG 0x09
#define NSA_REG_NEWDATA_FLAG 0x0A
#define NSA_REG_STEPS_MSB 0x0D
#define NSA_REG_STEPS_LSB 0x0E
#define NSA_REG_G_RANGE 0x0f
#define NSA_REG_ODR_AXIS_DISABLE 0x10
#define NSA_REG_POWERMODE_BW 0x11
#define NSA_REG_SWAP_POLARITY 0x12
#define NSA_REG_FIFO_CTRL 0x14
#define NSA_REG_INTERRUPT_SETTINGS0 0x15
#define NSA_REG_INTERRUPT_SETTINGS1 0x16
#define NSA_REG_INTERRUPT_SETTINGS2 0x17
#define NSA_REG_INTERRUPT_MAPPING1 0x19
#define NSA_REG_INTERRUPT_MAPPING2 0x1a
#define NSA_REG_INTERRUPT_MAPPING3 0x1b
#define NSA_REG_INT_PIN_CONFIG 0x20
#define NSA_REG_INT_LATCH 0x21
#define NSA_REG_ACTIVE_DURATION 0x27
#define NSA_REG_ACTIVE_THRESHOLD 0x28
#define NSA_REG_TAP_DURATION 0x2A
#define NSA_REG_TAP_THRESHOLD 0x2B
#define NSA_REG_RESET_STEP 0x2E
#define NSA_REG_STEP_CONGIF1 0x2F
#define NSA_REG_STEP_CONGIF2 0x30
#define NSA_REG_STEP_CONGIF3 0x31
#define NSA_REG_STEP_CONGIF4 0x32
#define NSA_REG_STEP_FILTER 0x33
#define NSA_REG_CUSTOM_OFFSET_X 0x38
#define NSA_REG_CUSTOM_OFFSET_Y 0x39
#define NSA_REG_CUSTOM_OFFSET_Z 0x3a
#define NSA_REG_ENGINEERING_MODE 0x7f
#define NSA_REG_SENSITIVITY_TRIM_X 0x80
#define NSA_REG_SENSITIVITY_TRIM_Y 0x81
#define NSA_REG_SENSITIVITY_TRIM_Z 0x82
#define NSA_REG_COARSE_OFFSET_TRIM_X 0x83
#define NSA_REG_COARSE_OFFSET_TRIM_Y 0x84
#define NSA_REG_COARSE_OFFSET_TRIM_Z 0x85
#define NSA_REG_FINE_OFFSET_TRIM_X 0x86
#define NSA_REG_FINE_OFFSET_TRIM_Y 0x87
#define NSA_REG_FINE_OFFSET_TRIM_Z 0x88
#define NSA_REG_SENS_COMP 0x8c
#define NSA_REG_SENS_COARSE_TRIM 0xd1
#define DA217_NORMAL_MODE 0x00
#define DA217_SUSPEND_MODE 0x01
#define DA217_I2C_SLAVE_ADDR_LOW (0x26)
#define DA217_I2C_SLAVE_ADDR_HIGN (0x27)
#define DA217_ACC_DATA_SIZE 6
#define DA217_CHIP_ID_VAL 0x13
#define DA217_ADDR_TRANS(n) ((n) << 1)
#define DA217_GET_BITSLICE(regvar, bitname) \
((regvar & bitname##__MSK) >> bitname##__POS)
#define DA217_SET_BITSLICE(regvar, bitname, val) \
((regvar & ~bitname##__MSK) | ((val << bitname##__POS) & bitname##__MSK))
i2c_dev_t da217_ctx = { .port = 1,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr =
DA217_ADDR_TRANS(DA217_I2C_SLAVE_ADDR_HIGN) };
static int drv_acc_mir3_da217_validate_id(i2c_dev_t *drv, uint8_t id_value)
{
int ret = 0;
uint8_t value = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, NSA_REG_WHO_AM_I, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (id_value != value) {
return -1;
}
return 0;
}
UNUSED static int drv_acc_mir3_da217_open_step_counter(i2c_dev_t *drv)
{
int ret = 0;
uint8_t value = 0;
value = 0x01;
ret = sensor_i2c_write(drv, NSA_REG_STEP_CONGIF1, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x62;
ret = sensor_i2c_write(drv, NSA_REG_STEP_CONGIF2, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x46;
ret = sensor_i2c_write(drv, NSA_REG_STEP_CONGIF3, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x32;
ret = sensor_i2c_write(drv, NSA_REG_STEP_CONGIF4, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0xa2;
ret = sensor_i2c_write(drv, NSA_REG_STEP_FILTER, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_mir3_da217_close_step_counter(i2c_dev_t *drv)
{
int ret = 0;
uint8_t value = 0;
value = 0x22;
ret = sensor_i2c_write(drv, NSA_REG_STEP_FILTER, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_mir3_da217_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode;
switch (mode) {
case DEV_POWER_OFF:
case DEV_SLEEP: {
dev_mode = (uint8_t)0x80;
break;
}
case DEV_POWER_ON: {
dev_mode = (uint8_t)0x34;
break;
}
default:
return -1;
}
ret = sensor_i2c_write(drv, NSA_REG_POWERMODE_BW, &dev_mode, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_mir3_da217_set_default_config(i2c_dev_t *drv)
{
int ret = 0;
uint8_t value = 0;
value = 0x83;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x69;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0xbd;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, 0x8e, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (value == 0) {
value = 0x50;
ret = sensor_i2c_write(drv, 0x8e, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
}
value = 0x40;
ret = sensor_i2c_write(drv, NSA_REG_G_RANGE, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x00;
ret = sensor_i2c_write(drv, NSA_REG_INT_PIN_CONFIG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = drv_acc_mir3_da217_set_power_mode(drv, DEV_SLEEP);
if (unlikely(ret)) {
return ret;
}
value = 0x07;
ret = sensor_i2c_write(drv, NSA_REG_ODR_AXIS_DISABLE, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = drv_acc_mir3_da217_close_step_counter(drv);
if (unlikely(ret)) {
return ret;
}
value = 0x80;
ret = sensor_i2c_write(drv, NSA_REG_RESET_STEP, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x04;
ret = sensor_i2c_write(drv, NSA_REG_INTERRUPT_MAPPING2, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x04;
ret = sensor_i2c_write(drv, NSA_REG_INTERRUPT_SETTINGS0, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static void drv_acc_mir3_da217_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_mir3_da217_open(void)
{
int ret = 0;
ret = drv_acc_mir3_da217_set_power_mode(&da217_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
#ifdef AOS_SENSOR_ACC_SUPPORT_STEP
ret = drv_acc_mir3_da217_open_step_counter(&da217_ctx);
if (unlikely(ret)) {
return -1;
}
#endif
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_acc_mir3_da217_close(void)
{
int ret = 0;
#ifdef AOS_SENSOR_ACC_SUPPORT_STEP
ret = drv_acc_mir3_da217_close_step_counter(&da217_ctx);
if (unlikely(ret)) {
return -1;
}
#endif
ret = drv_acc_mir3_da217_set_power_mode(&da217_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_acc_mir3_da217_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t acc_raw[DA217_ACC_DATA_SIZE] = { 0 };
accel_data_t *pdata = (accel_data_t *)buf;
#ifdef AOS_SENSOR_ACC_SUPPORT_STEP
uint8_t step_raw[2] = { 0 };
#endif
if (buf == NULL) {
return -1;
}
size = sizeof(accel_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(&da217_ctx, NSA_REG_ACC_X_LSB, acc_raw,
DA217_ACC_DATA_SIZE, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->data[0] = (int32_t)((int16_t)(acc_raw[1] << 8 | acc_raw[0]) >> 4);
pdata->data[1] = (int32_t)((int16_t)(acc_raw[3] << 8 | acc_raw[2]) >> 4);
pdata->data[2] = (int32_t)((int16_t)(acc_raw[5] << 8 | acc_raw[4]) >> 4);
#ifdef AOS_SENSOR_ACC_SUPPORT_STEP
ret = sensor_i2c_read(&da217_ctx, NSA_REG_STEPS_MSB, step_raw, 2,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->step = ((uint16_t)((step_raw[0] << 8 | step_raw[1]))) / 2;
#endif
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_mir3_da217_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_acc_mir3_da217_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
ret = drv_acc_mir3_da217_set_power_mode(&da217_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "DA217";
info->unit = mg;
} break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_acc_mir3_da217_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_acc_mir3_da217_open;
sensor.close = drv_acc_mir3_da217_close;
sensor.read = drv_acc_mir3_da217_read;
sensor.write = drv_acc_mir3_da217_write;
sensor.ioctl = drv_acc_mir3_da217_ioctl;
sensor.irq_handle = drv_acc_mir3_da217_irq_handle;
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da217_validate_id(&da217_ctx, DA217_CHIP_ID_VAL);
if (unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da217_set_default_config(&da217_ctx);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_mir3_da217_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_mir3_da217.c
|
C
|
apache-2.0
| 11,591
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define NSA_REG_SPI_I2C 0x00
#define NSA_REG_WHO_AM_I 0x01
#define NSA_REG_ACC_X_LSB 0x02
#define NSA_REG_ACC_X_MSB 0x03
#define NSA_REG_ACC_Y_LSB 0x04
#define NSA_REG_ACC_Y_MSB 0x05
#define NSA_REG_ACC_Z_LSB 0x06
#define NSA_REG_ACC_Z_MSB 0x07
#define NSA_REG_MOTION_FLAG 0x09
#define NSA_REG_NEWDATA_FLAG 0x0A
#define NSA_REG_STEPS_MSB 0x0D
#define NSA_REG_STEPS_LSB 0x0E
#define NSA_REG_G_RANGE 0x0f
#define NSA_REG_ODR_AXIS_DISABLE 0x10
#define NSA_REG_POWERMODE_BW 0x11
#define NSA_REG_SWAP_POLARITY 0x12
#define NSA_REG_FIFO_CTRL 0x14
#define NSA_REG_INTERRUPT_SETTINGS0 0x15
#define NSA_REG_INTERRUPT_SETTINGS1 0x16
#define NSA_REG_INTERRUPT_SETTINGS2 0x17
#define NSA_REG_INTERRUPT_MAPPING1 0x19
#define NSA_REG_INTERRUPT_MAPPING2 0x1a
#define NSA_REG_INTERRUPT_MAPPING3 0x1b
#define NSA_REG_INT_PIN_CONFIG 0x20
#define NSA_REG_INT_LATCH 0x21
#define NSA_REG_ACTIVE_DURATION 0x27
#define NSA_REG_ACTIVE_THRESHOLD 0x28
#define NSA_REG_TAP_DURATION 0x2A
#define NSA_REG_TAP_THRESHOLD 0x2B
#define NSA_REG_RESET_STEP 0x2E
#define NSA_REG_STEP_CONGIF1 0x2F
#define NSA_REG_STEP_CONGIF2 0x30
#define NSA_REG_STEP_CONGIF3 0x31
#define NSA_REG_STEP_CONGIF4 0x32
#define NSA_REG_STEP_FILTER 0x33
#define NSA_REG_CUSTOM_OFFSET_X 0x38
#define NSA_REG_CUSTOM_OFFSET_Y 0x39
#define NSA_REG_CUSTOM_OFFSET_Z 0x3a
#define NSA_REG_ENGINEERING_MODE 0x7f
#define NSA_REG_SENSITIVITY_TRIM_X 0x80
#define NSA_REG_SENSITIVITY_TRIM_Y 0x81
#define NSA_REG_SENSITIVITY_TRIM_Z 0x82
#define NSA_REG_COARSE_OFFSET_TRIM_X 0x83
#define NSA_REG_COARSE_OFFSET_TRIM_Y 0x84
#define NSA_REG_COARSE_OFFSET_TRIM_Z 0x85
#define NSA_REG_FINE_OFFSET_TRIM_X 0x86
#define NSA_REG_FINE_OFFSET_TRIM_Y 0x87
#define NSA_REG_FINE_OFFSET_TRIM_Z 0x88
#define NSA_REG_SENS_COMP 0x8c
#define NSA_REG_SENS_COARSE_TRIM 0xd1
#define DA270_NORMAL_MODE 0x00
#define DA270_SUSPEND_MODE 0x01
#define DA270_I2C_SLAVE_ADDR_LOW (0x26)
#define DA270_I2C_SLAVE_ADDR_HIGN (0x27)
#define DA270_ACC_DATA_SIZE 6
#define DA270_CHIP_ID_VAL 0x13
#define DA270_ADDR_TRANS(n) ((n) << 1)
#define DA270_GET_BITSLICE(regvar, bitname) ((regvar & bitname##__MSK) >> bitname##__POS)
#define DA270_SET_BITSLICE(regvar, bitname, val) ((regvar & ~bitname##__MSK) | ((val<<bitname##__POS)&bitname##__MSK))
i2c_dev_t da270_ctx = {
.port = 2,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr = DA270_ADDR_TRANS(DA270_I2C_SLAVE_ADDR_HIGN)
};
static int drv_acc_mir3_da270_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
int ret = 0;
uint8_t value = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, NSA_REG_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
UNUSED static int drv_acc_mir3_da270_open_step_counter(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = 0x01;
ret = sensor_i2c_write(drv, NSA_REG_STEP_CONGIF1,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x62;
ret = sensor_i2c_write(drv, NSA_REG_STEP_CONGIF2,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x46;
ret = sensor_i2c_write(drv, NSA_REG_STEP_CONGIF3,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x32;
ret = sensor_i2c_write(drv, NSA_REG_STEP_CONGIF4,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0xa2;
ret = sensor_i2c_write(drv, NSA_REG_STEP_FILTER,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_mir3_da270_close_step_counter(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = 0x22;
ret = sensor_i2c_write(drv, NSA_REG_STEP_FILTER,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_mir3_da270_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode;
switch(mode){
case DEV_POWER_OFF:
case DEV_SLEEP:{
dev_mode = (uint8_t)0x80;
break;
}
case DEV_POWER_ON:{
dev_mode = (uint8_t)0x04;
break;
}
default:return -1;
}
ret = sensor_i2c_write(drv, NSA_REG_POWERMODE_BW, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
dev_mode = 0;
ret = sensor_i2c_read(drv, NSA_REG_POWERMODE_BW, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
LOG("sensor_i2c_read:0x%x \n", dev_mode);
return 0;
}
static int drv_acc_mir3_da270_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = 0x83;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x69;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0xbd;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, 0x8e, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (value == 0) {
value = 0x50;
ret = sensor_i2c_write(drv, 0x8e, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
}
value = 0x40;
ret = sensor_i2c_write(drv, NSA_REG_G_RANGE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x00;
ret = sensor_i2c_write(drv, NSA_REG_INT_PIN_CONFIG,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = drv_acc_mir3_da270_set_power_mode(drv, DEV_SLEEP);
if (unlikely(ret)) {
return ret;
}
value = 0x07;
ret = sensor_i2c_write(drv, NSA_REG_ODR_AXIS_DISABLE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = drv_acc_mir3_da270_close_step_counter(drv);
if (unlikely(ret)) {
return ret;
}
value = 0x80;
ret = sensor_i2c_write(drv, NSA_REG_RESET_STEP,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x04;
ret = sensor_i2c_write(drv, NSA_REG_INTERRUPT_MAPPING2,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x04;
ret = sensor_i2c_write(drv, NSA_REG_INTERRUPT_SETTINGS0,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static void drv_acc_mir3_da270_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_mir3_da270_open(void)
{
int ret = 0;
ret = drv_acc_mir3_da270_set_power_mode(&da270_ctx, DEV_POWER_ON);
if(unlikely(ret)) {
return -1;
}
#ifdef AOS_SENSOR_ACC_SUPPORT_STEP
ret = drv_acc_mir3_da270_open_step_counter(&da270_ctx);
if(unlikely(ret)) {
return -1;
}
#endif
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_acc_mir3_da270_close(void)
{
int ret = 0;
#ifdef AOS_SENSOR_ACC_SUPPORT_STEP
ret = drv_acc_mir3_da270_close_step_counter(&da270_ctx);
if(unlikely(ret)) {
return -1;
}
#endif
ret = drv_acc_mir3_da270_set_power_mode(&da270_ctx, DEV_POWER_OFF);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_acc_mir3_da270_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t acc_raw[DA270_ACC_DATA_SIZE] = {0};
accel_data_t* pdata = (accel_data_t*)buf;
#ifdef AOS_SENSOR_ACC_SUPPORT_STEP
uint8_t step_raw[2] = {0};
#endif
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&da270_ctx, NSA_REG_ACC_X_LSB, acc_raw, DA270_ACC_DATA_SIZE, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->data[0] = (int32_t)((int16_t)(acc_raw[1] << 8 | acc_raw[0]) >> 4);
pdata->data[1] = (int32_t)((int16_t)(acc_raw[3] << 8 | acc_raw[2]) >> 4);
pdata->data[2] = (int32_t)((int16_t)(acc_raw[5] << 8 | acc_raw[4]) >> 4);
#ifdef AOS_SENSOR_ACC_SUPPORT_STEP
ret = sensor_i2c_read(&da270_ctx, NSA_REG_STEPS_MSB, step_raw, 2, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->step = ((uint16_t)((step_raw[0] << 8 | step_raw[1]))) / 2;
#endif
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_mir3_da270_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_acc_mir3_da270_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_mir3_da270_set_power_mode(&da270_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "DA270";
info->unit = mg;
}break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_acc_mir3_da270_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_acc_mir3_da270_open;
sensor.close = drv_acc_mir3_da270_close;
sensor.read = drv_acc_mir3_da270_read;
sensor.write = drv_acc_mir3_da270_write;
sensor.ioctl = drv_acc_mir3_da270_ioctl;
sensor.irq_handle = drv_acc_mir3_da270_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da270_validate_id(&da270_ctx, DA270_CHIP_ID_VAL);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da270_set_default_config(&da270_ctx);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_mir3_da270_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_mir3_da270.c
|
C
|
apache-2.0
| 12,735
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define NSA_REG_SPI_I2C 0x00
#define NSA_REG_WHO_AM_I 0x01
#define NSA_REG_ACC_X_LSB 0x02
#define NSA_REG_ACC_X_MSB 0x03
#define NSA_REG_ACC_Y_LSB 0x04
#define NSA_REG_ACC_Y_MSB 0x05
#define NSA_REG_ACC_Z_LSB 0x06
#define NSA_REG_ACC_Z_MSB 0x07
#define NSA_REG_MOTION_FLAG 0x09
#define NSA_REG_NEWDATA_FLAG 0x0A
#define NSA_REG_G_RANGE 0x0f
#define NSA_REG_ODR_AXIS_DISABLE 0x10
#define NSA_REG_POWERMODE_BW 0x11
#define NSA_REG_SWAP_POLARITY 0x12
#define NSA_REG_INTERRUPT_SETTINGS0 0x15
#define NSA_REG_INTERRUPT_SETTINGS1 0x16
#define NSA_REG_INTERRUPT_SETTINGS2 0x17
#define NSA_REG_INTERRUPT_MAPPING1 0x19
#define NSA_REG_INTERRUPT_MAPPING2 0x1a
#define NSA_REG_INTERRUPT_MAPPING3 0x1b
#define NSA_REG_INT_PIN_CONFIG 0x20
#define NSA_REG_INT_LATCH 0x21
#define NSA_REG_ACTIVE_DURATION 0x27
#define NSA_REG_ACTIVE_THRESHOLD 0x28
#define NSA_REG_CUSTOM_OFFSET_X 0x38
#define NSA_REG_CUSTOM_OFFSET_Y 0x39
#define NSA_REG_CUSTOM_OFFSET_Z 0x3a
#define NSA_REG_ENGINEERING_MODE 0x7f
#define NSA_REG_SENSITIVITY_TRIM_X 0x80
#define NSA_REG_SENSITIVITY_TRIM_Y 0x81
#define NSA_REG_SENSITIVITY_TRIM_Z 0x82
#define NSA_REG_COARSE_OFFSET_TRIM_X 0x83
#define NSA_REG_COARSE_OFFSET_TRIM_Y 0x84
#define NSA_REG_COARSE_OFFSET_TRIM_Z 0x85
#define NSA_REG_FINE_OFFSET_TRIM_X 0x86
#define NSA_REG_FINE_OFFSET_TRIM_Y 0x87
#define NSA_REG_FINE_OFFSET_TRIM_Z 0x88
#define NSA_REG_SENS_COMP 0x8c
#define NSA_REG_SENS_COARSE_TRIM 0xd1
#define DA312B_NORMAL_MODE 0x00
#define DA312B_SUSPEND_MODE 0x01
#define DA312B_I2C_SLAVE_ADDR (0x27)
#define DA312B_ACC_DATA_SIZE 6
#define DA312B_CHIP_ID_VAL 0x13
#define DA312B_ADDR_TRANS(n) ((n) << 1)
#define DA312B_GET_BITSLICE(regvar, bitname) ((regvar & bitname##__MSK) >> bitname##__POS)
#define DA312B_SET_BITSLICE(regvar, bitname, val) ((regvar & ~bitname##__MSK) | ((val<<bitname##__POS)&bitname##__MSK))
i2c_dev_t da312B_ctx = {
.port = 2,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr = DA312B_ADDR_TRANS(DA312B_I2C_SLAVE_ADDR)
};
static int drv_acc_mir3_da312B_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
int ret = 0;
uint8_t value = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, NSA_REG_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_mir3_da312B_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode;
switch(mode){
case DEV_POWER_OFF:
case DEV_SLEEP:{
dev_mode = (uint8_t)0x80;
break;
}
case DEV_POWER_ON:{
dev_mode = (uint8_t)0x34;
break;
}
default:return -1;
}
ret = sensor_i2c_write(drv, NSA_REG_POWERMODE_BW, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_mir3_da312B_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = 0x83;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x69;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0xbd;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, 0x8e, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (value == 0) {
value = 0x50;
ret = sensor_i2c_write(drv, 0x8e, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
}
value = 0x40;
ret = sensor_i2c_write(drv, NSA_REG_G_RANGE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x00;
ret = sensor_i2c_write(drv, NSA_REG_INT_PIN_CONFIG,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = drv_acc_mir3_da312B_set_power_mode(drv, DEV_SLEEP);
if (unlikely(ret)) {
return ret;
}
value = 0x07;
ret = sensor_i2c_write(drv, NSA_REG_ODR_AXIS_DISABLE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x04;
ret = sensor_i2c_write(drv, NSA_REG_INTERRUPT_MAPPING2,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x04;
ret = sensor_i2c_write(drv, NSA_REG_INTERRUPT_SETTINGS0,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static void drv_acc_mir3_da312B_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_mir3_da312B_open(void)
{
int ret = 0;
ret = drv_acc_mir3_da312B_set_power_mode(&da312B_ctx, DEV_POWER_ON);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_acc_mir3_da312B_close(void)
{
int ret = 0;
ret = drv_acc_mir3_da312B_set_power_mode(&da312B_ctx, DEV_POWER_OFF);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_acc_mir3_da312B_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t acc_raw[DA312B_ACC_DATA_SIZE] = {0};
accel_data_t* pdata = (accel_data_t*)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&da312B_ctx, NSA_REG_ACC_X_LSB, acc_raw, DA312B_ACC_DATA_SIZE, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->data[0] = (int32_t)((int16_t)(acc_raw[1] << 8 | acc_raw[0]) >> 4);
pdata->data[1] = (int32_t)((int16_t)(acc_raw[3] << 8 | acc_raw[2]) >> 4);
pdata->data[2] = (int32_t)((int16_t)(acc_raw[5] << 8 | acc_raw[4]) >> 4);
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_mir3_da312B_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_acc_mir3_da312B_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_mir3_da312B_set_power_mode(&da312B_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "DA312B";
info->unit = mg;
}break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_acc_mir3_da312B_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_acc_mir3_da312B_open;
sensor.close = drv_acc_mir3_da312B_close;
sensor.read = drv_acc_mir3_da312B_read;
sensor.write = drv_acc_mir3_da312B_write;
sensor.ioctl = drv_acc_mir3_da312B_ioctl;
sensor.irq_handle = drv_acc_mir3_da312B_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da312B_validate_id(&da312B_ctx, DA312B_CHIP_ID_VAL);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da312B_set_default_config(&da312B_ctx);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_mir3_da312B_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_mir3_da312B.c
|
C
|
apache-2.0
| 9,549
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define NSA_REG_SPI_I2C 0x00
#define NSA_REG_WHO_AM_I 0x01
#define NSA_REG_ACC_X_LSB 0x02
#define NSA_REG_ACC_X_MSB 0x03
#define NSA_REG_ACC_Y_LSB 0x04
#define NSA_REG_ACC_Y_MSB 0x05
#define NSA_REG_ACC_Z_LSB 0x06
#define NSA_REG_ACC_Z_MSB 0x07
#define NSA_REG_MOTION_FLAG 0x09
#define NSA_REG_NEWDATA_FLAG 0x0A
#define NSA_REG_G_RANGE 0x0f
#define NSA_REG_ODR_AXIS_DISABLE 0x10
#define NSA_REG_POWERMODE_BW 0x11
#define NSA_REG_SWAP_POLARITY 0x12
#define NSA_REG_INTERRUPT_SETTINGS0 0x15
#define NSA_REG_INTERRUPT_SETTINGS1 0x16
#define NSA_REG_INTERRUPT_SETTINGS2 0x17
#define NSA_REG_INTERRUPT_MAPPING1 0x19
#define NSA_REG_INTERRUPT_MAPPING2 0x1a
#define NSA_REG_INTERRUPT_MAPPING3 0x1b
#define NSA_REG_INT_PIN_CONFIG 0x20
#define NSA_REG_INT_LATCH 0x21
#define NSA_REG_ACTIVE_DURATION 0x27
#define NSA_REG_ACTIVE_THRESHOLD 0x28
#define NSA_REG_CUSTOM_OFFSET_X 0x38
#define NSA_REG_CUSTOM_OFFSET_Y 0x39
#define NSA_REG_CUSTOM_OFFSET_Z 0x3a
#define NSA_REG_ENGINEERING_MODE 0x7f
#define NSA_REG_SENSITIVITY_TRIM_X 0x80
#define NSA_REG_SENSITIVITY_TRIM_Y 0x81
#define NSA_REG_SENSITIVITY_TRIM_Z 0x82
#define NSA_REG_COARSE_OFFSET_TRIM_X 0x83
#define NSA_REG_COARSE_OFFSET_TRIM_Y 0x84
#define NSA_REG_COARSE_OFFSET_TRIM_Z 0x85
#define NSA_REG_FINE_OFFSET_TRIM_X 0x86
#define NSA_REG_FINE_OFFSET_TRIM_Y 0x87
#define NSA_REG_FINE_OFFSET_TRIM_Z 0x88
#define NSA_REG_SENS_COMP 0x8c
#define NSA_REG_SENS_COARSE_TRIM 0xd1
#define DA380B_NORMAL_MODE 0x00
#define DA380B_SUSPEND_MODE 0x01
#define DA380B_I2C_SLAVE_ADDR (0x27)
#define DA380B_ACC_DATA_SIZE 6
#define DA380B_CHIP_ID_VAL 0x13
#define DA380B_ADDR_TRANS(n) ((n) << 1)
#define DA380B_GET_BITSLICE(regvar, bitname) ((regvar & bitname##__MSK) >> bitname##__POS)
#define DA380B_SET_BITSLICE(regvar, bitname, val) ((regvar & ~bitname##__MSK) | ((val<<bitname##__POS)&bitname##__MSK))
i2c_dev_t da380B_ctx = {
.port = 2,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr = DA380B_ADDR_TRANS(DA380B_I2C_SLAVE_ADDR)
};
static int drv_acc_mir3_da380B_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
int ret = 0;
uint8_t value = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, NSA_REG_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_mir3_da380B_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode;
switch(mode){
case DEV_POWER_OFF:
case DEV_SLEEP:{
dev_mode = (uint8_t)0x80;
break;
}
case DEV_POWER_ON:{
dev_mode = (uint8_t)0x34;
break;
}
default:return -1;
}
ret = sensor_i2c_write(drv, NSA_REG_POWERMODE_BW, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_mir3_da380B_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = 0x83;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x69;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0xbd;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, 0x8e, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (value == 0) {
value = 0x50;
ret = sensor_i2c_write(drv, 0x8e, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
}
value = 0x40;
ret = sensor_i2c_write(drv, NSA_REG_G_RANGE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x00;
ret = sensor_i2c_write(drv, NSA_REG_INT_PIN_CONFIG,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = drv_acc_mir3_da380B_set_power_mode(drv, DEV_SLEEP);
if (unlikely(ret)) {
return ret;
}
value = 0x07;
ret = sensor_i2c_write(drv, NSA_REG_ODR_AXIS_DISABLE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x04;
ret = sensor_i2c_write(drv, NSA_REG_INTERRUPT_MAPPING2,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x04;
ret = sensor_i2c_write(drv, NSA_REG_INTERRUPT_SETTINGS0,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static void drv_acc_mir3_da380B_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_mir3_da380B_open(void)
{
int ret = 0;
ret = drv_acc_mir3_da380B_set_power_mode(&da380B_ctx, DEV_POWER_ON);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_acc_mir3_da380B_close(void)
{
int ret = 0;
ret = drv_acc_mir3_da380B_set_power_mode(&da380B_ctx, DEV_POWER_OFF);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_acc_mir3_da380B_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t acc_raw[DA380B_ACC_DATA_SIZE] = {0};
accel_data_t* pdata = (accel_data_t*)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&da380B_ctx, NSA_REG_ACC_X_LSB, acc_raw, DA380B_ACC_DATA_SIZE, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->data[0] = (int32_t)((int16_t)(acc_raw[1] << 8 | acc_raw[0]) >> 4);
pdata->data[1] = (int32_t)((int16_t)(acc_raw[3] << 8 | acc_raw[2]) >> 4);
pdata->data[2] = (int32_t)((int16_t)(acc_raw[5] << 8 | acc_raw[4]) >> 4);
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_mir3_da380B_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_acc_mir3_da380B_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_mir3_da380B_set_power_mode(&da380B_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "DA380B";
info->unit = mg;
}break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_acc_mir3_da380B_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_acc_mir3_da380B_open;
sensor.close = drv_acc_mir3_da380B_close;
sensor.read = drv_acc_mir3_da380B_read;
sensor.write = drv_acc_mir3_da380B_write;
sensor.ioctl = drv_acc_mir3_da380B_ioctl;
sensor.irq_handle = drv_acc_mir3_da380B_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da380B_validate_id(&da380B_ctx, DA380B_CHIP_ID_VAL);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da380B_set_default_config(&da380B_ctx);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_mir3_da380B_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_mir3_da380B.c
|
C
|
apache-2.0
| 9,550
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define AIS328DQ_I2C_ADDR1 (0x18)
#define AIS328DQ_I2C_ADDR2 (0x19)
#define AIS328DQ_I2C_ADDR_TRANS(n) ((n)<<1)
#define AIS328DQ_I2C_ADDR AIS328DQ_I2C_ADDR_TRANS(AIS328DQ_I2C_ADDR1)
#define AIS328DQ_ACC_WHO_AM_I 0x0F
#define AIS328DQ_ACC_CTRL_REG1 0x20
#define AIS328DQ_ACC_CTRL_REG2 0x21
#define AIS328DQ_ACC_CTRL_REG3 0x22
#define AIS328DQ_ACC_CTRL_REG4 0x23
#define AIS328DQ_ACC_CTRL_REG5 0x24
#define AIS328DQ_ACC_STATUS_REG 0x27
#define AIS328DQ_ACC_OUT_X_L 0x28
#define AIS328DQ_ACC_OUT_X_H 0x29
#define AIS328DQ_ACC_OUT_Y_L 0x2A
#define AIS328DQ_ACC_OUT_Y_H 0x2B
#define AIS328DQ_ACC_OUT_Z_L 0x2C
#define AIS328DQ_ACC_OUT_Z_H 0x2D
#define AIS328DQ_ACC_RANGE_2G (0x0)
#define AIS328DQ_ACC_RANGE_4G (0x1)
#define AIS328DQ_ACC_RANGE_8G (0x3)
#define AIS328DQ_ACC_RANGE_MSK (0x30)
#define AIS328DQ_ACC_RANGE_POS (4)
#define AIS328DQ_ACC_SENSITIVITY_2G (980)
#define AIS328DQ_ACC_SENSITIVITY_4G (1950)
#define AIS328DQ_ACC_SENSITIVITY_8G (3910)
#define AIS328DQ_ACC_CHIP_ID_VALUE (0x32)
#define AIS328DQ_SHIFT_EIGHT_BITS (8)
#define AIS328DQ_SHIFT_FOUR_BITS (4)
#define AIS328DQ_16_BIT_SHIFT (0xFF)
#define AIS328DQ_ACC_ODR_POWER_DOWN (0x00)
#define AIS328DQ_ACC_ODR_0_5_HZ (0x40)
#define AIS328DQ_ACC_ODR_1_HZ (0x60)
#define AIS328DQ_ACC_ODR_2_HZ (0x80)
#define AIS328DQ_ACC_ODR_5_HZ (0xA0)
#define AIS328DQ_ACC_ODR_10_HZ (0xC0)
#define AIS328DQ_ACC_ODR_50_HZ (0x20)
#define AIS328DQ_ACC_ODR_100_HZ (0x28)
#define AIS328DQ_ACC_ODR_400_HZ (0x30)
#define AIS328DQ_ACC_ODR_1000_HZ (0x38)
#define AIS328DQ_ACC_ODR_MSK (0xF8)
#define AIS328DQ_ACC_ODR_POS (3)
#define AIS328DQ_ACC_DEFAULT_ODR_100HZ (100)
#define AIS328DQ_BDU_ENABLE (0x80)
#define AIS328DQ_ACC_STATUS_ZYXDA (0x08)
#define AIS328DQ_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define AIS328DQ_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t ais328dq_acc_factor[ACC_RANGE_MAX] = { AIS328DQ_ACC_SENSITIVITY_2G, AIS328DQ_ACC_SENSITIVITY_4G,
AIS328DQ_ACC_SENSITIVITY_8G, 0 };
static int32_t cur_acc_factor = 0;
i2c_dev_t ais328dq_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = AIS328DQ_I2C_ADDR,
};
static int drv_acc_st_ais328dq_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, AIS328DQ_ACC_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_st_ais328dq_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, AIS328DQ_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = AIS328DQ_SET_BITSLICE(value,AIS328DQ_ACC_ODR,AIS328DQ_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, AIS328DQ_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = AIS328DQ_SET_BITSLICE(value,AIS328DQ_ACC_ODR,AIS328DQ_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, AIS328DQ_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = AIS328DQ_SET_BITSLICE(value,AIS328DQ_ACC_ODR,AIS328DQ_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, AIS328DQ_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_acc_st_ais328dq_hz2odr(uint32_t hz)
{
if(hz > 400)
return AIS328DQ_ACC_ODR_1000_HZ;
else if(hz > 100)
return AIS328DQ_ACC_ODR_400_HZ;
else if(hz > 50)
return AIS328DQ_ACC_ODR_100_HZ;
else if(hz > 10)
return AIS328DQ_ACC_ODR_50_HZ;
else if(hz > 5)
return AIS328DQ_ACC_ODR_10_HZ;
else if(hz > 2)
return AIS328DQ_ACC_ODR_5_HZ;
else if(hz > 1)
return AIS328DQ_ACC_ODR_2_HZ;
else
return AIS328DQ_ACC_ODR_1_HZ;
}
static int drv_acc_st_ais328dq_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_ais328dq_hz2odr(hz);
ret = sensor_i2c_read(drv, AIS328DQ_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = AIS328DQ_SET_BITSLICE(value,AIS328DQ_ACC_ODR,odr);
ret = sensor_i2c_write(drv, AIS328DQ_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_ais328dq_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, AIS328DQ_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_2G:{
tmp = AIS328DQ_ACC_RANGE_2G;
}break;
case ACC_RANGE_4G:{
tmp = AIS328DQ_ACC_RANGE_4G;
}break;
case ACC_RANGE_8G:{
tmp = AIS328DQ_ACC_RANGE_8G;
}break;
default:break;
}
value = AIS328DQ_SET_BITSLICE(value,AIS328DQ_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, AIS328DQ_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_8G)){
cur_acc_factor = ais328dq_acc_factor[range];
}
return 0;
}
static int drv_acc_st_ais328dq_set_bdu(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, AIS328DQ_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= AIS328DQ_BDU_ENABLE;
ret = sensor_i2c_write(drv, AIS328DQ_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static void drv_acc_st_ais328dq_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_ais328dq_open(void)
{
int ret = 0;
ret = drv_acc_st_ais328dq_set_power_mode(&ais328dq_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_ais328dq_set_range(&ais328dq_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_ais328dq_set_odr(&ais328dq_ctx, AIS328DQ_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_ais328dq_close(void)
{
int ret = 0;
ret = drv_acc_st_ais328dq_set_power_mode(&ais328dq_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_ais328dq_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&ais328dq_ctx, (AIS328DQ_ACC_OUT_X_L | 0x80), reg, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< AIS328DQ_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] >> AIS328DQ_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< AIS328DQ_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] >> AIS328DQ_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< AIS328DQ_SHIFT_EIGHT_BITS)|(reg[4]));
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] >> AIS328DQ_SHIFT_FOUR_BITS;
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] * cur_acc_factor / 1000;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] * cur_acc_factor / 1000;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] * cur_acc_factor / 1000;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_ais328dq_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_ais328dq_set_odr(&ais328dq_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_st_ais328dq_set_range(&ais328dq_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_ais328dq_set_power_mode(&ais328dq_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
info->model = "AIS328DQ";
info->range_max = 8;
info->range_min = 2;
info->unit = mg;
}break;
default:break;
}
return 0;
}
int drv_acc_st_ais328dq_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_ais328dq_open;
sensor.close = drv_acc_st_ais328dq_close;
sensor.read = drv_acc_st_ais328dq_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_ais328dq_ioctl;
sensor.irq_handle = drv_acc_st_ais328dq_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_ais328dq_validate_id(&ais328dq_ctx, AIS328DQ_ACC_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_ais328dq_set_range(&ais328dq_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_ais328dq_set_bdu(&ais328dq_ctx);
if(unlikely(ret)){
return -1;
}
//set odr is 100hz, and will update
ret = drv_acc_st_ais328dq_set_odr(&ais328dq_ctx, AIS328DQ_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_ais328dq_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_st_ais328dq.c
|
C
|
apache-2.0
| 11,548
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define H3LIS100DL_I2C_ADDR1 (0x18)
#define H3LIS100DL_I2C_ADDR2 (0x19)
#define H3LIS100DL_I2C_ADDR_TRANS(n) ((n)<<1)
#define H3LIS100DL_I2C_ADDR H3LIS100DL_I2C_ADDR_TRANS(H3LIS100DL_I2C_ADDR1)
#define H3LIS100DL_ACC_WHO_AM_I 0x0F
#define H3LIS100DL_ACC_CTRL_REG1 0x20
#define H3LIS100DL_ACC_CTRL_REG2 0x21
#define H3LIS100DL_ACC_CTRL_REG3 0x22
#define H3LIS100DL_ACC_CTRL_REG4 0x23
#define H3LIS100DL_ACC_CTRL_REG5 0x24
#define H3LIS100DL_ACC_STATUS_REG 0x27
#define H3LIS100DL_ACC_OUT_X 0x29
#define H3LIS100DL_ACC_OUT_Y 0x2B
#define H3LIS100DL_ACC_OUT_Z 0x2D
#define H3LIS100DL_ACC_SENSITIVITY_100G 780
#define H3LIS100DL_ACC_CHIP_ID_VALUE (0x32)
#define H3LIS100DL_SHIFT_EIGHT_BITS (8)
#define H3LIS100DL_SHIFT_FOUR_BITS (4)
#define H3LIS100DL_16_BIT_SHIFT (0xFF)
#define H3LIS100DL_ACC_ODR_POWER_DOWN (0x00)
#define H3LIS100DL_ACC_ODR_0_5_HZ (0x40)
#define H3LIS100DL_ACC_ODR_1_HZ (0x60)
#define H3LIS100DL_ACC_ODR_2_HZ (0x80)
#define H3LIS100DL_ACC_ODR_5_HZ (0xA0)
#define H3LIS100DL_ACC_ODR_10_HZ (0xC0)
#define H3LIS100DL_ACC_ODR_50_HZ (0x20)
#define H3LIS100DL_ACC_ODR_100_HZ (0x28)
#define H3LIS100DL_ACC_ODR_400_HZ (0x30)
#define H3LIS100DL_ACC_ODR_MSK (0xF8)
#define H3LIS100DL_ACC_DEFAULT_ODR_100HZ (100)
#define H3LIS100DL_ACC_STATUS_ZYXDA (0x08)
#define H3LIS100DL_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define H3LIS100DL_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
#if 0
static int32_t h3lis100dl_acc_factor[ACC_RANGE_MAX] = { 0, 0, 0, 0, 0, 0, 0, H3LIS100DL_ACC_SENSITIVITY_100G};
static int32_t cur_acc_factor = 0;
#endif
i2c_dev_t h3lis100dl_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = H3LIS100DL_I2C_ADDR,
};
static int drv_acc_st_h3lis100dl_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, H3LIS100DL_ACC_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_st_h3lis100dl_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, H3LIS100DL_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value &= ~H3LIS100DL_ACC_ODR_MSK;
value |= H3LIS100DL_ACC_ODR_10_HZ;
ret = sensor_i2c_write(drv, H3LIS100DL_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value &= ~H3LIS100DL_ACC_ODR_MSK;
value |= H3LIS100DL_ACC_ODR_POWER_DOWN;
ret = sensor_i2c_write(drv, H3LIS100DL_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value &= ~H3LIS100DL_ACC_ODR_MSK;
value |= H3LIS100DL_ACC_ODR_10_HZ;
ret = sensor_i2c_write(drv, H3LIS100DL_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_acc_st_h3lis100dl_hz2odr(uint32_t hz)
{
if(hz > 100)
return H3LIS100DL_ACC_ODR_400_HZ;
else if(hz > 50)
return H3LIS100DL_ACC_ODR_100_HZ;
else if(hz > 10)
return H3LIS100DL_ACC_ODR_50_HZ;
else if(hz > 5)
return H3LIS100DL_ACC_ODR_10_HZ;
else if(hz > 2)
return H3LIS100DL_ACC_ODR_5_HZ;
else if(hz > 1)
return H3LIS100DL_ACC_ODR_2_HZ;
else
return H3LIS100DL_ACC_ODR_1_HZ;
}
static int drv_acc_st_h3lis100dl_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_h3lis100dl_hz2odr(hz);
ret = sensor_i2c_read(drv, H3LIS100DL_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value &= ~H3LIS100DL_ACC_ODR_MSK;
value |= odr;
ret = sensor_i2c_write(drv, H3LIS100DL_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static void drv_acc_st_h3lis100dl_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_h3lis100dl_open(void)
{
int ret = 0;
ret = drv_acc_st_h3lis100dl_set_power_mode(&h3lis100dl_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_h3lis100dl_set_odr(&h3lis100dl_ctx, H3LIS100DL_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_h3lis100dl_close(void)
{
int ret = 0;
ret = drv_acc_st_h3lis100dl_set_power_mode(&h3lis100dl_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_h3lis100dl_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
ret = sensor_i2c_read(&h3lis100dl_ctx, H3LIS100DL_ACC_CTRL_REG1, ®[5], I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&h3lis100dl_ctx, H3LIS100DL_ACC_OUT_X, ®[0], 1, I2C_OP_RETRIES);
ret = sensor_i2c_read(&h3lis100dl_ctx, H3LIS100DL_ACC_OUT_Y, ®[1], 1, I2C_OP_RETRIES);
ret = sensor_i2c_read(&h3lis100dl_ctx, H3LIS100DL_ACC_OUT_Z, ®[2], 1, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int8_t)reg[0];
accel->data[DATA_AXIS_Y] = (int8_t)reg[1];
accel->data[DATA_AXIS_Z] = (int8_t)reg[2];
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] * H3LIS100DL_ACC_SENSITIVITY_100G;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] * H3LIS100DL_ACC_SENSITIVITY_100G;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] * H3LIS100DL_ACC_SENSITIVITY_100G;
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_h3lis100dl_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_h3lis100dl_set_odr(&h3lis100dl_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_h3lis100dl_set_power_mode(&h3lis100dl_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
info->model = "H3LIS100DL";
info->range_max = 100;
info->range_min = 100;
info->unit = mg;
}break;
default:break;
}
return 0;
}
int drv_acc_st_h3lis100dl_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_h3lis100dl_open;
sensor.close = drv_acc_st_h3lis100dl_close;
sensor.read = drv_acc_st_h3lis100dl_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_h3lis100dl_ioctl;
sensor.irq_handle = drv_acc_st_h3lis100dl_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_h3lis100dl_validate_id(&h3lis100dl_ctx, H3LIS100DL_ACC_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
//set odr is 100hz, and will update
ret = drv_acc_st_h3lis100dl_set_odr(&h3lis100dl_ctx, H3LIS100DL_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_h3lis100dl_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_st_h3lis100dl.c
|
C
|
apache-2.0
| 8,894
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define H3LIS331DL_I2C_ADDR1 (0x18)
#define H3LIS331DL_I2C_ADDR2 (0x19)
#define H3LIS331DL_I2C_ADDR_TRANS(n) ((n)<<1)
#define H3LIS331DL_I2C_ADDR H3LIS331DL_I2C_ADDR_TRANS(H3LIS331DL_I2C_ADDR1)
#define H3LIS331DL_ACC_TEMP_L 0x0B
#define H3LIS331DL_ACC_TEMP_H 0x0C
#define H3LIS331DL_ACC_WHO_AM_I 0x0F
#define H3LIS331DL_ACC_ACT_THS 0x1E
#define H3LIS331DL_ACC_ACT_DUR 0x1F
#define H3LIS331DL_ACC_CTRL_REG1 0x20
#define H3LIS331DL_ACC_CTRL_REG2 0x21
#define H3LIS331DL_ACC_CTRL_REG3 0x22
#define H3LIS331DL_ACC_CTRL_REG4 0x23
#define H3LIS331DL_ACC_CTRL_REG5 0x24
#define H3LIS331DL_ACC_STATUS_REG 0x27
#define H3LIS331DL_ACC_OUT_X_L 0x28
#define H3LIS331DL_ACC_OUT_X_H 0x29
#define H3LIS331DL_ACC_OUT_Y_L 0x2A
#define H3LIS331DL_ACC_OUT_Y_H 0x2B
#define H3LIS331DL_ACC_OUT_Z_L 0x2C
#define H3LIS331DL_ACC_OUT_Z_H 0x2D
#define H3LIS331DL_ACC_RANGE_100G (0x0)
#define H3LIS331DL_ACC_RANGE_200G (0x1)
#define H3LIS331DL_ACC_RANGE_400G (0x3)
#define H3LIS331DL_ACC_RANGE_MSK (0x30)
#define H3LIS331DL_ACC_RANGE_POS (4)
#define H3LIS331DL_ACC_SENSITIVITY_100G 49
#define H3LIS331DL_ACC_SENSITIVITY_200G 98
#define H3LIS331DL_ACC_SENSITIVITY_400G 195
#define H3LIS331DL_ACC_CHIP_ID_VALUE (0x32)
#define H3LIS331DL_SHIFT_EIGHT_BITS (8)
#define H3LIS331DL_SHIFT_FOUR_BITS (4)
#define H3LIS331DL_16_BIT_SHIFT (0xFF)
#define H3LIS331DL_ACC_MUL (1000)
#define H3LIS331DL_ACC_ODR_POWER_DOWN (0x00)
#define H3LIS331DL_ACC_ODR_0_5_HZ (0x40)
#define H3LIS331DL_ACC_ODR_1_HZ (0x60)
#define H3LIS331DL_ACC_ODR_2_HZ (0x80)
#define H3LIS331DL_ACC_ODR_5_HZ (0xA0)
#define H3LIS331DL_ACC_ODR_10_HZ (0xC0)
#define H3LIS331DL_ACC_ODR_50_HZ (0x20)
#define H3LIS331DL_ACC_ODR_100_HZ (0x28)
#define H3LIS331DL_ACC_ODR_400_HZ (0x30)
#define H3LIS331DL_ACC_ODR_1000_HZ (0x38)
#define H3LIS331DL_ACC_ODR_MSK (0xF8)
#define H3LIS331DL_ACC_ODR_POS (3)
#define H3LIS331DL_ACC_DEFAULT_ODR_100HZ (100)
#define H3LIS331DL_BDU_ENABLE (0x80)
#define H3LIS331DL_ACC_STATUS_ZYXDA (0x08)
#define H3LIS331DL_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define H3LIS331DL_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t h3lis331dl_acc_factor[ACC_RANGE_MAX] = { 0, 0, 0, 0, 0, 0, 0, H3LIS331DL_ACC_SENSITIVITY_100G, H3LIS331DL_ACC_SENSITIVITY_200G,
H3LIS331DL_ACC_SENSITIVITY_400G };
static int32_t cur_acc_factor = 0;
i2c_dev_t h3lis331dl_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = H3LIS331DL_I2C_ADDR,
};
static int drv_acc_st_h3lis331dl_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, H3LIS331DL_ACC_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
LOG("H3LIS331DL ID: %x\n", value);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_st_h3lis331dl_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, H3LIS331DL_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = H3LIS331DL_SET_BITSLICE(value,H3LIS331DL_ACC_ODR,H3LIS331DL_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, H3LIS331DL_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = H3LIS331DL_SET_BITSLICE(value,H3LIS331DL_ACC_ODR,H3LIS331DL_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, H3LIS331DL_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = H3LIS331DL_SET_BITSLICE(value,H3LIS331DL_ACC_ODR,H3LIS331DL_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, H3LIS331DL_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_acc_st_h3lis331dl_hz2odr(uint32_t hz)
{
if(hz > 400)
return H3LIS331DL_ACC_ODR_1000_HZ;
else if(hz > 100)
return H3LIS331DL_ACC_ODR_400_HZ;
else if(hz > 50)
return H3LIS331DL_ACC_ODR_100_HZ;
else if(hz > 10)
return H3LIS331DL_ACC_ODR_50_HZ;
else if(hz > 5)
return H3LIS331DL_ACC_ODR_10_HZ;
else if(hz > 2)
return H3LIS331DL_ACC_ODR_5_HZ;
else if(hz > 1)
return H3LIS331DL_ACC_ODR_2_HZ;
else
return H3LIS331DL_ACC_ODR_1_HZ;
}
static int drv_acc_st_h3lis331dl_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_h3lis331dl_hz2odr(hz);
ret = sensor_i2c_read(drv, H3LIS331DL_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = H3LIS331DL_SET_BITSLICE(value,H3LIS331DL_ACC_ODR,odr);
ret = sensor_i2c_write(drv, H3LIS331DL_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_h3lis331dl_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, H3LIS331DL_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_100G:{
tmp = H3LIS331DL_ACC_RANGE_100G;
}break;
case ACC_RANGE_200G:{
tmp = H3LIS331DL_ACC_RANGE_200G;
}break;
case ACC_RANGE_400G:{
tmp = H3LIS331DL_ACC_RANGE_400G;
}break;
default:break;
}
value = H3LIS331DL_SET_BITSLICE(value,H3LIS331DL_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, H3LIS331DL_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_100G)&&(range <= ACC_RANGE_400G)){
cur_acc_factor = h3lis331dl_acc_factor[range];
}
return 0;
}
static int drv_acc_st_h3lis331dl_set_bdu(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, H3LIS331DL_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= H3LIS331DL_BDU_ENABLE;
ret = sensor_i2c_write(drv, H3LIS331DL_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static void drv_acc_st_h3lis331dl_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_h3lis331dl_open(void)
{
int ret = 0;
ret = drv_acc_st_h3lis331dl_set_power_mode(&h3lis331dl_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_h3lis331dl_set_range(&h3lis331dl_ctx, ACC_RANGE_100G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_h3lis331dl_set_odr(&h3lis331dl_ctx, H3LIS331DL_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_h3lis331dl_close(void)
{
int ret = 0;
ret = drv_acc_st_h3lis331dl_set_power_mode(&h3lis331dl_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_h3lis331dl_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&h3lis331dl_ctx, (H3LIS331DL_ACC_OUT_X_L | 0x80), reg, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< H3LIS331DL_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] >> H3LIS331DL_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< H3LIS331DL_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] >> H3LIS331DL_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< H3LIS331DL_SHIFT_EIGHT_BITS)|(reg[4]));
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] >> H3LIS331DL_SHIFT_FOUR_BITS;
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] * cur_acc_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] * cur_acc_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] * cur_acc_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_h3lis331dl_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_h3lis331dl_set_odr(&h3lis331dl_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_st_h3lis331dl_set_range(&h3lis331dl_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_h3lis331dl_set_power_mode(&h3lis331dl_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
info->model = "H3LIS331DL";
info->range_max = 100;
info->range_min = 400;
info->unit = mg;
}break;
default:break;
}
return 0;
}
int drv_acc_st_h3lis331dl_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_h3lis331dl_open;
sensor.close = drv_acc_st_h3lis331dl_close;
sensor.read = drv_acc_st_h3lis331dl_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_h3lis331dl_ioctl;
sensor.irq_handle = drv_acc_st_h3lis331dl_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_h3lis331dl_validate_id(&h3lis331dl_ctx, H3LIS331DL_ACC_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_h3lis331dl_set_range(&h3lis331dl_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_h3lis331dl_set_bdu(&h3lis331dl_ctx);
if(unlikely(ret)){
return -1;
}
//set odr is 100hz, and will update
ret = drv_acc_st_h3lis331dl_set_odr(&h3lis331dl_ctx, H3LIS331DL_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_h3lis331dl_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_st_h3lis331dl.c
|
C
|
apache-2.0
| 12,179
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LIS2DH12_I2C_ADDR1 (0x18)
#define LIS2DH12_I2C_ADDR2 (0x19)
#define LIS2DH12_I2C_ADDR_TRANS(n) ((n)<<1)
#define LIS2DH12_I2C_ADDR LIS2DH12_I2C_ADDR_TRANS(LIS2DH12_I2C_ADDR2)
#define LIS2DH12_STATUS_REG_AUX 0x07
#define LIS2DH12_ACC_OUT_TEMP_L 0x0C
#define LIS2DH12_ACC_OUT_TEMP_H 0x0D
#define LIS2DH12_ACC_WHO_AM_I 0x0F
#define LIS2DH12_ACC_CTRL_REG0 0x1E
#define LIS2DH12_ACC_TEMP_CFG_REG 0x1F
#define LIS2DH12_ACC_CTRL_REG1 0x20
#define LIS2DH12_ACC_CTRL_REG2 0x21
#define LIS2DH12_ACC_CTRL_REG3 0x22
#define LIS2DH12_ACC_CTRL_REG4 0x23
#define LIS2DH12_ACC_CTRL_REG5 0x24
#define LIS2DH12_ACC_CTRL_REG6 0x25
#define LIS2DH12_ACC_REFERENCE 0x26
#define LIS2DH12_ACC_STATUS_REG 0x27
#define LIS2DH12_ACC_OUT_X_L 0x28
#define LIS2DH12_ACC_OUT_X_H 0x29
#define LIS2DH12_ACC_OUT_Y_L 0x2A
#define LIS2DH12_ACC_OUT_Y_H 0x2B
#define LIS2DH12_ACC_OUT_Z_L 0x2C
#define LIS2DH12_ACC_OUT_Z_H 0x2D
#define LIS2DH12_ACC_FIFO_CTRL_REG 0x2E
#define LIS2DH12_ACC_FIFO_SRC_REG 0x2F
#define LIS2DH12_ACC_INT1_CFG 0x30
#define LIS2DH12_ACC_INT1_SRC 0x31
#define LIS2DH12_ACC_INT1_THS 0x32
#define LIS2DH12_ACC_INT1_DURATION 0x33
#define LIS2DH12_ACC_INT2_CFG 0x34
#define LIS2DH12_ACC_INT2_SRC 0x35
#define LIS2DH12_ACC_INT2_THS 0x36
#define LIS2DH12_ACC_INT2_DURATION 0x37
#define LIS2DH12_ACC_CLICK_CFG 0x38
#define LIS2DH12_ACC_CLICK_SRC 0x39
#define LIS2DH12_ACC_CLICK_THS 0x3A
#define LIS2DH12_ACC_TIME_LIMIT 0x3B
#define LIS2DH12_ACC_TIME_LATENCY 0x3C
#define LIS2DH12_ACC_TIME_WINDOW 0x3D
#define LIS2DH12_ACC_ACT_THS 0x3E
#define LIS2DH12_ACC_ACT_DUR 0x3F
#define LIS2DH12_ACC_SELFTESTDISABLE (0x0)
#define LIS2DH12_ACC_SELFTESTENABLE (0x2)
#define LIS2DH12_ACC_SELFTEST_MSK (0x06)
#define LIS2DH12_ACC_SELFTEST_POS (2)
#define LIS2DH12_ACC_RANGE_2G (0x0)
#define LIS2DH12_ACC_RANGE_4G (0x1)
#define LIS2DH12_ACC_RANGE_8G (0x2)
#define LIS2DH12_ACC_RANGE_16G (0x3)
#define LIS2DH12_ACC_RANGE_MSK (0X30)
#define LIS2DH12_ACC_RANGE_POS (4)
#define LIS2DH12_ACC_SENSITIVITY_2G (1)
#define LIS2DH12_ACC_SENSITIVITY_4G (2)
#define LIS2DH12_ACC_SENSITIVITY_8G (4)
#define LIS2DH12_ACC_SENSITIVITY_16G (12)
#define LIS2DH12_ACC_CHIP_ID_VALUE (0x33)
#define LIS2DH12_SHIFT_EIGHT_BITS (8)
#define LIS2DH12_SHIFT_FOUR_BITS (4)
#define LIS2DH12_16_BIT_SHIFT (0xFF)
#define LIS2DH12_ACC_MUL (1000)
#define LIS2DH12_ACC_ODR_POWER_DOWN (0x00)
#define LIS2DH12_ACC_ODR_1_HZ (0x01)
#define LIS2DH12_ACC_ODR_10_HZ (0x02)
#define LIS2DH12_ACC_ODR_25_HZ (0x03)
#define LIS2DH12_ACC_ODR_50_HZ (0x04)
#define LIS2DH12_ACC_ODR_100_HZ (0x05)
#define LIS2DH12_ACC_ODR_200_HZ (0x06)
#define LIS2DH12_ACC_ODR_400_HZ (0x07)
#define LIS2DH12_ACC_ODR_1_62_KHZ (0x08)
#define LIS2DH12_ACC_ODR_5_376_KHZ (0x09)
#define LIS2DH12_ACC_ODR_1_344_HZ (0x09)
#define LIS2DH12_ACC_ODR_MSK (0XF0)
#define LIS2DH12_ACC_ODR_POS (4)
#define LIS2DH12_ACC_DEFAULT_ODR_100HZ (100)
#define LIS2DH12_BDU_ENABLE (0x80)
#define LIS2DH12_ACC_STATUS_ZYXDA (0x08)
#define LIS2DH12_DEFAULT_ODR_100HZ (100)
#define LIS2DH12_ACC_SELF_TEST_MIN_X (17 * 4) // 17 counts, per count 4mg
#define LIS2DH12_ACC_SELF_TEST_MIN_Y (17 * 4) // 17 counts, per count 4mg
#define LIS2DH12_ACC_SELF_TEST_MIN_Z (17 * 4) // 17 counts, per count 4mg
#define LIS2DH12_ACC_SELF_TEST_MAX_X (360 * 4) // 360 counts, per count 4mg
#define LIS2DH12_ACC_SELF_TEST_MAX_Y (360 * 4) // 360 counts, per count 4mg
#define LIS2DH12_ACC_SELF_TEST_MAX_Z (360 * 4) // 360 counts, per count 4mg
#define LIS2DH12_ACC_SELF_TEST_DRY_WAIT_CNT 5
#define LIS2DH12_ACC_SELF_TEST_AVG_SAMPLE_CNT 5
#define LIS2DH12_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define LIS2DH12_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t lis2dh12_acc_factor[ACC_RANGE_MAX] = { LIS2DH12_ACC_SENSITIVITY_2G, LIS2DH12_ACC_SENSITIVITY_4G,
LIS2DH12_ACC_SENSITIVITY_8G, LIS2DH12_ACC_SENSITIVITY_16G };
static int32_t cur_acc_factor = 0;
i2c_dev_t lis2dh12_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LIS2DH12_I2C_ADDR,
};
static int drv_acc_st_lis2dh12_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, LIS2DH12_ACC_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_st_lis2dh12_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LIS2DH12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LIS2DH12_SET_BITSLICE(value,LIS2DH12_ACC_ODR,LIS2DH12_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, LIS2DH12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LIS2DH12_SET_BITSLICE(value,LIS2DH12_ACC_ODR,LIS2DH12_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LIS2DH12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LIS2DH12_SET_BITSLICE(value,LIS2DH12_ACC_ODR,LIS2DH12_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, LIS2DH12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_acc_st_lis2dh12_hz2odr(uint32_t hz)
{
if(hz > 1620)
return LIS2DH12_ACC_ODR_5_376_KHZ;
else if(hz > 1344)
return LIS2DH12_ACC_ODR_1_62_KHZ;
else if(hz > 400)
return LIS2DH12_ACC_ODR_1_344_HZ;
else if(hz > 200)
return LIS2DH12_ACC_ODR_400_HZ;
else if(hz > 100)
return LIS2DH12_ACC_ODR_200_HZ;
else if(hz > 50)
return LIS2DH12_ACC_ODR_100_HZ;
else if(hz > 25)
return LIS2DH12_ACC_ODR_50_HZ;
else if(hz > 10)
return LIS2DH12_ACC_ODR_25_HZ;
else if(hz >= 1)
return LIS2DH12_ACC_ODR_10_HZ;
else
return LIS2DH12_ACC_ODR_1_HZ;
}
static int drv_acc_st_lis2dh12_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_lis2dh12_hz2odr(hz);
ret = sensor_i2c_read(drv, LIS2DH12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LIS2DH12_SET_BITSLICE(value,LIS2DH12_ACC_ODR,odr);
ret = sensor_i2c_write(drv, LIS2DH12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lis2dh12_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LIS2DH12_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_2G:{
tmp = LIS2DH12_ACC_RANGE_2G;
}break;
case ACC_RANGE_4G:{
tmp = LIS2DH12_ACC_RANGE_4G;
}break;
case ACC_RANGE_8G:{
tmp = LIS2DH12_ACC_RANGE_8G;
}break;
case ACC_RANGE_16G:{
tmp = LIS2DH12_ACC_RANGE_16G;
}break;
default:break;
}
value = LIS2DH12_SET_BITSLICE(value,LIS2DH12_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, LIS2DH12_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)){
cur_acc_factor = lis2dh12_acc_factor[range];
}
return 0;
}
static int drv_acc_st_lis2dh12_set_bdu(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LIS2DH12_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LIS2DH12_BDU_ENABLE;
ret = sensor_i2c_write(drv, LIS2DH12_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lis2dh12_st_discard(i2c_dev_t* drv)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
for (i = 0; i < LIS2DH12_ACC_SELF_TEST_DRY_WAIT_CNT; i ++) {
ret = sensor_i2c_read(drv, LIS2DH12_ACC_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x08)
break;
aos_msleep(20);
}
if (i >= LIS2DH12_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, (LIS2DH12_ACC_OUT_X_L | 0x80), buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
return ret;
}
static int drv_acc_st_lis2dh12_st_data(i2c_dev_t* drv,int32_t* data)
{
uint8_t i, j;
int16_t x_raw, y_raw, z_raw;
int32_t x_mg, y_mg, z_mg;
int32_t x_sum, y_sum, z_sum;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
x_sum = 0; y_sum = 0; z_sum = 0;
for (i = 0; i < LIS2DH12_ACC_SELF_TEST_AVG_SAMPLE_CNT; i ++) {
for (j = 0; j < LIS2DH12_ACC_SELF_TEST_DRY_WAIT_CNT; j ++) {
ret = sensor_i2c_read(drv, LIS2DH12_ACC_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x08)
break;
aos_msleep(20);
}
if (j >= LIS2DH12_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, (LIS2DH12_ACC_OUT_X_L | 0x80), buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
x_raw = (buffer[1] << 8) + buffer[0];
y_raw = (buffer[3] << 8) + buffer[2];
z_raw = (buffer[5] << 8) + buffer[4];
//LOG("%s %s %d: i(%d), raw(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_raw, y_raw, z_raw);
x_mg = x_raw >> 4;
y_mg = y_raw >> 4;
z_mg = z_raw >> 4;
//LOG("%s %s %d: i(%d), mg(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_mg, y_mg, z_mg);
x_sum += x_mg;
y_sum += y_mg;
z_sum += z_mg;
}
data[0] = x_sum / LIS2DH12_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[1] = y_sum / LIS2DH12_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[2] = z_sum / LIS2DH12_ACC_SELF_TEST_AVG_SAMPLE_CNT;
return ret;
}
static int drv_acc_st_lis2dh12_self_test(i2c_dev_t* drv,int32_t* data)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t ctrl_reg[4];
int32_t out_nost[3];
int32_t out_st[3];
int32_t out_diff[3];
// Save cfg registers which will be modified during self-test
ret = sensor_i2c_read(drv, (LIS2DH12_ACC_CTRL_REG1 | 0x80), ctrl_reg, 4, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
// Initialize Sensor, turn on sensor, enable X/Y/Z axes
// Set BDU=1, FS=2G, Normal mode, ODR = 50Hz
value = 0;
ret = sensor_i2c_write(drv, LIS2DH12_ACC_CTRL_REG2, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0;
ret = sensor_i2c_write(drv, LIS2DH12_ACC_CTRL_REG3, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0x80;
ret = sensor_i2c_write(drv, LIS2DH12_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0x47;
ret = sensor_i2c_write(drv, LIS2DH12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(90);
// Discard the first sample
ret = drv_acc_st_lis2dh12_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and averate them
ret = drv_acc_st_lis2dh12_st_data(drv, out_nost);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Enable seft-test
value = 0x82;
ret = sensor_i2c_write(drv, LIS2DH12_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(90);
// Discard the first sample
ret = drv_acc_st_lis2dh12_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and average them
ret = drv_acc_st_lis2dh12_st_data(drv, out_st);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Check if the differences are between min and max
for (i = 0; i < 3; i ++) {
out_diff[i] = abs(out_st[i] - out_nost[i]);
data[i] = out_diff[i];
}
if ((LIS2DH12_ACC_SELF_TEST_MIN_X > out_diff[0]) || (out_diff[0] > LIS2DH12_ACC_SELF_TEST_MAX_X)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LIS2DH12_ACC_SELF_TEST_MIN_Y > out_diff[1]) || (out_diff[1] > LIS2DH12_ACC_SELF_TEST_MAX_Y)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LIS2DH12_ACC_SELF_TEST_MIN_Z > out_diff[2]) || (out_diff[2] > LIS2DH12_ACC_SELF_TEST_MAX_Z)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
restore:
ret += sensor_i2c_write(drv, LIS2DH12_ACC_CTRL_REG1 | 0x80, ctrl_reg, 4, I2C_OP_RETRIES);
return ret;
}
static void drv_acc_st_lis2dh12_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_lis2dh12_open(void)
{
int ret = 0;
ret = drv_acc_st_lis2dh12_set_power_mode(&lis2dh12_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis2dh12_set_range(&lis2dh12_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis2dh12_set_odr(&lis2dh12_ctx, LIS2DH12_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lis2dh12_close(void)
{
int ret = 0;
ret = drv_acc_st_lis2dh12_set_power_mode(&lis2dh12_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lis2dh12_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lis2dh12_ctx, (LIS2DH12_ACC_OUT_X_L | 0x80), reg, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< LIS2DH12_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] >> LIS2DH12_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< LIS2DH12_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] >> LIS2DH12_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< LIS2DH12_SHIFT_EIGHT_BITS)|(reg[4]));
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] >> LIS2DH12_SHIFT_FOUR_BITS;
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] * cur_acc_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] * cur_acc_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] * cur_acc_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_lis2dh12_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_lis2dh12_set_odr(&lis2dh12_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_st_lis2dh12_set_range(&lis2dh12_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_lis2dh12_set_power_mode(&lis2dh12_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
info->model = "LIS2DH12";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}break;
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_acc_st_lis2dh12_self_test(&lis2dh12_ctx, (int32_t*)info->data);
//printf("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
LOG("%s %s: %d, %d, %d\n", SENSOR_STR, __func__, info->data[0],info->data[1],info->data[2]);
return ret;
}
default:break;
}
return 0;
}
int drv_acc_st_lis2dh12_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_lis2dh12_open;
sensor.close = drv_acc_st_lis2dh12_close;
sensor.read = drv_acc_st_lis2dh12_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_lis2dh12_ioctl;
sensor.irq_handle = drv_acc_st_lis2dh12_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis2dh12_validate_id(&lis2dh12_ctx, LIS2DH12_ACC_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis2dh12_set_range(&lis2dh12_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
//set odr is 100hz, and will update
ret = drv_acc_st_lis2dh12_set_odr(&lis2dh12_ctx, LIS2DH12_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
//set bdu
ret = drv_acc_st_lis2dh12_set_bdu(&lis2dh12_ctx);
if(unlikely(ret)){
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_lis2dh12_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_st_lis2dh12.c
|
C
|
apache-2.0
| 20,973
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LIS2DW12_I2C_ADDR1 (0x18)
#define LIS2DW12_I2C_ADDR2 (0x19)
#define LIS2DW12_I2C_ADDR_TRANS(n) ((n)<<1)
#define LIS2DW12_I2C_ADDR LIS2DW12_I2C_ADDR_TRANS(LIS2DW12_I2C_ADDR1)
#define LIS2DW12_STATUS_REG_AUX 0x07
#define LIS2DW12_ACC_OUT_TEMP_L 0x0C
#define LIS2DW12_ACC_OUT_TEMP_H 0x0D
#define LIS2DW12_ACC_WHO_AM_I 0x0F
#define LIS2DW12_ACC_CTRL_REG1 0x20
#define LIS2DW12_ACC_CTRL_REG2 0x21
#define LIS2DW12_ACC_CTRL_REG3 0x22
#define LIS2DW12_ACC_CTRL_REG4 0x23
#define LIS2DW12_ACC_CTRL_REG5 0x24
#define LIS2DW12_ACC_CTRL_REG6 0x25
#define LIS2DW12_ACC_OUTT_REG 0x26
#define LIS2DW12_ACC_STATUS_REG 0x27
#define LIS2DW12_ACC_OUT_X_L 0x28
#define LIS2DW12_ACC_OUT_X_H 0x29
#define LIS2DW12_ACC_OUT_Y_L 0x2A
#define LIS2DW12_ACC_OUT_Y_H 0x2B
#define LIS2DW12_ACC_OUT_Z_L 0x2C
#define LIS2DW12_ACC_OUT_Z_H 0x2D
#define LIS2DW12_ACC_FIFO_CTRL_REG 0x2E
#define LIS2DW12_ACC_FIFO_SRC_REG 0x2F
#define LIS2DW12_ACC_CTRL_REG7 0x3F
#define LIS2DW12_ACC_SELFTESTDISABLE (0x0)
#define LIS2DW12_ACC_SELFTESTENABLE (0x2)
#define LIS2DW12_ACC_SELFTEST_MSK (0xC0)
#define LIS2DW12_ACC_SELFTEST_POS (6)
#define LIS2DW12_ACC_RANGE_2G (0x0)
#define LIS2DW12_ACC_RANGE_4G (0x1)
#define LIS2DW12_ACC_RANGE_8G (0x2)
#define LIS2DW12_ACC_RANGE_16G (0x3)
#define LIS2DW12_ACC_RANGE_MSK (0X30)
#define LIS2DW12_ACC_RANGE_POS (4)
#define LIS2DW12_ACC_SENSITIVITY_2G (244)
#define LIS2DW12_ACC_SENSITIVITY_4G (488)
#define LIS2DW12_ACC_SENSITIVITY_8G (976)
#define LIS2DW12_ACC_SENSITIVITY_16G (1952)
#define LIS2DW12_ACC_CHIP_ID_VALUE (0x44)
#define LIS2DW12_SHIFT_EIGHT_BITS (8)
#define LIS2DW12_SHIFT_FOUR_BITS (4)
#define LIS2DW12_SHIFT_TWO_BITS (2)
#define LIS2DW12_16_BIT_SHIFT (0xFF)
#define LIS2DW12_ACC_MUL (1000)
#define LIS2DW12_ACC_ODR_POWER_DOWN (0x00)
#define LIS2DW12_ACC_ODR_1_6_HZ (0x01)
#define LIS2DW12_ACC_ODR_12_5_HZ (0x02)
#define LIS2DW12_ACC_ODR_25_HZ (0x03)
#define LIS2DW12_ACC_ODR_50_HZ (0x04)
#define LIS2DW12_ACC_ODR_100_HZ (0x05)
#define LIS2DW12_ACC_ODR_200_HZ (0x06)
#define LIS2DW12_ACC_ODR_400_HZ (0x07)
#define LIS2DW12_ACC_ODR_800_HZ (0x08)
#define LIS2DW12_ACC_ODR_1600_HZ (0x09)
#define LIS2DW12_ACC_ODR_MSK (0xF0)
#define LIS2DW12_ACC_ODR_POS (4)
#define LIS2DW12_ACC_HIGH_PERFORMANCE (0x04)
#define LIS2DW12_ACC_LOW_POWER_1 (0x00)
#define LIS2DW12_ACC_LOW_POWER_2 (0x01)
#define LIS2DW12_ACC_LOW_POWER_3 (0x02)
#define LIS2DW12_ACC_LOW_POWER_4 (0x03)
#define LIS2DW12_ACC_MODE_MSK (0x0F)
#define LIS2DW12_ACC_MODE_POS (0)
#define LIS2DW12_ACC_DEFAULT_ODR_100HZ (100)
#define LIS2DW12_BDU_ENABLE (0x08)
#define LIS2DW12_ACC_STATUS_ZYXDA (0x01)
#define LIS2DW12_DEFAULT_ODR_100HZ (100)
#define LIS2DW12_ACC_SELF_TEST_MIN_X (17 * 4) // 17 counts, per count 4mg
#define LIS2DW12_ACC_SELF_TEST_MIN_Y (17 * 4) // 17 counts, per count 4mg
#define LIS2DW12_ACC_SELF_TEST_MIN_Z (17 * 4) // 17 counts, per count 4mg
#define LIS2DW12_ACC_SELF_TEST_MAX_X (375 * 4) // 375 counts, per count 4mg
#define LIS2DW12_ACC_SELF_TEST_MAX_Y (375 * 4) // 375 counts, per count 4mg
#define LIS2DW12_ACC_SELF_TEST_MAX_Z (375 * 4) // 375 counts, per count 4mg
#define LIS2DW12_ACC_SELF_TEST_DRY_WAIT_CNT 5
#define LIS2DW12_ACC_SELF_TEST_AVG_SAMPLE_CNT 5
#define LIS2DW12_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define LIS2DW12_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t lis2dw12_acc_factor[ACC_RANGE_MAX] = { LIS2DW12_ACC_SENSITIVITY_2G, LIS2DW12_ACC_SENSITIVITY_4G,
LIS2DW12_ACC_SENSITIVITY_8G, LIS2DW12_ACC_SENSITIVITY_16G };
static int32_t cur_acc_factor = 0;
i2c_dev_t lis2dw12_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LIS2DW12_I2C_ADDR,
};
static int drv_acc_st_lis2dw12_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, LIS2DW12_ACC_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_st_lis2dw12_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LIS2DW12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LIS2DW12_SET_BITSLICE(value,LIS2DW12_ACC_ODR,LIS2DW12_ACC_ODR_12_5_HZ);
value = LIS2DW12_SET_BITSLICE(value,LIS2DW12_ACC_MODE,LIS2DW12_ACC_HIGH_PERFORMANCE);
ret = sensor_i2c_write(drv, LIS2DW12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LIS2DW12_SET_BITSLICE(value,LIS2DW12_ACC_ODR,LIS2DW12_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LIS2DW12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LIS2DW12_SET_BITSLICE(value,LIS2DW12_ACC_ODR,LIS2DW12_ACC_ODR_1_6_HZ);
value = LIS2DW12_SET_BITSLICE(value,LIS2DW12_ACC_MODE,LIS2DW12_ACC_LOW_POWER_1);
ret = sensor_i2c_write(drv, LIS2DW12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_acc_st_lis2dw12_hz2odr(uint32_t hz)
{
if(hz > 800)
return LIS2DW12_ACC_ODR_1600_HZ;
else if(hz > 400)
return LIS2DW12_ACC_ODR_800_HZ;
else if(hz > 200)
return LIS2DW12_ACC_ODR_400_HZ;
else if(hz > 100)
return LIS2DW12_ACC_ODR_200_HZ;
else if(hz > 50)
return LIS2DW12_ACC_ODR_100_HZ;
else if(hz > 25)
return LIS2DW12_ACC_ODR_50_HZ;
else if(hz > 13)
return LIS2DW12_ACC_ODR_25_HZ;
else if(hz >= 1)
return LIS2DW12_ACC_ODR_12_5_HZ;
else
return LIS2DW12_ACC_ODR_1_6_HZ;
}
static int drv_acc_st_lis2dw12_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_lis2dw12_hz2odr(hz);
ret = sensor_i2c_read(drv, LIS2DW12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LIS2DW12_SET_BITSLICE(value,LIS2DW12_ACC_ODR,odr);
ret = sensor_i2c_write(drv, LIS2DW12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lis2dw12_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LIS2DW12_ACC_CTRL_REG6, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_2G:{
tmp = LIS2DW12_ACC_RANGE_2G;
}break;
case ACC_RANGE_4G:{
tmp = LIS2DW12_ACC_RANGE_4G;
}break;
case ACC_RANGE_8G:{
tmp = LIS2DW12_ACC_RANGE_8G;
}break;
case ACC_RANGE_16G:{
tmp = LIS2DW12_ACC_RANGE_16G;
}break;
default:break;
}
value = LIS2DW12_SET_BITSLICE(value,LIS2DW12_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, LIS2DW12_ACC_CTRL_REG6, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)){
cur_acc_factor = lis2dw12_acc_factor[range];
}
return 0;
}
static int drv_acc_st_lis2dw12_set_bdu(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LIS2DW12_ACC_CTRL_REG2, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LIS2DW12_BDU_ENABLE;
ret = sensor_i2c_write(drv, LIS2DW12_ACC_CTRL_REG2, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lis2dw12_st_discard(i2c_dev_t* drv)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
for (i = 0; i < LIS2DW12_ACC_SELF_TEST_DRY_WAIT_CNT; i ++) {
ret = sensor_i2c_read(drv, LIS2DW12_ACC_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x01)
break;
aos_msleep(20);
}
if (i >= LIS2DW12_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, (LIS2DW12_ACC_OUT_X_L | 0x80), buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
return ret;
}
static int drv_acc_st_lis2dw12_st_data(i2c_dev_t* drv,int32_t* data)
{
uint8_t i, j;
int16_t x_raw, y_raw, z_raw;
int32_t x_mg, y_mg, z_mg;
int32_t x_sum, y_sum, z_sum;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
x_sum = 0; y_sum = 0; z_sum = 0;
for (i = 0; i < LIS2DW12_ACC_SELF_TEST_AVG_SAMPLE_CNT; i ++) {
for (j = 0; j < LIS2DW12_ACC_SELF_TEST_DRY_WAIT_CNT; j ++) {
ret = sensor_i2c_read(drv, LIS2DW12_ACC_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x08)
break;
aos_msleep(20);
}
if (j >= LIS2DW12_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, (LIS2DW12_ACC_OUT_X_L | 0x80), buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
x_raw = (buffer[1] << 8) + buffer[0];
y_raw = (buffer[3] << 8) + buffer[2];
z_raw = (buffer[5] << 8) + buffer[4];
//LOG("%s %s %d: i(%d), raw(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_raw, y_raw, z_raw);
x_mg = x_raw >> 4;
y_mg = y_raw >> 4;
z_mg = z_raw >> 4;
//LOG("%s %s %d: i(%d), mg(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_mg, y_mg, z_mg);
x_sum += x_mg;
y_sum += y_mg;
z_sum += z_mg;
}
data[0] = x_sum / LIS2DW12_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[1] = y_sum / LIS2DW12_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[2] = z_sum / LIS2DW12_ACC_SELF_TEST_AVG_SAMPLE_CNT;
return ret;
}
static int drv_acc_st_lis2dw12_self_test(i2c_dev_t* drv,int32_t* data)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t ctrl_reg[6];
int32_t out_nost[3];
int32_t out_st[3];
int32_t out_diff[3];
// Save cfg registers which will be modified during self-test
ret = sensor_i2c_read(drv, (LIS2DW12_ACC_CTRL_REG1 | 0x80), ctrl_reg, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
// Initialize Sensor, turn on sensor, enable X/Y/Z axes
// Set BDU=1, FS=4G, High-Performance mode, ODR = 50Hz
value = 0x08;
ret = sensor_i2c_write(drv, LIS2DW12_ACC_CTRL_REG2, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0x00;
ret = sensor_i2c_write(drv, LIS2DW12_ACC_CTRL_REG3, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0x00;
ret = sensor_i2c_write(drv, LIS2DW12_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0x00;
ret = sensor_i2c_write(drv, LIS2DW12_ACC_CTRL_REG5, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0x10;
ret = sensor_i2c_write(drv, LIS2DW12_ACC_CTRL_REG6, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0x44;
ret = sensor_i2c_write(drv, LIS2DW12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(100);
// Discard the first sample
ret = drv_acc_st_lis2dw12_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and averate them
ret = drv_acc_st_lis2dw12_st_data(drv, out_nost);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Enable seft-test
value = 0x40;
ret = sensor_i2c_write(drv, LIS2DW12_ACC_CTRL_REG3, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(100);
// Discard the first sample
ret = drv_acc_st_lis2dw12_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and average them
ret = drv_acc_st_lis2dw12_st_data(drv, out_st);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Check if the differences are between min and max
for (i = 0; i < 3; i ++) {
out_diff[i] = abs(out_st[i] - out_nost[i]);
data[i] = out_diff[i];
}
if ((LIS2DW12_ACC_SELF_TEST_MIN_X > out_diff[0]) || (out_diff[0] > LIS2DW12_ACC_SELF_TEST_MAX_X)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LIS2DW12_ACC_SELF_TEST_MIN_Y > out_diff[1]) || (out_diff[1] > LIS2DW12_ACC_SELF_TEST_MAX_Y)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LIS2DW12_ACC_SELF_TEST_MIN_Z > out_diff[2]) || (out_diff[2] > LIS2DW12_ACC_SELF_TEST_MAX_Z)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
restore:
ret += sensor_i2c_write(drv, LIS2DW12_ACC_CTRL_REG1 | 0x80, ctrl_reg, 6, I2C_OP_RETRIES);
return ret;
}
static void drv_acc_st_lis2dw12_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_lis2dw12_open(void)
{
int ret = 0;
ret = drv_acc_st_lis2dw12_set_power_mode(&lis2dw12_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis2dw12_set_range(&lis2dw12_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis2dw12_set_odr(&lis2dw12_ctx, LIS2DW12_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lis2dw12_close(void)
{
int ret = 0;
ret = drv_acc_st_lis2dw12_set_power_mode(&lis2dw12_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lis2dw12_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lis2dw12_ctx, (LIS2DW12_ACC_OUT_X_L | 0x80), reg, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< LIS2DW12_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] >> LIS2DW12_SHIFT_TWO_BITS;
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< LIS2DW12_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] >> LIS2DW12_SHIFT_TWO_BITS;
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< LIS2DW12_SHIFT_EIGHT_BITS)|(reg[4]));
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] >> LIS2DW12_SHIFT_TWO_BITS;
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] * cur_acc_factor / LIS2DW12_ACC_MUL;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] * cur_acc_factor / LIS2DW12_ACC_MUL;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] * cur_acc_factor / LIS2DW12_ACC_MUL;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_lis2dw12_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_lis2dw12_set_odr(&lis2dw12_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_st_lis2dw12_set_range(&lis2dw12_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_lis2dw12_set_power_mode(&lis2dw12_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
info->model = "LIS2DW12";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}break;
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_acc_st_lis2dw12_self_test(&lis2dw12_ctx, (int32_t*)info->data);
//printf("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
LOG("%s %s: %d, %d, %d\n", SENSOR_STR, __func__, info->data[0],info->data[1],info->data[2]);
return ret;
}
default:break;
}
return 0;
}
int drv_acc_st_lis2dw12_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_lis2dw12_open;
sensor.close = drv_acc_st_lis2dw12_close;
sensor.read = drv_acc_st_lis2dw12_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_lis2dw12_ioctl;
sensor.irq_handle = drv_acc_st_lis2dw12_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis2dw12_validate_id(&lis2dw12_ctx, LIS2DW12_ACC_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis2dw12_set_range(&lis2dw12_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
//set odr is 100hz, and will update
ret = drv_acc_st_lis2dw12_set_odr(&lis2dw12_ctx, LIS2DW12_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
//set bdu
ret = drv_acc_st_lis2dw12_set_bdu(&lis2dw12_ctx);
if(unlikely(ret)){
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_lis2dw12_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_st_lis2dw12.c
|
C
|
apache-2.0
| 21,125
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LIS2HH12_I2C_ADDR1 (0x1E)
#define LIS2HH12_I2C_ADDR2 (0x1D)
#define LIS2HH12_I2C_ADDR_TRANS(n) ((n)<<1)
#define LIS2HH12_I2C_ADDR LIS2HH12_I2C_ADDR_TRANS(LIS2HH12_I2C_ADDR2)
#define LIS2HH12_ACC_TEMP_L 0x0B
#define LIS2HH12_ACC_TEMP_H 0x0C
#define LIS2HH12_ACC_WHO_AM_I 0x0F
#define LIS2HH12_ACC_ACT_THS 0x1E
#define LIS2HH12_ACC_ACT_DUR 0x1F
#define LIS2HH12_ACC_CTRL_REG1 0x20
#define LIS2HH12_ACC_CTRL_REG2 0x21
#define LIS2HH12_ACC_CTRL_REG3 0x22
#define LIS2HH12_ACC_CTRL_REG4 0x23
#define LIS2HH12_ACC_CTRL_REG5 0x24
#define LIS2HH12_ACC_CTRL_REG6 0x25
#define LIS2HH12_ACC_CTRL_REG7 0x26
#define LIS2HH12_ACC_STATUS_REG 0x27
#define LIS2HH12_ACC_OUT_X_L 0x28
#define LIS2HH12_ACC_OUT_X_H 0x29
#define LIS2HH12_ACC_OUT_Y_L 0x2A
#define LIS2HH12_ACC_OUT_Y_H 0x2B
#define LIS2HH12_ACC_OUT_Z_L 0x2C
#define LIS2HH12_ACC_OUT_Z_H 0x2D
#define LIS2HH12_ACC_RANGE_2G (0x0)
#define LIS2HH12_ACC_RANGE_4G (0x2)
#define LIS2HH12_ACC_RANGE_8G (0x3)
#define LIS2HH12_ACC_RANGE_MSK (0x30)
#define LIS2HH12_ACC_RANGE_POS (4)
#define LIS2HH12_ACC_SENSITIVITY_2G (61)
#define LIS2HH12_ACC_SENSITIVITY_4G (122)
#define LIS2HH12_ACC_SENSITIVITY_8G (244)
#define LIS2HH12_ACC_CHIP_ID_VALUE (0x41)
#define LIS2HH12_SHIFT_EIGHT_BITS (8)
#define LIS2HH12_SHIFT_FOUR_BITS (4)
#define LIS2HH12_16_BIT_SHIFT (0xFF)
#define LIS2HH12_ACC_ODR_POWER_DOWN (0x00)
#define LIS2HH12_ACC_ODR_10_HZ (0x01)
#define LIS2HH12_ACC_ODR_50_HZ (0x02)
#define LIS2HH12_ACC_ODR_100_HZ (0x03)
#define LIS2HH12_ACC_ODR_200_HZ (0x04)
#define LIS2HH12_ACC_ODR_400_HZ (0x05)
#define LIS2HH12_ACC_ODR_800_HZ (0x06)
#define LIS2HH12_ACC_ODR_MSK (0X70)
#define LIS2HH12_ACC_ODR_POS (4)
#define LIS2HH12_ENABLE_SOFT_RESET_VALUE (0x40)
#define LIS2HH12_ACC_DEFAULT_ODR_100HZ (100)
#define LIS2HH12_BDU_ENABLE (0x08)
#define LIS2HH12_ACC_STATUS_ZYXDA (0x08)
#define LIS2HH12_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define LIS2HH12_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t lis2hh12_acc_factor[ACC_RANGE_MAX] = { LIS2HH12_ACC_SENSITIVITY_2G, LIS2HH12_ACC_SENSITIVITY_4G,
LIS2HH12_ACC_SENSITIVITY_8G};
static int32_t cur_acc_factor = 0;
i2c_dev_t lis2hh12_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LIS2HH12_I2C_ADDR,
};
static int drv_acc_st_lis2hh12_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = LIS2HH12_ENABLE_SOFT_RESET_VALUE;
ret = sensor_i2c_write(drv, LIS2HH12_ACC_CTRL_REG5, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lis2hh12_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
aos_msleep(20);
ret = sensor_i2c_read(drv, LIS2HH12_ACC_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_st_lis2hh12_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LIS2HH12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LIS2HH12_SET_BITSLICE(value,LIS2HH12_ACC_ODR,LIS2HH12_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, LIS2HH12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LIS2HH12_SET_BITSLICE(value,LIS2HH12_ACC_ODR,LIS2HH12_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LIS2HH12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LIS2HH12_SET_BITSLICE(value,LIS2HH12_ACC_ODR,LIS2HH12_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, LIS2HH12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_acc_st_lis2hh12_hz2odr(uint32_t hz)
{
if(hz > 400)
return LIS2HH12_ACC_ODR_800_HZ;
else if(hz > 200)
return LIS2HH12_ACC_ODR_400_HZ;
else if(hz > 100)
return LIS2HH12_ACC_ODR_200_HZ;
else if(hz > 50)
return LIS2HH12_ACC_ODR_100_HZ;
else if(hz > 10)
return LIS2HH12_ACC_ODR_50_HZ;
else
return LIS2HH12_ACC_ODR_10_HZ;
}
static int drv_acc_st_lis2hh12_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_lis2hh12_hz2odr(hz);
ret = sensor_i2c_read(drv, LIS2HH12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LIS2HH12_SET_BITSLICE(value,LIS2HH12_ACC_ODR,odr);
ret = sensor_i2c_write(drv, LIS2HH12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lis2hh12_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LIS2HH12_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_2G:{
tmp = LIS2HH12_ACC_RANGE_2G;
}break;
case ACC_RANGE_4G:{
tmp = LIS2HH12_ACC_RANGE_4G;
}break;
case ACC_RANGE_8G:{
tmp = LIS2HH12_ACC_RANGE_8G;
}break;
default:break;
}
value = LIS2HH12_SET_BITSLICE(value,LIS2HH12_ACC_RANGE,tmp);
LOG("LIS2HH12 SetRang %2x:0x%2x\n", range, value);
ret = sensor_i2c_write(drv, LIS2HH12_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_8G)){
cur_acc_factor = lis2hh12_acc_factor[range];
}
return 0;
}
static int drv_acc_st_lis2hh12_set_bdu(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LIS2HH12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LIS2HH12_BDU_ENABLE;
ret = sensor_i2c_write(drv, LIS2HH12_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static void drv_acc_st_lis2hh12_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_lis2hh12_open(void)
{
int ret = 0;
ret = drv_acc_st_lis2hh12_set_power_mode(&lis2hh12_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis2hh12_set_range(&lis2hh12_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis2hh12_set_odr(&lis2hh12_ctx, LIS2HH12_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lis2hh12_close(void)
{
int ret = 0;
ret = drv_acc_st_lis2hh12_set_power_mode(&lis2hh12_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lis2hh12_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lis2hh12_ctx, (LIS2HH12_ACC_OUT_X_L | 0x80), reg, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< LIS2HH12_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< LIS2HH12_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< LIS2HH12_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] * cur_acc_factor / 1000;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] * cur_acc_factor / 1000;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] * cur_acc_factor / 1000;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_lis2hh12_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_lis2hh12_set_odr(&lis2hh12_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_st_lis2hh12_set_range(&lis2hh12_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_lis2hh12_set_power_mode(&lis2hh12_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
info->model = "LIS2HH12";
info->range_max = 8;
info->range_min = 2;
info->unit = mg;
}break;
default:break;
}
return 0;
}
int drv_acc_st_lis2hh12_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_lis2hh12_open;
sensor.close = drv_acc_st_lis2hh12_close;
sensor.read = drv_acc_st_lis2hh12_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_lis2hh12_ioctl;
sensor.irq_handle = drv_acc_st_lis2hh12_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis2hh12_validate_id(&lis2hh12_ctx, LIS2HH12_ACC_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis2hh12_soft_reset(&lis2hh12_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis2hh12_set_range(&lis2hh12_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis2hh12_set_bdu(&lis2hh12_ctx);
if(unlikely(ret)){
return -1;
}
//set odr is 100hz, and will update
ret = drv_acc_st_lis2hh12_set_odr(&lis2hh12_ctx, LIS2HH12_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_lis2hh12_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_st_lis2hh12.c
|
C
|
apache-2.0
| 11,900
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LIS331HH_I2C_ADDR1 (0x18)
#define LIS331HH_I2C_ADDR2 (0x19)
#define LIS331HH_I2C_ADDR_TRANS(n) ((n)<<1)
#define LIS331HH_I2C_ADDR LIS331HH_I2C_ADDR_TRANS(LIS331HH_I2C_ADDR1)
#define LIS331HH_ACC_WHO_AM_I 0x0F
#define LIS331HH_ACC_CTRL_REG1 0x20
#define LIS331HH_ACC_CTRL_REG2 0x21
#define LIS331HH_ACC_CTRL_REG3 0x22
#define LIS331HH_ACC_CTRL_REG4 0x23
#define LIS331HH_ACC_CTRL_REG5 0x24
#define LIS331HH_ACC_STATUS_REG 0x27
#define LIS331HH_ACC_OUT_X_L 0x28
#define LIS331HH_ACC_OUT_X_H 0x29
#define LIS331HH_ACC_OUT_Y_L 0x2A
#define LIS331HH_ACC_OUT_Y_H 0x2B
#define LIS331HH_ACC_OUT_Z_L 0x2C
#define LIS331HH_ACC_OUT_Z_H 0x2D
#define LIS331HH_ACC_RANGE_6G (0x0)
#define LIS331HH_ACC_RANGE_12G (0x1)
#define LIS331HH_ACC_RANGE_24G (0x3)
#define LIS331HH_ACC_RANGE_MSK (0x30)
#define LIS331HH_ACC_RANGE_POS (4)
#define LIS331HH_ACC_SENSITIVITY_6G 3
#define LIS331HH_ACC_SENSITIVITY_12G 6
#define LIS331HH_ACC_SENSITIVITY_24G 12
#define LIS331HH_SHIFT_EIGHT_BITS (8)
#define LIS331HH_SHIFT_FOUR_BITS (4)
#define LIS331HH_16_BIT_SHIFT (0xFF)
#define LIS331HH_ACC_ODR_POWER_DOWN (0x00)
#define LIS331HH_ACC_ODR_0_5_HZ (0x40)
#define LIS331HH_ACC_ODR_1_HZ (0x60)
#define LIS331HH_ACC_ODR_2_HZ (0x80)
#define LIS331HH_ACC_ODR_5_HZ (0xA0)
#define LIS331HH_ACC_ODR_10_HZ (0xC0)
#define LIS331HH_ACC_ODR_50_HZ (0x20)
#define LIS331HH_ACC_ODR_100_HZ (0x28)
#define LIS331HH_ACC_ODR_400_HZ (0x30)
#define LIS331HH_ACC_ODR_1000_HZ (0x38)
#define LIS331HH_ACC_ODR_MSK (0xF8)
#define LIS331HH_ACC_ODR_POS (3)
#define LIS331HH_ACC_DEFAULT_ODR_100HZ (100)
#define LIS331HH_BDU_ENABLE (0x80)
#define LIS331HH_ACC_STATUS_ZYXDA (0x08)
#define LIS331HH_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define LIS331HH_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t lis331hh_acc_factor[ACC_RANGE_MAX] = {0, 0, 0, 0, LIS331HH_ACC_SENSITIVITY_6G,
LIS331HH_ACC_SENSITIVITY_12G, LIS331HH_ACC_SENSITIVITY_24G };
static int32_t cur_acc_factor = 0;
i2c_dev_t lis331hh_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LIS331HH_I2C_ADDR,
};
static int drv_acc_st_lis331hh_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LIS331HH_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LIS331HH_SET_BITSLICE(value,LIS331HH_ACC_ODR,LIS331HH_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, LIS331HH_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LIS331HH_SET_BITSLICE(value,LIS331HH_ACC_ODR,LIS331HH_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LIS331HH_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LIS331HH_SET_BITSLICE(value,LIS331HH_ACC_ODR,LIS331HH_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, LIS331HH_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_acc_st_lis331hh_hz2odr(uint32_t hz)
{
if(hz > 400)
return LIS331HH_ACC_ODR_1000_HZ;
else if(hz > 100)
return LIS331HH_ACC_ODR_400_HZ;
else if(hz > 50)
return LIS331HH_ACC_ODR_100_HZ;
else if(hz > 10)
return LIS331HH_ACC_ODR_50_HZ;
else if(hz > 5)
return LIS331HH_ACC_ODR_10_HZ;
else if(hz > 2)
return LIS331HH_ACC_ODR_5_HZ;
else if(hz > 1)
return LIS331HH_ACC_ODR_2_HZ;
else
return LIS331HH_ACC_ODR_1_HZ;
}
static int drv_acc_st_lis331hh_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_lis331hh_hz2odr(hz);
ret = sensor_i2c_read(drv, LIS331HH_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LIS331HH_SET_BITSLICE(value,LIS331HH_ACC_ODR,odr);
ret = sensor_i2c_write(drv, LIS331HH_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lis331hh_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LIS331HH_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_6G:{
tmp = LIS331HH_ACC_RANGE_6G;
}break;
case ACC_RANGE_12G:{
tmp = LIS331HH_ACC_RANGE_12G;
}break;
case ACC_RANGE_24G:{
tmp = LIS331HH_ACC_RANGE_24G;
}break;
default:break;
}
value = LIS331HH_SET_BITSLICE(value,LIS331HH_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, LIS331HH_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_6G)&&(range <= ACC_RANGE_24G)){
cur_acc_factor = lis331hh_acc_factor[range];
}
return 0;
}
static int drv_acc_st_lis331hh_set_bdu(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LIS331HH_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LIS331HH_BDU_ENABLE;
ret = sensor_i2c_write(drv, LIS331HH_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static void drv_acc_st_lis331hh_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_lis331hh_open(void)
{
int ret = 0;
ret = drv_acc_st_lis331hh_set_power_mode(&lis331hh_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis331hh_set_range(&lis331hh_ctx, ACC_RANGE_6G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis331hh_set_odr(&lis331hh_ctx, LIS331HH_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lis331hh_close(void)
{
int ret = 0;
ret = drv_acc_st_lis331hh_set_power_mode(&lis331hh_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lis331hh_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lis331hh_ctx, (LIS331HH_ACC_OUT_X_L | 0x80), reg, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< LIS331HH_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] >> LIS331HH_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< LIS331HH_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] >> LIS331HH_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< LIS331HH_SHIFT_EIGHT_BITS)|(reg[4]));
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] >> LIS331HH_SHIFT_FOUR_BITS;
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] * cur_acc_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] * cur_acc_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] * cur_acc_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_lis331hh_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_lis331hh_set_odr(&lis331hh_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_st_lis331hh_set_range(&lis331hh_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_lis331hh_set_power_mode(&lis331hh_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
info->model = "LIS331HH";
info->range_max = 24;
info->range_min = 6;
info->unit = mg;
}break;
default:break;
}
return 0;
}
int drv_acc_st_lis331hh_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_lis331hh_open;
sensor.close = drv_acc_st_lis331hh_close;
sensor.read = drv_acc_st_lis331hh_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_lis331hh_ioctl;
sensor.irq_handle = drv_acc_st_lis331hh_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis331hh_set_range(&lis331hh_ctx, ACC_RANGE_6G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis331hh_set_bdu(&lis331hh_ctx);
if(unlikely(ret)){
return -1;
}
//set odr is 100hz, and will update
ret = drv_acc_st_lis331hh_set_odr(&lis331hh_ctx, LIS331HH_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_lis331hh_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_st_lis331hh.c
|
C
|
apache-2.0
| 10,949
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LIS3DH_I2C_ADDR1 (0x18)
#define LIS3DH_I2C_ADDR2 (0x19)
#define LIS3DH_I2C_ADDR_TRANS(n) ((n)<<1)
#define LIS3DH_I2C_ADDR LIS3DH_I2C_ADDR_TRANS(LIS3DH_I2C_ADDR2)
#define LIS3DH_STATUS_REG_AUX 0x07
#define LIS3DH_ACC_OUT_TEMP_L 0x0C
#define LIS3DH_ACC_OUT_TEMP_H 0x0D
#define LIS3DH_ACC_WHO_AM_I 0x0F
#define LIS3DH_ACC_CTRL_REG0 0x1E
#define LIS3DH_ACC_TEMP_CFG_REG 0x1F
#define LIS3DH_ACC_CTRL_REG1 0x20
#define LIS3DH_ACC_CTRL_REG2 0x21
#define LIS3DH_ACC_CTRL_REG3 0x22
#define LIS3DH_ACC_CTRL_REG4 0x23
#define LIS3DH_ACC_CTRL_REG5 0x24
#define LIS3DH_ACC_CTRL_REG6 0x25
#define LIS3DH_ACC_REFERENCE 0x26
#define LIS3DH_ACC_STATUS_REG 0x27
#define LIS3DH_ACC_OUT_X_L 0x28
#define LIS3DH_ACC_OUT_X_H 0x29
#define LIS3DH_ACC_OUT_Y_L 0x2A
#define LIS3DH_ACC_OUT_Y_H 0x2B
#define LIS3DH_ACC_OUT_Z_L 0x2C
#define LIS3DH_ACC_OUT_Z_H 0x2D
#define LIS3DH_ACC_FIFO_CTRL_REG 0x2E
#define LIS3DH_ACC_FIFO_SRC_REG 0x2F
#define LIS3DH_ACC_INT1_CFG 0x30
#define LIS3DH_ACC_INT1_SRC 0x31
#define LIS3DH_ACC_INT1_THS 0x32
#define LIS3DH_ACC_INT1_DURATION 0x33
#define LIS3DH_ACC_INT2_CFG 0x34
#define LIS3DH_ACC_INT2_SRC 0x35
#define LIS3DH_ACC_INT2_THS 0x36
#define LIS3DH_ACC_INT2_DURATION 0x37
#define LIS3DH_ACC_CLICK_CFG 0x38
#define LIS3DH_ACC_CLICK_SRC 0x39
#define LIS3DH_ACC_CLICK_THS 0x3A
#define LIS3DH_ACC_TIME_LIMIT 0x3B
#define LIS3DH_ACC_TIME_LATENCY 0x3C
#define LIS3DH_ACC_TIME_WINDOW 0x3D
#define LIS3DH_ACC_ACT_THS 0x3E
#define LIS3DH_ACC_ACT_DUR 0x3F
#define LIS3DH_ACC_SELFTESTDISABLE (0x0)
#define LIS3DH_ACC_SELFTESTENABLE (0x2)
#define LIS3DH_ACC_SELFTEST_MSK (0x06)
#define LIS3DH_ACC_SELFTEST_POS (2)
#define LIS3DH_ACC_RANGE_2G (0x0)
#define LIS3DH_ACC_RANGE_4G (0x1)
#define LIS3DH_ACC_RANGE_8G (0x2)
#define LIS3DH_ACC_RANGE_16G (0x3)
#define LIS3DH_ACC_RANGE_MSK (0X30)
#define LIS3DH_ACC_RANGE_POS (4)
#define LIS3DH_ACC_SENSITIVITY_2G (1)
#define LIS3DH_ACC_SENSITIVITY_4G (2)
#define LIS3DH_ACC_SENSITIVITY_8G (4)
#define LIS3DH_ACC_SENSITIVITY_16G (12)
#define LIS3DH_ACC_CHIP_ID_VALUE (0x33)
#define LIS3DH_SHIFT_EIGHT_BITS (8)
#define LIS3DH_SHIFT_FOUR_BITS (4)
#define LIS3DH_16_BIT_SHIFT (0xFF)
#define LIS3DH_ACC_MUL (1000)
#define LIS3DH_ACC_ODR_POWER_DOWN (0x00)
#define LIS3DH_ACC_ODR_1_HZ (0x01)
#define LIS3DH_ACC_ODR_10_HZ (0x02)
#define LIS3DH_ACC_ODR_25_HZ (0x03)
#define LIS3DH_ACC_ODR_50_HZ (0x04)
#define LIS3DH_ACC_ODR_100_HZ (0x05)
#define LIS3DH_ACC_ODR_200_HZ (0x06)
#define LIS3DH_ACC_ODR_400_HZ (0x07)
#define LIS3DH_ACC_ODR_1_62_KHZ (0x08)
#define LIS3DH_ACC_ODR_5_376_KHZ (0x09)
#define LIS3DH_ACC_ODR_1_344_HZ (0x09)
#define LIS3DH_ACC_ODR_MSK (0XF0)
#define LIS3DH_ACC_ODR_POS (4)
#define LIS3DH_ACC_DEFAULT_ODR_100HZ (100)
#define LIS3DH_BDU_ENABLE (0x80)
#define LIS3DH_ACC_STATUS_ZYXDA (0x08)
#define LIS3DH_DEFAULT_ODR_100HZ (100)
#define LIS3DH_ACC_SELF_TEST_MIN_X (17 * 4) // 17 counts, per count 4mg
#define LIS3DH_ACC_SELF_TEST_MIN_Y (17 * 4) // 17 counts, per count 4mg
#define LIS3DH_ACC_SELF_TEST_MIN_Z (17 * 4) // 17 counts, per count 4mg
#define LIS3DH_ACC_SELF_TEST_MAX_X (360 * 4) // 360 counts, per count 4mg
#define LIS3DH_ACC_SELF_TEST_MAX_Y (360 * 4) // 360 counts, per count 4mg
#define LIS3DH_ACC_SELF_TEST_MAX_Z (360 * 4) // 360 counts, per count 4mg
#define LIS3DH_ACC_SELF_TEST_DRY_WAIT_CNT 5
#define LIS3DH_ACC_SELF_TEST_AVG_SAMPLE_CNT 5
#define LIS3DH_DEFAULT_ODR_100HZ (100)
#define LIS3DH_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define LIS3DH_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t lis3dh_acc_factor[ACC_RANGE_MAX] = { LIS3DH_ACC_SENSITIVITY_2G, LIS3DH_ACC_SENSITIVITY_4G,
LIS3DH_ACC_SENSITIVITY_8G, LIS3DH_ACC_SENSITIVITY_16G };
static int32_t cur_acc_factor = 0;
i2c_dev_t lis3dh_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LIS3DH_I2C_ADDR,
};
static int drv_acc_st_lis3dh_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, LIS3DH_ACC_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_st_lis3dh_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LIS3DH_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LIS3DH_SET_BITSLICE(value,LIS3DH_ACC_ODR,LIS3DH_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, LIS3DH_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LIS3DH_SET_BITSLICE(value,LIS3DH_ACC_ODR,LIS3DH_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LIS3DH_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LIS3DH_SET_BITSLICE(value,LIS3DH_ACC_ODR,LIS3DH_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, LIS3DH_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_acc_st_lis3dh_hz2odr(uint32_t hz)
{
if(hz > 1620)
return LIS3DH_ACC_ODR_5_376_KHZ;
else if(hz > 1344)
return LIS3DH_ACC_ODR_1_62_KHZ;
else if(hz > 400)
return LIS3DH_ACC_ODR_1_344_HZ;
else if(hz > 200)
return LIS3DH_ACC_ODR_400_HZ;
else if(hz > 100)
return LIS3DH_ACC_ODR_200_HZ;
else if(hz > 50)
return LIS3DH_ACC_ODR_100_HZ;
else if(hz > 25)
return LIS3DH_ACC_ODR_50_HZ;
else if(hz > 10)
return LIS3DH_ACC_ODR_25_HZ;
else if(hz >= 1)
return LIS3DH_ACC_ODR_10_HZ;
else
return LIS3DH_ACC_ODR_1_HZ;
}
static int drv_acc_st_lis3dh_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_lis3dh_hz2odr(hz);
ret = sensor_i2c_read(drv, LIS3DH_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LIS3DH_SET_BITSLICE(value,LIS3DH_ACC_ODR,odr);
ret = sensor_i2c_write(drv, LIS3DH_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lis3dh_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LIS3DH_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_2G:{
tmp = LIS3DH_ACC_RANGE_2G;
}break;
case ACC_RANGE_4G:{
tmp = LIS3DH_ACC_RANGE_4G;
}break;
case ACC_RANGE_8G:{
tmp = LIS3DH_ACC_RANGE_8G;
}break;
case ACC_RANGE_16G:{
tmp = LIS3DH_ACC_RANGE_16G;
}break;
default:break;
}
value = LIS3DH_SET_BITSLICE(value,LIS3DH_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, LIS3DH_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)){
cur_acc_factor = lis3dh_acc_factor[range];
}
return 0;
}
static int drv_acc_st_lis3dh_set_bdu(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LIS3DH_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LIS3DH_BDU_ENABLE;
ret = sensor_i2c_write(drv, LIS3DH_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lis3dh_st_discard(i2c_dev_t* drv)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
for (i = 0; i < LIS3DH_ACC_SELF_TEST_DRY_WAIT_CNT; i ++) {
ret = sensor_i2c_read(drv, LIS3DH_ACC_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x08)
break;
aos_msleep(20);
}
if (i >= LIS3DH_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, (LIS3DH_ACC_OUT_X_L | 0x80), buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
return ret;
}
static int drv_acc_st_lis3dh_st_data(i2c_dev_t* drv,int32_t* data)
{
uint8_t i, j;
int16_t x_raw, y_raw, z_raw;
int32_t x_mg, y_mg, z_mg;
int32_t x_sum, y_sum, z_sum;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
x_sum = 0; y_sum = 0; z_sum = 0;
for (i = 0; i < LIS3DH_ACC_SELF_TEST_AVG_SAMPLE_CNT; i ++) {
for (j = 0; j < LIS3DH_ACC_SELF_TEST_DRY_WAIT_CNT; j ++) {
ret = sensor_i2c_read(drv, LIS3DH_ACC_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x08)
break;
aos_msleep(20);
}
if (j >= LIS3DH_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, (LIS3DH_ACC_OUT_X_L | 0x80), buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
x_raw = (buffer[1] << 8) + buffer[0];
y_raw = (buffer[3] << 8) + buffer[2];
z_raw = (buffer[5] << 8) + buffer[4];
//LOG("%s %s %d: i(%d), raw(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_raw, y_raw, z_raw);
x_mg = x_raw >> 4;
y_mg = y_raw >> 4;
z_mg = z_raw >> 4;
//LOG("%s %s %d: i(%d), mg(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_mg, y_mg, z_mg);
x_sum += x_mg;
y_sum += y_mg;
z_sum += z_mg;
}
data[0] = x_sum / LIS3DH_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[1] = y_sum / LIS3DH_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[2] = z_sum / LIS3DH_ACC_SELF_TEST_AVG_SAMPLE_CNT;
return ret;
}
static int drv_acc_st_lis3dh_self_test(i2c_dev_t* drv,int32_t* data)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t ctrl_reg[4];
int32_t out_nost[3];
int32_t out_st[3];
int32_t out_diff[3];
// Save cfg registers which will be modified during self-test
ret = sensor_i2c_read(drv, (LIS3DH_ACC_CTRL_REG1 | 0x80), ctrl_reg, 4, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
// Initialize Sensor, turn on sensor, enable X/Y/Z axes
// Set BDU=1, FS=2G, Normal mode, ODR = 50Hz
value = 0;
ret = sensor_i2c_write(drv, LIS3DH_ACC_CTRL_REG2, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0;
ret = sensor_i2c_write(drv, LIS3DH_ACC_CTRL_REG3, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0x80;
ret = sensor_i2c_write(drv, LIS3DH_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0x47;
ret = sensor_i2c_write(drv, LIS3DH_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(90);
// Discard the first sample
ret = drv_acc_st_lis3dh_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and averate them
ret = drv_acc_st_lis3dh_st_data(drv, out_nost);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Enable seft-test
value = 0x82;
ret = sensor_i2c_write(drv, LIS3DH_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(90);
// Discard the first sample
ret = drv_acc_st_lis3dh_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and average them
ret = drv_acc_st_lis3dh_st_data(drv, out_st);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Check if the differences are between min and max
for (i = 0; i < 3; i ++) {
out_diff[i] = abs(out_st[i] - out_nost[i]);
data[i] = out_diff[i];
}
if ((LIS3DH_ACC_SELF_TEST_MIN_X > out_diff[0]) || (out_diff[0] > LIS3DH_ACC_SELF_TEST_MAX_X)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LIS3DH_ACC_SELF_TEST_MIN_Y > out_diff[1]) || (out_diff[1] > LIS3DH_ACC_SELF_TEST_MAX_Y)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((LIS3DH_ACC_SELF_TEST_MIN_Z > out_diff[2]) || (out_diff[2] > LIS3DH_ACC_SELF_TEST_MAX_Z)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
restore:
ret += sensor_i2c_write(drv, LIS3DH_ACC_CTRL_REG1 | 0x80, ctrl_reg, 4, I2C_OP_RETRIES);
return ret;
}
static void drv_acc_st_lis3dh_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_lis3dh_open(void)
{
int ret = 0;
ret = drv_acc_st_lis3dh_set_power_mode(&lis3dh_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis3dh_set_range(&lis3dh_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis3dh_set_odr(&lis3dh_ctx, LIS3DH_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lis3dh_close(void)
{
int ret = 0;
ret = drv_acc_st_lis3dh_set_power_mode(&lis3dh_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lis3dh_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lis3dh_ctx, (LIS3DH_ACC_OUT_X_L | 0x80), reg, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< LIS3DH_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] >> LIS3DH_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< LIS3DH_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] >> LIS3DH_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< LIS3DH_SHIFT_EIGHT_BITS)|(reg[4]));
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] >> LIS3DH_SHIFT_FOUR_BITS;
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] * cur_acc_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] * cur_acc_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] * cur_acc_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_lis3dh_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_lis3dh_set_odr(&lis3dh_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_st_lis3dh_set_range(&lis3dh_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_lis3dh_set_power_mode(&lis3dh_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
info->model = "LIS3DH";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}break;
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_acc_st_lis3dh_self_test(&lis3dh_ctx, (int32_t*)info->data);
//printf("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
LOG("%s %s: %d, %d, %d\n", SENSOR_STR, __func__, info->data[0],info->data[1],info->data[2]);
return ret;
}
default:break;
}
return 0;
}
int drv_acc_st_lis3dh_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_lis3dh_open;
sensor.close = drv_acc_st_lis3dh_close;
sensor.read = drv_acc_st_lis3dh_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_lis3dh_ioctl;
sensor.irq_handle = drv_acc_st_lis3dh_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis3dh_validate_id(&lis3dh_ctx, LIS3DH_ACC_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis3dh_set_range(&lis3dh_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lis3dh_set_bdu(&lis3dh_ctx);
if(unlikely(ret)){
return -1;
}
//set odr is 100hz, and will update
ret = drv_acc_st_lis3dh_set_odr(&lis3dh_ctx, LIS3DH_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_lis3dh_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_st_lis3dh.c
|
C
|
apache-2.0
| 20,581
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define N2DM_I2C_ADDR1 (0x8)
#define N2DM_I2C_ADDR2 (0x9)
#define N2DM_I2C_ADDR_TRANS(n) ((n)<<1)
#define N2DM_I2C_ADDR N2DM_I2C_ADDR_TRANS(N2DM_I2C_ADDR2)
#define N2DM_STATUS_REG_AUX 0x07
#define N2DM_ACC_OUT_TEMP_L 0x0C
#define N2DM_ACC_OUT_TEMP_H 0x0D
#define N2DM_ACC_WHO_AM_I 0x0F
#define N2DM_ACC_CTRL_REG0 0x1E
#define N2DM_ACC_TEMP_CFG_REG 0x1F
#define N2DM_ACC_CTRL_REG1 0x20
#define N2DM_ACC_CTRL_REG2 0x21
#define N2DM_ACC_CTRL_REG3 0x22
#define N2DM_ACC_CTRL_REG4 0x23
#define N2DM_ACC_CTRL_REG5 0x24
#define N2DM_ACC_CTRL_REG6 0x25
#define N2DM_ACC_REFERENCE 0x26
#define N2DM_ACC_STATUS_REG 0x27
#define N2DM_ACC_OUT_X_L 0x28
#define N2DM_ACC_OUT_X_H 0x29
#define N2DM_ACC_OUT_Y_L 0x2A
#define N2DM_ACC_OUT_Y_H 0x2B
#define N2DM_ACC_OUT_Z_L 0x2C
#define N2DM_ACC_OUT_Z_H 0x2D
#define N2DM_ACC_FIFO_CTRL_REG 0x2E
#define N2DM_ACC_FIFO_SRC_REG 0x2F
#define N2DM_ACC_INT1_CFG 0x30
#define N2DM_ACC_INT1_SRC 0x31
#define N2DM_ACC_INT1_THS 0x32
#define N2DM_ACC_INT1_DURATION 0x33
#define N2DM_ACC_INT2_CFG 0x34
#define N2DM_ACC_INT2_SRC 0x35
#define N2DM_ACC_INT2_THS 0x36
#define N2DM_ACC_INT2_DURATION 0x37
#define N2DM_ACC_CLICK_CFG 0x38
#define N2DM_ACC_CLICK_SRC 0x39
#define N2DM_ACC_CLICK_THS 0x3A
#define N2DM_ACC_TIME_LIMIT 0x3B
#define N2DM_ACC_TIME_LATENCY 0x3C
#define N2DM_ACC_TIME_WINDOW 0x3D
#define N2DM_ACC_ACT_THS 0x3E
#define N2DM_ACC_ACT_DUR 0x3F
#define N2DM_ACC_SELFTESTDISABLE (0x0)
#define N2DM_ACC_SELFTESTENABLE (0x2)
#define N2DM_ACC_SELFTEST_MSK (0x06)
#define N2DM_ACC_SELFTEST_POS (2)
#define N2DM_ACC_RANGE_2G (0x0)
#define N2DM_ACC_RANGE_4G (0x1)
#define N2DM_ACC_RANGE_8G (0x2)
#define N2DM_ACC_RANGE_16G (0x3)
#define N2DM_ACC_RANGE_MSK (0x30)
#define N2DM_ACC_RANGE_POS (4)
#define N2DM_ACC_SENSITIVITY_2G 976
#define N2DM_ACC_SENSITIVITY_4G 1953
#define N2DM_ACC_SENSITIVITY_8G 3906
#define N2DM_ACC_SENSITIVITY_16G 11718
#define N2DM_ACC_CHIP_ID_VALUE (0x33)
#define N2DM_SHIFT_EIGHT_BITS (8)
#define N2DM_SHIFT_FOUR_BITS (4)
#define N2DM_16_BIT_SHIFT (0xFF)
#define N2DM_ACC_MUL (1000)
#define N2DM_ACC_ODR_POWER_DOWN (0x00)
#define N2DM_ACC_ODR_1_HZ (0x01)
#define N2DM_ACC_ODR_10_HZ (0x02)
#define N2DM_ACC_ODR_25_HZ (0x03)
#define N2DM_ACC_ODR_50_HZ (0x04)
#define N2DM_ACC_ODR_100_HZ (0x05)
#define N2DM_ACC_ODR_200_HZ (0x06)
#define N2DM_ACC_ODR_400_HZ (0x07)
#define N2DM_ACC_ODR_1_62_KHZ (0x08)
#define N2DM_ACC_ODR_5_376_KHZ (0x09)
#define N2DM_ACC_ODR_1_344_HZ (0x09)
#define N2DM_ACC_ODR_MSK (0XF0)
#define N2DM_ACC_ODR_POS (4)
#define N2DM_ACC_DEFAULT_ODR_100HZ (100)
#define N2DM_BDU_ENABLE (0x80)
#define N2DM_ACC_STATUS_ZYXDA (0x08)
#define N2DM_DEFAULT_ODR_100HZ (100)
#define N2DM_ACC_SELF_TEST_MIN_X (17 * 4) // 17 counts, per count 4mg
#define N2DM_ACC_SELF_TEST_MIN_Y (17 * 4) // 17 counts, per count 4mg
#define N2DM_ACC_SELF_TEST_MIN_Z (17 * 4) // 17 counts, per count 4mg
#define N2DM_ACC_SELF_TEST_MAX_X (360 * 4) // 360 counts, per count 4mg
#define N2DM_ACC_SELF_TEST_MAX_Y (360 * 4) // 360 counts, per count 4mg
#define N2DM_ACC_SELF_TEST_MAX_Z (360 * 4) // 360 counts, per count 4mg
#define N2DM_ACC_SELF_TEST_DRY_WAIT_CNT 5
#define N2DM_ACC_SELF_TEST_AVG_SAMPLE_CNT 5
#define N2DM_DEFAULT_ODR_100HZ (100)
#define N2DM_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define N2DM_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t n2dm_acc_factor[ACC_RANGE_MAX] = { N2DM_ACC_SENSITIVITY_2G, N2DM_ACC_SENSITIVITY_4G,
N2DM_ACC_SENSITIVITY_8G, N2DM_ACC_SENSITIVITY_16G };
static int32_t cur_acc_factor = 0;
i2c_dev_t n2dm_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = N2DM_I2C_ADDR,
};
static int drv_acc_st_n2dm_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, N2DM_ACC_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_st_n2dm_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, N2DM_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = N2DM_SET_BITSLICE(value,N2DM_ACC_ODR,N2DM_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, N2DM_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = N2DM_SET_BITSLICE(value,N2DM_ACC_ODR,N2DM_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, N2DM_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = N2DM_SET_BITSLICE(value,N2DM_ACC_ODR,N2DM_ACC_ODR_10_HZ);
ret = sensor_i2c_write(drv, N2DM_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_acc_st_n2dm_hz2odr(uint32_t hz)
{
if(hz > 1620)
return N2DM_ACC_ODR_5_376_KHZ;
else if(hz > 1344)
return N2DM_ACC_ODR_1_62_KHZ;
else if(hz > 400)
return N2DM_ACC_ODR_1_344_HZ;
else if(hz > 200)
return N2DM_ACC_ODR_400_HZ;
else if(hz > 100)
return N2DM_ACC_ODR_200_HZ;
else if(hz > 50)
return N2DM_ACC_ODR_100_HZ;
else if(hz > 25)
return N2DM_ACC_ODR_50_HZ;
else if(hz > 10)
return N2DM_ACC_ODR_25_HZ;
else if(hz >= 1)
return N2DM_ACC_ODR_10_HZ;
else
return N2DM_ACC_ODR_1_HZ;
}
static int drv_acc_st_n2dm_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_n2dm_hz2odr(hz);
ret = sensor_i2c_read(drv, N2DM_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = N2DM_SET_BITSLICE(value,N2DM_ACC_ODR,odr);
ret = sensor_i2c_write(drv, N2DM_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_n2dm_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, N2DM_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_2G:{
tmp = N2DM_ACC_RANGE_2G;
}break;
case ACC_RANGE_4G:{
tmp = N2DM_ACC_RANGE_4G;
}break;
case ACC_RANGE_8G:{
tmp = N2DM_ACC_RANGE_8G;
}break;
case ACC_RANGE_16G:{
tmp = N2DM_ACC_RANGE_16G;
}break;
default:break;
}
value = N2DM_SET_BITSLICE(value,N2DM_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, N2DM_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)){
cur_acc_factor = n2dm_acc_factor[range];
}
return 0;
}
static int drv_acc_st_n2dm_set_bdu(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, N2DM_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= N2DM_BDU_ENABLE;
ret = sensor_i2c_write(drv, N2DM_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_n2dm_st_discard(i2c_dev_t* drv)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
for (i = 0; i < N2DM_ACC_SELF_TEST_DRY_WAIT_CNT; i ++) {
ret = sensor_i2c_read(drv, N2DM_ACC_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x08)
break;
aos_msleep(20);
}
if (i >= N2DM_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, (N2DM_ACC_OUT_X_L | 0x80), buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
return ret;
}
static int drv_acc_st_n2dm_st_data(i2c_dev_t* drv,int32_t* data)
{
uint8_t i, j;
int16_t x_raw, y_raw, z_raw;
int32_t x_mg, y_mg, z_mg;
int32_t x_sum, y_sum, z_sum;
uint8_t value = 0x00;
int ret = 0;
uint8_t buffer[6];
x_sum = 0; y_sum = 0; z_sum = 0;
for (i = 0; i < N2DM_ACC_SELF_TEST_AVG_SAMPLE_CNT; i ++) {
for (j = 0; j < N2DM_ACC_SELF_TEST_DRY_WAIT_CNT; j ++) {
ret = sensor_i2c_read(drv, N2DM_ACC_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
if (value & 0x08)
break;
aos_msleep(20);
}
if (j >= N2DM_ACC_SELF_TEST_DRY_WAIT_CNT) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return -1;
}
ret = sensor_i2c_read(drv, (N2DM_ACC_OUT_X_L | 0x80), buffer, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
x_raw = (buffer[1] << 8) + buffer[0];
y_raw = (buffer[3] << 8) + buffer[2];
z_raw = (buffer[5] << 8) + buffer[4];
//LOG("%s %s %d: i(%d), raw(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_raw, y_raw, z_raw);
x_mg = x_raw >> 4;
y_mg = y_raw >> 4;
z_mg = z_raw >> 4;
//LOG("%s %s %d: i(%d), mg(%d, %d, %d)\n", SENSOR_STR, __func__, __LINE__, i, x_mg, y_mg, z_mg);
x_sum += x_mg;
y_sum += y_mg;
z_sum += z_mg;
}
data[0] = x_sum / N2DM_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[1] = y_sum / N2DM_ACC_SELF_TEST_AVG_SAMPLE_CNT;
data[2] = z_sum / N2DM_ACC_SELF_TEST_AVG_SAMPLE_CNT;
return ret;
}
static int drv_acc_st_n2dm_self_test(i2c_dev_t* drv,int32_t* data)
{
uint8_t i;
uint8_t value = 0x00;
int ret = 0;
uint8_t ctrl_reg[4];
int32_t out_nost[3];
int32_t out_st[3];
int32_t out_diff[3];
// Save cfg registers which will be modified during self-test
ret = sensor_i2c_read(drv, (N2DM_ACC_CTRL_REG1 | 0x80), ctrl_reg, 4, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
return ret;
}
// Initialize Sensor, turn on sensor, enable X/Y/Z axes
// Set BDU=1, FS=2G, Normal mode, ODR = 50Hz
value = 0;
ret = sensor_i2c_write(drv, N2DM_ACC_CTRL_REG2, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0;
ret = sensor_i2c_write(drv, N2DM_ACC_CTRL_REG3, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0x80;
ret = sensor_i2c_write(drv, N2DM_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
value = 0x47;
ret = sensor_i2c_write(drv, N2DM_ACC_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(90);
// Discard the first sample
ret = drv_acc_st_n2dm_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and averate them
ret = drv_acc_st_n2dm_st_data(drv, out_nost);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Enable seft-test
value = 0x82;
ret = sensor_i2c_write(drv, N2DM_ACC_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
aos_msleep(90);
// Discard the first sample
ret = drv_acc_st_n2dm_st_discard(drv);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Read some samples, and average them
ret = drv_acc_st_n2dm_st_data(drv, out_st);
if(unlikely(ret)){
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
goto restore;
}
// Check if the differences are between min and max
for (i = 0; i < 3; i ++) {
out_diff[i] = abs(out_st[i] - out_nost[i]);
data[i] = out_diff[i];
}
if ((N2DM_ACC_SELF_TEST_MIN_X > out_diff[0]) || (out_diff[0] > N2DM_ACC_SELF_TEST_MAX_X)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((N2DM_ACC_SELF_TEST_MIN_Y > out_diff[1]) || (out_diff[1] > N2DM_ACC_SELF_TEST_MAX_Y)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
if ((N2DM_ACC_SELF_TEST_MIN_Z > out_diff[2]) || (out_diff[2] > N2DM_ACC_SELF_TEST_MAX_Z)) {
LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__);
ret = -1;
goto restore;
}
restore:
ret += sensor_i2c_write(drv, N2DM_ACC_CTRL_REG1 | 0x80, ctrl_reg, 4, I2C_OP_RETRIES);
return ret;
}
static void drv_acc_st_n2dm_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_n2dm_open(void)
{
int ret = 0;
ret = drv_acc_st_n2dm_set_power_mode(&n2dm_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_n2dm_set_range(&n2dm_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_n2dm_set_odr(&n2dm_ctx, N2DM_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_n2dm_close(void)
{
int ret = 0;
ret = drv_acc_st_n2dm_set_power_mode(&n2dm_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_n2dm_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&n2dm_ctx, (N2DM_ACC_OUT_X_L | 0x80), reg, 6, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< N2DM_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] >> N2DM_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< N2DM_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] >> N2DM_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< N2DM_SHIFT_EIGHT_BITS)|(reg[4]));
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] >> N2DM_SHIFT_FOUR_BITS;
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] * cur_acc_factor / 1000;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] * cur_acc_factor / 1000;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] * cur_acc_factor / 1000;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_n2dm_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_n2dm_set_odr(&n2dm_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_st_n2dm_set_range(&n2dm_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_n2dm_set_power_mode(&n2dm_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
info->model = "N2DM";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}break;
case SENSOR_IOCTL_SELF_TEST:{
ret = drv_acc_st_n2dm_self_test(&n2dm_ctx, (int32_t*)info->data);
//printf("%d %d %d\n",info->data[0],info->data[1],info->data[2]);
LOG("%s %s: %d, %d, %d\n", SENSOR_STR, __func__, info->data[0],info->data[1],info->data[2]);
return ret;
}
default:break;
}
return 0;
}
int drv_acc_st_n2dm_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_n2dm_open;
sensor.close = drv_acc_st_n2dm_close;
sensor.read = drv_acc_st_n2dm_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_n2dm_ioctl;
sensor.irq_handle = drv_acc_st_n2dm_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_n2dm_validate_id(&n2dm_ctx, N2DM_ACC_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_n2dm_set_range(&n2dm_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_n2dm_set_bdu(&n2dm_ctx);
if(unlikely(ret)){
return -1;
}
//set odr is 100hz, and will update
ret = drv_acc_st_n2dm_set_odr(&n2dm_ctx, N2DM_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_acc_st_n2dm_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_acc_st_n2dm.c
|
C
|
apache-2.0
| 20,112
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "ulog/ulog.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define TCS3400_ENABLE 0x80
#define TCS3400_ALS_TIME 0x81
#define TCS3400_WAIT_TIME 0x83
#define TCS3400_ALS_MINTHRESHLO 0x84
#define TCS3400_ALS_MINTHRESHHI 0x85
#define TCS3400_ALS_MAXTHRESHLO 0x86
#define TCS3400_ALS_MAXTHRESHHI 0x87
#define TCS3400_PERSISTENCE 0x8C
#define TCS3400_CONFIG 0x8D
#define TCS3400_CONTROL 0x8F
#define TCS3400_REG_AUX 0x90
#define TCS3400_REVID 0x91
#define TCS3400_CHIPID 0x92
#define TCS3400_STATUS 0x93
#define TCS3400_CLR_CHANLO 0x94
#define TCS3400_CLR_CHANHI 0x95
#define TCS3400_RED_CHANLO 0x96
#define TCS3400_RED_CHANHI 0x97
#define TCS3400_GRN_CHANLO 0x98
#define TCS3400_GRN_CHANHI 0x99
#define TCS3400_BLU_CHANLO 0x9A
#define TCS3400_BLU_CHANHI 0x9B
#define TCS3400_IR_TOGGLE 0xC0
#define TCS3400_IFORCE 0xE4
#define TCS3400_CLCLEAR 0xE6
#define TCS3400_AICLEAR 0xE7
#define TCS3400_I2C_SLAVE_ADDR 0x29
#define TCS3400_ADDR_TRANS(n) ((n) << 1)
#define TCS3400_I2C_ADDR TCS3400_ADDR_TRANS(TCS3400_I2C_SLAVE_ADDR)
#define TCS3400_CHIPID_VALUE 0x90 // 0x90 or 0x93
#define MAX_REGS 256
#define INTEGRATION_CYCLE 2780
#define TCS3400_MASK_AGAIN 0x03
#define TCS3400_MAX_LUX 0xffff
#define TCS3400_MAX_ALS_VALUE 0xffff
#define TCS3400_MIN_ALS_VALUE 3
#define DGF 783
#define R_Coef 50
#define G_Coef 530
#define B_Coef -230
#define CT_Coef 3647
#define CT_Offset 1319
#define TCS3400_CMD_ALS_INT_CLR 0xE6
#define TCS3400_CMD_ALL_INT_CLR 0xE7
#define GAIN1 0
#define GAIN4 1
#define GAIN16 2
#define GAIN64 3
#define ALS_PERSIST(p) (((p)&0xf) << 3)
#define AW_TIME_MS(p) \
((((p)*1000) + (INTEGRATION_CYCLE - 1)) / INTEGRATION_CYCLE)
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
struct tcs3400_als_info
{
uint32_t sat;
uint32_t cpl;
uint16_t clear;
uint16_t red;
uint16_t green;
uint16_t blue;
int16_t ir_data;
uint16_t lux;
uint16_t cct;
};
enum tcs3400_pwr_state
{
POWER_ON,
POWER_OFF,
POWER_STANDBY,
};
enum tcs3400_ctrl_reg
{
AGAIN_1 = (0 << 0),
AGAIN_4 = (1 << 0),
AGAIN_16 = (2 << 0),
AGAIN_64 = (3 << 0),
};
enum tcs3400_en_reg
{
TCS3400_EN_PWR_ON = (1 << 0),
TCS3400_EN_ALS = (1 << 1),
TCS3400_EN_WAIT = (1 << 3),
TCS3400_EN_ALS_IRQ = (1 << 4),
TCS3400_EN_ALS_SAT_IRQ = (1 << 5),
TCS3400_EN_IRQ_PWRDN = (1 << 6),
};
// 0x93 Register
enum tcs3400_status
{
TCS3400_ST_ALS_VALID = (1 << 0),
TCS3400_ST_ALS_IRQ = (1 << 4),
TCS3400_ST_ALS_SAT = (1 << 7),
};
enum
{
TCS3400_ALS_GAIN_MASK = (3 << 0),
TCS3400_ATIME_DEFAULT_MS = 50,
MAX_ALS_VALUE = 0xffff,
MIN_ALS_VALUE = 1,
};
static uint8_t const regs[] = {
TCS3400_ENABLE, TCS3400_ALS_TIME, TCS3400_ALS_MINTHRESHLO,
TCS3400_ALS_MINTHRESHHI, TCS3400_ALS_MAXTHRESHLO, TCS3400_ALS_MAXTHRESHHI,
TCS3400_PERSISTENCE, TCS3400_CONFIG, TCS3400_CONTROL,
TCS3400_REG_AUX,
};
static uint8_t const als_gains[] = { 1, 4, 16, 64 };
struct tcs3400_chips
{
bool als_enabled;
uint8_t atime;
uint8_t again;
uint8_t persist;
uint8_t in_asat;
uint8_t shadow[MAX_REGS];
struct tcs3400_als_info als_inf;
};
i2c_dev_t tcs3400_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = TCS3400_I2C_ADDR,
};
static struct tcs3400_chips tcs3400_chip;
static int drv_als_ams_tcs3400_validate_id(i2c_dev_t *drv, uint8_t id_value)
{
int ret = 0;
uint8_t chipid_value;
ret = sensor_i2c_read(drv, TCS3400_CHIPID, &chipid_value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
LOG("%s %s Sensor_i2c_read failure \n", SENSOR_STR, __func__);
return ret;
}
if (!((chipid_value == 0x90) || (chipid_value == 0x93)))
return -1;
return 0;
}
static int drv_als_ams_tcs3400_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
int ret = 0;
uint8_t temp_zero = 0;
switch (mode) {
case DEV_POWER_ON: {
if (!(tcs3400_chip.als_enabled)) {
ret = sensor_i2c_write(drv, TCS3400_CMD_ALL_INT_CLR, &temp_zero,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
tcs3400_chip.shadow[TCS3400_ENABLE] |=
(TCS3400_EN_PWR_ON | TCS3400_EN_ALS | TCS3400_EN_ALS_IRQ);
ret = sensor_i2c_write(drv, TCS3400_ENABLE,
&(tcs3400_chip.shadow[TCS3400_ENABLE]),
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
LOG("%s %s PowerEnable failure \n", SENSOR_STR, __func__);
return ret;
}
tcs3400_chip.shadow[TCS3400_REG_AUX] |= TCS3400_EN_ALS_SAT_IRQ;
sensor_i2c_write(drv, TCS3400_REG_AUX,
&(tcs3400_chip.shadow[TCS3400_REG_AUX]),
I2C_DATA_LEN, I2C_OP_RETRIES);
tcs3400_chip.als_enabled = 1;
}
} break;
case DEV_POWER_OFF:
case DEV_SLEEP: {
if (tcs3400_chip.als_enabled) {
ret = sensor_i2c_write(drv, TCS3400_CMD_ALL_INT_CLR, &temp_zero,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
tcs3400_chip.shadow[TCS3400_ENABLE] = 0x00;
ret = sensor_i2c_write(drv, TCS3400_ENABLE,
&(tcs3400_chip.shadow[TCS3400_ENABLE]),
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
LOG("%s %s PowerOFF or SLEEP failure \n", SENSOR_STR,
__func__);
return ret;
}
tcs3400_chip.als_enabled = 0;
}
} break;
default:
break;
}
return 0;
}
static int tcs3400_reset_regs(i2c_dev_t *drv)
{
int i;
int ret = 0;
uint8_t reg;
uint8_t temp = 0;
uint8_t temp_zero = 0;
// clear interrupt
ret = sensor_i2c_write(drv, TCS3400_CMD_ALL_INT_CLR, &temp_zero,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
LOG("%s %s reset_regs INT_CLR failure \n", SENSOR_STR, __func__);
return -1;
}
sensor_i2c_read(drv, TCS3400_ENABLE, &temp, I2C_DATA_LEN, I2C_OP_RETRIES);
sensor_i2c_write(drv, TCS3400_ENABLE, &temp_zero, I2C_DATA_LEN,
I2C_OP_RETRIES);
for (i = 0; i < ARRAY_SIZE(regs); i++) {
reg = regs[i];
ret = sensor_i2c_write(drv, reg, &(tcs3400_chip.shadow[reg]),
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
LOG("%s %s reset_regs failure \n", SENSOR_STR, __func__);
return ret;
}
}
sensor_i2c_write(drv, TCS3400_ENABLE, &temp, I2C_DATA_LEN, I2C_OP_RETRIES);
return ret;
}
static int drv_als_ams_tcs3400_set_default_config(i2c_dev_t *drv)
{
int ret;
tcs3400_chip.again = AGAIN_16;
tcs3400_chip.atime = 0xee;
tcs3400_chip.als_enabled = 0;
tcs3400_chip.persist = ALS_PERSIST(0);
tcs3400_chip.shadow[TCS3400_CONTROL] &= ~0x3;
tcs3400_chip.shadow[TCS3400_CONTROL] |= tcs3400_chip.again;
tcs3400_chip.shadow[TCS3400_ALS_TIME] |= tcs3400_chip.atime;
tcs3400_chip.shadow[TCS3400_PERSISTENCE] = tcs3400_chip.persist;
tcs3400_chip.shadow[TCS3400_CONFIG] = 0x40;
ret = tcs3400_reset_regs(&tcs3400_ctx);
if (unlikely(ret)) {
LOG("%s %s set_default_config failure \n", SENSOR_STR, __func__);
return ret;
}
return 0;
}
static void drv_als_ams_tcs3400_irq_handle(void)
{
/* no handle so far */
}
static int drv_als_ams_tcs3400_open(void)
{
int ret = 0;
ret = drv_als_ams_tcs3400_set_power_mode(&tcs3400_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_als_ams_tcs3400_close(void)
{
int ret = 0;
ret = drv_als_ams_tcs3400_set_power_mode(&tcs3400_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int tcs3400_read_als_data()
{
int ret;
uint8_t *buf;
int16_t ir_data;
ret = sensor_i2c_read(&tcs3400_ctx, TCS3400_CLR_CHANLO,
&tcs3400_chip.shadow[TCS3400_CLR_CHANLO], 8,
I2C_OP_RETRIES);
if (unlikely(ret)) {
LOG("%s %s TCS3400_READ_all_channel data failure \n", SENSOR_STR,
__func__);
return ret;
}
buf = &tcs3400_chip.shadow[TCS3400_CLR_CHANLO];
tcs3400_chip.als_inf.clear = (uint16_t)((buf[1] << 8) | buf[0]);
tcs3400_chip.als_inf.red = (uint16_t)((buf[3] << 8) | buf[2]);
tcs3400_chip.als_inf.green = (uint16_t)((buf[5] << 8) | buf[4]);
tcs3400_chip.als_inf.blue = (uint16_t)((buf[7] << 8) | buf[6]);
ir_data = (tcs3400_chip.als_inf.red + tcs3400_chip.als_inf.green +
tcs3400_chip.als_inf.blue - tcs3400_chip.als_inf.clear + 1) /
2;
if (ir_data < 0)
ir_data = 0;
tcs3400_chip.als_inf.ir_data = ir_data;
// LOG("clear is %d ,red is %d, green is %d, blue is %d, ir_data is %d,atime
// is %d, again is %d \n",
// tcs3400_chip.als_inf.clear,tcs3400_chip.als_inf.red,tcs3400_chip.als_inf.green,tcs3400_chip.als_inf.blue,tcs3400_chip.als_inf.ir_data,tcs3400_chip.atime,tcs3400_chip.again);
return 0;
}
static int tcs3400_max_als_value()
{
int val;
val = 256 - tcs3400_chip.shadow[TCS3400_ALS_TIME];
val = ((val)*1024);
val = val > MAX_ALS_VALUE ? MAX_ALS_VALUE : val;
return val;
}
static int tcs3400_cal_cpl()
{
uint32_t CPL = 0;
uint8_t atime = 256 - tcs3400_chip.shadow[TCS3400_ALS_TIME];
int32_t dgf = DGF;
uint32_t sat;
uint8_t gain = als_gains[(tcs3400_chip.shadow[TCS3400_CONTROL] & 0x3)];
CPL = (atime * gain);
CPL *= INTEGRATION_CYCLE;
CPL /= dgf;
if (CPL < 1)
CPL = 1;
sat = (int32_t)(atime << 10);
if (sat > TCS3400_MAX_ALS_VALUE)
sat = TCS3400_MAX_ALS_VALUE;
sat = sat * 8 / 10;
tcs3400_chip.als_inf.sat = sat;
tcs3400_chip.als_inf.cpl = (uint32_t)CPL;
return 1;
}
static int tcs3400_als_enable(int on)
{
int ret = 0;
uint8_t temp_zero = 0;
if (on) {
tcs3400_cal_cpl();
ret = sensor_i2c_write(&tcs3400_ctx, TCS3400_CMD_ALL_INT_CLR,
&temp_zero, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
tcs3400_chip.shadow[TCS3400_ENABLE] |=
(TCS3400_EN_PWR_ON | TCS3400_EN_ALS | TCS3400_EN_ALS_IRQ);
ret = sensor_i2c_write(&tcs3400_ctx, TCS3400_ENABLE,
&(tcs3400_chip.shadow[TCS3400_ENABLE]),
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
LOG("%s %s als_enable failure \n", SENSOR_STR, __func__);
return ret;
}
tcs3400_chip.shadow[TCS3400_REG_AUX] |= TCS3400_EN_ALS_SAT_IRQ;
sensor_i2c_write(&tcs3400_ctx, TCS3400_REG_AUX,
&(tcs3400_chip.shadow[TCS3400_REG_AUX]), I2C_DATA_LEN,
I2C_OP_RETRIES);
tcs3400_chip.als_enabled = 1;
} else {
ret = sensor_i2c_write(&tcs3400_ctx, TCS3400_CMD_ALL_INT_CLR,
&temp_zero, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
tcs3400_chip.shadow[TCS3400_ENABLE] = 0x00;
ret = sensor_i2c_write(&tcs3400_ctx, TCS3400_ENABLE,
&(tcs3400_chip.shadow[TCS3400_ENABLE]),
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
LOG("%s %s als_enable failure \n", SENSOR_STR, __func__);
return ret;
}
tcs3400_chip.als_enabled = 0;
}
return 0;
}
static int tcs3400_set_als_gain(int gain)
{
int ret;
uint8_t ctrl_reg;
bool current_state = tcs3400_chip.als_enabled;
tcs3400_als_enable(0);
switch (gain) {
case 1:
ctrl_reg = AGAIN_1;
break;
case 4:
ctrl_reg = AGAIN_4;
break;
case 16:
ctrl_reg = AGAIN_16;
break;
case 64:
ctrl_reg = AGAIN_64;
break;
default:
LOG("set als_gain wrong gain data \n");
return -1;
}
tcs3400_chip.again = ctrl_reg;
tcs3400_chip.shadow[TCS3400_CONTROL] &= ~0x3;
tcs3400_chip.shadow[TCS3400_CONTROL] |= ctrl_reg;
ret = tcs3400_reset_regs(&tcs3400_ctx);
if (unlikely(ret)) {
LOG("%s %s tcs3400_reset_regs failure \n", SENSOR_STR, __func__);
return ret;
}
tcs3400_cal_cpl();
if (current_state)
tcs3400_als_enable(1);
return 0;
}
static void tcs3400_dec_gain()
{
int ret;
uint8_t gain = (tcs3400_chip.shadow[TCS3400_CONTROL]) & 0x3;
uint8_t idx;
if ((gain <= 0))
return;
for (idx = (ARRAY_SIZE(als_gains) - 1); idx >= 0; idx--) {
if ((als_gains[idx] == 0) || (idx >= gain))
continue;
else if (idx < gain) {
gain = idx;
break;
}
}
LOG("%s %s in the dec_gain the alg_gain value is %d \n", SENSOR_STR,
__func__, als_gains[gain]);
ret = tcs3400_set_als_gain(als_gains[gain]);
if (ret == 0)
tcs3400_cal_cpl();
}
static void tcs3400_inc_gain()
{
int ret;
uint8_t gain = (tcs3400_chip.shadow[TCS3400_CONTROL]) & 0x3;
uint8_t idx;
LOG("kavin print gain value is %d\n", gain);
if ((gain >= (ARRAY_SIZE(als_gains) - 1)))
return;
for (idx = 0; idx <= (ARRAY_SIZE(als_gains) - 1); idx++) {
if ((als_gains[idx] == 0) || (idx <= gain))
continue;
else if (idx > gain) {
gain = idx;
break;
}
}
LOG("%s %s in the inc_gain the alg_gain value is %d \n", SENSOR_STR,
__func__, als_gains[gain]);
ret = tcs3400_set_als_gain(als_gains[gain]);
if (ret == 0)
tcs3400_cal_cpl();
}
static int tcs3400_get_lux_cct()
{
int32_t rp1 = 0, gp1 = 0, bp1 = 0, cp1 = 0;
int32_t rp2 = 0, gp2 = 0, bp2 = 0;
uint32_t lux, temp_lux, CPL = 0;
int32_t ir, cct = 0, r_coef = R_Coef, g_coef = G_Coef,
b_coef = B_Coef;
int32_t quintile = (tcs3400_max_als_value() / 5);
tcs3400_cal_cpl();
rp1 = (tcs3400_chip.als_inf.red);
gp1 = (tcs3400_chip.als_inf.green);
bp1 = (tcs3400_chip.als_inf.blue);
cp1 = (tcs3400_chip.als_inf.clear);
ir = (tcs3400_chip.als_inf.ir_data);
CPL = (tcs3400_chip.als_inf.cpl);
/*if(tcs3400_chip.shadow[TCS3400_CONTROL]==0x03)
ir=0; */
/* remove ir from counts */
rp1 -= ir;
gp1 -= ir;
bp1 -= ir;
cp1 -= ir;
rp2 = r_coef * rp1;
gp2 = g_coef * gp1;
bp2 = b_coef * bp1;
lux = (rp2 + gp2 + bp2);
temp_lux = lux / CPL;
// avoid div err;
if (rp1 == 0)
rp1 = 1;
cct = ((CT_Coef * (uint32_t)bp1) / (uint32_t)rp1) + CT_Offset;
if ((tcs3400_chip.als_inf.clear >= tcs3400_chip.als_inf.sat) ||
tcs3400_chip.in_asat) {
LOG("%s %s enter dec_gain", SENSOR_STR, __func__);
tcs3400_dec_gain();
tcs3400_reset_regs(&tcs3400_ctx);
} else if (tcs3400_chip.als_inf.clear < quintile) {
LOG("%s %s enter inc_gain", SENSOR_STR, __func__);
tcs3400_inc_gain();
tcs3400_reset_regs(&tcs3400_ctx);
}
if (temp_lux > 0) {
tcs3400_chip.als_inf.lux = (uint16_t)temp_lux;
tcs3400_chip.als_inf.cct = (uint16_t)cct;
}
// LOG("%s %s tcs3400_get_lux_cct lux is %d, cct is %d \n", SENSOR_STR,
// __func__, temp_lux, cct);
return 0;
}
static int drv_als_ams_tcs3400_read(void *buf, size_t len)
{
// LOG("%s %s drv_als_ams_tcs3400_read enter \n", SENSOR_STR, __func__);
int ret;
size_t size;
uint8_t temp_zero = 0;
uint8_t status = 0;
als_data_t *sensordata = (als_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(als_data_t);
if (len < size) {
return -1;
}
// LOG("%s %s drv_als_ams_tcs3400_read begin \n", SENSOR_STR, __func__);
ret = sensor_i2c_read(&tcs3400_ctx, TCS3400_STATUS,
&(tcs3400_chip.shadow[TCS3400_STATUS]), I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
LOG("%s %s TCS3400_READ_STATUS failure \n", SENSOR_STR, __func__);
return ret;
} else {
status = tcs3400_chip.shadow[TCS3400_STATUS];
if (status & TCS3400_ST_ALS_SAT)
tcs3400_chip.in_asat = true;
else
tcs3400_chip.in_asat = false;
if (((status & TCS3400_ST_ALS_IRQ) &&
(status & TCS3400_ST_ALS_VALID)) ||
(tcs3400_chip.in_asat)) {
// clear interrupt
sensor_i2c_write(&tcs3400_ctx, TCS3400_CMD_ALL_INT_CLR, &temp_zero,
I2C_DATA_LEN, I2C_OP_RETRIES);
LOG("%s %s drv_als_ams_tcs3400_read enter read_als_data \n",
SENSOR_STR, __func__);
tcs3400_read_als_data();
tcs3400_get_lux_cct();
}
sensordata->lux = (uint32_t)(tcs3400_chip.als_inf.lux);
sensordata->timestamp = aos_now_ms();
return (int)size;
}
return 0;
}
static int drv_als_ams_tcs3400_write(const void *buf, size_t len)
{
// no handle so far
return 0;
}
static int drv_als_ams_tcs3400_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
ret = drv_als_ams_tcs3400_set_power_mode(&tcs3400_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "TCS3400";
info->unit = lux;
} break;
default:
break;
}
return 0;
}
int drv_als_ams_tcs3400_init(void)
{
int ret = 0;
sensor_obj_t sensor_als;
memset(&sensor_als, 0, sizeof(sensor_als));
/* fill the sensor obj parameters here */
sensor_als.tag = TAG_DEV_ALS;
sensor_als.path = dev_als_path;
sensor_als.io_port = I2C_PORT;
sensor_als.open = drv_als_ams_tcs3400_open;
sensor_als.close = drv_als_ams_tcs3400_close;
sensor_als.read = drv_als_ams_tcs3400_read;
sensor_als.write = drv_als_ams_tcs3400_write;
sensor_als.ioctl = drv_als_ams_tcs3400_ioctl;
sensor_als.irq_handle = drv_als_ams_tcs3400_irq_handle;
ret = sensor_create_obj(&sensor_als);
if (unlikely(ret)) {
return -1;
}
ret = drv_als_ams_tcs3400_validate_id(&tcs3400_ctx, TCS3400_CHIPID_VALUE);
if (unlikely(ret)) {
return -1;
}
ret = drv_als_ams_tcs3400_set_default_config(&tcs3400_ctx);
if (unlikely(ret)) {
return -1;
}
return 0;
}
SENSOR_DRV_ADD(drv_als_ams_tcs3400_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_als_ams_tcs3400.c
|
C
|
apache-2.0
| 20,018
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
/*******************************************************************************
********************************* MACROS **********************************
******************************************************************************/
#define LTR303_ADDR_TRANS(n) ((n) << 1)
#define LTR303_GET_BITSLICE(uint8Val, bitName) (((uint8Val) & (LTR303_##bitName##__MSK)) >> (LTR303_##bitName##__POS))
#define LTR303_SET_BITSLICE(uint8Val, bitName, bitVal) (((uint8Val) & ~(LTR303_##bitName##__MSK)) | ((bitVal << (LTR303_##bitName##__POS)) & (LTR303_##bitName##__MSK)))
/*******************************************************************************
************************** SENSOR SPECIFICATIONS **************************
******************************************************************************/
/* I2C device address */
#define LTR303_SLAVE_ADDR (0x29)
#define LTR303_I2C_ADDR LTR303_ADDR_TRANS(LTR303_SLAVE_ADDR)
/* Device info */
#define LTR303_PART_ID_VAL 0xA0
#define LTR303_MANUFAC_ID_VAL 0x05
#define LTR303_WAIT_TIME_PER_CHECK (10)
#define LTR303_WAIT_TIME_TOTAL (100)
/*******************************************************************************
************* Non-Configurable (Unless data sheet is updated) *************
******************************************************************************/
/* Device register set address */
#define LTR303_ALS_CONTR_REG (0x80)
#define LTR303_ALS_MEAS_RATE_REG (0x85)
#define LTR303_PART_ID_REG (0x86)
#define LTR303_MANUFAC_ID_REG (0x87)
#define LTR303_ALS_DATA_CH1_0_REG (0x88)
#define LTR303_ALS_DATA_CH1_1_REG (0x89)
#define LTR303_ALS_DATA_CH0_0_REG (0x8A)
#define LTR303_ALS_DATA_CH0_1_REG (0x8B)
#define LTR303_ALS_STATUS_REG (0x8C)
#define LTR303_INTERRUPT_REG (0x8F)
#define LTR303_ALS_THRES_UP_0_REG (0x97)
#define LTR303_ALS_THRES_UP_1_REG (0x98)
#define LTR303_ALS_THRES_LOW_0_REG (0x99)
#define LTR303_ALS_THRES_LOW_1_REG (0x9A)
#define LTR303_INTERRUPT_PERSIST_REG (0x9E)
/* Register ALS_CONTR field */
#define LTR303_ALS_MODE__REG (LTR303_ALS_CONTR_REG)
#define LTR303_ALS_MODE__POS (0)
#define LTR303_ALS_MODE__MSK (0x01)
#define LTR303_SW_RESET__REG (LTR303_ALS_CONTR_REG)
#define LTR303_SW_RESET__POS (1)
#define LTR303_SW_RESET__MSK (0x02)
#define LTR303_ALS_GAIN__REG (LTR303_ALS_CONTR_REG)
#define LTR303_ALS_GAIN__POS (2)
#define LTR303_ALS_GAIN__MSK (0x1C)
/* Register ALS_MEAS_RATE field */
#define LTR303_ALS_MEAS_RPT_RATE__REG (LTR303_ALS_MEAS_RATE_REG)
#define LTR303_ALS_MEAS_RPT_RATE__POS (0)
#define LTR303_ALS_MEAS_RPT_RATE__MSK (0x07)
#define LTR303_ALS_INTEG_TIME__REG (LTR303_ALS_MEAS_RATE_REG)
#define LTR303_ALS_INTEG_TIME__POS (3)
#define LTR303_ALS_INTEG_TIME__MSK (0x38)
/* Register PART_ID field */
#define LTR303_REVISION_ID__REG (LTR303_PART_ID_REG)
#define LTR303_REVISION_ID__POS (0)
#define LTR303_REVISION_ID__MSK (0x0F)
#define LTR303_PART_NUMBER_ID__REG (LTR303_PART_ID_REG)
#define LTR303_PART_NUMBER_ID__POS (4)
#define LTR303_PART_NUMBER_ID__MSK (0xF0)
/* Register MANUFAC_ID field */
#define LTR303_MANUFAC_ID__REG (LTR303_MANUFAC_ID_REG)
#define LTR303_MANUFAC_ID__POS (0)
#define LTR303_MANUFAC_ID__MSK (0xFF)
/* Register ALS_DATA field */
#define LTR303_ALS_DATA_CH1_0__REG (LTR303_ALS_DATA_CH1_0_REG)
#define LTR303_ALS_DATA_CH1_0__POS (0)
#define LTR303_ALS_DATA_CH1_0__MSK (0xFF)
#define LTR303_ALS_DATA_CH1_1__REG (LTR303_ALS_DATA_CH1_1_REG)
#define LTR303_ALS_DATA_CH1_1__POS (0)
#define LTR303_ALS_DATA_CH1_1__MSK (0xFF)
#define LTR303_ALS_DATA_CH0_0__REG (LTR303_ALS_DATA_CH0_0_REG)
#define LTR303_ALS_DATA_CH0_0__POS (0)
#define LTR303_ALS_DATA_CH0_0__MSK (0xFF)
#define LTR303_ALS_DATA_CH0_1__REG (LTR303_ALS_DATA_CH0_1_REG)
#define LTR303_ALS_DATA_CH0_1__POS (0)
#define LTR303_ALS_DATA_CH0_1__MSK (0xFF)
/* Register ALS_STATUS field */
#define LTR303_ALS_DATA_STATUS__REG (LTR303_ALS_STATUS_REG)
#define LTR303_ALS_DATA_STATUS__POS (2)
#define LTR303_ALS_DATA_STATUS__MSK (0x04)
#define LTR303_ALS_INT_STATUS__REG (LTR303_ALS_STATUS_REG)
#define LTR303_ALS_INT_STATUS__POS (3)
#define LTR303_ALS_INT_STATUS__MSK (0x08)
#define LTR303_ALS_GAIN_STATUS__REG (LTR303_ALS_STATUS_REG)
#define LTR303_ALS_GAIN_STATUS__POS (4)
#define LTR303_ALS_GAIN_STATUS__MSK (0x70)
#define LTR303_ALS_DATA_VALIDITY__REG (LTR303_ALS_STATUS_REG)
#define LTR303_ALS_DATA_VALIDITY__POS (7)
#define LTR303_ALS_DATA_VALIDITY__MSK (0x80)
/* Register INTERRUPT field */
#define LTR303_INT_MODE__REG (LTR303_INTERRUPT_REG)
#define LTR303_INT_MODE__POS (1)
#define LTR303_INT_MODE__MSK (0x02)
#define LTR303_INT_POLARITY__REG (LTR303_INTERRUPT_REG)
#define LTR303_INT_POLARITY__POS (2)
#define LTR303_INT_POLARITY__MSK (0x04)
/* Register ALS_THRES field */
#define LTR303_ALS_THRES_UP_0__REG (LTR303_ALS_THRES_UP_0_REG)
#define LTR303_ALS_THRES_UP_0__POS (0)
#define LTR303_ALS_THRES_UP_0__MSK (0xFF)
#define LTR303_ALS_THRES_UP_1__REG (LTR303_ALS_THRES_UP_1_REG)
#define LTR303_ALS_THRES_UP_1__POS (0)
#define LTR303_ALS_THRES_UP_1__MSK (0xFF)
#define LTR303_ALS_THRES_LOW_0__REG (LTR303_ALS_THRES_LOW_0_REG)
#define LTR303_ALS_THRES_LOW_0__POS (0)
#define LTR303_ALS_THRES_LOW_0__MSK (0xFF)
#define LTR303_ALS_THRES_LOW_1__REG (LTR303_ALS_THRES_LOW_1_REG)
#define LTR303_ALS_THRES_LOW_1__POS (0)
#define LTR303_ALS_THRES_LOW_1__MSK (0xFF)
/* Register INTERRUPT_PERSIST field */
#define LTR303_ALS_PERSIST__REG (LTR303_INTERRUPT_PERSIST_REG)
#define LTR303_ALS_PERSIST__POS (0)
#define LTR303_ALS_PERSIST__MSK (0x0F)
/* Field value enumeration */
typedef enum {
LTR303_ALS_STANDBY_MODE = 0x00,
LTR303_ALS_ACTIVE_MODE = 0x01,
} LTR303_ALS_MODE_VAL;
typedef enum {
LTR303_ALS_NO_RESET = 0x00,
LTR303_ALS_RESET = 0x01,
} LTR_303_SW_RESET_VAL;
typedef enum {
LTR303_ALS_GAIN_1x = 0x00, /* 1 lux to 64k lux (default) */
LTR303_ALS_GAIN_2x = 0x01, /* 0.5 lux to 32k lux */
LTR303_ALS_GAIN_4x = 0x02, /* 0.25 lux to 16k lux */
LTR303_ALS_GAIN_8x = 0x03, /* 0.125 lux to 8k lux */
LTR303_ALS_GAIN_48x = 0x06, /* 0.02 lux to 1.3k lux */
LTR303_ALS_GAIN_96x = 0x07, /* 0.01 lux to 600 lux */
} LTR303_ALS_Gain_VAL;
typedef enum {
LTR303_ALS_MEAS_RPT_RATE_50MS = 0x00,
LTR303_ALS_MEAS_RPT_RATE_100MS = 0x01,
LTR303_ALS_MEAS_RPT_RATE_200MS = 0x02,
LTR303_ALS_MEAS_RPT_RATE_500MS = 0x03,
LTR303_ALS_MEAS_RPT_RATE_1000MS = 0x04,
LTR303_ALS_MEAS_RPT_RATE_2000MS = 0x05,
} LTR303_ALS_MEAS_RPT_RATE_VAL;
typedef enum {
LTR303_ALS_INTEG_TIME_100MS = 0x00,
LTR303_ALS_INTEG_TIME_50MS = 0x01,
LTR303_ALS_INTEG_TIME_200MS = 0x02,
LTR303_ALS_INTEG_TIME_400MS = 0x03,
LTR303_ALS_INTEG_TIME_150MS = 0x04,
LTR303_ALS_INTEG_TIME_250MS = 0x05,
LTR303_ALS_INTEG_TIME_300MS = 0x06,
LTR303_ALS_INTEG_TIME_350MS = 0x07,
} LTR303_ALS_INTEG_TIME_VAL;
typedef enum {
LTR303_ALS_DATA_OLD = 0x00,
LTR303_ALS_DATA_NEW = 0x01,
} LTR303_ALS_DATA_STATUS_VAL;
typedef enum {
LTR303_ALS_INT_INACTIVE = 0x00,
LTR303_ALS_INT_ACTIVE = 0x01,
} LTR303_ALS_INT_STATUS_VAL;
typedef enum {
LTR303_ALS_DATA_VALID = 0x00,
LTR303_ALS_DATA_INVALID = 0x01,
} LTR303_ALS_DATA_VALIDITY_VAL;
typedef enum {
LTR303_INT_MODE_INACTIVE = 0x00,
LTR303_INT_MODE_ACTIVE = 0x01,
} LTR303_INT_MODE_VAL;
typedef enum {
LTR303_INT_POLARITY_ACTIVE_LO = 0x00,
LTR303_INT_POLARITY_ACTIVE_HI = 0x01,
} LTR303_INT_POLARITY_VAL;
typedef enum {
LTR303_ALS_PERSIST_EACH = 0x00,
LTR303_ALS_PERSIST_2_CONT = 0x01,
LTR303_ALS_PERSIST_16_CONT = 0x0F,
} LTR303_ALS_PERSIST_VAL;
i2c_dev_t ltr303_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr = LTR303_I2C_ADDR,
};
static uint8_t g_init_bitwise = 0;
static int drv_als_liteon_ltr303_validate_id(i2c_dev_t* drv, uint8_t part_id, uint8_t manufac_id)
{
int ret = 0;
uint8_t part_id_value = 0;
uint8_t manufac_id_value = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, LTR303_PART_ID_REG, &part_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, LTR303_MANUFAC_ID_REG, &manufac_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (part_id_value != part_id || manufac_id_value != manufac_id) {
return -1;
}
return 0;
}
static int drv_als_liteon_ltr303_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR303_ALS_CONTR_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_OFF:
case DEV_SLEEP:
dev_mode = LTR303_SET_BITSLICE(value, ALS_MODE, LTR303_ALS_STANDBY_MODE);
break;
case DEV_POWER_ON:
dev_mode = LTR303_SET_BITSLICE(value, ALS_MODE, LTR303_ALS_ACTIVE_MODE);
break;
default:
return -1;
}
ret = sensor_i2c_write(drv, LTR303_ALS_CONTR_REG, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
UNUSED static int drv_als_liteon_ltr303_is_ready(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR303_ALS_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return 0;
}
ret = (LTR303_GET_BITSLICE(value, ALS_DATA_STATUS) == LTR303_ALS_DATA_NEW) ? 1 : 0;
return ret;
}
/**************************************************************************//**
* @brief
* Configure the settings of the sensor.
* This function assumes that the 100ms wait time requirement
* after sensor power up has been fulfilled.
* @details
* 1. The function first sets ALS_MODE field to Standby mode.
* 2. Then it configures the corresponding registers to default configurations.
* @param[in] drv
* The I2C peripheral to use.
* @return
* 0 if configuration is successful, -1 otherwise.
*****************************************************************************/
static int drv_als_liteon_ltr303_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
/* Set ALS_MODE field to standby mode, no SW reset, and set ALS_GAIN field */
value = LTR303_SET_BITSLICE(value, ALS_MODE, LTR303_ALS_STANDBY_MODE);
value = LTR303_SET_BITSLICE(value, SW_RESET, LTR303_ALS_NO_RESET);
value = LTR303_SET_BITSLICE(value, ALS_GAIN, LTR303_ALS_GAIN_1x);
ret = sensor_i2c_write(drv, LTR303_ALS_CONTR_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
/* Set ALS_MEAS_RPT_RATE, ALS_INTEG_TIME fields */
value = 0;
value = LTR303_SET_BITSLICE(value, ALS_MEAS_RPT_RATE, LTR303_ALS_MEAS_RPT_RATE_500MS);
value = LTR303_SET_BITSLICE(value, ALS_INTEG_TIME, LTR303_ALS_INTEG_TIME_100MS);
ret = sensor_i2c_write(drv, LTR303_ALS_MEAS_RATE_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
/* Set INT_MODE, INT_POLARITY fields */
value = 0;
value = LTR303_SET_BITSLICE(value, INT_MODE, LTR303_INT_MODE_INACTIVE);
value = LTR303_SET_BITSLICE(value, INT_POLARITY, LTR303_INT_POLARITY_ACTIVE_LO);
ret = sensor_i2c_write(drv, LTR303_INTERRUPT_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
/* Set ALS_PERSIST fields */
value = 0;
value = LTR303_SET_BITSLICE(value, ALS_PERSIST, LTR303_ALS_PERSIST_EACH);
ret = sensor_i2c_write(drv, LTR303_INTERRUPT_PERSIST_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static uint8_t drv_als_liteon_ltr303_get_gain_val(i2c_dev_t* drv)
{
uint8_t als_gain = 0, als_gain_val = 0;
bool ret = false;
ret = sensor_i2c_read(drv, LTR303_ALS_STATUS_REG, &als_gain, I2C_DATA_LEN, I2C_OP_RETRIES);
if (!unlikely(ret))
{
als_gain = LTR303_GET_BITSLICE(als_gain, ALS_GAIN_STATUS);
switch (als_gain)
{
case LTR303_ALS_GAIN_1x:
als_gain_val = 1;
break;
case LTR303_ALS_GAIN_2x:
als_gain_val = 2;
break;
case LTR303_ALS_GAIN_4x:
als_gain_val = 4;
break;
case LTR303_ALS_GAIN_8x:
als_gain_val = 8;
break;
case LTR303_ALS_GAIN_48x:
als_gain_val = 48;
break;
case LTR303_ALS_GAIN_96x:
als_gain_val = 96;
break;
default:
als_gain_val = 1;
break;
}
}
else
{
als_gain_val = 0;
}
return als_gain_val;
}
static uint16_t drv_als_liteon_ltr303_get_integ_time_val(i2c_dev_t* drv)
{
uint16_t als_integ = 0, als_integ_val = 0;
bool ret = false;
ret = sensor_i2c_read(drv, LTR303_ALS_MEAS_RATE_REG, (uint8_t*)&als_integ, I2C_DATA_LEN, I2C_OP_RETRIES);
if (!unlikely(ret))
{
als_integ = LTR303_GET_BITSLICE(als_integ, ALS_INTEG_TIME);
switch (als_integ)
{
case LTR303_ALS_INTEG_TIME_100MS:
als_integ_val = 10;
break;
case LTR303_ALS_INTEG_TIME_50MS:
als_integ_val = 5;
break;
case LTR303_ALS_INTEG_TIME_200MS:
als_integ_val = 20;
break;
case LTR303_ALS_INTEG_TIME_400MS:
als_integ_val = 40;
break;
case LTR303_ALS_INTEG_TIME_150MS:
als_integ_val = 15;
break;
case LTR303_ALS_INTEG_TIME_250MS:
als_integ_val = 25;
break;
case LTR303_ALS_INTEG_TIME_300MS:
als_integ_val = 30;
break;
case LTR303_ALS_INTEG_TIME_350MS:
als_integ_val = 35;
break;
default:
als_integ_val = 10;
break;
}
}
else
{
als_integ_val = 0;
}
return als_integ_val;
}
static void drv_als_liteon_ltr303_irq_handle(void)
{
/* no handle so far */
}
static int drv_als_liteon_ltr303_open(void)
{
int ret = 0;
ret = drv_als_liteon_ltr303_set_power_mode(<r303_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_als_liteon_ltr303_close(void)
{
int ret = 0;
ret = drv_als_liteon_ltr303_set_power_mode(<r303_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_als_liteon_ltr303_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg_ch1_data[2] = { 0 };
uint8_t reg_ch0_data[2] = { 0 };
uint32_t als_data_ch0 = 0, als_data_ch1 = 0, chRatio = 0, tmpCalc = 0;
uint16_t als_gain_val = 0, als_integ_time_val = 0;
als_data_t * pdata = (als_data_t *) buf;
if (buf == NULL){
return -1;
}
size = sizeof(als_data_t);
if (len < size){
return -1;
}
ret = sensor_i2c_read(<r303_ctx, LTR303_ALS_DATA_CH1_0_REG, ®_ch1_data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r303_ctx, LTR303_ALS_DATA_CH1_1_REG, ®_ch1_data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r303_ctx, LTR303_ALS_DATA_CH0_0_REG, ®_ch0_data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r303_ctx, LTR303_ALS_DATA_CH0_1_REG, ®_ch0_data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
als_data_ch0 = ((uint16_t) reg_ch0_data[1] << 8 | reg_ch0_data[0]);
als_data_ch1 = ((uint16_t) reg_ch1_data[1] << 8 | reg_ch1_data[0]);
chRatio = (als_data_ch1 * 100) / (als_data_ch0 + als_data_ch1);
if (chRatio < 45)
{
tmpCalc = (1774 * als_data_ch0 + 1106 * als_data_ch1);
}
else if (chRatio >= 45 && chRatio < 64)
{
tmpCalc = (4279 * als_data_ch0 - 1955 * als_data_ch1);
}
else if (chRatio >= 64 && chRatio < 85)
{
tmpCalc = (593 * als_data_ch0 + 119 * als_data_ch1);
}
else
{
tmpCalc = 0;
}
als_gain_val = drv_als_liteon_ltr303_get_gain_val(<r303_ctx);
als_integ_time_val = drv_als_liteon_ltr303_get_integ_time_val(<r303_ctx);
if ((als_gain_val != 0) && (als_integ_time_val != 0))
{
pdata->lux = tmpCalc / als_gain_val / als_integ_time_val / 100;
}
else
{
pdata->lux = 0;
}
pdata->timestamp = aos_now_ms();
return (int) size;
}
static int drv_als_liteon_ltr303_write(const void *buf, size_t len)
{
(void) buf;
(void) len;
return 0;
}
static int drv_als_liteon_ltr303_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
ret = drv_als_liteon_ltr303_set_power_mode(<r303_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *) arg;
info->vendor = DEV_SENSOR_VENDOR_LITEON;
info->model = "LTR303";
info->unit = lux;
} break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_als_liteon_ltr303_init(void)
{
int ret = 0;
sensor_obj_t sensor_als;
memset(&sensor_als, 0, sizeof(sensor_als));
if (!g_init_bitwise) {
ret = drv_als_liteon_ltr303_validate_id(<r303_ctx, LTR303_PART_ID_VAL, LTR303_MANUFAC_ID_VAL);
if (unlikely(ret)) {
return -1;
}
}
if (!g_init_bitwise) {
/* fill the sensor_als obj parameters here */
sensor_als.path = dev_als_path;
sensor_als.tag = TAG_DEV_ALS;
sensor_als.io_port = I2C_PORT;
sensor_als.mode = DEV_POLLING;
sensor_als.power = DEV_POWER_OFF;
sensor_als.open = drv_als_liteon_ltr303_open;
sensor_als.close = drv_als_liteon_ltr303_close;
sensor_als.read = drv_als_liteon_ltr303_read;
sensor_als.write = drv_als_liteon_ltr303_write;
sensor_als.ioctl = drv_als_liteon_ltr303_ioctl;
sensor_als.irq_handle = drv_als_liteon_ltr303_irq_handle;
ret = sensor_create_obj(&sensor_als);
if (unlikely(ret)) {
return -1;
}
ret = drv_als_liteon_ltr303_set_default_config(<r303_ctx);
if (unlikely(ret)) {
return -1;
}
g_init_bitwise |= 1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_als_liteon_ltr303_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_als_liteon_ltr303.c
|
C
|
apache-2.0
| 20,755
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LTR568_I2C_SLAVE_ADDR 0x23
#define LTR568_ALS_AVE_LIMIT 0x7E /* ALS digital averaging limit */
#define LTR568_ALS_AVE_FAC 0x7F /* ALS digital averaging factor */
#define LTR568_ALS_CONTR 0x80 /* ALS operation mode */
#define LTR568_PS_CONTR 0x81 /* PS operation mode, SW reset */
#define LTR568_PS_LED 0x82 /* PS LED pulse freq, current duty, peak current */
#define LTR568_PS_N_PULSES 0x83 /* PS number of pulses */
#define LTR568_PS_MEAS_RATE 0x84 /* PS measurement rate*/
#define LTR568_ALS_INT_TIME 0x85 /* ALS integ time, measurement rate*/
#define LTR568_PART_ID 0x86
#define LTR568_MANUFAC_ID 0x87
#define LTR568_ALS_STATUS 0x88
#define LTR568_IR_DATA_LSB 0x89 /* ALS/RGB measurement IR data, LSB */
#define LTR568_IR_DATA_MSB 0x8A /* ALS/RGB measurement IR data, MSB */
#define LTR568_GREEN_DATA_LSB 0x8B /* ALS/RGB measurement Green data, LSB */
#define LTR568_GREEN_DATA_MSB 0x8C /* ALS/RGB measurement Green data, MSB */
#define LTR568_PS_STATUS 0x91
#define LTR568_PS_DATA_LSB 0x92
#define LTR568_PS_DATA_MSB 0x93
#define LTR568_PS_SAR 0x94
#define LTR568_ALS_SAR 0x95
#define LTR568_INTERRUPT 0x98
#define LTR568_INTR_PRST 0x99 /* ALS/PS interrupt persist setting */
#define LTR568_PS_THRES_HIGH_LSB 0x9A /* PS interrupt upper threshold, lower byte */
#define LTR568_PS_THRES_HIGH_MSB 0x9B /* PS interrupt upper threshold, upper byte */
#define LTR568_PS_THRES_LOW_LSB 0x9C /* PS interrupt lower threshold, lower byte */
#define LTR568_PS_THRES_LOW_MSB 0x9D /* PS interrupt lower threshold, upper byte */
#define LTR568_PXTALK_LSB 0x9E /* Crosstalk correction on PS CH0 PD, lower byte */
#define LTR568_PXTALK_MSB 0x9F /* Crosstalk correction on PS CH0 PD, upper byte */
#define LTR568_PS_VREHL 0xB6 /* External PS VREHL value, affect PS */
#define LTR568_ADDR_TRANS(n) ((n) << 1)
#define LTR568_I2C_ADDR LTR568_ADDR_TRANS(LTR568_I2C_SLAVE_ADDR)
#define LTR568_PART_ID_VAL 0x1C
#define LTR568_MANUFAC_ID_VAL 0x05
#define LTR568_ALS_AVE_LIMIT_REG_ALS_AVE_LIMIT__POS (0)
#define LTR568_ALS_AVE_LIMIT_REG_ALS_AVE_LIMIT__MSK (0x03)
#define LTR568_ALS_AVE_LIMIT_REG_ALS_AVE_LIMIT__REG (LTR568_ALS_AVE_LIMIT)
#define LTR568_ALS_CONTR_REG_ALS_MODE__POS (0)
#define LTR568_ALS_CONTR_REG_ALS_MODE__MSK (0x01)
#define LTR568_ALS_CONTR_REG_ALS_MODE__REG (LTR568_ALS_CONTR)
#define LTR568_ALS_CONTR_REG_ALS_SAR__POS (1)
#define LTR568_ALS_CONTR_REG_ALS_SAR__MSK (0x02)
#define LTR568_ALS_CONTR_REG_ALS_SAR__REG (LTR568_ALS_CONTR)
#define LTR568_ALS_CONTR_REG_ALS_GAIN__POS (2)
#define LTR568_ALS_CONTR_REG_ALS_GAIN__MSK (0x1C)
#define LTR568_ALS_CONTR_REG_ALS_GAIN__REG (LTR568_ALS_CONTR)
#define LTR568_ALS_CONTR_REG_IR_EN__POS (5)
#define LTR568_ALS_CONTR_REG_IR_EN__MSK (0x20)
#define LTR568_ALS_CONTR_REG_IR_EN__REG (LTR568_ALS_CONTR)
#define LTR568_ALS_CONTR_REG_ALS_RES__POS (6)
#define LTR568_ALS_CONTR_REG_ALS_RES__MSK (0xC0)
#define LTR568_ALS_CONTR_REG_ALS_RES__REG (LTR568_ALS_CONTR)
#define LTR568_PS_CONTR_REG_SW_RESET__POS (0)
#define LTR568_PS_CONTR_REG_SW_RESET__MSK (0x01)
#define LTR568_PS_CONTR_REG_SW_RESET__REG (LTR568_PS_CONTR)
#define LTR568_PS_CONTR_REG_PS_MODE__POS (1)
#define LTR568_PS_CONTR_REG_PS_MODE__MSK (0x02)
#define LTR568_PS_CONTR_REG_PS_MODE__REG (LTR568_PS_CONTR)
#define LTR568_PS_CONTR_REG_FTN_NTF_EN__POS (2)
#define LTR568_PS_CONTR_REG_FTN_NTF_EN__MSK (0x04)
#define LTR568_PS_CONTR_REG_FTN_NTF_EN__REG (LTR568_PS_CONTR)
#define LTR568_PS_CONTR_REG_PS_OS__POS (3)
#define LTR568_PS_CONTR_REG_PS_OS__MSK (0x08)
#define LTR568_PS_CONTR_REG_PS_OS__REG (LTR568_PS_CONTR)
#define LTR568_PS_LED_REG_LED_CURR__POS (0)
#define LTR568_PS_LED_REG_LED_CURR__MSK (0x07)
#define LTR568_PS_LED_REG_LED_CURR__REG (LTR568_PS_LED)
#define LTR568_PS_LED_REG_PULSE_WIDTH__POS (3)
#define LTR568_PS_LED_REG_PULSE_WIDTH__MSK (0x18)
#define LTR568_PS_LED_REG_PULSE_WIDTH__REG (LTR568_PS_LED)
#define LTR568_PS_LED_REG_PULSE_DUTY__POS (5)
#define LTR568_PS_LED_REG_PULSE_DUTY__MSK (0x60)
#define LTR568_PS_LED_REG_PULSE_DUTY__REG (LTR568_PS_LED)
#define LTR568_PS_N_PULSES_REG_PULSE_COUNT__POS (0)
#define LTR568_PS_N_PULSES_REG_PULSE_COUNT__MSK (0x3F)
#define LTR568_PS_N_PULSES_REG_PULSE_COUNT__REG (LTR568_PS_N_PULSES)
#define LTR568_PS_N_PULSES_REG_PS_AVE_FAC__POS (6)
#define LTR568_PS_N_PULSES_REG_PS_AVE_FAC__MSK (0xC0)
#define LTR568_PS_N_PULSES_REG_PS_AVE_FAC__REG (LTR568_PS_N_PULSES)
#define LTR568_PS_MEAS_RATE_REG_MEAS_RATE__POS (0)
#define LTR568_PS_MEAS_RATE_REG_MEAS_RATE__MSK (0x07)
#define LTR568_PS_MEAS_RATE_REG_MEAS_RATE__REG (LTR568_PS_MEAS_RATE)
#define LTR568_ALS_INT_TIME_REG_MEAS_RATE__POS (0)
#define LTR568_ALS_INT_TIME_REG_MEAS_RATE__MSK (0x03)
#define LTR568_ALS_INT_TIME_REG_MEAS_RATE__REG (LTR568_ALS_INT_TIME)
#define LTR568_ALS_INT_TIME_REG_INTEG_TIME__POS (2)
#define LTR568_ALS_INT_TIME_REG_INTEG_TIME__MSK (0x0C)
#define LTR568_ALS_INT_TIME_REG_INTEG_TIME__REG (LTR568_ALS_INT_TIME)
#define LTR568_ALS_STATUS_REG_ALS_DATA_STATUS__POS (0)
#define LTR568_ALS_STATUS_REG_ALS_DATA_STATUS__MSK (0x01)
#define LTR568_ALS_STATUS_REG_ALS_DATA_STATUS__REG (LTR568_ALS_STATUS)
#define LTR568_ALS_STATUS_REG_ALS_INT_STATUS__POS (1)
#define LTR568_ALS_STATUS_REG_ALS_INT_STATUS__MSK (0x02)
#define LTR568_ALS_STATUS_REG_ALS_INT_STATUS__REG (LTR568_ALS_STATUS)
#define LTR568_ALS_STATUS_REG_ALS_GAIN__POS (3)
#define LTR568_ALS_STATUS_REG_ALS_GAIN__MSK (0x78)
#define LTR568_ALS_STATUS_REG_ALS_GAIN__REG (LTR568_ALS_STATUS)
#define LTR568_ALS_STATUS_REG_DATA_VALIDITY__POS (7)
#define LTR568_ALS_STATUS_REG_DATA_VALIDITY__MSK (0x80)
#define LTR568_ALS_STATUS_REG_DATA_VALIDITY__REG (LTR568_ALS_STATUS)
#define LTR568_PS_STATUS_REG_PS_DATA_STATUS__POS (0)
#define LTR568_PS_STATUS_REG_PS_DATA_STATUS__MSK (0x01)
#define LTR568_PS_STATUS_REG_PS_DATA_STATUS__REG (LTR568_PS_STATUS)
#define LTR568_PS_STATUS_REG_PS_INT_STATUS__POS (1)
#define LTR568_PS_STATUS_REG_PS_INT_STATUS__MSK (0x02)
#define LTR568_PS_STATUS_REG_PS_INT_STATUS__REG (LTR568_PS_STATUS)
#define LTR568_PS_STATUS_REG_AMBIENT_SAT__POS (2)
#define LTR568_PS_STATUS_REG_AMBIENT_SAT__MSK (0x04)
#define LTR568_PS_STATUS_REG_AMBIENT_SAT__REG (LTR568_PS_STATUS)
#define LTR568_PS_STATUS_REG_NTF__POS (4)
#define LTR568_PS_STATUS_REG_NTF__MSK (0x10)
#define LTR568_PS_STATUS_REG_NTF__REG (LTR568_PS_STATUS)
#define LTR568_PS_STATUS_REG_FTN__POS (5)
#define LTR568_PS_STATUS_REG_FTN__MSK (0x20)
#define LTR568_PS_STATUS_REG_FTN__REG (LTR568_PS_STATUS)
#define LTR568_INTERRUPT_REG_INT_MODE__POS (0)
#define LTR568_INTERRUPT_REG_INT_MODE__MSK (0x03)
#define LTR568_INTERRUPT_REG_INT_MODE__REG (LTR568_INTERRUPT)
#define LTR568_INTERRUPT_REG_INT_POLARITY__POS (2)
#define LTR568_INTERRUPT_REG_INT_POLARITY__MSK (0x04)
#define LTR568_INTERRUPT_REG_INT_POLARITY__REG (LTR568_INTERRUPT)
#define LTR568_INTR_PRST_REG_ALS_PERSIST__POS (0)
#define LTR568_INTR_PRST_REG_ALS_PERSIST__MSK (0x0F)
#define LTR568_INTR_PRST_REG_ALS_PERSIST__REG (LTR568_INTR_PRST)
#define LTR568_INTR_PRST_REG_PS_PERSIST__POS (4)
#define LTR568_INTR_PRST_REG_PS_PERSIST__MSK (0xF0)
#define LTR568_INTR_PRST_REG_PS_PERSIST__REG (LTR568_INTR_PRST)
#define LTR568_GET_BITSLICE(regvar, bitname) ((regvar & LTR568_##bitname##__MSK) >> LTR568_##bitname##__POS)
#define LTR568_SET_BITSLICE(regvar, bitname, val) ((regvar & ~LTR568_##bitname##__MSK) | ((val<<LTR568_##bitname##__POS)<R568_##bitname##__MSK))
#define LTR568_WAIT_TIME_PER_CHECK (10)
#define LTR568_WAIT_TIME_TOTAL (100)
typedef enum {
LTR568_ALS_AVE_LIMIT_511 = 0x00,
LTR568_ALS_AVE_LIMIT_255 = 0x01,
LTR568_ALS_AVE_LIMIT_127 = 0x02,
} LTR568_CFG_ALS_AVE_LIMIT;
typedef enum {
LTR568_ALS_STANDBY = 0x00,
LTR568_ALS_ACTIVE = 0x01,
} LTR568_CFG_ALS_MODE;
typedef enum {
LTR568_ALS_SAR_ENABLE = 0x00,
LTR568_ALS_SAR_DISABLE = 0x01,
} LTR568_CFG_ALS_SAR_ENB;
typedef enum {
LTR568_ALS_GAIN_1X = 0x00,
LTR568_ALS_GAIN_4X = 0x01,
LTR568_ALS_GAIN_16X = 0x02,
LTR568_ALS_GAIN_64X = 0x03,
LTR568_ALS_GAIN_128X = 0x04,
LTR568_ALS_GAIN_512X = 0x05,
} LTR568_CFG_ALS_Gain;
typedef enum {
LTR568_IR_DISABLE = 0x00,
LTR568_IR_ENABLE = 0x01,
} LTR568_CFG_IR_EN;
typedef enum {
LTR568_ALS_RES_16BIT = 0x00,
LTR568_ALS_RES_15BIT = 0x01,
LTR568_ALS_RES_14BIT = 0x02,
LTR568_ALS_RES_13BIT = 0x03,
} LTR568_CFG_ALS_RESOLUTION;
typedef enum {
LTR568_SW_RESET_FALSE = 0x00,
LTR568_SW_RESET_TRUE = 0x01,
} LTR568_CFG_SW_RESET;
typedef enum {
LTR568_PS_STANDBY = 0x00,
LTR568_PS_ACTIVE = 0x01,
} LTR568_CFG_PS_MODE;
typedef enum {
LTR568_FTN_NTF_DISABLE = 0x00,
LTR568_FTN_NTF_ENABLE = 0x01,
} LTR568_CFG_FTN_NTF_EN;
typedef enum {
LTR568_PS_OS_DISABLE = 0x00,
LTR568_PS_OS_ENABLE = 0x01,
} LTR568_CFG_PS_OS;
typedef enum {
LTR568_PS_LED_CURRENT_0mA = 0x00,
LTR568_PS_LED_CURRENT_50mA = 0x01,
LTR568_PS_LED_CURRENT_100mA = 0x02,
LTR568_PS_LED_CURRENT_120mA = 0x03,
LTR568_PS_LED_CURRENT_140mA = 0x04,
LTR568_PS_LED_CURRENT_170mA = 0x05,
LTR568_PS_LED_CURRENT_190mA = 0x06,
LTR568_PS_LED_CURRENT_240mA = 0x07,
} LTR568_CFG_PS_LED_CURRENT;
typedef enum {
LTR568_PS_PULSE_WIDTH_4us = 0x00,
LTR568_PS_PULSE_WIDTH_8us = 0x01,
LTR568_PS_PULSE_WIDTH_16us = 0x02,
LTR568_PS_PULSE_WIDTH_32us = 0x03,
} LTR568_CFG_PS_LED_PULSE_WIDTH;
typedef enum {
LTR568_PS_PULSE_DUTY_12_5PCT = 0x00,
LTR568_PS_PULSE_DUTY_25PCT = 0x01,
LTR568_PS_PULSE_DUTY_50PCT = 0x02,
LTR568_PS_PULSE_DUTY_100PCT = 0x03,
} LTR568_CFG_PS_LED_PULSE_DUTY;
typedef enum {
LTR568_PS_AVE_FAC_0n = 0x00,
LTR568_PS_AVE_FAC_2n = 0x01,
LTR568_PS_AVE_FAC_4n = 0x02,
LTR568_PS_AVE_FAC_5n = 0x03,
} LTR568_CFG_PS_AVE_FAC;
typedef enum {
LTR568_PS_MEAS_RATE_6_125 = 0x00, /* PS Measurement Repeat Rate = 6.125ms */
LTR568_PS_MEAS_RATE_12_5 = 0x01, /* PS Measurement Repeat Rate = 12.5ms */
LTR568_PS_MEAS_RATE_25 = 0x02, /* PS Measurement Repeat Rate = 25ms */
LTR568_PS_MEAS_RATE_50 = 0x03, /* PS Measurement Repeat Rate = 50ms */
LTR568_PS_MEAS_RATE_100 = 0x04, /* PS Measurement Repeat Rate = 100ms (default) */
LTR568_PS_MEAS_RATE_200 = 0x05, /* PS Measurement Repeat Rate = 200ms */
LTR568_PS_MEAS_RATE_400 = 0x06, /* PS Measurement Repeat Rate = 400ms */
LTR568_PS_MEAS_RATE_800 = 0x07, /* PS Measurement Repeat Rate = 800ms */
} LTR568_CFG_PS_MEAS_RATE;
typedef enum {
LTR568_ALS_MEAS_RATE_100 = 0x00, /* ALS Measurement Repeat Rate = 100ms */
LTR568_ALS_MEAS_RATE_200 = 0x01, /* ALS Measurement Repeat Rate = 200ms */
LTR568_ALS_MEAS_RATE_400 = 0x02, /* ALS Measurement Repeat Rate = 400ms (default) */
LTR568_ALS_MEAS_RATE_800 = 0x03, /* ALS Measurement Repeat Rate = 800ms */
} LTR568_CFG_ALS_MEAS_RATE;
typedef enum {
LTR568_ALS_INT_TIME_50 = 0x00, /* ALS Measurement Repeat Rate = 50ms */
LTR568_ALS_INT_TIME_100 = 0x01, /* ALS Measurement Repeat Rate = 100ms (default) */
LTR568_ALS_INT_TIME_200 = 0x02, /* ALS Measurement Repeat Rate = 200ms */
LTR568_ALS_INT_TIME_400 = 0x03, /* ALS Measurement Repeat Rate = 400ms */
} LTR568_CFG_ALS_INT_TIME;
typedef enum {
LTR568_ALS_DATA_STATUS_OLD = 0x00,
LTR568_ALS_DATA_STATUS_NEW = 0x01,
} LTR568_CFG_ALS_DATA_STATUS;
typedef enum {
LTR568_ALS_INT_FALSE = 0x00,
LTR568_ALS_INT_TRUE = 0x01,
} LTR568_CFG_ALS_INT_STATUS;
typedef enum {
LTR568_ALS_DATA_VALID = 0x00,
LTR568_ALS_DATA_INVALID = 0x01,
} LTR568_CFG_ALS_DATA_VALIDITY;
typedef enum {
LTR568_PS_DATA_STATUS_OLD = 0x00,
LTR568_PS_DATA_STATUS_NEW = 0x01,
} LTR568_CFG_PS_DATA_STATUS;
typedef enum {
LTR568_PS_INT_FALSE = 0x00,
LTR568_PS_INT_TRUE = 0x01,
} LTR568_CFG_PS_INT_STATUS;
typedef enum {
LTR568_PS_AMBIENT_SAT_FALSE = 0x00,
LTR568_PS_AMBIENT_SAT_TRUE = 0x01,
} LTR568_CFG_PS_AMBIENT_SAT_STATUS;
typedef enum {
LTR568_PS_NTF_FALSE = 0x00,
LTR568_PS_NTF_TRUE = 0x01,
} LTR568_CFG_PS_NTF_STATUS;
typedef enum {
LTR568_PS_FTN_FALSE = 0x00,
LTR568_PS_FTN_TRUE = 0x01,
} LTR568_CFG_PS_FTN_STATUS;
typedef enum {
LTR568_INT_INACTIVE = 0x00,
LTR568_INT_PS = 0x01,
LTR568_INT_ALS = 0x02,
LTR568_INT_ALS_PS = 0x02,
} LTR568_CFG_INT_MODE;
typedef enum {
LTR568_INT_ACTIVE_LO = 0x00,
LTR568_INT_ACTIVE_HI = 0x01,
} LTR568_CFG_INT_POLARITY;
typedef enum {
LTR568_FLAG_INIT_ALS = 0,
LTR568_FLAG_INIT_PS,
LTR568_FLAG_INIT_RGB,
} LTR568_FLAG_INIT_BIT;
i2c_dev_t ltr568_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr = LTR568_I2C_ADDR,
};
static uint8_t g_init_bitwise = 0;
static int drv_als_ps_liteon_ltr568_validate_id(i2c_dev_t* drv, uint8_t part_id, uint8_t manufac_id)
{
int ret = 0;
uint8_t part_id_value = 0;
uint8_t manufac_id_value = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, LTR568_PART_ID, &part_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, LTR568_MANUFAC_ID, &manufac_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (part_id_value != part_id || manufac_id_value != manufac_id) {
return -1;
}
return 0;
}
static int drv_als_liteon_ltr568_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR568_ALS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_OFF:
case DEV_SLEEP:
dev_mode = LTR568_SET_BITSLICE(value, ALS_CONTR_REG_ALS_MODE, LTR568_ALS_STANDBY);
break;
case DEV_POWER_ON:
dev_mode = LTR568_SET_BITSLICE(value, ALS_CONTR_REG_ALS_MODE, LTR568_ALS_ACTIVE);
break;
default:
return -1;
}
ret = sensor_i2c_write(drv, LTR568_ALS_CONTR, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_ps_liteon_ltr568_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR568_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_OFF:
case DEV_SLEEP:
dev_mode = LTR568_SET_BITSLICE(value, PS_CONTR_REG_PS_MODE, LTR568_PS_STANDBY);
break;
case DEV_POWER_ON:
dev_mode = LTR568_SET_BITSLICE(value, PS_CONTR_REG_PS_MODE, LTR568_PS_ACTIVE);
break;
default:
return -1;
}
ret = sensor_i2c_write(drv, LTR568_PS_CONTR, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
UNUSED static int drv_als_liteon_ltr568_is_ready(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR568_ALS_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return 0;
}
ret = (LTR568_GET_BITSLICE(value, ALS_STATUS_REG_ALS_DATA_STATUS) == LTR568_ALS_DATA_STATUS_NEW) ? 1 : 0;
return ret;
}
UNUSED static int drv_ps_liteon_ltr568_is_ready(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR568_PS_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return 0;
}
ret = (LTR568_GET_BITSLICE(value, PS_STATUS_REG_PS_DATA_STATUS) == LTR568_PS_DATA_STATUS_NEW) ? 1 : 0;
return ret;
}
static int drv_als_liteon_ltr568_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = LTR568_SET_BITSLICE(value, ALS_AVE_LIMIT_REG_ALS_AVE_LIMIT, LTR568_ALS_AVE_LIMIT_255);
ret = sensor_i2c_write(drv, LTR568_ALS_AVE_LIMIT, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
ret = sensor_i2c_write(drv, LTR568_ALS_AVE_FAC, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, LTR568_ALS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = LTR568_SET_BITSLICE(value, ALS_CONTR_REG_ALS_SAR, LTR568_ALS_SAR_DISABLE);
value = LTR568_SET_BITSLICE(value, ALS_CONTR_REG_ALS_GAIN, LTR568_ALS_GAIN_1X);
value = LTR568_SET_BITSLICE(value, ALS_CONTR_REG_IR_EN, LTR568_IR_ENABLE);
value = LTR568_SET_BITSLICE(value, ALS_CONTR_REG_ALS_RES, LTR568_ALS_RES_16BIT);
ret = sensor_i2c_write(drv, LTR568_ALS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR568_SET_BITSLICE(value, ALS_INT_TIME_REG_MEAS_RATE, LTR568_ALS_MEAS_RATE_400);
value = LTR568_SET_BITSLICE(value, ALS_INT_TIME_REG_INTEG_TIME, LTR568_ALS_INT_TIME_100);
ret = sensor_i2c_write(drv, LTR568_ALS_INT_TIME, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_ps_liteon_ltr568_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR568_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = LTR568_SET_BITSLICE(value, PS_CONTR_REG_FTN_NTF_EN, LTR568_FTN_NTF_DISABLE);
value = LTR568_SET_BITSLICE(value, PS_CONTR_REG_PS_OS, LTR568_PS_OS_DISABLE);
ret = sensor_i2c_write(drv, LTR568_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR568_SET_BITSLICE(value, PS_LED_REG_LED_CURR, LTR568_PS_LED_CURRENT_100mA);
value = LTR568_SET_BITSLICE(value, PS_LED_REG_PULSE_WIDTH, LTR568_PS_PULSE_WIDTH_32us);
value = LTR568_SET_BITSLICE(value, PS_LED_REG_PULSE_DUTY, LTR568_PS_PULSE_DUTY_100PCT);
ret = sensor_i2c_write(drv, LTR568_PS_LED, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR568_SET_BITSLICE(value, PS_N_PULSES_REG_PULSE_COUNT, 0);
value = LTR568_SET_BITSLICE(value, PS_N_PULSES_REG_PS_AVE_FAC, LTR568_PS_AVE_FAC_0n);
ret = sensor_i2c_write(drv, LTR568_PS_N_PULSES, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR568_SET_BITSLICE(value, PS_MEAS_RATE_REG_MEAS_RATE, LTR568_PS_MEAS_RATE_100);
ret = sensor_i2c_write(drv, LTR568_PS_MEAS_RATE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static void drv_als_liteon_ltr568_irq_handle(void)
{
/* no handle so far */
}
static int drv_als_liteon_ltr568_open(void)
{
int ret = 0;
ret = drv_als_liteon_ltr568_set_power_mode(<r568_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_als_liteon_ltr568_close(void)
{
int ret = 0;
ret = drv_als_liteon_ltr568_set_power_mode(<r568_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static uint16_t drv_als_liteon_ltr568_get_gain_val(i2c_dev_t* drv)
{
uint16_t als_gain = 0, als_gain_val = 0;
bool ret = false;
ret = sensor_i2c_read(drv, LTR568_ALS_STATUS, (uint8_t*)&als_gain, I2C_DATA_LEN, I2C_OP_RETRIES);
if (!unlikely(ret))
{
als_gain = LTR568_GET_BITSLICE(als_gain, ALS_STATUS_REG_ALS_GAIN);
switch (als_gain)
{
case LTR568_ALS_GAIN_1X:
als_gain_val = 1;
break;
case LTR568_ALS_GAIN_4X:
als_gain_val = 4;
break;
case LTR568_ALS_GAIN_16X:
als_gain_val = 16;
break;
case LTR568_ALS_GAIN_64X:
als_gain_val = 64;
break;
case LTR568_ALS_GAIN_128X:
als_gain_val = 128;
break;
case LTR568_ALS_GAIN_512X:
als_gain_val = 512;
break;
default:
als_gain_val = 1;
break;
}
}
else
{
als_gain_val = 0;
}
return als_gain_val;
}
static uint16_t drv_als_liteon_ltr568_get_integ_time_val(i2c_dev_t* drv)
{
uint16_t als_integ = 0, als_integ_val = 0;
bool ret = false;
ret = sensor_i2c_read(drv, LTR568_ALS_INT_TIME, (uint8_t*)&als_integ, I2C_DATA_LEN, I2C_OP_RETRIES);
if (!unlikely(ret))
{
als_integ = LTR568_GET_BITSLICE(als_integ, ALS_INT_TIME_REG_INTEG_TIME);
switch (als_integ)
{
case LTR568_ALS_INT_TIME_50:
als_integ_val = 5;
break;
case LTR568_ALS_INT_TIME_100:
als_integ_val = 10;
break;
case LTR568_ALS_INT_TIME_200:
als_integ_val = 20;
break;
case LTR568_ALS_INT_TIME_400:
als_integ_val = 40;
break;
default:
als_integ_val = 5;
break;
}
}
else
{
als_integ_val = 0;
}
return als_integ_val;
}
static int drv_als_liteon_ltr568_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t ir_data_reg[2] = { 0 };
uint8_t als_data_reg[2] = { 0 };
uint8_t als_sar = 0;
uint16_t als_gain_val = 0, als_integ_time_val = 0;
uint32_t als_data = 0;
als_data_t * pdata = (als_data_t *) buf;
if (buf == NULL){
return -1;
}
size = sizeof(als_data_t);
if (len < size){
return -1;
}
ret = sensor_i2c_read(<r568_ctx, LTR568_IR_DATA_LSB, &ir_data_reg[0], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r568_ctx, LTR568_IR_DATA_MSB, &ir_data_reg[1], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r568_ctx, LTR568_GREEN_DATA_LSB, &als_data_reg[0], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r568_ctx, LTR568_GREEN_DATA_MSB, &als_data_reg[1], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r568_ctx, LTR568_ALS_SAR, &als_sar, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
als_data = ((uint32_t) als_data_reg[1] << 8 | als_data_reg[0]);
als_gain_val = drv_als_liteon_ltr568_get_gain_val(<r568_ctx);
als_integ_time_val = drv_als_liteon_ltr568_get_integ_time_val(<r568_ctx);
if ((als_gain_val != 0) && (als_integ_time_val != 0))
{
pdata->lux = (als_data * 25) / als_gain_val / als_integ_time_val / 10;
}
else
{
pdata->lux = 0;
}
pdata->timestamp = aos_now_ms();
return (int) size;
}
static int drv_als_liteon_ltr568_write(const void *buf, size_t len)
{
(void) buf;
(void) len;
return 0;
}
static int drv_als_liteon_ltr568_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
ret = drv_als_liteon_ltr568_set_power_mode(<r568_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->vendor = DEV_SENSOR_VENDOR_LITEON;
info->model = "LTR568";
info->unit = lux;
} break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static void drv_ps_liteon_ltr568_irq_handle(void)
{
/* no handle so far */
}
static int drv_ps_liteon_ltr568_open(void)
{
int ret = 0;
ret = drv_ps_liteon_ltr568_set_power_mode(<r568_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_ps_liteon_ltr568_close(void)
{
int ret = 0;
ret = drv_ps_liteon_ltr568_set_power_mode(<r568_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_ps_liteon_ltr568_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg_data[2] = { 0 };
proximity_data_t * pdata = (proximity_data_t *) buf;
if (buf == NULL) {
return -1;
}
size = sizeof(proximity_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(<r568_ctx, LTR568_PS_DATA_LSB, ®_data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r568_ctx, LTR568_PS_DATA_MSB, ®_data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->present = ((uint32_t) reg_data[1] << 8 | reg_data[0]);
pdata->timestamp = aos_now_ms();
return (int) size;
}
static int drv_ps_liteon_ltr568_write(const void *buf, size_t len)
{
(void) buf;
(void) len;
return 0;
}
static int drv_ps_liteon_ltr568_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
ret = drv_ps_liteon_ltr568_set_power_mode(<r568_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *) arg;
info->vendor = DEV_SENSOR_VENDOR_LITEON;
info->model = "LTR568";
info->unit = cm;
} break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_als_liteon_ltr568_init(void)
{
int ret = 0;
sensor_obj_t sensor_als;
memset(&sensor_als, 0, sizeof(sensor_als));
if (!g_init_bitwise) {
ret = drv_als_ps_liteon_ltr568_validate_id(<r568_ctx, LTR568_PART_ID_VAL, LTR568_MANUFAC_ID_VAL);
if (unlikely(ret)) {
return -1;
}
}
if (!(g_init_bitwise & (1 << LTR568_FLAG_INIT_ALS))) {
/* fill the sensor_als obj parameters here */
sensor_als.path = dev_als_path;
sensor_als.tag = TAG_DEV_ALS;
sensor_als.io_port = I2C_PORT;
sensor_als.mode = DEV_POLLING;
sensor_als.power = DEV_POWER_OFF;
sensor_als.open = drv_als_liteon_ltr568_open;
sensor_als.close = drv_als_liteon_ltr568_close;
sensor_als.read = drv_als_liteon_ltr568_read;
sensor_als.write = drv_als_liteon_ltr568_write;
sensor_als.ioctl = drv_als_liteon_ltr568_ioctl;
sensor_als.irq_handle = drv_als_liteon_ltr568_irq_handle;
ret = sensor_create_obj(&sensor_als);
if (unlikely(ret)) {
return -1;
}
ret = drv_als_liteon_ltr568_set_default_config(<r568_ctx);
if (unlikely(ret)) {
return -1;
}
g_init_bitwise |= 1 << LTR568_FLAG_INIT_ALS;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_ps_liteon_ltr568_init(void)
{
int ret = 0;
sensor_obj_t sensor_ps;
memset(&sensor_ps, 0, sizeof(sensor_ps));
if (!g_init_bitwise) {
ret = drv_als_ps_liteon_ltr568_validate_id(<r568_ctx, LTR568_PART_ID_VAL, LTR568_MANUFAC_ID_VAL);
if (unlikely(ret)) {
return -1;
}
}
if (!(g_init_bitwise & (1 << LTR568_FLAG_INIT_PS))) {
/* fill the sensor_ps obj parameters here */
sensor_ps.tag = TAG_DEV_PS;
sensor_ps.path = dev_ps_path;
sensor_ps.io_port = I2C_PORT;
sensor_ps.mode = DEV_POLLING;
sensor_ps.power = DEV_POWER_OFF;
sensor_ps.open = drv_ps_liteon_ltr568_open;
sensor_ps.close = drv_ps_liteon_ltr568_close;
sensor_ps.read = drv_ps_liteon_ltr568_read;
sensor_ps.write = drv_ps_liteon_ltr568_write;
sensor_ps.ioctl = drv_ps_liteon_ltr568_ioctl;
sensor_ps.irq_handle = drv_ps_liteon_ltr568_irq_handle;
ret = sensor_create_obj(&sensor_ps);
if (unlikely(ret)) {
return -1;
}
ret = drv_ps_liteon_ltr568_set_default_config(<r568_ctx);
if (unlikely(ret)) {
return -1;
}
g_init_bitwise |= 1 << LTR568_FLAG_INIT_PS;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_als_liteon_ltr568_init);
SENSOR_DRV_ADD(drv_ps_liteon_ltr568_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_als_liteon_ltr568.c
|
C
|
apache-2.0
| 31,450
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define TMD2725_REG_ENABLE 0x80
#define TMD2725_REG_ATIME 0x81
#define TMD2725_REG_PTIME 0x82
#define TMD2725_REG_WTIME 0x83
#define TMD2725_REG_AILT 0x84
#define TMD2725_REG_AILT_HI 0x85
#define TMD2725_REG_AIHT 0x86
#define TMD2725_REG_AIHT_HI 0x87
#define TMD2725_REG_PILT 0x88
#define TMD2725_REG_PIHT 0x8A
#define TMD2725_REG_PERS 0x8C
#define TMD2725_REG_CFG0 0x8D
#define TMD2725_REG_PGCFG0 0x8E
#define TMD2725_REG_PGCFG1 0x8F
#define TMD2725_REG_CFG1 0x90
#define TMD2725_REG_REVID 0x91
#define TMD2725_REG_CHIPID 0x92
#define TMD2725_REG_STATUS 0x93
#define TMD2725_REG_CH0DATA 0x94
#define TMD2725_REG_CH0DATA_HI 0x95
#define TMD2725_REG_CH1DATA 0x96
#define TMD2725_REG_CH1DATA_HI 0x97
#define TMD2725_REG_PDATA 0x9C
#define TMD2725_REG_ADCDATA_L 0x9D
#define TMD2725_REG_AUXID 0x9E
#define TMD2725_REG_CFG2 0x9F
#define TMD2725_REG_CFG3 0xAB
#define TMD2725_REG_CFG4 0xAC
#define TMD2725_REG_CFG5 0xAD
#define TMD2725_REG_POFFSET_L 0xC0
#define TMD2725_REG_POFFSET_H 0xC1
#define TMD2725_REG_AZ_CONFIG 0xD6
#define TMD2725_REG_CALIB 0xD7
#define TMD2725_REG_CALIBCFG 0xD9
#define TMD2725_REG_CALIBSTAT 0xDC
#define TMD2725_REG_INTENAB 0xDD
#define TMD2725_CHIPID_VALUE 0xE4
#define TMD2725_I2C_SLAVE_ADDR 0x39
#define TMD2725_ADDR_TRANS(n) ((n) << 1)
#define TMD2725_I2C_ADDR TMD2725_ADDR_TRANS(TMD2725_I2C_SLAVE_ADDR)
enum tmd2725_reg
{
TMD2725_MASK_BINSRCH_TARGET = 0x70,
TMD2725_SHIFT_BINSRCH_TARGET = 4,
TMD2725_MASK_START_OFFSET_CALIB = 0x01,
TMD2725_MASK_PROX_PERS = 0xf0,
TMD2725_MASK_PDRIVE = 0x1f,
TMD2725_MASK_PGAIN = 0xC0,
TMD2725_SHIFT_PGAIN = 6,
TMD2725_MASK_AGAIN = 0x03,
TMD2725_SHIFT_AGAIN = 0,
TMD2725_MASK_APERS = 0x0f,
TMD2725_MASK_POFFSET_H = 0x01,
TMD2725_SHIFT_POFFSET_H = 0,
TMD2725_MASK_PROX_DATA_AVG = 0x07, // AVG 8counts
TMD2725_SHIFT_PROX_DATA_AVG = 0,
TMD2725_MASK_PROX_AUTO_OFFSET_ADJUST = 0x08,
TMD2725_SHIFT_PROX_AUTO_OFFSET_ADJUST = 3,
};
enum tmd2725_en_reg
{
TMD2725_PON = (1 << 0),
TMD2725_AEN = (1 << 1),
TMD2725_PEN = (1 << 2),
TMD2725_WEN = (1 << 3),
TMD2725_EN_ALL = (TMD2725_AEN | TMD2725_PEN | TMD2725_WEN),
};
static uint8_t const regs[] = {
TMD2725_REG_PILT, TMD2725_REG_PIHT, TMD2725_REG_PERS, TMD2725_REG_PGCFG0,
TMD2725_REG_PGCFG1, TMD2725_REG_CFG1, TMD2725_REG_PTIME, TMD2725_REG_ATIME,
};
static uint8_t const als_regs[] = {
TMD2725_REG_ATIME, TMD2725_REG_WTIME, TMD2725_REG_PERS,
TMD2725_REG_CFG0, TMD2725_REG_CFG1,
};
enum tmd2725_status
{
TMD2725_ST_PGSAT_AMBIENT = (1 << 0),
TMD2725_ST_PGSAT_RELFLECT = (1 << 1),
TMD2725_ST_ZERODET = (1 << 2),
TMD2725_ST_CAL_IRQ = (1 << 3),
TMD2725_ST_ALS_IRQ = (1 << 4),
TMD2725_ST_PRX_IRQ = (1 << 5),
TMD2725_ST_PRX_SAT = (1 << 6),
TMD2725_ST_ALS_SAT = (1 << 7),
};
enum tmd2725_intenab_reg
{
TMD2725_CIEN = (1 << 3),
TMD2725_AIEN = (1 << 4),
TMD2725_PIEN = (1 << 5),
TMD2725_PSIEN = (1 << 6),
TMD2725_ASIEN = (1 << 7),
};
enum tmd2725_pwr_state
{
POWER_ON,
POWER_OFF,
POWER_STANDBY,
};
enum tmd2725_prox_state
{
PROX_STATE_NONE = 0,
PROX_STATE_INIT,
PROX_STATE_CALIB,
PROX_STATE_WAIT_AND_CALIB
};
enum tmd2725_ctrl_reg
{
AGAIN_1 = (0 << 0),
AGAIN_4 = (1 << 0),
AGAIN_16 = (2 << 0),
AGAIN_64 = (3 << 0),
PGAIN_1 = (0 << TMD2725_SHIFT_PGAIN),
PGAIN_2 = (1 << TMD2725_SHIFT_PGAIN),
PGAIN_4 = (2 << TMD2725_SHIFT_PGAIN),
PGAIN_8 = (3 << TMD2725_SHIFT_PGAIN),
PG_PULSE_4US = (0 << 6),
PG_PULSE_8US = (1 << 6),
PG_PULSE_16US = (2 << 6),
PG_PULSE_32US = (3 << 6),
};
static uint8_t const als_gains[] = { 1, 4, 16, 64 };
// pldriver
#define PDRIVE_MA(p) (((uint8_t)((p) / 6) - 1) & 0x1f)
#define P_TIME_US(p) ((((p) / 88) - 1.0) + 0.5)
#define PRX_PERSIST(p) (((p)&0xf) << 4)
#define INTEGRATION_CYCLE 2816
#define AW_TIME_MS(p) \
((((p)*1000) + (INTEGRATION_CYCLE - 1)) / INTEGRATION_CYCLE)
#define ALS_PERSIST(p) (((p)&0xf) << 0)
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
// lux
#define INDOOR_LUX_TRIGGER 6000
#define OUTDOOR_LUX_TRIGGER 10000
#define TMD2725_MAX_LUX 0xffff
#define TMD2725_MAX_ALS_VALUE 0xffff
#define TMD2725_MIN_ALS_VALUE 10
/* Default LUX coefficients */
#define DFG 56
#define CoefA 1000
#define CoefB 82
#define CoefC 788
#define CoefD 41
#define MAX_REGS 256
#define max(a, b) (((a) > (b)) ? (a) : (b))
#define min(a, b) (((a) < (b)) ? (a) : (b))
struct tmd2725_lux_segment
{
uint32_t ch0_coef;
uint32_t ch1_coef;
};
struct tmd2725_als_inf
{
uint16_t als_ch0;
uint16_t als_ch1;
uint32_t CPL;
uint32_t lux1_ch0_coef;
uint32_t lux1_ch1_coef;
uint32_t lux2_ch0_coef;
uint32_t lux2_ch1_coef;
uint32_t sat;
uint16_t lux;
};
struct tmd2725_prox_inf
{
uint16_t raw;
int detected;
};
struct tmd2725_chips
{
bool als_enabled;
uint8_t atime;
uint8_t again;
uint8_t persist;
bool prox_enabled;
int16_t prox_th_min;
int16_t prox_th_max;
uint8_t prox_gain;
uint8_t prox_drive;
uint8_t prox_pulse_cnt;
uint8_t prox_pulse_len;
int16_t prox_offset;
uint8_t shadow[MAX_REGS];
struct tmd2725_lux_segment lux_segment[2];
struct tmd2725_prox_inf prx_inf;
struct tmd2725_als_inf als_inf;
};
i2c_dev_t tmd2725_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = TMD2725_I2C_ADDR,
};
static struct tmd2725_chips tmd2725_chip;
static uint8_t init_flag = 0;
static int drv_als_ps_ams_tmd2725_validate_id(i2c_dev_t *drv, uint8_t id_value)
{
int ret = 0;
uint8_t chipid_value;
ret = sensor_i2c_read(drv, TMD2725_REG_CHIPID, &chipid_value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
LOG("%s %s Sensor_i2c_read failure \n", SENSOR_STR, __func__);
return ret;
}
if (chipid_value != id_value)
return -1;
return 0;
}
static int tmd2725_reset_als_regs(i2c_dev_t *drv)
{
int i;
int ret = 0;
uint8_t reg;
for (i = 0; i < ARRAY_SIZE(als_regs); i++) {
reg = als_regs[i];
ret = sensor_i2c_write(drv, reg, &(tmd2725_chip.shadow[reg]),
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
LOG("%s %s tmd2725 reset_als_regs failure \n", SENSOR_STR,
__func__);
return ret;
}
}
return 0;
}
static int32_t sensor_i2c_modify(i2c_dev_t *drv, uint8_t *shadow, uint16_t reg,
uint8_t mask, uint8_t value)
{
int ret;
uint8_t temp;
ret = sensor_i2c_read(drv, reg, &temp, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
LOG("%s %s tmd2725 sensor_i2c_modify \n", SENSOR_STR, __func__);
return ret;
}
temp &= ~mask;
temp |= value;
sensor_i2c_write(drv, reg, &temp, I2C_DATA_LEN, I2C_OP_RETRIES);
shadow[reg] = temp;
return 0;
}
static int drv_als_ams_tmd2725_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
switch (mode) {
case DEV_POWER_ON: {
if (!(tmd2725_chip.als_enabled)) {
tmd2725_chip.shadow[TMD2725_REG_ATIME] = tmd2725_chip.atime;
tmd2725_chip.shadow[TMD2725_REG_PERS] &= (~TMD2725_MASK_APERS);
tmd2725_chip.shadow[TMD2725_REG_PERS] |= 0x02;
tmd2725_reset_als_regs(drv);
sensor_i2c_modify(drv, tmd2725_chip.shadow, TMD2725_REG_INTENAB,
TMD2725_AIEN, TMD2725_AIEN);
sensor_i2c_modify(drv, tmd2725_chip.shadow, TMD2725_REG_ENABLE,
TMD2725_WEN | TMD2725_AEN | TMD2725_PON,
TMD2725_WEN | TMD2725_AEN | TMD2725_PON);
tmd2725_chip.als_enabled = true;
}
} break;
case DEV_POWER_OFF:
case DEV_SLEEP: {
sensor_i2c_modify(drv, tmd2725_chip.shadow, TMD2725_REG_INTENAB,
TMD2725_AIEN, 0);
sensor_i2c_modify(drv, tmd2725_chip.shadow, TMD2725_REG_ENABLE,
TMD2725_WEN | TMD2725_AEN, 0);
tmd2725_chip.als_enabled = false;
if (!(tmd2725_chip.shadow[TMD2725_REG_ENABLE] & TMD2725_EN_ALL))
sensor_i2c_modify(drv, tmd2725_chip.shadow, TMD2725_REG_ENABLE,
TMD2725_PON, 0);
} break;
default:
break;
}
return 0;
}
static int tmd2725_reset_regs(i2c_dev_t *drv)
{
int i;
int ret = 0;
uint8_t reg;
for (i = 0; i < ARRAY_SIZE(regs); i++) {
reg = regs[i];
ret = sensor_i2c_write(drv, reg, &(tmd2725_chip.shadow[reg]),
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
LOG("%s %s tmd2725 reset_regs failure %d \n", SENSOR_STR,
__func__);
return ret;
}
}
return 0;
}
static int drv_als_ps_ams_tmd2725_set_default_config(i2c_dev_t *drv)
{
int ret = 0;
if (!init_flag) {
tmd2725_chip.prox_th_min = 50;
tmd2725_chip.prox_th_max = 80;
tmd2725_chip.persist = PRX_PERSIST(0) | ALS_PERSIST(0);
tmd2725_chip.prox_pulse_cnt = 4;
tmd2725_chip.prox_gain = PGAIN_4;
tmd2725_chip.prox_drive = PDRIVE_MA(75);
tmd2725_chip.prox_offset = 0;
tmd2725_chip.prox_pulse_len = PG_PULSE_16US;
tmd2725_chip.again = AGAIN_16;
tmd2725_chip.atime = AW_TIME_MS(200);
tmd2725_chip.lux_segment[0].ch0_coef = CoefA;
tmd2725_chip.lux_segment[0].ch1_coef = CoefB;
tmd2725_chip.lux_segment[1].ch0_coef = CoefC;
tmd2725_chip.lux_segment[1].ch1_coef = CoefD;
tmd2725_chip.als_enabled = false;
tmd2725_chip.prox_enabled = false;
/* initial some config register */
tmd2725_chip.shadow[TMD2725_REG_PILT] = tmd2725_chip.prox_th_min & 0xff;
tmd2725_chip.shadow[TMD2725_REG_PIHT] = tmd2725_chip.prox_th_max & 0xff;
tmd2725_chip.shadow[TMD2725_REG_PERS] = tmd2725_chip.persist;
tmd2725_chip.shadow[TMD2725_REG_PGCFG0] =
tmd2725_chip.prox_pulse_cnt | tmd2725_chip.prox_pulse_len;
tmd2725_chip.shadow[TMD2725_REG_ATIME] = tmd2725_chip.atime;
tmd2725_chip.shadow[TMD2725_REG_CFG1] = tmd2725_chip.again;
tmd2725_chip.shadow[TMD2725_REG_PTIME] = P_TIME_US(2816);
tmd2725_chip.shadow[TMD2725_REG_PGCFG1] =
(tmd2725_chip.prox_gain & TMD2725_MASK_PGAIN) |
tmd2725_chip.prox_drive;
struct tmd2725_lux_segment *als = &(tmd2725_chip.lux_segment[0]);
tmd2725_chip.als_inf.lux1_ch0_coef = DFG * (als[0].ch0_coef);
tmd2725_chip.als_inf.lux1_ch1_coef = DFG * (als[0].ch1_coef);
tmd2725_chip.als_inf.lux2_ch0_coef = DFG * (als[1].ch0_coef);
tmd2725_chip.als_inf.lux2_ch1_coef = DFG * (als[1].ch1_coef);
ret = tmd2725_reset_regs(&tmd2725_ctx);
if (unlikely(ret)) {
LOG("%s %s , tmd2725 reset regs failure \n", SENSOR_STR, __func__);
return ret;
}
init_flag = 1;
}
return 0;
}
static void drv_als_ams_tmd2725_irq_handle(void)
{
/* no handle so far */
}
static int drv_als_ams_tmd2725_open(void)
{
int ret = 0;
ret = drv_als_ams_tmd2725_set_power_mode(&tmd2725_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_als_ams_tmd2725_close(void)
{
int ret = 0;
ret = drv_als_ams_tmd2725_set_power_mode(&tmd2725_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int tmd2725_read_als_data()
{
int ret;
uint8_t *buf;
ret = sensor_i2c_read(&tmd2725_ctx, TMD2725_REG_CH0DATA,
&(tmd2725_chip.shadow[TMD2725_REG_CH0DATA]), 4,
I2C_OP_RETRIES);
if (unlikely(ret)) {
LOG("%s %s tmd2725_read_als_data failure \n", SENSOR_STR, __func__);
return ret;
}
buf = &(tmd2725_chip.shadow[TMD2725_REG_CH0DATA]);
tmd2725_chip.als_inf.als_ch0 = (uint16_t)((buf[1] << 8) | buf[0]);
tmd2725_chip.als_inf.als_ch1 = (uint16_t)((buf[3] << 8) | buf[2]);
// LOG("%s %s als_ch0 is %d als_ch1 is %d \n",
// SENSOR_STR,__func__,tmd2725_chip.als_inf.als_ch0,tmd2725_chip.als_inf.als_ch1);
return 0;
}
static int tmd2725_als_cal_cpl()
{
uint32_t cpl;
uint32_t sat;
uint8_t atime;
atime = tmd2725_chip.shadow[TMD2725_REG_ATIME];
cpl = atime;
cpl *= INTEGRATION_CYCLE;
cpl *=
als_gains[tmd2725_chip.shadow[TMD2725_REG_CFG1] & TMD2725_MASK_AGAIN];
sat = (int32_t)(atime << 10);
if (sat > TMD2725_MAX_ALS_VALUE)
sat = TMD2725_MAX_ALS_VALUE;
sat = sat * 8 / 10;
tmd2725_chip.als_inf.CPL = cpl;
tmd2725_chip.als_inf.sat = sat;
// LOG("CPL is %d sat is %d, atime is %d again is
// %d\n",tmd2725_chip.als_inf.CPL,tmd2725_chip.als_inf.sat,
// tmd2725_chip.atime, tmd2725_chip.again);
return 0;
}
static int tmd2725_set_als_gain(uint8_t gain)
{
uint8_t ctrl_reg;
uint8_t temp, temp_zero = 0;
switch (gain) {
case 1:
ctrl_reg = AGAIN_1;
break;
case 4:
ctrl_reg = AGAIN_4;
break;
case 16:
ctrl_reg = AGAIN_16;
break;
case 64:
ctrl_reg = AGAIN_64;
break;
default:
LOG("set als_gain wrong Gain data \n");
return -1;
}
sensor_i2c_read(&tmd2725_ctx, TMD2725_REG_ENABLE, &temp, I2C_DATA_LEN,
I2C_OP_RETRIES);
sensor_i2c_write(&tmd2725_ctx, TMD2725_REG_ENABLE, &temp_zero, I2C_DATA_LEN,
I2C_OP_RETRIES);
sensor_i2c_modify(&tmd2725_ctx, tmd2725_chip.shadow, TMD2725_REG_CFG1,
TMD2725_MASK_AGAIN, ctrl_reg);
sensor_i2c_write(&tmd2725_ctx, TMD2725_REG_ENABLE, &temp, I2C_DATA_LEN,
I2C_OP_RETRIES);
tmd2725_chip.again = tmd2725_chip.shadow[TMD2725_REG_CFG1];
return 0;
}
static int tmd2725_als_inc_gain()
{
int ret;
uint8_t gain = (tmd2725_chip.shadow[TMD2725_REG_CFG1] & TMD2725_MASK_AGAIN);
if (gain > AGAIN_16)
return 1;
else if (gain < AGAIN_4)
gain = als_gains[AGAIN_4];
else if (gain < AGAIN_16)
gain = als_gains[AGAIN_16];
else
gain = als_gains[AGAIN_64];
ret = tmd2725_set_als_gain(gain);
if (unlikely(ret)) {
LOG("%s %s tmd2725_set_als_gain false\n", SENSOR_STR, __func__);
return ret;
}
tmd2725_als_cal_cpl();
return 0;
}
static int tmd2725_als_dec_gain()
{
int ret;
uint8_t gain = (tmd2725_chip.shadow[TMD2725_REG_CFG1] & TMD2725_MASK_AGAIN);
if (gain == AGAIN_1)
return 1;
else if (gain > AGAIN_16)
gain = als_gains[AGAIN_16];
else if (gain > AGAIN_4)
gain = als_gains[AGAIN_4];
else
gain = als_gains[AGAIN_1];
ret = tmd2725_set_als_gain(gain);
if (unlikely(ret)) {
LOG("%s %s tmd2725_set_als_gain false in dec_gain\n", SENSOR_STR,
__func__);
return ret;
}
tmd2725_als_cal_cpl();
return 0;
}
static int tmd2725_max_als_value()
{
int val;
val = tmd2725_chip.shadow[TMD2725_REG_ATIME];
if (val > 63)
val = 0xffff;
else
val = ((val * 1024) - 1);
return val;
}
static int tmd2725_get_lux()
{
int ch0, ch1, lux1, lux2, lux;
ch0 = tmd2725_chip.als_inf.als_ch0;
ch1 = tmd2725_chip.als_inf.als_ch1;
tmd2725_als_cal_cpl();
lux1 = ((tmd2725_chip.als_inf.lux1_ch0_coef * ch0) -
(tmd2725_chip.als_inf.lux1_ch1_coef * ch1)) /
tmd2725_chip.als_inf.CPL;
lux2 = ((tmd2725_chip.als_inf.lux2_ch0_coef * ch0) -
(tmd2725_chip.als_inf.lux2_ch1_coef * ch1)) /
tmd2725_chip.als_inf.CPL;
lux = max(lux1, lux2);
lux = min(TMD2725_MAX_LUX, max(0, lux));
tmd2725_chip.als_inf.lux = lux;
if (ch0 < 100) {
tmd2725_als_inc_gain();
tmd2725_reset_als_regs(&tmd2725_ctx);
} else if (ch0 >= tmd2725_max_als_value()) {
tmd2725_als_dec_gain();
tmd2725_reset_als_regs(&tmd2725_ctx);
}
return 0;
}
static int drv_als_ams_tmd2725_read(void *buf, size_t len)
{
int ret;
size_t size;
uint8_t status = 0;
als_data_t *sensordata = (als_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(als_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(&tmd2725_ctx, TMD2725_REG_STATUS,
&(tmd2725_chip.shadow[TMD2725_REG_STATUS]),
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
LOG("%s %s TMD2725_READ_STATUS failure \n", SENSOR_STR, __func__);
return ret;
}
status = tmd2725_chip.shadow[TMD2725_REG_STATUS];
if (status & TMD2725_ST_ALS_IRQ) {
// clear AINT
sensor_i2c_modify(&tmd2725_ctx, tmd2725_chip.shadow, TMD2725_REG_STATUS,
TMD2725_ST_ALS_IRQ, 0);
tmd2725_read_als_data();
tmd2725_get_lux();
}
sensordata->lux = (uint32_t)(tmd2725_chip.als_inf.lux);
sensordata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_als_ams_tmd2725_write(const void *buf, size_t len)
{
// no handle so far
return 0;
}
static int drv_als_ams_tmd2725_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
ret = drv_als_ams_tmd2725_set_power_mode(&tmd2725_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "TMD2725_ALS";
info->unit = lux;
} break;
default:
break;
}
return 0;
}
int drv_als_ams_tmd2725_init(void)
{
int ret = 0;
sensor_obj_t sensor_als;
memset(&sensor_als, 0, sizeof(sensor_als));
/* fill the sensor obj parameters here */
sensor_als.tag = TAG_DEV_ALS;
sensor_als.path = dev_als_path;
sensor_als.io_port = I2C_PORT;
sensor_als.open = drv_als_ams_tmd2725_open;
sensor_als.close = drv_als_ams_tmd2725_close;
sensor_als.read = drv_als_ams_tmd2725_read;
sensor_als.write = drv_als_ams_tmd2725_write;
sensor_als.ioctl = drv_als_ams_tmd2725_ioctl;
sensor_als.irq_handle = drv_als_ams_tmd2725_irq_handle;
ret = sensor_create_obj(&sensor_als);
if (unlikely(ret)) {
return -1;
}
ret =
drv_als_ps_ams_tmd2725_validate_id(&tmd2725_ctx, TMD2725_CHIPID_VALUE);
if (unlikely(ret)) {
return -1;
}
ret = drv_als_ps_ams_tmd2725_set_default_config(&tmd2725_ctx);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static uint32_t ams_sensor_i2c_write(i2c_dev_t *drv, uint8_t *shadow,
uint16_t reg, uint8_t data)
{
sensor_i2c_write(drv, reg, &data, I2C_DATA_LEN, I2C_OP_RETRIES);
tmd2725_chip.shadow[reg] = data;
return 0;
}
int tmd2725_offset_calibration()
{
uint8_t temp;
sensor_i2c_read(&tmd2725_ctx, TMD2725_REG_ENABLE, &temp, I2C_DATA_LEN,
I2C_OP_RETRIES);
// enable prox enb bit
sensor_i2c_modify(&tmd2725_ctx, tmd2725_chip.shadow, TMD2725_REG_ENABLE,
TMD2725_PEN | TMD2725_PON, TMD2725_PON);
sensor_i2c_modify(&tmd2725_ctx, tmd2725_chip.shadow, TMD2725_REG_INTENAB,
TMD2725_PIEN | TMD2725_CIEN, TMD2725_CIEN);
sensor_i2c_modify(&tmd2725_ctx, tmd2725_chip.shadow, TMD2725_REG_CALIBCFG,
TMD2725_MASK_BINSRCH_TARGET | TMD2725_MASK_PROX_DATA_AVG |
TMD2725_MASK_PROX_AUTO_OFFSET_ADJUST,
(0x03 << TMD2725_SHIFT_BINSRCH_TARGET) |
(1 << TMD2725_SHIFT_PROX_DATA_AVG) |
(1 << TMD2725_SHIFT_PROX_AUTO_OFFSET_ADJUST));
sensor_i2c_modify(&tmd2725_ctx, tmd2725_chip.shadow, TMD2725_REG_CALIB,
TMD2725_MASK_START_OFFSET_CALIB, 0x01);
// set calibration default time 100ms
aos_msleep(100);
sensor_i2c_read(&tmd2725_ctx, TMD2725_REG_POFFSET_L,
&tmd2725_chip.shadow[TMD2725_REG_POFFSET_L], 2,
I2C_OP_RETRIES);
tmd2725_chip.prox_offset = tmd2725_chip.shadow[TMD2725_REG_POFFSET_L];
if (tmd2725_chip.shadow[TMD2725_REG_POFFSET_H] & TMD2725_MASK_POFFSET_H) {
tmd2725_chip.prox_offset *= -1;
}
sensor_i2c_modify(&tmd2725_ctx, tmd2725_chip.shadow, TMD2725_REG_ENABLE,
TMD2725_PEN, temp);
return 0;
}
static int drv_ps_ams_tmd2725_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
switch (mode) {
case DEV_POWER_ON: {
if (!(tmd2725_chip.prox_enabled)) {
tmd2725_chip.prox_th_min = 50;
tmd2725_chip.prox_th_max = 80;
ams_sensor_i2c_write(&tmd2725_ctx, tmd2725_chip.shadow,
TMD2725_REG_PILT,
tmd2725_chip.prox_th_min);
ams_sensor_i2c_write(&tmd2725_ctx, tmd2725_chip.shadow,
TMD2725_REG_PIHT,
tmd2725_chip.prox_th_max);
tmd2725_offset_calibration();
sensor_i2c_modify(&tmd2725_ctx, tmd2725_chip.shadow,
TMD2725_REG_PERS, TMD2725_MASK_PROX_PERS,
tmd2725_chip.persist &
TMD2725_MASK_PROX_PERS);
ams_sensor_i2c_write(
&tmd2725_ctx, tmd2725_chip.shadow, TMD2725_REG_PGCFG0,
tmd2725_chip.prox_pulse_cnt | tmd2725_chip.prox_pulse_len);
sensor_i2c_modify(
&tmd2725_ctx, tmd2725_chip.shadow, TMD2725_REG_PGCFG1,
(tmd2725_chip.prox_gain & TMD2725_MASK_PGAIN) |
(tmd2725_chip.prox_drive & TMD2725_MASK_PDRIVE),
TMD2725_MASK_PGAIN | TMD2725_MASK_PDRIVE);
ams_sensor_i2c_write(&tmd2725_ctx, tmd2725_chip.shadow,
TMD2725_REG_PTIME, P_TIME_US(2816));
// enable proximity and interrupt
sensor_i2c_modify(&tmd2725_ctx, tmd2725_chip.shadow,
TMD2725_REG_ENABLE, TMD2725_PEN | TMD2725_PON,
TMD2725_PEN | TMD2725_PON);
sensor_i2c_modify(&tmd2725_ctx, tmd2725_chip.shadow,
TMD2725_REG_INTENAB, TMD2725_PIEN,
TMD2725_PIEN);
tmd2725_chip.prox_enabled = true;
tmd2725_chip.prx_inf.detected = false;
}
} break;
case DEV_POWER_OFF:
case DEV_SLEEP: {
if (tmd2725_chip.prox_enabled) {
sensor_i2c_modify(&tmd2725_ctx, tmd2725_chip.shadow,
TMD2725_REG_ENABLE, TMD2725_PEN, 0);
sensor_i2c_modify(&tmd2725_ctx, tmd2725_chip.shadow,
TMD2725_REG_INTENAB, TMD2725_PIEN, 0);
tmd2725_chip.prox_enabled = false;
if (!(tmd2725_chip.shadow[TMD2725_REG_ENABLE] & TMD2725_EN_ALL))
sensor_i2c_modify(drv, tmd2725_chip.shadow,
TMD2725_REG_ENABLE, TMD2725_PON, 0);
}
} break;
default:
break;
}
return 0;
}
static void drv_ps_ams_tmd2725_irq_handle(void)
{
/* no handle so far */
}
static int drv_ps_ams_tmd2725_open(void)
{
int ret = 0;
ret = drv_ps_ams_tmd2725_set_power_mode(&tmd2725_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_ps_ams_tmd2725_close(void)
{
int ret = 0;
ret = drv_ps_ams_tmd2725_set_power_mode(&tmd2725_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static void tmd2725_read_prox_data()
{
sensor_i2c_read(&tmd2725_ctx, TMD2725_REG_PDATA,
&tmd2725_chip.shadow[TMD2725_REG_PDATA], I2C_DATA_LEN,
I2C_OP_RETRIES);
tmd2725_chip.prx_inf.raw = tmd2725_chip.shadow[TMD2725_REG_PDATA];
// LOG("%s %s read_prox_data raw data is
// %d\n",SENSOR_STR,__func__,tmd2725_chip.prx_inf.raw);
}
static void tmd2725_get_prox()
{
if (tmd2725_chip.prx_inf.detected == false) {
if (tmd2725_chip.prx_inf.raw > tmd2725_chip.prox_th_max) {
tmd2725_chip.prx_inf.detected = true;
}
} else {
if (tmd2725_chip.prx_inf.raw < tmd2725_chip.prox_th_min) {
tmd2725_chip.prx_inf.detected = false;
}
}
}
static int drv_ps_ams_tmd2725_read(void *buf, size_t len)
{
size_t size;
proximity_data_t *sensordata = (proximity_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(proximity_data_t);
if (len < size) {
return -1;
}
tmd2725_read_prox_data();
tmd2725_get_prox();
//prx_inf.detected describe the near or far, and prx_inf.raw is pdata
//sensordata->present = tmd2725_chip.prx_inf.detected;
sensordata->present = tmd2725_chip.prx_inf.raw;
sensordata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_ps_ams_tmd2725_write(const void *buf, size_t len)
{
// no handle so far
return 0;
}
static int drv_ps_ams_tmd2725_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
ret = drv_ps_ams_tmd2725_set_power_mode(&tmd2725_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "TMD2725_PS";
info->unit = cm;
} break;
default:
break;
}
return 0;
}
int drv_ps_ams_tmd2725_init(void)
{
int ret = 0;
sensor_obj_t sensor_ps;
memset(&sensor_ps, 0, sizeof(sensor_ps));
/* fill the sensor obj parameters here */
sensor_ps.tag = TAG_DEV_PS;
sensor_ps.path = dev_ps_path;
sensor_ps.io_port = I2C_PORT;
sensor_ps.open = drv_ps_ams_tmd2725_open;
sensor_ps.close = drv_ps_ams_tmd2725_close;
sensor_ps.read = drv_ps_ams_tmd2725_read;
sensor_ps.write = drv_ps_ams_tmd2725_write;
sensor_ps.ioctl = drv_ps_ams_tmd2725_ioctl;
sensor_ps.irq_handle = drv_ps_ams_tmd2725_irq_handle;
ret = sensor_create_obj(&sensor_ps);
if (unlikely(ret)) {
return -1;
}
ret =
drv_als_ps_ams_tmd2725_validate_id(&tmd2725_ctx, TMD2725_CHIPID_VALUE);
if (unlikely(ret)) {
return -1;
}
ret = drv_als_ps_ams_tmd2725_set_default_config(&tmd2725_ctx);
if (unlikely(ret)) {
return -1;
}
return 0;
}
SENSOR_DRV_ADD(drv_als_ams_tmd2725_init);
SENSOR_DRV_ADD(drv_ps_ams_tmd2725_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_als_ps_ams_tmd2725.c
|
C
|
apache-2.0
| 28,164
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LTR507_I2C_SLAVE_ADDR 0x23
#define LTR507_ALS_CONTR 0x80 /* ALS operation mode, SW reset */
#define LTR507_PS_CONTR 0x81 /* PS operation mode */
#define LTR507_PS_LED 0x82 /* LED pulse freq, current duty, peak current */
#define LTR507_PS_N_PULSES 0x83 /* PS number of pulses */
#define LTR507_PS_MEAS_RATE 0x84 /* measurement rate*/
#define LTR507_ALS_MEAS_RATE 0x85 /* ALS integ time, measurement rate*/
#define LTR507_PART_ID 0x86
#define LTR507_MANUFAC_ID 0x87
#define LTR507_ALS_DATA_0 0x88
#define LTR507_ALS_DATA_1 0x89
#define LTR507_ALS_PS_STATUS 0x8A
#define LTR507_PS_DATA_0 0x8B
#define LTR507_PS_DATA_1 0x8C
#define LTR507_ALS_DATA_CH1_0 0x8D
#define LTR507_ALS_DATA_CH1_1 0x8E
#define LTR507_ALS_DATA_CH1_2 0x8F
#define LTR507_ALS_DATA_CH2_0 0x90
#define LTR507_ALS_DATA_CH2_1 0x91
#define LTR507_ALS_DATA_CH2_2 0x92
#define LTR507_ALS_COEFF1_DATA_0 0x93
#define LTR507_ALS_COEFF1_DATA_1 0x94
#define LTR507_ALS_COEFF2_DATA_0 0x95
#define LTR507_ALS_COEFF2_DATA_1 0x96
#define LTR507_ALS_IRF_CUT_OFF 0x97
#define LTR507_INTERRUPT 0x98
#define LTR507_PS_THRES_UP_0 0x99 /* ps interrupt upper threshold, lower byte */
#define LTR507_PS_THRES_UP_1 0x9A /* ps interrupt upper threshold, upper byte */
#define LTR507_PS_THRES_LOW_0 0x9B /* ps interrupt lower threshold, lower byte */
#define LTR507_PS_THRES_LOW_1 0x9C /* ps interrupt lower threshold, upper byte */
#define LTR507_ALS_THRES_UP_0 0x9E /* ALS interrupt upper threshold, lower byte */
#define LTR507_ALS_THRES_UP_1 0x9F /* ALS interrupt upper threshold, upper byte */
#define LTR507_ALS_THRES_LOW_0 0xA0 /* ALS interrupt lower threshold, lower byte */
#define LTR507_ALS_THRES_LOW_1 0xA1 /* ALS interrupt lower threshold, upper byte */
#define LTR507_INTR_PRST 0xA4 /* ALS/PS interrupt persist setting */
#define LTR507_MAX_REG 0xA5
#define LTR507_ADDR_TRANS(n) ((n) << 1)
#define LTR507_I2C_ADDR LTR507_ADDR_TRANS(LTR507_I2C_SLAVE_ADDR)
#define LTR507_PART_ID_VAL 0x91
#define LTR507_MANUFAC_ID_VAL 0x05
#define LTR507_ALS_CONTR_REG_ALS_GAIN__POS (3)
#define LTR507_ALS_CONTR_REG_ALS_GAIN__MSK (0x18)
#define LTR507_ALS_CONTR_REG_ALS_GAIN__REG (LTR507_ALS_CONTR)
#define LTR507_ALS_CONTR_REG_ALS_SW_RESET__POS (2)
#define LTR507_ALS_CONTR_REG_ALS_SW_RESET__MSK (0x04)
#define LTR507_ALS_CONTR_REG_ALS_SW_RESET__REG (LTR507_ALS_CONTR)
#define LTR507_ALS_CONTR_REG_ALS_MODE__POS (1)
#define LTR507_ALS_CONTR_REG_ALS_MODE__MSK (0x02)
#define LTR507_ALS_CONTR_REG_ALS_MODE__REG (LTR507_ALS_CONTR)
#define LTR507_PS_CONTR_REG_PS_GAIN__POS (2)
#define LTR507_PS_CONTR_REG_PS_GAIN__MSK (0x0C)
#define LTR507_PS_CONTR_REG_PS_GAIN__REG (LTR507_PS_CONTR)
#define LTR507_PS_CONTR_REG_PS_MODE__POS (1)
#define LTR507_PS_CONTR_REG_PS_MODE__MSK (0x02)
#define LTR507_PS_CONTR_REG_PS_MODE__REG (LTR507_PS_CONTR)
#define LTR507_PS_LED_REG_PEAK_CURR__POS (0)
#define LTR507_PS_LED_REG_PEAK_CURR__MSK (0x07)
#define LTR507_PS_LED_REG_PEAK_CURR__REG (LTR507_PS_LED)
#define LTR507_PS_LED_REG_DUTY_CYCLE__POS (3)
#define LTR507_PS_LED_REG_DUTY_CYCLE__MSK (0x18)
#define LTR507_PS_LED_REG_DUTY_CYCLE__REG (LTR507_PS_LED)
#define LTR507_PS_LED_REG_PULSE_FREQ__POS (5)
#define LTR507_PS_LED_REG_PULSE_FREQ__MSK (0xE0)
#define LTR507_PS_LED_REG_PULSE_FREQ__REG (LTR507_PS_LED)
#define LTR507_PS_MEAS_RATE_REG_MEAS_RATE__POS (0)
#define LTR507_PS_MEAS_RATE_REG_MEAS_RATE__MSK (0x07)
#define LTR507_PS_MEAS_RATE_REG_MEAS_RATE__REG (LTR507_PS_MEAS_RATE)
#define LTR507_ALS_MEAS_RATE_REG_ADC_RES__POS (5)
#define LTR507_ALS_MEAS_RATE_REG_ADC_RES__MSK (0xE0)
#define LTR507_ALS_MEAS_RATE_REG_ADC_RES__REG (LTR507_ALS_MEAS_RATE)
#define LTR507_ALS_MEAS_RATE_REG_MEAS_RATE__POS (0)
#define LTR507_ALS_MEAS_RATE_REG_MEAS_RATE__MSK (0x07)
#define LTR507_ALS_MEAS_RATE_REG_MEAS_RATE__REG (LTR507_ALS_MEAS_RATE)
#define LTR507_ALS_PS_STATUS_REG_INT_SOURCE__POS (4)
#define LTR507_ALS_PS_STATUS_REG_INT_SOURCE__MSK (0x30)
#define LTR507_ALS_PS_STATUS_REG_INT_SOURCE__REG (LTR507_ALS_PS_STATUS)
#define LTR507_ALS_PS_STATUS_REG_ALS_INT_STATUS__POS (3)
#define LTR507_ALS_PS_STATUS_REG_ALS_INT_STATUS__MSK (0x08)
#define LTR507_ALS_PS_STATUS_REG_ALS_INT_STATUS__REG (LTR507_ALS_PS_STATUS)
#define LTR507_ALS_PS_STATUS_REG_ALS_DATA_STATUS__POS (2)
#define LTR507_ALS_PS_STATUS_REG_ALS_DATA_STATUS__MSK (0x04)
#define LTR507_ALS_PS_STATUS_REG_ALS_DATA_STATUS__REG (LTR507_ALS_PS_STATUS)
#define LTR507_ALS_PS_STATUS_REG_PS_INT_STATUS__POS (1)
#define LTR507_ALS_PS_STATUS_REG_PS_INT_STATUS__MSK (0x02)
#define LTR507_ALS_PS_STATUS_REG_PS_INT_STATUS__REG (LTR507_ALS_PS_STATUS)
#define LTR507_ALS_PS_STATUS_REG_PS_DATA_STATUS__POS (0)
#define LTR507_ALS_PS_STATUS_REG_PS_DATA_STATUS__MSK (0x01)
#define LTR507_ALS_PS_STATUS_REG_PS_DATA_STATUS__REG (LTR507_ALS_PS_STATUS)
#define LTR507_GET_BITSLICE(regvar, bitname) ((regvar & LTR507_##bitname##__MSK) >> LTR507_##bitname##__POS)
#define LTR507_SET_BITSLICE(regvar, bitname, val) ((regvar & ~LTR507_##bitname##__MSK) | ((val<<LTR507_##bitname##__POS)<R507_##bitname##__MSK))
#define LTR507_WAIT_TIME_PER_CHECK (10)
#define LTR507_WAIT_TIME_TOTAL (100)
typedef enum {
LTR507_ALS_GAIN_1 = 0x00, /* 1 lux to 64k lux (default) */
LTR507_ALS_GAIN_2 = 0x01, /* 0.5 lux to 32k lux */
LTR507_ALS_GAIN_3 = 0x02, /* 0.02 lux to 640 lux */
LTR507_ALS_GAIN_4 = 0x03, /* 0.01 lux to 320 lux */
} LTR507_CFG_ALS_Gain;
typedef enum {
LTR507_SW_RESET_NEG = 0x00,
LTR507_SW_RESET = 0x01,
} LTR507_CFG_SW_RESET;
typedef enum {
LTR507_ALS_STANDBY = 0x00,
LTR507_ALS_ACTIVE = 0x01,
} LTR507_CFG_ALS_MODE;
typedef enum {
LTR507_PS_GAIN = 0x03,
} LTR507_CFG_PS_GAIN;
typedef enum {
LTR507_PS_STANDBY = 0x00,
LTR507_PS_ACTIVE = 0x01,
} LTR507_CFG_PS_MODE;
typedef enum {
LTR507_PS_PULSE_FREQ_30K = 0x00, /* LED pulse period = 30kHz */
LTR507_PS_PULSE_FREQ_40K = 0x01, /* LED pulse period = 40kHz */
LTR507_PS_PULSE_FREQ_50K = 0x02, /* LED pulse period = 50kHz */
LTR507_PS_PULSE_FREQ_60K = 0x03, /* LED pulse period = 60kHz (default) */
LTR507_PS_PULSE_FREQ_70K = 0x04, /* LED pulse period = 70kHz */
LTR507_PS_PULSE_FREQ_80K = 0x05, /* LED pulse period = 80kHz */
LTR507_PS_PULSE_FREQ_90K = 0x06, /* LED pulse period = 90kHz */
LTR507_PS_PULSE_FREQ_100K = 0x07, /* LED pulse period = 100kHz */
} LTR507_CFG_PS_LED_PULSE_FREQ;
typedef enum {
LTR507_PS_DUTY_CYCLE = 0x01,
} LTR507_CFG_PS_LED_DUTY_CYCLE;
typedef enum {
LTR507_PS_PEAK_CURRENT_5 = 0x00, /* LED pulse current level = 5mA */
LTR507_PS_PEAK_CURRENT_10 = 0x01, /* LED pulse current level = 10mA */
LTR507_PS_PEAK_CURRENT_20 = 0x02, /* LED pulse current level = 20mA */
LTR507_PS_PEAK_CURRENT_50 = 0x03, /* LED pulse current level = 50mA (default) */
LTR507_PS_PEAK_CURRENT_100 = 0x04, /* LED pulse current level = 100mA */
} LTR507_CFG_PS_LED_PEAK_CURRENT;
typedef enum {
LTR507_PS_MEAS_RATE_12_5 = 0x00, /* PS Measurement Repeat Rate = 12.5ms */
LTR507_PS_MEAS_RATE_50 = 0x01, /* PS Measurement Repeat Rate = 50ms */
LTR507_PS_MEAS_RATE_70 = 0x02, /* PS Measurement Repeat Rate = 70ms */
LTR507_PS_MEAS_RATE_100 = 0x03, /* PS Measurement Repeat Rate = 100ms (default) */
LTR507_PS_MEAS_RATE_200 = 0x04, /* PS Measurement Repeat Rate = 200ms */
LTR507_PS_MEAS_RATE_500 = 0x05, /* PS Measurement Repeat Rate = 500ms */
LTR507_PS_MEAS_RATE_1000 = 0x06, /* PS Measurement Repeat Rate = 1000ms */
LTR507_PS_MEAS_RATE_2000 = 0x07, /* PS Measurement Repeat Rate = 2000ms */
} LTR507_CFG_PS_MEAS_RATE;
typedef enum {
LTR507_ALS_ADC_RES_20BIT = 0x00, /* 20 bit, integration time - 1200ms */
LTR507_ALS_ADC_RES_19BIT = 0x01, /* 19 bit, integration time - 600ms */
LTR507_ALS_ADC_RES_18BIT = 0x02, /* 18 bit, integration time - 300ms */
LTR507_ALS_ADC_RES_17BIT = 0x03, /* 17 bit, integration time - 150ms */
LTR507_ALS_ADC_RES_16BIT = 0x04, /* 16 bit, integration time - 75ms (default) */
LTR507_ALS_ADC_RES_12BIT = 0x05, /* 12 bit, integration time - 4.685ms */
LTR507_ALS_ADC_RES_8BIT = 0x06, /* 8 bit, integration time - 292us */
LTR507_ALS_ADC_RES_4BIT = 0x07, /* 4 bit, integration time - 18us */
} LTR507_CFG_ALS_ADC_RESOLUTION;
typedef enum {
LTR507_ALS_MEAS_RATE_100 = 0x00, /* ALS Measurement Repeat Rate = 100ms (default) */
LTR507_ALS_MEAS_RATE_200 = 0x01, /* ALS Measurement Repeat Rate = 200ms */
LTR507_ALS_MEAS_RATE_500 = 0x02, /* ALS Measurement Repeat Rate = 500ms */
LTR507_ALS_MEAS_RATE_1000 = 0x03, /* ALS Measurement Repeat Rate = 1000ms */
LTR507_ALS_MEAS_RATE_2000 = 0x04, /* ALS Measurement Repeat Rate = 2000ms */
} LTR507_CFG_ALS_MEAS_RATE;
typedef enum {
LTR507_INT_NEG = 0x00,
LTR507_INT_PS = 0x01,
LTR507_INT_ALS = 0x02,
} LTR507_CFG_INT_SOURCE;
typedef enum {
LTR507_ALS_INT_CLEAR = 0x00,
LTR507_ALS_INT_TRIG = 0x01,
} LTR507_CFG_ALS_INT_STATUS;
typedef enum {
LTR507_ALS_DATA_STATUS_OLD = 0x00,
LTR507_ALS_DATA_STATUS_NEW = 0x01,
} LTR507_CFG_ALS_DATA_STATUS;
typedef enum {
LTR507_PS_INT_CLEAR = 0x00,
LTR507_PS_INT_TRIG = 0x01,
} LTR507_CFG_PS_INT_STATUS;
typedef enum {
LTR507_PS_DATA_STATUS_OLD = 0x00,
LTR507_PS_DATA_STATUS_NEW = 0x01,
} LTR507_CFG_PS_DATA_STATUS;
typedef enum {
LTR507_FLAG_INIT_ALS = 0,
LTR507_FLAG_INIT_PS,
} LTR507_FLAG_INIT_BIT;
i2c_dev_t ltr507_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr = LTR507_I2C_ADDR,
};
static uint8_t g_init_bitwise = 0;
static int drv_als_ps_liteon_ltr507_validate_id(i2c_dev_t* drv, uint8_t part_id, uint8_t manufac_id)
{
int ret = 0;
uint8_t part_id_value = 0;
uint8_t manufac_id_value = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, LTR507_PART_ID, &part_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, LTR507_MANUFAC_ID, &manufac_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (part_id_value != part_id || manufac_id_value != manufac_id) {
return -1;
}
return 0;
}
static int drv_als_liteon_ltr507_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR507_ALS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_OFF:
case DEV_SLEEP:
dev_mode = LTR507_SET_BITSLICE(value, ALS_CONTR_REG_ALS_MODE, LTR507_ALS_STANDBY);
break;
case DEV_POWER_ON:
dev_mode = LTR507_SET_BITSLICE(value, ALS_CONTR_REG_ALS_MODE, LTR507_ALS_ACTIVE);
break;
default:
return -1;
}
ret = sensor_i2c_write(drv, LTR507_ALS_CONTR, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_ps_liteon_ltr507_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR507_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_OFF:
case DEV_SLEEP:
dev_mode = LTR507_SET_BITSLICE(value, PS_CONTR_REG_PS_MODE, LTR507_PS_STANDBY);
break;
case DEV_POWER_ON:
dev_mode = LTR507_SET_BITSLICE(value, PS_CONTR_REG_PS_MODE, LTR507_PS_ACTIVE);
break;
default:
return -1;
}
ret = sensor_i2c_write(drv, LTR507_PS_CONTR, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
UNUSED static int drv_als_liteon_ltr507_is_ready(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR507_ALS_PS_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return 0;
}
ret = (LTR507_GET_BITSLICE(value, ALS_PS_STATUS_REG_ALS_DATA_STATUS) == LTR507_ALS_DATA_STATUS_NEW) ? 1 : 0;
return ret;
}
UNUSED static int drv_ps_liteon_ltr507_is_ready(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR507_ALS_PS_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return 0;
}
ret = (LTR507_GET_BITSLICE(value, ALS_PS_STATUS_REG_PS_DATA_STATUS) == LTR507_PS_DATA_STATUS_NEW) ? 1 : 0;
return ret;
}
static int drv_als_liteon_ltr507_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR507_ALS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = LTR507_SET_BITSLICE(value, ALS_CONTR_REG_ALS_GAIN, LTR507_ALS_GAIN_1);
ret = sensor_i2c_write(drv, LTR507_ALS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR507_SET_BITSLICE(value, ALS_MEAS_RATE_REG_MEAS_RATE, LTR507_ALS_MEAS_RATE_500);
value = LTR507_SET_BITSLICE(value, ALS_MEAS_RATE_REG_ADC_RES, LTR507_ALS_ADC_RES_16BIT);
ret = sensor_i2c_write(drv, LTR507_ALS_MEAS_RATE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_ps_liteon_ltr507_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR507_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = LTR507_SET_BITSLICE(value, PS_CONTR_REG_PS_GAIN, LTR507_PS_GAIN);
ret = sensor_i2c_write(drv, LTR507_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR507_SET_BITSLICE(value, PS_LED_REG_PEAK_CURR, LTR507_PS_PEAK_CURRENT_50);
value = LTR507_SET_BITSLICE(value, PS_LED_REG_DUTY_CYCLE, LTR507_PS_DUTY_CYCLE);
value = LTR507_SET_BITSLICE(value, PS_LED_REG_PULSE_FREQ, LTR507_PS_PULSE_FREQ_60K);
ret = sensor_i2c_write(drv, LTR507_PS_LED, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 127;
ret = sensor_i2c_write(drv, LTR507_PS_N_PULSES, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR507_SET_BITSLICE(value, PS_MEAS_RATE_REG_MEAS_RATE, LTR507_PS_MEAS_RATE_100);
ret = sensor_i2c_write(drv, LTR507_PS_MEAS_RATE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static void drv_als_liteon_ltr507_irq_handle(void)
{
/* no handle so far */
}
static int drv_als_liteon_ltr507_open(void)
{
int ret = 0;
ret = drv_als_liteon_ltr507_set_power_mode(<r507_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_als_liteon_ltr507_close(void)
{
int ret = 0;
ret = drv_als_liteon_ltr507_set_power_mode(<r507_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_als_liteon_ltr507_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg_data[2] = { 0 };
als_data_t * pdata = (als_data_t *) buf;
if (buf == NULL){
return -1;
}
size = sizeof(als_data_t);
if (len < size){
return -1;
}
ret = sensor_i2c_read(<r507_ctx, LTR507_ALS_DATA_0, ®_data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r507_ctx, LTR507_ALS_DATA_1, ®_data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->lux = ((uint32_t) reg_data[1] << 8 | reg_data[0]);
pdata->timestamp = aos_now_ms();
return (int) size;
}
static int drv_als_liteon_ltr507_write(const void *buf, size_t len)
{
(void) buf;
(void) len;
return 0;
}
static int drv_als_liteon_ltr507_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
ret = drv_als_liteon_ltr507_set_power_mode(<r507_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->vendor = DEV_SENSOR_VENDOR_LITEON;
info->model = "LTR507";
info->unit = lux;
} break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static void drv_ps_liteon_ltr507_irq_handle(void)
{
/* no handle so far */
}
static int drv_ps_liteon_ltr507_open(void)
{
int ret = 0;
ret = drv_ps_liteon_ltr507_set_power_mode(<r507_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_ps_liteon_ltr507_close(void)
{
int ret = 0;
ret = drv_ps_liteon_ltr507_set_power_mode(<r507_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_ps_liteon_ltr507_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg_data[2] = { 0 };
proximity_data_t * pdata = (proximity_data_t *) buf;
if (buf == NULL) {
return -1;
}
size = sizeof(proximity_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(<r507_ctx, LTR507_PS_DATA_0, ®_data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r507_ctx, LTR507_PS_DATA_1, ®_data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
if (((reg_data[1] & 0x10) >> 4) == 0x00) {
pdata->present = (((uint32_t) (reg_data[1] & 0x07) << 8) | reg_data[0]);
}
else {
pdata->present = 0;
}
pdata->timestamp = aos_now_ms();
return (int) size;
}
static int drv_ps_liteon_ltr507_write(const void *buf, size_t len)
{
(void) buf;
(void) len;
return 0;
}
static int drv_ps_liteon_ltr507_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
ret = drv_ps_liteon_ltr507_set_power_mode(<r507_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *) arg;
info->vendor = DEV_SENSOR_VENDOR_LITEON;
info->model = "LTR507";
info->unit = cm;
} break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_als_liteon_ltr507_init(void)
{
int ret = 0;
sensor_obj_t sensor_als;
memset(&sensor_als, 0, sizeof(sensor_als));
if (!g_init_bitwise) {
ret = drv_als_ps_liteon_ltr507_validate_id(<r507_ctx, LTR507_PART_ID_VAL, LTR507_MANUFAC_ID_VAL);
if (unlikely(ret)) {
return -1;
}
}
if (!(g_init_bitwise & (1 << LTR507_FLAG_INIT_ALS))) {
/* fill the sensor_als obj parameters here */
sensor_als.path = dev_als_path;
sensor_als.tag = TAG_DEV_ALS;
sensor_als.io_port = I2C_PORT;
sensor_als.mode = DEV_POLLING;
sensor_als.power = DEV_POWER_OFF;
sensor_als.open = drv_als_liteon_ltr507_open;
sensor_als.close = drv_als_liteon_ltr507_close;
sensor_als.read = drv_als_liteon_ltr507_read;
sensor_als.write = drv_als_liteon_ltr507_write;
sensor_als.ioctl = drv_als_liteon_ltr507_ioctl;
sensor_als.irq_handle = drv_als_liteon_ltr507_irq_handle;
ret = sensor_create_obj(&sensor_als);
if (unlikely(ret)) {
return -1;
}
ret = drv_als_liteon_ltr507_set_default_config(<r507_ctx);
if (unlikely(ret)) {
return -1;
}
g_init_bitwise |= 1 << LTR507_FLAG_INIT_ALS;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_ps_liteon_ltr507_init(void)
{
int ret = 0;
sensor_obj_t sensor_ps;
memset(&sensor_ps, 0, sizeof(sensor_ps));
if (!g_init_bitwise) {
ret = drv_als_ps_liteon_ltr507_validate_id(<r507_ctx, LTR507_PART_ID_VAL, LTR507_MANUFAC_ID_VAL);
if (unlikely(ret)) {
return -1;
}
}
if (!(g_init_bitwise & (1 << LTR507_FLAG_INIT_PS))) {
/* fill the sensor_ps obj parameters here */
sensor_ps.tag = TAG_DEV_PS;
sensor_ps.path = dev_ps_path;
sensor_ps.io_port = I2C_PORT;
sensor_ps.mode = DEV_POLLING;
sensor_ps.power = DEV_POWER_OFF;
sensor_ps.open = drv_ps_liteon_ltr507_open;
sensor_ps.close = drv_ps_liteon_ltr507_close;
sensor_ps.read = drv_ps_liteon_ltr507_read;
sensor_ps.write = drv_ps_liteon_ltr507_write;
sensor_ps.ioctl = drv_ps_liteon_ltr507_ioctl;
sensor_ps.irq_handle = drv_ps_liteon_ltr507_irq_handle;
ret = sensor_create_obj(&sensor_ps);
if (unlikely(ret)) {
return -1;
}
ret = drv_ps_liteon_ltr507_set_default_config(<r507_ctx);
if (unlikely(ret)) {
return -1;
}
g_init_bitwise |= 1 << LTR507_FLAG_INIT_PS;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_als_liteon_ltr507_init);
SENSOR_DRV_ADD(drv_ps_liteon_ltr507_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_als_ps_liteon_ltr507.c
|
C
|
apache-2.0
| 24,492
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "ulog/ulog.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LTR553_ALS_CONTR 0x80 /* ALS operation mode, SW reset */
#define LTR553_PS_CONTR 0x81 /* PS operation mode */
#define LTR553_PS_LED 0x82 /* LED pulse freq, current duty, peak current */
#define LTR553_PS_MEAS_RATE 0x84 /* measurement rate*/
#define LTR553_ALS_MEAS_RATE 0x85 /* ALS integ time, measurement rate*/
#define LTR553_PART_ID 0x86
#define LTR553_MANUFAC_ID 0x87
#define LTR553_ALS_DATA1_L 0x88
#define LTR553_ALS_DATA1_H 0x89
#define LTR553_ALS_DATA0_L 0x8a
#define LTR553_ALS_DATA0_H 0x8b
#define LTR553_ALS_PS_STATUS 0x8c
#define LTR553_PS_DATA_L 0x8d
#define LTR553_PS_DATA_H 0x8e
#define LTR553_INTR 0x8f /* output mode, polarity, mode */
#define LTR553_PS_THRESH_UP 0x90 /* 11 bit, ps upper threshold */
#define LTR553_PS_THRESH_LOW 0x92 /* 11 bit, ps lower threshold */
#define LTR553_ALS_THRESH_UP 0x97 /* 16 bit, ALS upper threshold */
#define LTR553_ALS_THRESH_LOW 0x99 /* 16 bit, ALS lower threshold */
#define LTR553_INTR_PRST 0x9e /* ps thresh, als thresh */
#define LTR553_MAX_REG 0x9f
#define LTR553_I2C_SLAVE_ADDR 0x23
#define LTR553_ADDR_TRANS(n) ((n) << 1)
#define LTR553_I2C_ADDR LTR553_ADDR_TRANS(LTR553_I2C_SLAVE_ADDR)
#define LTR553_PART_ID_VAL 0x92
#define LTR553_MANUFAC_ID_VAL 0x05
#define LTR553_ALS_CONTR_REG_ALS_GAIN__POS (2)
#define LTR553_ALS_CONTR_REG_ALS_GAIN__MSK (0x1c)
#define LTR553_ALS_CONTR_REG_ALS_GAIN__REG (LTR553_ALS_CONTR)
#define LTR553_ALS_CONTR_REG_ALS_MODE__POS (0)
#define LTR553_ALS_CONTR_REG_ALS_MODE__MSK (0x01)
#define LTR553_ALS_CONTR_REG_ALS_MODE__REG (LTR553_ALS_CONTR)
#define LTR553_ALS_MEAS_RATE_REG_INTEG_TIME__POS (3)
#define LTR553_ALS_MEAS_RATE_REG_INTEG_TIME__MSK (0x38)
#define LTR553_ALS_MEAS_RATE_REG_INTEG_TIME__REG (LTR553_ALS_MEAS_RATE)
#define LTR553_ALS_MEAS_RATE_REG_MEAS_RATE__POS (0)
#define LTR553_ALS_MEAS_RATE_REG_MEAS_RATE__MSK (0x07)
#define LTR553_ALS_MEAS_RATE_REG_MEAS_RATE__REG (LTR553_ALS_MEAS_RATE)
#define LTR553_ALS_PS_STATUS_REG_ALS_STATUS__POS (2)
#define LTR553_ALS_PS_STATUS_REG_ALS_STATUS__MSK (0x04)
#define LTR553_ALS_PS_STATUS_REG_ALS_STATUS__REG (LTR553_ALS_PS_STATUS)
#define LTR553_PS_CONTR_REG_PS_GAIN__POS (2)
#define LTR553_PS_CONTR_REG_PS_GAIN__MSK (0x0c)
#define LTR553_PS_CONTR_REG_PS_GAIN__REG (LTR553_PS_CONTR)
#define LTR553_PS_CONTR_REG_PS_MODE__POS (0)
#define LTR553_PS_CONTR_REG_PS_MODE__MSK (0x03)
#define LTR553_PS_CONTR_REG_PS_MODE__REG (LTR553_PS_CONTR)
#define LTR553_PS_LED_REG_PLUSE_FREQ__POS (5)
#define LTR553_PS_LED_REG_PLUSE_FREQ__MSK (0xe0)
#define LTR553_PS_LED_REG_PLUSE_FREQ__REG (LTR553_PS_LED)
#define LTR553_PS_LED_REG_CURRENT_DUTY__POS (3)
#define LTR553_PS_LED_REG_CURRENT_DUTY__MSK (0x18)
#define LTR553_PS_LED_REG_CURRENT_DUTY__REG (LTR553_PS_LED)
#define LTR553_PS_LED_REG_CURRENT__POS (0)
#define LTR553_PS_LED_REG_CURRENT__MSK (0x07)
#define LTR553_PS_LED_REG_CURRENT__REG (LTR553_PS_LED)
#define LTR553_PS_MEAS_RATE_REG_MEAS_RATE__POS (0)
#define LTR553_PS_MEAS_RATE_REG_MEAS_RATE__MSK (0x0F)
#define LTR553_PS_MEAS_RATE_REG_MEAS_RATE__REG (LTR553_PS_MEAS_RATE)
#define LTR553_ALS_PS_STATUS_REG_PS_STATUS__POS (0)
#define LTR553_ALS_PS_STATUS_REG_PS_STATUS__MSK (0x01)
#define LTR553_ALS_PS_STATUS_REG_PS_STATUS__REG (LTR553_ALS_PS_STATUS)
#define LTR553_GET_BITSLICE(regvar, bitname) \
((regvar & bitname##__MSK) >> bitname##__POS)
#define LTR553_SET_BITSLICE(regvar, bitname, val) \
((regvar & ~bitname##__MSK) | ((val << bitname##__POS) & bitname##__MSK))
#define LTR553_WAIT_TIME_PER_CHECK (10)
#define LTR553_WAIT_TIME_TOTAL (1000)
typedef enum
{
AG_GAIN_1X = 0x0, /* 1 lux to 64k lux (default) */
AG_GAIN_2X = 0x1, /* 0.5 lux to 32k lux */
AG_GAIN_4X = 0x2, /* 0.25 lux to 16k lux */
AG_GAIN_8X = 0x3, /* 0.125 lux to 8k lux */
AG_GAIN_48X = 0x6, /* 0.02 lux to 1.3k lux */
AG_GAIN_96X = 0x7, /* 0.01 lux to 600 lux */
} CFG_ALS_Gain;
typedef enum
{
PG_GAIN_X16 = 0x0, /* X16 (default) */
PG_GAIN_X32 = 0x2, /* X32 */
PG_GAIN_X64 = 0x3, /* X64 */
} CFG_PS_Gain;
typedef enum
{
LPMF_PERIOD_30K = 0x0, /* LED pulse period = 30kHz */
LPMF_PERIOD_40K = 0x1, /* LED pulse period = 40kHz */
LPMF_PERIOD_50K = 0x2, /* LED pulse period = 50kHz */
LPMF_PERIOD_60K = 0x3, /* LED pulse period = 60kHz(default) */
LPMF_PERIOD_70K = 0x4, /* LED pulse period = 70kHz */
LPMF_PERIOD_80K = 0x5, /* LED pulse period = 80kHz */
LPMF_PERIOD_90K = 0x6, /* LED pulse period = 90kHz */
LPMF_PERIOD_100K = 0x7, /* LED pulse period = 100kHz */
} CFG_LED_pulse_Modulation_Frequency;
typedef enum
{
LCD_PER_25 = 0x0, /* DUTY = 25% */
LCD_PER_50 = 0x1, /* DUTY = 50% */
LCD_PER_75 = 0x2, /* DUTY = 75% */
LCD_PER_100 = 0x3, /* DUTY = 100%(default) */
} CFG_LED_Current_DUTY;
typedef enum
{
LC_LEVEL_5 = 0x0, /* LED pulse current level = 5mA */
LC_LEVEL_10 = 0x1, /* LED pulse current level = 10mA */
LC_LEVEL_20 = 0x2, /* LED pulse current level = 20mA */
LC_LEVEL_50 = 0x3, /* LED pulse current level = 50mA */
LC_LEVEL_100 = 0x4, /* LED pulse current level = 100mA(default) */
} CFG_LED_Current;
typedef enum
{
PMR_RATE_50 = 0x0, /* PS Measurement Repeat Rate = 50ms */
PMR_RATE_70 = 0x1, /* PS Measurement Repeat Rate = 70ms */
PMR_RATE_100 = 0x2, /* PS Measurement Repeat Rate = 100ms(default) */
PMR_RATE_200 = 0x3, /* PS Measurement Repeat Rate = 200ms */
PMR_RATE_500 = 0x4, /* PS Measurement Repeat Rate = 500ms */
PMR_RATE_1000 = 0x5, /* PS Measurement Repeat Rate = 1000ms */
PMR_RATE_2000 = 0x6, /* PS Measurement Repeat Rate = 2000ms */
PMR_RATE_10 = 0x8, /* PS Measurement Repeat Rate = 10ms */
} CFG_PS_measurement_rate;
typedef enum
{
AIT_TIME_100 = 0x0, /* ALS integration_time = 100ms(default) */
AIT_TIME_50 = 0x1, /* ALS integration_time = 50ms */
AIT_TIME_200 = 0x2, /* ALS integration_time = 200ms */
AIT_TIME_400 = 0x3, /* ALS integration_time = 400ms */
AIT_TIME_150 = 0x4, /* ALS integration_time = 150ms */
AIT_TIME_250 = 0x5, /* ALS integration_time = 250ms */
AIT_TIME_300 = 0x6, /* ALS integration_time = 300ms */
AIT_TIME_350 = 0x7, /* ALS integration_time = 350ms */
} CFG_ALS_integration_time;
typedef enum
{
AMR_RATE_50 = 0x0, /* ALS Measurement Repeat Rate = 50ms */
AMR_RATE_100 = 0x1, /* ALS Measurement Repeat Rate = 100ms */
AMR_RATE_200 = 0x2, /* ALS Measurement Repeat Rate = 200ms */
AMR_RATE_500 = 0x3, /* ALS Measurement Repeat Rate = 500ms(default) */
AMR_RATE_1000 = 0x4, /* ALS Measurement Repeat Rate = 1000ms */
AMR_RATE_2000 = 0x5, /* ALS Measurement Repeat Rate = 2000ms */
} CFG_ALS_measurement_rate;
typedef enum
{
PM_MODE_STANDBY = 0,
PM_MODE_ACTIVE = 3,
} CFG_PS_mode;
typedef enum
{
AM_MODE_STANDBY = 0,
AM_MODE_ACTIVE = 1,
} CFG_ALS_mode;
typedef enum
{
ADS_STATUS_OLD = 0,
ADS_STATUS_NEW = 1,
} CFG_ALS_data_status;
typedef enum
{
PDS_STATUS_OLD = 0,
PDS_STATUS_NEW = 1,
} CFG_PS_data_status;
typedef enum
{
FLAG_INIT_ALS = 0,
FLAG_INIT_PS,
} FLAG_INIT_BIT;
i2c_dev_t ltr553_ctx = {
.port = 2,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr = LTR553_I2C_ADDR,
};
static uint8_t g_init_bitwise = 0;
static int drv_als_ps_liteon_ltr553_validate_id(i2c_dev_t *drv, uint8_t part_id,
uint8_t manufac_id)
{
int ret = 0;
uint8_t part_id_value = 0;
uint8_t manufac_id_value = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, LTR553_PART_ID, &part_id_value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, LTR553_MANUFAC_ID, &manufac_id_value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (part_id_value != part_id || manufac_id_value != manufac_id) {
return -1;
}
return 0;
}
static int drv_als_liteon_ltr553_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR553_ALS_CONTR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_OFF:
case DEV_SLEEP:
dev_mode = LTR553_SET_BITSLICE(
dev_mode, LTR553_ALS_CONTR_REG_ALS_MODE, AM_MODE_STANDBY);
break;
case DEV_POWER_ON:
dev_mode = LTR553_SET_BITSLICE(
dev_mode, LTR553_ALS_CONTR_REG_ALS_MODE, AM_MODE_ACTIVE);
break;
default:
return -1;
}
ret = sensor_i2c_write(drv, LTR553_ALS_CONTR, &dev_mode, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_ps_liteon_ltr553_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR553_PS_CONTR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_OFF:
case DEV_SLEEP:
dev_mode = LTR553_SET_BITSLICE(value, LTR553_PS_CONTR_REG_PS_MODE,
PM_MODE_STANDBY);
break;
case DEV_POWER_ON:
dev_mode = LTR553_SET_BITSLICE(value, LTR553_PS_CONTR_REG_PS_MODE,
PM_MODE_ACTIVE);
break;
default:
return -1;
}
ret = sensor_i2c_write(drv, LTR553_PS_CONTR, &dev_mode, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
UNUSED static int drv_als_liteon_ltr553_is_ready(i2c_dev_t *drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR553_ALS_PS_STATUS, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return 0;
}
ret = (LTR553_GET_BITSLICE(value, LTR553_ALS_PS_STATUS_REG_ALS_STATUS) ==
ADS_STATUS_NEW)
? 1
: 0;
return ret;
}
UNUSED static int drv_ps_liteon_ltr553_is_ready(i2c_dev_t *drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR553_ALS_PS_STATUS, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return 0;
}
ret = (LTR553_GET_BITSLICE(value, LTR553_ALS_PS_STATUS_REG_PS_STATUS) ==
PDS_STATUS_NEW)
? 1
: 0;
return ret;
}
static int drv_als_liteon_ltr553_set_default_config(i2c_dev_t *drv)
{
int ret = 0;
uint8_t value = 0;
value = LTR553_SET_BITSLICE(value, LTR553_ALS_MEAS_RATE_REG_INTEG_TIME,
AIT_TIME_100);
value = LTR553_SET_BITSLICE(value, LTR553_ALS_MEAS_RATE_REG_MEAS_RATE,
AMR_RATE_100);
ret = sensor_i2c_write(drv, LTR553_ALS_MEAS_RATE, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, LTR553_ALS_CONTR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value =
LTR553_SET_BITSLICE(value, LTR553_ALS_CONTR_REG_ALS_GAIN, AG_GAIN_1X);
ret = sensor_i2c_write(drv, LTR553_ALS_CONTR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_ps_liteon_ltr553_set_default_config(i2c_dev_t *drv)
{
int ret = 0;
uint8_t value = 0;
value = LTR553_SET_BITSLICE(value, LTR553_PS_MEAS_RATE_REG_MEAS_RATE,
PMR_RATE_100);
ret = sensor_i2c_write(drv, LTR553_PS_MEAS_RATE, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value =
LTR553_SET_BITSLICE(value, LTR553_PS_LED_REG_PLUSE_FREQ, LPMF_PERIOD_60K);
value =
LTR553_SET_BITSLICE(value, LTR553_PS_LED_REG_CURRENT_DUTY, LCD_PER_100);
value = LTR553_SET_BITSLICE(value, LTR553_PS_LED_REG_CURRENT, LC_LEVEL_100);
ret = sensor_i2c_write(drv, LTR553_PS_MEAS_RATE, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, LTR553_PS_CONTR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value =
LTR553_SET_BITSLICE(value, LTR553_PS_CONTR_REG_PS_GAIN, PG_GAIN_X16);
ret = sensor_i2c_write(drv, LTR553_PS_CONTR, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static void drv_als_liteon_ltr553_irq_handle(void)
{
/* no handle so far */
}
static int drv_als_liteon_ltr553_open(void)
{
int ret = 0;
ret = drv_als_liteon_ltr553_set_power_mode(<r553_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_als_liteon_ltr553_close(void)
{
int ret = 0;
ret = drv_als_liteon_ltr553_set_power_mode(<r553_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_als_liteon_ltr553_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint16_t als_raw[2] = { 0 };
uint8_t reg_ch0[2] = { 0 };
uint8_t reg_ch1[2] = { 0 };
als_data_t *pdata = (als_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(als_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(<r553_ctx, LTR553_ALS_DATA1_L, ®_ch1[0],
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r553_ctx, LTR553_ALS_DATA1_H, ®_ch1[1],
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r553_ctx, LTR553_ALS_DATA0_L, ®_ch0[0],
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r553_ctx, LTR553_ALS_DATA0_H, ®_ch0[1],
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
als_raw[0] = (uint16_t)reg_ch0[1] << 8 | reg_ch0[0];
als_raw[1] = (uint16_t)reg_ch1[1] << 8 | reg_ch1[0];
pdata->lux = (uint32_t)((als_raw[0] + als_raw[1]) >> 1);
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_als_liteon_ltr553_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_als_liteon_ltr553_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
ret = drv_als_liteon_ltr553_set_power_mode(<r553_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LTR553";
info->unit = lux;
} break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static void drv_ps_liteon_ltr553_irq_handle(void)
{
/* no handle so far */
}
static int drv_ps_liteon_ltr553_open(void)
{
int ret = 0;
ret = drv_ps_liteon_ltr553_set_power_mode(<r553_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_ps_liteon_ltr553_close(void)
{
int ret = 0;
ret = drv_ps_liteon_ltr553_set_power_mode(<r553_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_ps_liteon_ltr553_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg_data[2] = { 0 };
proximity_data_t *pdata = (proximity_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(proximity_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(<r553_ctx, LTR553_PS_DATA_L, ®_data[0],
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r553_ctx, LTR553_PS_DATA_H, ®_data[1],
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->present = (uint32_t)(reg_data[1] << 8 | reg_data[0]);
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_ps_liteon_ltr553_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_ps_liteon_ltr553_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
ret = drv_ps_liteon_ltr553_set_power_mode(<r553_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LTR553";
info->unit = cm;
} break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_als_liteon_ltr553_init(void)
{
int ret = 0;
sensor_obj_t sensor_als;
memset(&sensor_als, 0, sizeof(sensor_als));
if (!g_init_bitwise) {
ret = drv_als_ps_liteon_ltr553_validate_id(
<r553_ctx, LTR553_PART_ID_VAL, LTR553_MANUFAC_ID_VAL);
if (unlikely(ret)) {
return -1;
}
}
if (!(g_init_bitwise & (1 << FLAG_INIT_ALS))) {
/* fill the sensor_als obj parameters here */
sensor_als.tag = TAG_DEV_ALS;
sensor_als.path = dev_als_path;
sensor_als.io_port = I2C_PORT;
sensor_als.open = drv_als_liteon_ltr553_open;
sensor_als.close = drv_als_liteon_ltr553_close;
sensor_als.read = drv_als_liteon_ltr553_read;
sensor_als.write = drv_als_liteon_ltr553_write;
sensor_als.ioctl = drv_als_liteon_ltr553_ioctl;
sensor_als.irq_handle = drv_als_liteon_ltr553_irq_handle;
ret = sensor_create_obj(&sensor_als);
if (unlikely(ret)) {
return -1;
}
ret = drv_als_liteon_ltr553_set_default_config(<r553_ctx);
if (unlikely(ret)) {
return -1;
}
g_init_bitwise |= 1 << FLAG_INIT_ALS;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_ps_liteon_ltr553_init(void)
{
int ret = 0;
sensor_obj_t sensor_ps;
memset(&sensor_ps, 0, sizeof(sensor_ps));
if (!g_init_bitwise) {
ret = drv_als_ps_liteon_ltr553_validate_id(
<r553_ctx, LTR553_PART_ID_VAL, LTR553_MANUFAC_ID_VAL);
if (unlikely(ret)) {
return -1;
}
}
if (!(g_init_bitwise & (1 << FLAG_INIT_PS))) {
/* fill the sensor_ps obj parameters here */
sensor_ps.tag = TAG_DEV_PS;
sensor_ps.path = dev_ps_path;
sensor_ps.io_port = I2C_PORT;
sensor_ps.open = drv_ps_liteon_ltr553_open;
sensor_ps.close = drv_ps_liteon_ltr553_close;
sensor_ps.read = drv_ps_liteon_ltr553_read;
sensor_ps.write = drv_ps_liteon_ltr553_write;
sensor_ps.ioctl = drv_ps_liteon_ltr553_ioctl;
sensor_ps.irq_handle = drv_ps_liteon_ltr553_irq_handle;
ret = sensor_create_obj(&sensor_ps);
if (unlikely(ret)) {
return -1;
}
ret = drv_ps_liteon_ltr553_set_default_config(<r553_ctx);
if (unlikely(ret)) {
return -1;
}
g_init_bitwise |= 1 << FLAG_INIT_PS;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_als_liteon_ltr553_init);
SENSOR_DRV_ADD(drv_ps_liteon_ltr553_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_als_ps_liteon_ltr553.c
|
C
|
apache-2.0
| 21,206
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LTR559_I2C_SLAVE_ADDR 0x23
#define LTR559_ALS_CONTR 0x80
#define LTR559_PS_CONTR 0x81 /* PS operation mode */
#define LTR559_PS_LED 0x82 /* LED pulse freq, current duty, peak current */
#define LTR559_PS_N_PULSES 0x83 /* PS number of pulses */
#define LTR559_PS_MEAS_RATE 0x84 /* measurement rate*/
#define LTR559_ALS_MEAS_RATE 0x85
#define LTR559_PART_ID 0x86
#define LTR559_MANUFAC_ID 0x87
#define LTR559_ALS_DATA_CH1_0 0x88
#define LTR559_ALS_DATA_CH1_1 0x89
#define LTR559_ALS_DATA_CH0_0 0x8A
#define LTR559_ALS_DATA_CH0_1 0x8B
#define LTR559_ALS_PS_STATUS 0x8C
#define LTR559_PS_DATA_0 0x8D
#define LTR559_PS_DATA_1 0x8E
#define LTR559_INTERRUPT 0x8F
#define LTR559_PS_THRES_UP_0 0x90 /* PS interrupt upper threshold, lower byte */
#define LTR559_PS_THRES_UP_1 0x91 /* PS interrupt upper threshold, upper byte */
#define LTR559_PS_THRES_LOW_0 0x92 /* PS interrupt lower threshold, lower byte */
#define LTR559_PS_THRES_LOW_1 0x93 /* PS interrupt lower threshold, upper byte */
#define LTR559_PS_OFFSET_1 0x94 /* PS offset, upper byte */
#define LTR559_PS_OFFSET_0 0x95 /* PS offset, lower byte */
#define LTR559_ALS_THRES_UP_0 0x97
#define LTR559_ALS_THRES_UP_1 0x98
#define LTR559_ALS_THRES_LOW_0 0x99
#define LTR559_ALS_THRES_LOW_1 0x9A
#define LTR559_INTR_PRST 0x9E /* PS interrupt persist setting */
#define LTR559_ADDR_TRANS(n) ((n) << 1)
#define LTR559_I2C_ADDR LTR559_ADDR_TRANS(LTR559_I2C_SLAVE_ADDR)
#define LTR559_PART_ID_VAL 0x92
#define LTR559_MANUFAC_ID_VAL 0x05
#define LTR559_ALS_CONTR_REG_ALS_MODE__POS (0)
#define LTR559_ALS_CONTR_REG_ALS_MODE__MSK (0x01)
#define LTR559_ALS_CONTR_REG_ALS_MODE__REG (LTR559_ALS_CONTR)
#define LTR559_ALS_CONTR_REG_SW_RESET__POS (1)
#define LTR559_ALS_CONTR_REG_SW_RESET__MSK (0x02)
#define LTR559_ALS_CONTR_REG_SW_RESET__REG (LTR559_ALS_CONTR)
#define LTR559_ALS_CONTR_REG_ALS_GAIN__POS (2)
#define LTR559_ALS_CONTR_REG_ALS_GAIN__MSK (0x1C)
#define LTR559_ALS_CONTR_REG_ALS_GAIN__REG (LTR559_ALS_CONTR)
#define LTR559_PS_CONTR_REG_PS_MODE__POS (0)
#define LTR559_PS_CONTR_REG_PS_MODE__MSK (0x03)
#define LTR559_PS_CONTR_REG_PS_MODE__REG (LTR559_PS_CONTR)
#define LTR559_PS_CONTR_REG_PS_SAT_IND_EN__POS (5)
#define LTR559_PS_CONTR_REG_PS_SAT_IND_EN__MSK (0x20)
#define LTR559_PS_CONTR_REG_PS_SAT_IND_EN__REG (LTR559_PS_CONTR)
#define LTR559_PS_LED_REG_LED_CURR__POS (0)
#define LTR559_PS_LED_REG_LED_CURR__MSK (0x07)
#define LTR559_PS_LED_REG_LED_CURR__REG (LTR559_PS_LED)
#define LTR559_PS_LED_REG_LED_DUTY__POS (3)
#define LTR559_PS_LED_REG_LED_DUTY__MSK (0x18)
#define LTR559_PS_LED_REG_LED_DUTY__REG (LTR559_PS_LED)
#define LTR559_PS_LED_REG_LED_PULSE__POS (5)
#define LTR559_PS_LED_REG_LED_PULSE__MSK (0xE0)
#define LTR559_PS_LED_REG_LED_PULSE__REG (LTR559_PS_LED)
#define LTR559_PS_N_PULSES_REG_PULSES__POS (0)
#define LTR559_PS_N_PULSES_REG_PULSES__MSK (0x0F)
#define LTR559_PS_N_PULSES_REG_PULSES__REG (LTR559_PS_N_PULSES)
#define LTR559_PS_MEAS_RATE_REG_MEAS_RPT_RATE__POS (0)
#define LTR559_PS_MEAS_RATE_REG_MEAS_RPT_RATE__MSK (0x0F)
#define LTR559_PS_MEAS_RATE_REG_MEAS_RPT_RATE__REG (LTR559_PS_MEAS_RATE)
#define LTR559_ALS_MEAS_RATE_REG_MEAS_RPT_RATE__POS (0)
#define LTR559_ALS_MEAS_RATE_REG_MEAS_RPT_RATE__MSK (0x07)
#define LTR559_ALS_MEAS_RATE_REG_MEAS_RPT_RATE__REG (LTR559_ALS_MEAS_RATE)
#define LTR559_ALS_MEAS_RATE_REG_INTEG_TIME__POS (3)
#define LTR559_ALS_MEAS_RATE_REG_INTEG_TIME__MSK (0x38)
#define LTR559_ALS_MEAS_RATE_REG_INTEG_TIME__REG (LTR559_ALS_MEAS_RATE)
#define LTR559_ALS_PS_STATUS_REG_PS_DATA_STATUS__POS (0)
#define LTR559_ALS_PS_STATUS_REG_PS_DATA_STATUS__MSK (0x01)
#define LTR559_ALS_PS_STATUS_REG_PS_DATA_STATUS__REG (LTR559_ALS_PS_STATUS)
#define LTR559_ALS_PS_STATUS_REG_PS_INT_STATUS__POS (1)
#define LTR559_ALS_PS_STATUS_REG_PS_INT_STATUS__MSK (0x02)
#define LTR559_ALS_PS_STATUS_REG_PS_INT_STATUS__REG (LTR559_ALS_PS_STATUS)
#define LTR559_ALS_PS_STATUS_REG_ALS_DATA_STATUS__POS (2)
#define LTR559_ALS_PS_STATUS_REG_ALS_DATA_STATUS__MSK (0x04)
#define LTR559_ALS_PS_STATUS_REG_ALS_DATA_STATUS__REG (LTR559_ALS_PS_STATUS)
#define LTR559_ALS_PS_STATUS_REG_ALS_INT_STATUS__POS (3)
#define LTR559_ALS_PS_STATUS_REG_ALS_INT_STATUS__MSK (0x08)
#define LTR559_ALS_PS_STATUS_REG_ALS_INT_STATUS__REG (LTR559_ALS_PS_STATUS)
#define LTR559_ALS_PS_STATUS_REG_ALS_GAIN__POS (4)
#define LTR559_ALS_PS_STATUS_REG_ALS_GAIN__MSK (0x70)
#define LTR559_ALS_PS_STATUS_REG_ALS_GAIN__REG (LTR559_ALS_PS_STATUS)
#define LTR559_ALS_PS_STATUS_REG_ALS_DATA_VALID__POS (7)
#define LTR559_ALS_PS_STATUS_REG_ALS_DATA_VALID__MSK (0x80)
#define LTR559_ALS_PS_STATUS_REG_ALS_DATA_VALID__REG (LTR559_ALS_PS_STATUS)
#define LTR559_INTERRUPT_REG_INT_MODE__POS (0)
#define LTR559_INTERRUPT_REG_INT_MODE__MSK (0x03)
#define LTR559_INTERRUPT_REG_INT_MODE__REG (LTR559_INTERRUPT)
#define LTR559_INTERRUPT_REG_INT_POLARITY__POS (2)
#define LTR559_INTERRUPT_REG_INT_POLARITY__MSK (0x04)
#define LTR559_INTERRUPT_REG_INT_POLARITY__REG (LTR559_INTERRUPT)
#define LTR559_INTR_PRST_REG_ALS_PERSIST__POS (0)
#define LTR559_INTR_PRST_REG_ALS_PERSIST__MSK (0x0F)
#define LTR559_INTR_PRST_REG_ALS_PERSIST__REG (LTR559_INTR_PRST)
#define LTR559_INTR_PRST_REG_PS_PERSIST__POS (4)
#define LTR559_INTR_PRST_REG_PS_PERSIST__MSK (0xF0)
#define LTR559_INTR_PRST_REG_PS_PERSIST__REG (LTR559_INTR_PRST)
#define LTR559_GET_BITSLICE(regvar, bitname) ((regvar & LTR559_##bitname##__MSK) >> LTR559_##bitname##__POS)
#define LTR559_SET_BITSLICE(regvar, bitname, val) ((regvar & ~LTR559_##bitname##__MSK) | ((val<<LTR559_##bitname##__POS)<R559_##bitname##__MSK))
#define LTR559_WAIT_TIME_PER_CHECK (10)
#define LTR559_WAIT_TIME_TOTAL (100)
typedef enum {
LTR559_ALS_STANDBY = 0x00,
LTR559_ALS_ACTIVE = 0x01,
} LTR559_CFG_ALS_MODE;
typedef enum {
LTR559_SW_RESET_FALSE = 0x00,
LTR559_SW_RESET_TRUE = 0x01,
} LTR559_CFG_SW_RESET;
typedef enum {
LTR559_ALS_GAIN_1X = 0x00, /* 1 lux to 64k lux (default) */
LTR559_ALS_GAIN_2X = 0x01, /* 0.5 lux to 32k lux */
LTR559_ALS_GAIN_4X = 0x02, /* 0.25 lux to 16k lux */
LTR559_ALS_GAIN_8X = 0x03, /* 0.125 lux to 8k lux */
LTR559_ALS_GAIN_48X = 0x06, /* 0.02 lux to 1.3k lux */
LTR559_ALS_GAIN_96X = 0x07, /* 0.01 lux to 600 lux */
} LTR559_CFG_ALS_Gain;
typedef enum {
LTR559_PS_STANDBY = 0x00,
LTR559_PS_ACTIVE = 0x02,
} LTR559_CFG_PS_MODE;
typedef enum {
LTR559_PS_SAT_IND_FALSE = 0x00,
LTR559_PS_SAT_IND_TRUE = 0x01,
} LTR559_CFG_PS_SAT_IND_EN;
typedef enum {
LTR559_LED_PEAK_CURRENT_5 = 0x00, /* LED pulse current level = 5mA */
LTR559_LED_PEAK_CURRENT_10 = 0x01, /* LED pulse current level = 10mA */
LTR559_LED_PEAK_CURRENT_20 = 0x02, /* LED pulse current level = 20mA */
LTR559_LED_PEAK_CURRENT_50 = 0x03, /* LED pulse current level = 50mA */
LTR559_LED_PEAK_CURRENT_100 = 0x04, /* LED pulse current level = 100mA (default) */
} LTR559_CFG_LED_PEAK_CURRENT;
typedef enum {
LTR559_LED_DUTY_CYCLE_25PCT = 0x00, /* Duty = 25% */
LTR559_LED_DUTY_CYCLE_50PCT = 0x01, /* Duty = 50% */
LTR559_LED_DUTY_CYCLE_75PCT = 0x02, /* Duty = 75% */
LTR559_LED_DUTY_CYCLE_100PCT = 0x03, /* Duty = 100% (default) */
} LTR559_CFG_LED_DUTY_CYCLE;
typedef enum {
LTR559_LED_PULSE_30kHZ = 0x00, /* LED pulse period = 30kHz */
LTR559_LED_PULSE_40kHZ = 0x01, /* LED pulse period = 40kHz */
LTR559_LED_PULSE_50kHZ = 0x02, /* LED pulse period = 50kHz */
LTR559_LED_PULSE_60kHZ = 0x03, /* LED pulse period = 60kHz */
LTR559_LED_PULSE_70kHZ = 0x04, /* LED pulse period = 70kHz */
LTR559_LED_PULSE_80kHZ = 0x05, /* LED pulse period = 80kHz */
LTR559_LED_PULSE_90kHZ = 0x06, /* LED pulse period = 90kHz */
LTR559_LED_PULSE_100kHZ = 0x07, /* LED pulse period = 100kHz */
} LTR559_CFG_LED_PULSE_FREQUENCY;
typedef enum {
LTR559_PS_MEAS_RATE_50 = 0x00, /* PS Measurement Repeat Rate = 50ms */
LTR559_PS_MEAS_RATE_70 = 0x01, /* PS Measurement Repeat Rate = 70ms */
LTR559_PS_MEAS_RATE_100 = 0x02, /* PS Measurement Repeat Rate = 100ms (default) */
LTR559_PS_MEAS_RATE_200 = 0x03, /* PS Measurement Repeat Rate = 20ms */
LTR559_PS_MEAS_RATE_500 = 0x04, /* PS Measurement Repeat Rate = 500ms */
LTR559_PS_MEAS_RATE_1000 = 0x05, /* PS Measurement Repeat Rate = 1000ms */
LTR559_PS_MEAS_RATE_2000 = 0x06, /* PS Measurement Repeat Rate = 2000ms */
LTR559_PS_MEAS_RATE_10 = 0x08, /* PS Measurement Repeat Rate = 10ms */
} LTR559_CFG_PS_MEAS_RPT_RATE;
typedef enum {
LTR559_ALS_MEAS_RATE_50 = 0x00, /* ALS Measurement Repeat Rate = 50ms */
LTR559_ALS_MEAS_RATE_100 = 0x01, /* ALS Measurement Repeat Rate = 100ms */
LTR559_ALS_MEAS_RATE_200 = 0x02, /* ALS Measurement Repeat Rate = 200ms */
LTR559_ALS_MEAS_RATE_500 = 0x03, /* ALS Measurement Repeat Rate = 500ms (default) */
LTR559_ALS_MEAS_RATE_1000 = 0x04, /* ALS Measurement Repeat Rate = 1000ms */
LTR559_ALS_MEAS_RATE_2000 = 0x05, /* ALS Measurement Repeat Rate = 2000ms */
} LTR559_CFG_ALS_MEAS_RATE;
typedef enum {
LTR559_ALS_INTEG_TIME_100 = 0x00, /* ALS Integration Time = 100ms (default) */
LTR559_ALS_INTEG_TIME_50 = 0x01, /* ALS Integration Time = 50ms */
LTR559_ALS_INTEG_TIME_200 = 0x02, /* ALS Integration Time = 200ms */
LTR559_ALS_INTEG_TIME_400 = 0x03, /* ALS Integration Time = 400ms */
LTR559_ALS_INTEG_TIME_150 = 0x04, /* ALS Integration Time = 150ms */
LTR559_ALS_INTEG_TIME_250 = 0x05, /* ALS Integration Time = 250ms */
LTR559_ALS_INTEG_TIME_300 = 0x06, /* ALS Integration Time = 300ms */
LTR559_ALS_INTEG_TIME_350 = 0x07, /* ALS Integration Time = 350ms */
} LTR559_CFG_ALS_INTEG_TIME;
typedef enum {
LTR559_PS_DATA_STATUS_OLD = 0x00,
LTR559_PS_DATA_STATUS_NEW = 0x01,
} LTR559_CFG_PS_DATA_STATUS;
typedef enum {
LTR559_PS_INT_STATUS_INACTIVE = 0x00,
LTR559_PS_INT_STATUS_ACTIVE = 0x01,
} LTR559_CFG_PS_INT_STATUS;
typedef enum {
LTR559_ALS_DATA_STATUS_OLD = 0x00,
LTR559_ALS_DATA_STATUS_NEW = 0x01,
} LTR559_CFG_ALS_DATA_STATUS;
typedef enum {
LTR559_ALS_INT_STATUS_INACTIVE = 0x00,
LTR559_ALS_INT_STATUS_ACTIVE = 0x01,
} LTR559_CFG_ALS_INT_STATUS;
typedef enum {
LTR559_ALS_DATA_VALID = 0x00,
LTR559_ALS_DATA_INVALID = 0x01,
} LTR559_CFG_ALS_DATA_VALID_STATUS;
typedef enum {
LTR559_INT_MODE_DISABLE = 0x00,
LTR559_INT_MODE_PS = 0x01,
LTR559_INT_MODE_ALS = 0x02,
LTR559_INT_MODE_PS_ALS = 0x03,
} LTR559_CFG_INT_MODE;
typedef enum {
LTR559_INT_POLARITY_ACTIVE_LO = 0x00,
LTR559_INT_POLARITY_ACTIVE_HI = 0x01,
} LTR559_CFG_INT_POLARITY;
typedef enum {
LTR559_FLAG_INIT_ALS = 0,
LTR559_FLAG_INIT_PS,
} LTR559_FLAG_INIT_BIT;
i2c_dev_t ltr559_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr = LTR559_I2C_ADDR,
};
static uint8_t g_init_bitwise = 0;
static int drv_als_ps_liteon_ltr559_validate_id(i2c_dev_t* drv, uint8_t part_id, uint8_t manufac_id)
{
int ret = 0;
uint8_t part_id_value = 0;
uint8_t manufac_id_value = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, LTR559_PART_ID, &part_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, LTR559_MANUFAC_ID, &manufac_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (part_id_value != part_id || manufac_id_value != manufac_id) {
return -1;
}
return 0;
}
static int drv_als_liteon_ltr559_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR559_ALS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_OFF:
case DEV_SLEEP:
dev_mode = LTR559_SET_BITSLICE(value, ALS_CONTR_REG_ALS_MODE, LTR559_ALS_STANDBY);
break;
case DEV_POWER_ON:
dev_mode = LTR559_SET_BITSLICE(value, ALS_CONTR_REG_ALS_MODE, LTR559_ALS_ACTIVE);
break;
default:
return -1;
}
ret = sensor_i2c_write(drv, LTR559_ALS_CONTR, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_ps_liteon_ltr559_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR559_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_OFF:
case DEV_SLEEP:
dev_mode = LTR559_SET_BITSLICE(value, PS_CONTR_REG_PS_MODE, LTR559_PS_STANDBY);
break;
case DEV_POWER_ON:
dev_mode = LTR559_SET_BITSLICE(value, PS_CONTR_REG_PS_MODE, LTR559_PS_ACTIVE);
break;
default:
return -1;
}
ret = sensor_i2c_write(drv, LTR559_PS_CONTR, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
UNUSED static int drv_als_liteon_ltr559_is_ready(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR559_ALS_PS_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return 0;
}
ret = (LTR559_GET_BITSLICE(value, ALS_PS_STATUS_REG_ALS_DATA_STATUS) == LTR559_ALS_DATA_STATUS_NEW) ? 1 : 0;
return ret;
}
UNUSED static int drv_ps_liteon_ltr559_is_ready(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR559_ALS_PS_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return 0;
}
ret = (LTR559_GET_BITSLICE(value, ALS_PS_STATUS_REG_PS_DATA_STATUS) == LTR559_PS_DATA_STATUS_NEW) ? 1 : 0;
return ret;
}
UNUSED static int drv_als_liteon_ltr559_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR559_ALS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = LTR559_SET_BITSLICE(value, ALS_CONTR_REG_ALS_GAIN, LTR559_ALS_GAIN_1X);
ret = sensor_i2c_write(drv, LTR559_ALS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR559_SET_BITSLICE(value, ALS_MEAS_RATE_REG_MEAS_RPT_RATE, LTR559_ALS_MEAS_RATE_500);
value = LTR559_SET_BITSLICE(value, ALS_MEAS_RATE_REG_INTEG_TIME, LTR559_ALS_INTEG_TIME_100);
ret = sensor_i2c_write(drv, LTR559_ALS_MEAS_RATE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_ps_liteon_ltr559_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR559_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = LTR559_SET_BITSLICE(value, PS_CONTR_REG_PS_SAT_IND_EN, LTR559_PS_SAT_IND_FALSE);
ret = sensor_i2c_write(drv, LTR559_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR559_SET_BITSLICE(value, PS_LED_REG_LED_CURR, LTR559_LED_PEAK_CURRENT_100);
value = LTR559_SET_BITSLICE(value, PS_LED_REG_LED_DUTY, LTR559_LED_DUTY_CYCLE_100PCT);
value = LTR559_SET_BITSLICE(value, PS_LED_REG_LED_PULSE, LTR559_LED_PULSE_60kHZ);
ret = sensor_i2c_write(drv, LTR559_PS_LED, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR559_SET_BITSLICE(value, PS_N_PULSES_REG_PULSES, 4);
ret = sensor_i2c_write(drv, LTR559_PS_N_PULSES, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR559_SET_BITSLICE(value, PS_MEAS_RATE_REG_MEAS_RPT_RATE, LTR559_PS_MEAS_RATE_100);
ret = sensor_i2c_write(drv, LTR559_PS_MEAS_RATE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static void drv_als_liteon_ltr559_irq_handle(void)
{
/* no handle so far */
}
static void drv_ps_liteon_ltr559_irq_handle(void)
{
/* no handle so far */
}
static int drv_als_liteon_ltr559_open(void)
{
int ret = 0;
ret = drv_als_liteon_ltr559_set_power_mode(<r559_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_ps_liteon_ltr559_open(void)
{
int ret = 0;
ret = drv_ps_liteon_ltr559_set_power_mode(<r559_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_als_liteon_ltr559_close(void)
{
int ret = 0;
ret = drv_als_liteon_ltr559_set_power_mode(<r559_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_ps_liteon_ltr559_close(void)
{
int ret = 0;
ret = drv_ps_liteon_ltr559_set_power_mode(<r559_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static uint8_t drv_als_liteon_ltr559_get_gain_val(i2c_dev_t* drv)
{
uint8_t als_gain = 0, als_gain_val = 0;
bool ret = false;
ret = sensor_i2c_read(drv, LTR559_ALS_PS_STATUS, &als_gain, I2C_DATA_LEN, I2C_OP_RETRIES);
if (!unlikely(ret))
{
als_gain = LTR559_GET_BITSLICE(als_gain, ALS_PS_STATUS_REG_ALS_GAIN);
switch (als_gain)
{
case LTR559_ALS_GAIN_1X:
als_gain_val = 1;
break;
case LTR559_ALS_GAIN_2X:
als_gain_val = 2;
break;
case LTR559_ALS_GAIN_4X:
als_gain_val = 4;
break;
case LTR559_ALS_GAIN_8X:
als_gain_val = 8;
break;
case LTR559_ALS_GAIN_48X:
als_gain_val = 48;
break;
case LTR559_ALS_GAIN_96X:
als_gain_val = 96;
break;
default:
als_gain_val = 1;
break;
}
}
else
{
als_gain_val = 0;
}
return als_gain_val;
}
static uint16_t drv_als_liteon_ltr559_get_integ_time_val(i2c_dev_t* drv)
{
uint16_t als_integ = 0, als_integ_val = 0;
bool ret = false;
ret = sensor_i2c_read(drv, LTR559_ALS_MEAS_RATE, (uint8_t*)&als_integ, I2C_DATA_LEN, I2C_OP_RETRIES);
if (!unlikely(ret))
{
als_integ = LTR559_GET_BITSLICE(als_integ, ALS_MEAS_RATE_REG_INTEG_TIME);
switch (als_integ)
{
case LTR559_ALS_INTEG_TIME_100:
als_integ_val = 10;
break;
case LTR559_ALS_INTEG_TIME_50:
als_integ_val = 5;
break;
case LTR559_ALS_INTEG_TIME_200:
als_integ_val = 20;
break;
case LTR559_ALS_INTEG_TIME_400:
als_integ_val = 40;
break;
case LTR559_ALS_INTEG_TIME_150:
als_integ_val = 15;
break;
case LTR559_ALS_INTEG_TIME_250:
als_integ_val = 25;
break;
case LTR559_ALS_INTEG_TIME_300:
als_integ_val = 30;
break;
case LTR559_ALS_INTEG_TIME_350:
als_integ_val = 35;
break;
default:
als_integ_val = 10;
break;
}
}
else
{
als_integ_val = 0;
}
return als_integ_val;
}
static int drv_als_liteon_ltr559_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg_ch1_data[2] = { 0 };
uint8_t reg_ch0_data[2] = { 0 };
uint32_t als_ch0_data = 0, als_ch1_data = 0, chRatio = 0, tmpCalc = 0;
uint16_t als_gain_val = 0, als_integ_time_val = 0;
als_data_t * pdata = (als_data_t *) buf;
if (buf == NULL){
return -1;
}
size = sizeof(als_data_t);
if (len < size){
return -1;
}
ret = sensor_i2c_read(<r559_ctx, LTR559_ALS_DATA_CH1_0, ®_ch1_data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r559_ctx, LTR559_ALS_DATA_CH1_1, ®_ch1_data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r559_ctx, LTR559_ALS_DATA_CH0_0, ®_ch0_data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r559_ctx, LTR559_ALS_DATA_CH0_1, ®_ch0_data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
als_ch0_data = ((uint16_t) reg_ch0_data[1] << 8 | reg_ch0_data[0]);
als_ch1_data = ((uint16_t) reg_ch1_data[1] << 8 | reg_ch1_data[0]);
chRatio = (als_ch1_data * 100) / (als_ch0_data + als_ch1_data);
if (chRatio < 45)
{
tmpCalc = (1774 * als_ch0_data + 1106 * als_ch1_data);
}
else if (chRatio >= 45 && chRatio < 64)
{
tmpCalc = (4279 * als_ch0_data - 1955 * als_ch1_data);
}
else if (chRatio >= 64 && chRatio < 85)
{
tmpCalc = (593 * als_ch0_data + 119 * als_ch1_data);
}
else
{
tmpCalc = 0;
}
als_gain_val = drv_als_liteon_ltr559_get_gain_val(<r559_ctx);
als_integ_time_val = drv_als_liteon_ltr559_get_integ_time_val(<r559_ctx);
if ((als_gain_val != 0) && (als_integ_time_val != 0))
{
pdata->lux = tmpCalc / als_gain_val / als_integ_time_val / 100;
}
else
{
pdata->lux = 0;
}
pdata->timestamp = aos_now_ms();
return (int) size;
}
static int drv_ps_liteon_ltr559_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg_data[2] = { 0 };
proximity_data_t * pdata = (proximity_data_t *) buf;
if (buf == NULL) {
return -1;
}
size = sizeof(proximity_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(<r559_ctx, LTR559_PS_DATA_0, ®_data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r559_ctx, LTR559_PS_DATA_1, ®_data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->present = (((uint32_t) (reg_data[1] & 0x07) << 8) | reg_data[0]);
pdata->timestamp = aos_now_ms();
return (int) size;
}
static int drv_als_liteon_ltr559_write(const void *buf, size_t len)
{
(void) buf;
(void) len;
return 0;
}
static int drv_ps_liteon_ltr559_write(const void *buf, size_t len)
{
(void) buf;
(void) len;
return 0;
}
static int drv_als_liteon_ltr559_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
ret = drv_als_liteon_ltr559_set_power_mode(<r559_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *) arg;
info->vendor = DEV_SENSOR_VENDOR_LITEON;
info->model = "LTR559";
info->unit = lux;
} break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_ps_liteon_ltr559_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
ret = drv_ps_liteon_ltr559_set_power_mode(<r559_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *) arg;
info->vendor = DEV_SENSOR_VENDOR_LITEON;
info->model = "LTR559";
info->unit = cm;
} break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_als_liteon_ltr559_init(void)
{
int ret = 0;
sensor_obj_t sensor_als;
memset(&sensor_als, 0, sizeof(sensor_als));
if (!g_init_bitwise) {
ret = drv_als_ps_liteon_ltr559_validate_id(<r559_ctx, LTR559_PART_ID_VAL, LTR559_MANUFAC_ID_VAL);
if (unlikely(ret)) {
return -1;
}
}
if (!(g_init_bitwise & (1 << LTR559_FLAG_INIT_ALS))) {
/* fill the sensor_ps obj parameters here */
sensor_als.tag = TAG_DEV_ALS;
sensor_als.path = dev_als_path;
sensor_als.io_port = I2C_PORT;
sensor_als.mode = DEV_POLLING;
sensor_als.power = DEV_POWER_OFF;
sensor_als.open = drv_als_liteon_ltr559_open;
sensor_als.close = drv_als_liteon_ltr559_close;
sensor_als.read = drv_als_liteon_ltr559_read;
sensor_als.write = drv_als_liteon_ltr559_write;
sensor_als.ioctl = drv_als_liteon_ltr559_ioctl;
sensor_als.irq_handle = drv_als_liteon_ltr559_irq_handle;
ret = sensor_create_obj(&sensor_als);
if (unlikely(ret)) {
return -1;
}
ret = drv_ps_liteon_ltr559_set_default_config(<r559_ctx);
if (unlikely(ret)) {
return -1;
}
g_init_bitwise |= 1 << LTR559_FLAG_INIT_ALS;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_ps_liteon_ltr559_init(void)
{
int ret = 0;
sensor_obj_t sensor_ps;
memset(&sensor_ps, 0, sizeof(sensor_ps));
if (!g_init_bitwise) {
ret = drv_als_ps_liteon_ltr559_validate_id(<r559_ctx, LTR559_PART_ID_VAL, LTR559_MANUFAC_ID_VAL);
if (unlikely(ret)) {
return -1;
}
}
if (!(g_init_bitwise & (1 << LTR559_FLAG_INIT_PS))) {
/* fill the sensor_ps obj parameters here */
sensor_ps.tag = TAG_DEV_PS;
sensor_ps.path = dev_ps_path;
sensor_ps.io_port = I2C_PORT;
sensor_ps.mode = DEV_POLLING;
sensor_ps.power = DEV_POWER_OFF;
sensor_ps.open = drv_ps_liteon_ltr559_open;
sensor_ps.close = drv_ps_liteon_ltr559_close;
sensor_ps.read = drv_ps_liteon_ltr559_read;
sensor_ps.write = drv_ps_liteon_ltr559_write;
sensor_ps.ioctl = drv_ps_liteon_ltr559_ioctl;
sensor_ps.irq_handle = drv_ps_liteon_ltr559_irq_handle;
ret = sensor_create_obj(&sensor_ps);
if (unlikely(ret)) {
return -1;
}
ret = drv_ps_liteon_ltr559_set_default_config(<r559_ctx);
if (unlikely(ret)) {
return -1;
}
g_init_bitwise |= 1 << LTR559_FLAG_INIT_PS;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_als_liteon_ltr559_init);
SENSOR_DRV_ADD(drv_ps_liteon_ltr559_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_als_ps_liteon_ltr559.c
|
C
|
apache-2.0
| 29,759
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
/************ define parameter for register ************/
#define REG_SP_INT_RESET (0xE1)
#define REG_SP_IMM_STOP (0xE2)
#define REG_SP_IMM_START (0xE3)
#define REG_SP_SW_RESET (0xE4)
/* REG_ALSCONTROL(0x00) */
#define MEAS_SERIAL (0 << 3)
#define MEAS_UNIT (1 << 3)
#define TYPE_BOTH (0 << 2)
#define TYPE_ONLY (1 << 2)
#define CTL_STANDBY (0)
#define CTL_STANDALONE (3)
#define CONTROL_MAX (16)
/* REG_INTERRUPT(0x02) */
#define INT_NONSTOP (0 << 6)
#define INT_STOP (1 << 6)
#define INT_DISABLE (0 << 4)
#define INT_ENABLE (1 << 4)
#define INT_PER_MAX (16)
#define INTRRUPT_MASK (0x5F)
/* REG_ALSGAIN(0x07) */
#define GAIN_X001 (0)
#define GAIN_X002 (1)
#define GAIN_X064 (2)
#define GAIN_X128 (3)
#define GAIN_MAX (4)
#define ALS_SET_CONTROL (MEAS_SERIAL)
#define ALS_SET_TIMING (218)
#define ALS_SET_INTR_PERSIST (1)
#define ALS_SET_INTR (INT_NONSTOP | INT_DISABLE | ALS_SET_INTR_PERSIST)
#define ALS_SET_ALSTH_UP_L (0xFF)
#define ALS_SET_ALSTH_UP_H (0xFF)
#define ALS_SET_ALSTH_LOW_L (0x00)
#define ALS_SET_ALSTH_LOW_H (0x00)
#define ALS_SET_GAIN (0x00)
/************ definition to dependent on sensor IC ************/
#define BH1730_I2C_NAME "bh1730_i2c"
#define BH1730_I2C_ADDRESS1 (0x29) // 7 bits slave address 010 1001
#define BH1730_ADDR_TRANS(n) ((n) << 1)
#define BH1730_I2C_ADDRESS BH1730_ADDR_TRANS(BH1730_I2C_ADDRESS1)
#define BH1730_PART_ID_NUMBER \
0x07 // PART_ID: part number 3:0 revision id
// 7:4
/************ define register for IC ************/
/* BH1730 REGSTER */
#define REG_ALSCONTROL (0x80)
#define REG_ALSTIMING (0x81)
#define REG_ALSINTERRUPT (0x82)
#define REG_ALSTHLOW (0x83)
#define REG_ALSTHLLOW (0x83)
#define REG_ALSTHLHIGH (0x84)
#define REG_ALSTHHIGH (0x85)
#define REG_ALSTHHLOW (0x85)
#define REG_ALSTHHHIGH (0x86)
#define REG_ALSGAIN (0x87)
#define REG_ID (0x92)
#define REG_ALSDATA0 (0x94)
#define REG_ALSDATA0_LOW (0x94)
#define REG_ALSDATA0_HIGH (0x95)
#define REG_ALSDATA1 (0x96)
#define REG_ALSDATA1_LOW (0x96)
#define REG_ALSDATA1_HIGH (0x97)
/************ command definition of ioctl ************/
#define IOCTL_APP_SET_TIMER (10)
#define IOCTL_APP_SET_PWRSET_ALS (11)
#define IOCTL_APP_SET_ALS_TH_UP (15)
#define IOCTL_APP_SET_ALS_TH_LOW (16)
#define IOCTL_APP_SET_INT_OUTRST (20)
#define IOCTL_APP_SET_SW_RST (21)
#define IOCTL_APP_SET_TIMING (22)
#define IOCTL_APP_SET_GAIN (23)
#define IOCTL_APP_SET_GENERAL (253)
#define IOCTL_APP_READ_GENERAL (254)
#define IOCTL_APP_READ_DRIVER_VER (255)
#define COEFFICIENT (4)
const unsigned long data0_coefficient[COEFFICIENT] = { 1290, 795, 510, 276 };
const unsigned long data1_coefficient[COEFFICIENT] = { 2733, 859, 345, 130 };
const unsigned long judge_coefficient[COEFFICIENT] = { 26, 55, 109, 213 };
/* value to calcrate */
#define DECIMAL_BIT (14)
i2c_dev_t bh1730_ctx = {
.config.dev_addr = BH1730_I2C_ADDRESS,
};
typedef struct
{
uint8_t als_data0_low; /* data value of ALS data0 low from sensor */
uint8_t als_data0_high; /* data value of ALS data0 high from sensor */
uint8_t als_data1_low; /* data value of ALS data1 low from sensor */
uint8_t als_data1_high; /* data value of ALS data1 high from sensor */
} READ_DATA_BUF;
/************************************************************
* logic function *
***********************************************************/
/******************************************************************************
* NAME : measure_calc_als
* FUNCTION : calculate illuminance data for BH1730
* REMARKS : final_data format
* :+-----------+-------------------------+------------------------+
* :| sign 1bit | positive values : 17bit | decimal values : 14bit |
* :+-----------+-------------------------+------------------------+
*****************************************************************************/
static int measure_calc_als(uint32_t *final_data)
{
#define ITIME_CYCLE_BASE (256)
#define ITIME_CYCLE_UNIT (27)
#define JUDGE_FIXED_COEF (100)
#define MAX_OUTRANGE (100000)
#define DEVICE_OUTMAX (0xFFFF)
READ_DATA_BUF data;
int ret;
uint16_t als_data0;
uint16_t als_data1;
uint8_t gain, read_time;
uint32_t calc_judge, calc_data, gain_time, timing;
uint32_t positive, decimal;
const uint8_t gain_table[GAIN_MAX] = { 1, 2, 64, 128 };
(void)decimal;
ret = sensor_i2c_read(&bh1730_ctx, REG_ALSGAIN, &gain, sizeof(gain),
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(&bh1730_ctx, REG_ALSTIMING, &read_time,
sizeof(read_time), I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(&bh1730_ctx, REG_ALSDATA0, (uint8_t*)&data, sizeof(data),
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
als_data0 = data.als_data0_low | (data.als_data0_high << 8);
als_data1 = data.als_data1_low | (data.als_data1_high << 8);
/* calculate data */
if (als_data0 == DEVICE_OUTMAX) {
positive = MAX_OUTRANGE;
decimal = 0;
} else {
timing = (ITIME_CYCLE_BASE - read_time) * ITIME_CYCLE_UNIT;
gain_time = timing * gain_table[gain & GAIN_X128];
calc_judge = als_data1 * JUDGE_FIXED_COEF;
if (calc_judge < (als_data0 * judge_coefficient[0])) {
calc_data = (data0_coefficient[0] * als_data0) -
(data1_coefficient[0] * als_data1);
} else if (calc_judge < (als_data0 * judge_coefficient[1])) {
calc_data = (data0_coefficient[1] * als_data0) -
(data1_coefficient[1] * als_data1);
} else if (calc_judge < (als_data0 * judge_coefficient[2])) {
calc_data = (data0_coefficient[2] * als_data0) -
(data1_coefficient[2] * als_data1);
} else if (calc_judge < (als_data0 * judge_coefficient[3])) {
calc_data = (data0_coefficient[3] * als_data0) -
(data1_coefficient[3] * als_data1);
} else {
calc_data = 0;
}
/* calculate a positive number */
positive = calc_data / gain_time;
decimal = 0;
if (positive < MAX_OUTRANGE) {
/* calculate over plus and shift 16bit */
calc_data = calc_data - (positive * gain_time);
if (calc_data != 0) {
calc_data = calc_data << DECIMAL_BIT;
/* calculate a decimal number */
decimal = calc_data / gain_time;
}
} else {
positive = MAX_OUTRANGE;
}
}
//*final_data = (uint32_t)(positive << DECIMAL_BIT) + decimal;
*final_data = positive;
return (0);
#undef ITIME_CYCLE_BASE
#undef ITIME_CYCLE_UNIT
#undef JUDGE_FIXED_COEF
#undef MAX_OUTRANGE
}
/******************************************************************************
* NAME : als_driver_read_power_state
* FUNCTION : read the value of ALS status in BH1730
* REMARKS :
*****************************************************************************/
static int als_driver_read_control_state(uint8_t *con_st)
{
uint8_t result;
int ret;
/* read register to BH1730 via i2c */
ret = sensor_i2c_read(&bh1730_ctx, REG_ALSCONTROL, &result, sizeof(result),
I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
*con_st = result;
return (ret);
}
static int drv_als_rohm_bh1730_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_con;
ret = als_driver_read_control_state(&dev_con);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_OFF:
dev_con = dev_con | CTL_STANDBY;
break;
case DEV_POWER_ON:
dev_con = dev_con | CTL_STANDALONE;
break;
default:
return -1;
}
ret = sensor_i2c_write(drv, REG_ALSCONTROL, &dev_con, sizeof(dev_con),
I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
return 0;
}
static int drv_als_rohm_bh1730_open(void)
{
int ret = 0;
ret = drv_als_rohm_bh1730_set_power_mode(&bh1730_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_als_rohm_bh1730_close(void)
{
int ret = 0;
ret = drv_als_rohm_bh1730_set_power_mode(&bh1730_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
return 0;
}
static int drv_als_rohm_bh1730_read(void *buf, size_t len)
{
als_data_t *pdata = (als_data_t *)buf;
if (buf == NULL) {
return -1;
}
measure_calc_als(&(pdata->lux));
pdata->timestamp = aos_now_ms();
return sizeof(humidity_data_t);
}
static int drv_als_rohm_bh1730_write(const void *buf, size_t len)
{
return 0;
}
static int drv_als_rohm_bh1730_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
ret = drv_als_rohm_bh1730_set_power_mode(&bh1730_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BH1730";
info->unit = lux;
} break;
default:
break;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static void drv_als_rohm_bh1730_handle(void)
{
/* no handle so far */
}
static int drv_als_rohm_bh1730_validate_id(i2c_dev_t *drv, uint8_t id_val)
{
int ret = 0;
uint8_t part_id_value = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, REG_ID, &part_id_value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if ((part_id_value >> 4) != id_val) {
return -1;
}
return 0;
}
int drv_als_rohm_bh1730_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
ret = drv_als_rohm_bh1730_validate_id(&bh1730_ctx, BH1730_PART_ID_NUMBER);
struct init_func_write_data
{
uint8_t control;
uint8_t timing;
uint8_t intr;
uint8_t alsth_ll;
uint8_t alsth_lh;
uint8_t alsth_hl;
uint8_t alsth_hh;
uint8_t als_gain;
} write_data;
write_data.control = ALS_SET_CONTROL;
write_data.timing = ALS_SET_TIMING;
write_data.intr = ALS_SET_INTR;
write_data.alsth_hl = ALS_SET_ALSTH_UP_L;
write_data.alsth_hh = ALS_SET_ALSTH_UP_H;
write_data.alsth_ll = ALS_SET_ALSTH_LOW_L;
write_data.alsth_lh = ALS_SET_ALSTH_LOW_H;
write_data.als_gain = ALS_SET_GAIN;
ret = sensor_i2c_write(&bh1730_ctx, REG_ALSCONTROL, (uint8_t *)&write_data,
sizeof(write_data), I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_ALS;
sensor.path = dev_als_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_als_rohm_bh1730_open;
sensor.close = drv_als_rohm_bh1730_close;
sensor.read = drv_als_rohm_bh1730_read;
sensor.write = drv_als_rohm_bh1730_write;
sensor.ioctl = drv_als_rohm_bh1730_ioctl;
sensor.irq_handle = drv_als_rohm_bh1730_handle;
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_als_rohm_bh1730_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_als_rohm_bh1730.c
|
C
|
apache-2.0
| 12,262
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "ulog/ulog.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define BMP280_TEMPERATURE_CALIB_DIG_T1_LSB_REG (0x88)
#define BMP280_TEMPERATURE_CALIB_DIG_T1_MSB_REG (0x89)
#define BMP280_TEMPERATURE_CALIB_DIG_T2_LSB_REG (0x8A)
#define BMP280_TEMPERATURE_CALIB_DIG_T2_MSB_REG (0x8B)
#define BMP280_TEMPERATURE_CALIB_DIG_T3_LSB_REG (0x8C)
#define BMP280_TEMPERATURE_CALIB_DIG_T3_MSB_REG (0x8D)
#define BMP280_PRESSURE_CALIB_DIG_P1_LSB_REG (0x8E)
#define BMP280_PRESSURE_CALIB_DIG_P1_MSB_REG (0x8F)
#define BMP280_PRESSURE_CALIB_DIG_P2_LSB_REG (0x90)
#define BMP280_PRESSURE_CALIB_DIG_P2_MSB_REG (0x91)
#define BMP280_PRESSURE_CALIB_DIG_P3_LSB_REG (0x92)
#define BMP280_PRESSURE_CALIB_DIG_P3_MSB_REG (0x93)
#define BMP280_PRESSURE_CALIB_DIG_P4_LSB_REG (0x94)
#define BMP280_PRESSURE_CALIB_DIG_P4_MSB_REG (0x95)
#define BMP280_PRESSURE_CALIB_DIG_P5_LSB_REG (0x96)
#define BMP280_PRESSURE_CALIB_DIG_P5_MSB_REG (0x97)
#define BMP280_PRESSURE_CALIB_DIG_P6_LSB_REG (0x98)
#define BMP280_PRESSURE_CALIB_DIG_P6_MSB_REG (0x99)
#define BMP280_PRESSURE_CALIB_DIG_P7_LSB_REG (0x9A)
#define BMP280_PRESSURE_CALIB_DIG_P7_MSB_REG (0x9B)
#define BMP280_PRESSURE_CALIB_DIG_P8_LSB_REG (0x9C)
#define BMP280_PRESSURE_CALIB_DIG_P8_MSB_REG (0x9D)
#define BMP280_PRESSURE_CALIB_DIG_P9_LSB_REG (0x9E)
#define BMP280_PRESSURE_CALIB_DIG_P9_MSB_REG (0x9F)
#define BMP280_CHIP_ID_REG (0xD0)
#define BMP280_RST_REG (0xE0)
#define BMP280_STAT_REG (0xF3)
#define BMP280_CTRL_MEAS_REG (0xF4)
#define BMP280_CONFIG_REG (0xF5)
#define BMP280_PRESSURE_MSB_REG (0xF7)
#define BMP280_PRESSURE_LSB_REG (0xF8)
#define BMP280_PRESSURE_XLSB_REG (0xF9)
#define BMP280_TEMPERATURE_MSB_REG (0xFA)
#define BMP280_TEMPERATURE_LSB_REG (0xFB)
#define BMP280_TEMPERATURE_XLSB_REG (0xFC)
#define BMP280_SHIFT_BY_01_BIT (1)
#define BMP280_SHIFT_BY_02_BITS (2)
#define BMP280_SHIFT_BY_03_BITS (3)
#define BMP280_SHIFT_BY_04_BITS (4)
#define BMP280_SHIFT_BY_05_BITS (5)
#define BMP280_SHIFT_BY_08_BITS (8)
#define BMP280_SHIFT_BY_11_BITS (11)
#define BMP280_SHIFT_BY_12_BITS (12)
#define BMP280_SHIFT_BY_13_BITS (13)
#define BMP280_SHIFT_BY_14_BITS (14)
#define BMP280_SHIFT_BY_15_BITS (15)
#define BMP280_SHIFT_BY_16_BITS (16)
#define BMP280_SHIFT_BY_17_BITS (17)
#define BMP280_SHIFT_BY_18_BITS (18)
#define BMP280_SHIFT_BY_19_BITS (19)
#define BMP280_SHIFT_BY_25_BITS (25)
#define BMP280_SHIFT_BY_31_BITS (31)
#define BMP280_SHIFT_BY_33_BITS (33)
#define BMP280_SHIFT_BY_35_BITS (35)
#define BMP280_SHIFT_BY_47_BITS (47)
#define BMP280_PRESSURE_TEMPERATURE_CALIB_DATA_LENGTH (24)
#define BMP280_GEN_READ_WRITE_DATA_LENGTH (1)
#define BMP280_REGISTER_READ_DELAY (1)
#define BMP280_TEMPERATURE_DATA_LENGTH (3)
#define BMP280_PRESSURE_DATA_LENGTH (3)
#define BMP280_ALL_DATA_FRAME_LENGTH (6)
#define BMP280_INIT_VALUE (0)
#define BMP280_CHIP_ID_READ_COUNT (5)
#define BMP280_CHIP_ID_READ_SUCCESS (0)
#define BMP280_CHIP_ID_READ_FAIL ((int8_t)-1)
#define BMP280_INVALID_DATA (0)
#define BMP280_TEMPERATURE_DATA_SIZE (3)
#define BMP280_PRESSURE_DATA_SIZE (3)
#define BMP280_DATA_FRAME_SIZE (6)
#define BMP280_CALIB_DATA_SIZE (24)
#define BMP280_TEMPERATURE_MSB_DATA (0)
#define BMP280_TEMPERATURE_LSB_DATA (1)
#define BMP280_TEMPERATURE_XLSB_DATA (2)
#define BMP280_I2C_ADDRESS1 (0x76)
#define BMP280_I2C_ADDRESS2 (0x77)
#define BMP280_SLEEP_MODE (0x00)
#define BMP280_FORCED_MODE (0x01)
#define BMP280_NORMAL_MODE (0x03)
#define BMP280_SOFT_RESET_CODE (0xB6)
#define BMP280_STANDBY_TIME_1_MS (0x00)
#define BMP280_STANDBY_TIME_63_MS (0x01)
#define BMP280_STANDBY_TIME_125_MS (0x02)
#define BMP280_STANDBY_TIME_250_MS (0x03)
#define BMP280_STANDBY_TIME_500_MS (0x04)
#define BMP280_STANDBY_TIME_1000_MS (0x05)
#define BMP280_STANDBY_TIME_2000_MS (0x06)
#define BMP280_STANDBY_TIME_4000_MS (0x07)
#define BMP280_OVERSAMP_SKIPPED (0x00)
#define BMP280_OVERSAMP_1X (0x01)
#define BMP280_OVERSAMP_2X (0x02)
#define BMP280_OVERSAMP_4X (0x03)
#define BMP280_OVERSAMP_8X (0x04)
#define BMP280_OVERSAMP_16X (0x05)
#define BMP280_FILTER_COEFF_OFF (0x00)
#define BMP280_FILTER_COEFF_2 (0x01)
#define BMP280_FILTER_COEFF_4 (0x02)
#define BMP280_FILTER_COEFF_8 (0x03)
#define BMP280_FILTER_COEFF_16 (0x04)
#define BMP280_ULTRA_LOW_POWER_MODE (0x00)
#define BMP280_LOW_POWER_MODE (0x01)
#define BMP280_STANDARD_RESOLUTION_MODE (0x02)
#define BMP280_HIGH_RESOLUTION_MODE (0x03)
#define BMP280_ULTRA_HIGH_RESOLUTION_MODE (0x04)
#define BMP280_ULTRALOWPOWER_OVERSAMP_PRESSURE BMP280_OVERSAMP_1X
#define BMP280_ULTRALOWPOWER_OVERSAMP_TEMPERATURE BMP280_OVERSAMP_1X
#define BMP280_LOWPOWER_OVERSAMP_PRESSURE BMP280_OVERSAMP_2X
#define BMP280_LOWPOWER_OVERSAMP_TEMPERATURE BMP280_OVERSAMP_1X
#define BMP280_STANDARDRESOLUTION_OVERSAMP_PRESSURE BMP280_OVERSAMP_4X
#define BMP280_STANDARDRESOLUTION_OVERSAMP_TEMPERATURE BMP280_OVERSAMP_1X
#define BMP280_HIGHRESOLUTION_OVERSAMP_PRESSURE BMP280_OVERSAMP_8X
#define BMP280_HIGHRESOLUTION_OVERSAMP_TEMPERATURE BMP280_OVERSAMP_1X
#define BMP280_ULTRAHIGHRESOLUTION_OVERSAMP_PRESSURE BMP280_OVERSAMP_16X
#define BMP280_ULTRAHIGHRESOLUTION_OVERSAMP_TEMPERATURE BMP280_OVERSAMP_2X
#define BMP280_STATUS_REG_MEASURING__POS (3)
#define BMP280_STATUS_REG_MEASURING__MSK (0x08)
#define BMP280_STATUS_REG_MEASURING__LEN (1)
#define BMP280_STATUS_REG_MEASURING__REG (BMP280_STAT_REG)
#define BMP280_STATUS_REG_IM_UPDATE__POS (0)
#define BMP280_STATUS_REG_IM_UPDATE__MSK (0x01)
#define BMP280_STATUS_REG_IM_UPDATE__LEN (1)
#define BMP280_STATUS_REG_IM_UPDATE__REG (BMP280_STAT_REG)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__POS (5)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__MSK (0xE0)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__LEN (3)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__REG (BMP280_CTRL_MEAS_REG)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__POS (2)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__MSK (0x1C)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__LEN (3)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__REG (BMP280_CTRL_MEAS_REG)
#define BMP280_CTRL_MEAS_REG_POWER_MODE__POS (0)
#define BMP280_CTRL_MEAS_REG_POWER_MODE__MSK (0x03)
#define BMP280_CTRL_MEAS_REG_POWER_MODE__LEN (2)
#define BMP280_CTRL_MEAS_REG_POWER_MODE__REG (BMP280_CTRL_MEAS_REG)
#define BMP280_CONFIG_REG_STANDBY_DURN__POS (5)
#define BMP280_CONFIG_REG_STANDBY_DURN__MSK (0xE0)
#define BMP280_CONFIG_REG_STANDBY_DURN__LEN (3)
#define BMP280_CONFIG_REG_STANDBY_DURN__REG (BMP280_CONFIG_REG)
#define BMP280_CONFIG_REG_FILTER__POS (2)
#define BMP280_CONFIG_REG_FILTER__MSK (0x1C)
#define BMP280_CONFIG_REG_FILTER__LEN (3)
#define BMP280_CONFIG_REG_FILTER__REG (BMP280_CONFIG_REG)
#define BMP280_CONFIG_REG_SPI3_ENABLE__POS (0)
#define BMP280_CONFIG_REG_SPI3_ENABLE__MSK (0x01)
#define BMP280_CONFIG_REG_SPI3_ENABLE__LEN (1)
#define BMP280_CONFIG_REG_SPI3_ENABLE__REG (BMP280_CONFIG_REG)
#define BMP280_PRESSURE_XLSB_REG_DATA__POS (4)
#define BMP280_PRESSURE_XLSB_REG_DATA__MSK (0xF0)
#define BMP280_PRESSURE_XLSB_REG_DATA__LEN (4)
#define BMP280_PRESSURE_XLSB_REG_DATA__REG (BMP280_PRESSURE_XLSB_REG)
#define BMP280_TEMPERATURE_XLSB_REG_DATA__POS (4)
#define BMP280_TEMPERATURE_XLSB_REG_DATA__MSK (0xF0)
#define BMP280_TEMPERATURE_XLSB_REG_DATA__LEN (4)
#define BMP280_TEMPERATURE_XLSB_REG_DATA__REG (BMP280_TEMPERATURE_XLSB_REG)
#define BMP280_TEMPERATURE_MSB_DATA (0)
#define BMP280_TEMPERATURE_LSB_DATA (1)
#define BMP280_TEMPERATURE_XLSB_DATA (2)
#define BMP280_PRESSURE_MSB_DATA (0)
#define BMP280_PRESSURE_LSB_DATA (1)
#define BMP280_PRESSURE_XLSB_DATA (2)
#define BMP280_DATA_FRAME_PRESSURE_MSB_BYTE (0)
#define BMP280_DATA_FRAME_PRESSURE_LSB_BYTE (1)
#define BMP280_DATA_FRAME_PRESSURE_XLSB_BYTE (2)
#define BMP280_DATA_FRAME_TEMPERATURE_MSB_BYTE (3)
#define BMP280_DATA_FRAME_TEMPERATURE_LSB_BYTE (4)
#define BMP280_DATA_FRAME_TEMPERATURE_XLSB_BYTE (5)
#define BMP280_TEMPERATURE_CALIB_DIG_T1_LSB (0)
#define BMP280_TEMPERATURE_CALIB_DIG_T1_MSB (1)
#define BMP280_TEMPERATURE_CALIB_DIG_T2_LSB (2)
#define BMP280_TEMPERATURE_CALIB_DIG_T2_MSB (3)
#define BMP280_TEMPERATURE_CALIB_DIG_T3_LSB (4)
#define BMP280_TEMPERATURE_CALIB_DIG_T3_MSB (5)
#define BMP280_PRESSURE_CALIB_DIG_P1_LSB (6)
#define BMP280_PRESSURE_CALIB_DIG_P1_MSB (7)
#define BMP280_PRESSURE_CALIB_DIG_P2_LSB (8)
#define BMP280_PRESSURE_CALIB_DIG_P2_MSB (9)
#define BMP280_PRESSURE_CALIB_DIG_P3_LSB (10)
#define BMP280_PRESSURE_CALIB_DIG_P3_MSB (11)
#define BMP280_PRESSURE_CALIB_DIG_P4_LSB (12)
#define BMP280_PRESSURE_CALIB_DIG_P4_MSB (13)
#define BMP280_PRESSURE_CALIB_DIG_P5_LSB (14)
#define BMP280_PRESSURE_CALIB_DIG_P5_MSB (15)
#define BMP280_PRESSURE_CALIB_DIG_P6_LSB (16)
#define BMP280_PRESSURE_CALIB_DIG_P6_MSB (17)
#define BMP280_PRESSURE_CALIB_DIG_P7_LSB (18)
#define BMP280_PRESSURE_CALIB_DIG_P7_MSB (19)
#define BMP280_PRESSURE_CALIB_DIG_P8_LSB (20)
#define BMP280_PRESSURE_CALIB_DIG_P8_MSB (21)
#define BMP280_PRESSURE_CALIB_DIG_P9_LSB (22)
#define BMP280_PRESSURE_CALIB_DIG_P9_MSB (23)
#define BMP280_SOFT_RESRT_VALUE (0XB6)
#define BMP280_I2C_SLAVE_ADDR_LOW (0X76)
#define BMP280_I2C_SLAVE_ADDR_HIGH (0X77)
#define BMP280_DEFAULT_ODR_1HZ (1)
#define BMP280_BIT(x) ((uint8_t)(x))
#define BMP280_CHIP_ID_VAL BMP280_BIT(0X58)
#define BMP280_I2C_ADDR_TRANS(n) ((n) << 1)
#define BMP280_I2C_ADDR BMP280_I2C_ADDR_TRANS(BMP280_I2C_SLAVE_ADDR_HIGH)
#define BMP280_GET_BITSLICE(regvar, bitname) \
((regvar & bitname##__MSK) >> bitname##__POS)
#define BMP280_SET_BITSLICE(regvar, bitname, val) \
((regvar & ~bitname##__MSK) | ((val << bitname##__POS) & bitname##__MSK))
typedef struct bmp280_calib_param_t
{
uint16_t dig_T1;
int16_t dig_T2;
int16_t dig_T3;
uint16_t dig_P1;
int16_t dig_P2;
int16_t dig_P3;
int16_t dig_P4;
int16_t dig_P5;
int16_t dig_P6;
int16_t dig_P7;
int16_t dig_P8;
int16_t dig_P9;
int t_fine;
} bmp280_calib_param_t;
typedef struct bmp280_device_cfg_t
{
uint8_t odr;
uint8_t mode_filter;
uint8_t mode_baro;
uint8_t mode_temp;
uint8_t mode_power;
uint8_t oversamp_temp;
uint8_t oversamp_baro;
} bmp280_device_cfg_t;
static bmp280_calib_param_t g_bmp280_calib_table;
i2c_dev_t bmp280_ctx = {
.port = 2,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = BMP280_I2C_ADDR,
};
static int drv_baro_bosch_bmp280_get_calib_param(i2c_dev_t *drv)
{
int ret = 0;
uint8_t a_data_u8[BMP280_CALIB_DATA_SIZE] = { 0 };
ret = sensor_i2c_read(
drv, BMP280_TEMPERATURE_CALIB_DIG_T1_LSB_REG, a_data_u8,
BMP280_PRESSURE_TEMPERATURE_CALIB_DATA_LENGTH, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
g_bmp280_calib_table.dig_T1 = (uint16_t)(
(((uint16_t)((uint8_t)a_data_u8[BMP280_TEMPERATURE_CALIB_DIG_T1_MSB]))
<< BMP280_SHIFT_BY_08_BITS) |
a_data_u8[BMP280_TEMPERATURE_CALIB_DIG_T1_LSB]);
g_bmp280_calib_table.dig_T2 = (int16_t)(
(((int16_t)((int8_t)a_data_u8[BMP280_TEMPERATURE_CALIB_DIG_T2_MSB]))
<< BMP280_SHIFT_BY_08_BITS) |
a_data_u8[BMP280_TEMPERATURE_CALIB_DIG_T2_LSB]);
g_bmp280_calib_table.dig_T3 = (int16_t)(
(((int16_t)((int8_t)a_data_u8[BMP280_TEMPERATURE_CALIB_DIG_T3_MSB]))
<< BMP280_SHIFT_BY_08_BITS) |
a_data_u8[BMP280_TEMPERATURE_CALIB_DIG_T3_LSB]);
g_bmp280_calib_table.dig_P1 = (uint16_t)(
(((uint16_t)((uint8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P1_MSB]))
<< BMP280_SHIFT_BY_08_BITS) |
a_data_u8[BMP280_PRESSURE_CALIB_DIG_P1_LSB]);
g_bmp280_calib_table.dig_P2 = (int16_t)(
(((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P2_MSB]))
<< BMP280_SHIFT_BY_08_BITS) |
a_data_u8[BMP280_PRESSURE_CALIB_DIG_P2_LSB]);
g_bmp280_calib_table.dig_P3 = (int16_t)(
(((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P3_MSB]))
<< BMP280_SHIFT_BY_08_BITS) |
a_data_u8[BMP280_PRESSURE_CALIB_DIG_P3_LSB]);
g_bmp280_calib_table.dig_P4 = (int16_t)(
(((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P4_MSB]))
<< BMP280_SHIFT_BY_08_BITS) |
a_data_u8[BMP280_PRESSURE_CALIB_DIG_P4_LSB]);
g_bmp280_calib_table.dig_P5 = (int16_t)(
(((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P5_MSB]))
<< BMP280_SHIFT_BY_08_BITS) |
a_data_u8[BMP280_PRESSURE_CALIB_DIG_P5_LSB]);
g_bmp280_calib_table.dig_P6 = (int16_t)(
(((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P6_MSB]))
<< BMP280_SHIFT_BY_08_BITS) |
a_data_u8[BMP280_PRESSURE_CALIB_DIG_P6_LSB]);
g_bmp280_calib_table.dig_P7 = (int16_t)(
(((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P7_MSB]))
<< BMP280_SHIFT_BY_08_BITS) |
a_data_u8[BMP280_PRESSURE_CALIB_DIG_P7_LSB]);
g_bmp280_calib_table.dig_P8 = (int16_t)(
(((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P8_MSB]))
<< BMP280_SHIFT_BY_08_BITS) |
a_data_u8[BMP280_PRESSURE_CALIB_DIG_P8_LSB]);
g_bmp280_calib_table.dig_P9 = (int16_t)(
(((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P9_MSB]))
<< BMP280_SHIFT_BY_08_BITS) |
a_data_u8[BMP280_PRESSURE_CALIB_DIG_P9_LSB]);
return 0;
}
static int drv_baro_bosch_bmp280_validate_id(i2c_dev_t *drv, uint8_t id_value)
{
int ret = 0;
uint8_t value = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, BMP280_CHIP_ID_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (id_value != value) {
return -1;
}
return 0;
}
static int drv_baro_bosch_bmp280_set_work_mode(i2c_dev_t *drv, uint8_t mode)
{
uint8_t ret = 0;
uint8_t value = 0;
uint8_t temp = 0;
uint8_t baro = 0;
switch (mode) {
case BMP280_ULTRA_LOW_POWER_MODE:
temp = BMP280_OVERSAMP_1X;
baro = BMP280_OVERSAMP_1X;
break;
case BMP280_LOW_POWER_MODE:
temp = BMP280_OVERSAMP_2X;
baro = BMP280_OVERSAMP_2X;
break;
case BMP280_STANDARD_RESOLUTION_MODE:
temp = BMP280_OVERSAMP_4X;
baro = BMP280_OVERSAMP_4X;
break;
case BMP280_HIGH_RESOLUTION_MODE:
temp = BMP280_OVERSAMP_8X;
baro = BMP280_OVERSAMP_8X;
break;
case BMP280_ULTRA_HIGH_RESOLUTION_MODE:
temp = BMP280_OVERSAMP_16X;
baro = BMP280_OVERSAMP_16X;
break;
default:
return -1;
}
ret = sensor_i2c_read(drv, BMP280_CTRL_MEAS_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value =
BMP280_SET_BITSLICE(value, BMP280_CTRL_MEAS_REG_OVERSAMP_PRESSURE, baro);
value = BMP280_SET_BITSLICE(
value, BMP280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE, temp);
ret = sensor_i2c_write(drv, BMP280_CTRL_MEAS_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return ret;
}
static int drv_baro_bosch_bmp280_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t dev_mode;
switch (mode) {
case DEV_POWER_OFF:
case DEV_SLEEP: {
dev_mode = (uint8_t)BMP280_SLEEP_MODE;
break;
}
case DEV_POWER_ON: {
dev_mode = (uint8_t)BMP280_NORMAL_MODE;
break;
}
default:
return -1;
}
ret = sensor_i2c_read(drv, BMP280_CTRL_MEAS_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value =
BMP280_SET_BITSLICE(value, BMP280_CTRL_MEAS_REG_POWER_MODE, dev_mode);
ret = sensor_i2c_write(drv, BMP280_CTRL_MEAS_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static uint8_t drv_baro_bosch_bmp280_hz2odr(int hz)
{
if (hz > 80) {
return BMP280_STANDBY_TIME_1_MS;
} else if (hz > 13) {
return BMP280_STANDBY_TIME_63_MS;
} else if (hz > 7) {
return BMP280_STANDBY_TIME_125_MS;
} else if (hz > 3) {
return BMP280_STANDBY_TIME_250_MS;
} else {
return BMP280_STANDBY_TIME_500_MS;
}
}
static int drv_baro_bosch_bmp280_set_odr(i2c_dev_t *drv, uint8_t odr)
{
int ret = 0;
uint8_t v_data_u8 = 0;
ret = sensor_i2c_read(drv, BMP280_CONFIG_REG_STANDBY_DURN__REG, &v_data_u8,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
v_data_u8 =
BMP280_SET_BITSLICE(v_data_u8, BMP280_CONFIG_REG_STANDBY_DURN, odr);
ret = sensor_i2c_write(drv, BMP280_CONFIG_REG_STANDBY_DURN__REG, &v_data_u8,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return ret;
}
static int drv_baro_bosch_bmp280_soft_reset(i2c_dev_t *drv)
{
int ret = 0;
uint8_t v_data_u8 = BMP280_SOFT_RESRT_VALUE;
ret = sensor_i2c_write(drv, BMP280_RST_REG, &v_data_u8, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return ret;
}
static int drv_baro_bosch_bmp280_set_default_config(i2c_dev_t *drv)
{
int ret = 0;
ret = drv_baro_bosch_bmp280_set_power_mode(drv, DEV_SLEEP);
if (unlikely(ret)) {
return ret;
}
ret = drv_baro_bosch_bmp280_set_odr(drv, BMP280_DEFAULT_ODR_1HZ);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_baro_bosch_bmp280_read_uncomp_baro(i2c_dev_t * drv,
barometer_data_t *pdata)
{
int ret = 0;
uint8_t data[BMP280_PRESSURE_DATA_SIZE] = { 0 };
ret = sensor_i2c_read(drv, BMP280_PRESSURE_MSB_REG, data,
BMP280_PRESSURE_DATA_SIZE, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
pdata->p = (int)((((uint32_t)(data[BMP280_PRESSURE_MSB_DATA]))
<< BMP280_SHIFT_BY_12_BITS) |
(((uint32_t)(data[BMP280_PRESSURE_LSB_DATA]))
<< BMP280_SHIFT_BY_04_BITS) |
((uint32_t)data[BMP280_PRESSURE_XLSB_DATA] >>
BMP280_SHIFT_BY_04_BITS));
return ret;
}
static int drv_baro_bosch_bmp280_compensate_baro(barometer_data_t *pdata)
{
int v_x1_u32r = 0;
int v_x2_u32r = 0;
uint32_t comp_baro = 0;
v_x1_u32r = (((int)g_bmp280_calib_table.t_fine) >> BMP280_SHIFT_BY_01_BIT) -
(int)64000;
v_x2_u32r = (((v_x1_u32r >> BMP280_SHIFT_BY_02_BITS) *
(v_x1_u32r >> BMP280_SHIFT_BY_02_BITS)) >>
BMP280_SHIFT_BY_11_BITS) *
((int)g_bmp280_calib_table.dig_P6);
v_x2_u32r = v_x2_u32r + ((v_x1_u32r * ((int)g_bmp280_calib_table.dig_P5))
<< BMP280_SHIFT_BY_01_BIT);
v_x2_u32r = (v_x2_u32r >> BMP280_SHIFT_BY_02_BITS) +
(((int)g_bmp280_calib_table.dig_P4) << BMP280_SHIFT_BY_16_BITS);
v_x1_u32r = (((g_bmp280_calib_table.dig_P3 *
(((v_x1_u32r >> BMP280_SHIFT_BY_02_BITS) *
(v_x1_u32r >> BMP280_SHIFT_BY_02_BITS)) >>
BMP280_SHIFT_BY_13_BITS)) >>
BMP280_SHIFT_BY_03_BITS) +
((((int)g_bmp280_calib_table.dig_P2) * v_x1_u32r) >>
BMP280_SHIFT_BY_01_BIT)) >>
BMP280_SHIFT_BY_18_BITS;
v_x1_u32r = ((((32768 + v_x1_u32r)) * ((int)g_bmp280_calib_table.dig_P1)) >>
BMP280_SHIFT_BY_15_BITS);
comp_baro = (((uint32_t)(((int)1048576) - pdata->p) -
(v_x2_u32r >> BMP280_SHIFT_BY_12_BITS))) *
3125;
if (comp_baro < 0x80000000) {
if (v_x1_u32r != 0) {
comp_baro =
(comp_baro << BMP280_SHIFT_BY_01_BIT) / ((uint32_t)v_x1_u32r);
} else {
return -1;
}
} else if (v_x1_u32r != 0) {
comp_baro = (comp_baro / (uint32_t)v_x1_u32r) * 2;
} else {
return -1;
}
v_x1_u32r = (((int)g_bmp280_calib_table.dig_P9) *
((int)(((comp_baro >> BMP280_SHIFT_BY_03_BITS) *
(comp_baro >> BMP280_SHIFT_BY_03_BITS)) >>
BMP280_SHIFT_BY_13_BITS))) >>
BMP280_SHIFT_BY_12_BITS;
v_x2_u32r = (((int)(comp_baro >> BMP280_SHIFT_BY_02_BITS)) *
((int)g_bmp280_calib_table.dig_P8)) >>
BMP280_SHIFT_BY_13_BITS;
comp_baro = (uint32_t)(
(int)comp_baro + ((v_x1_u32r + v_x2_u32r + g_bmp280_calib_table.dig_P7) >>
BMP280_SHIFT_BY_04_BITS));
pdata->p = comp_baro;
return 0;
}
static int drv_baro_bosch_bmp280_read_baro(i2c_dev_t * drv,
barometer_data_t *pdata)
{
int ret = 0;
ret = drv_baro_bosch_bmp280_read_uncomp_baro(drv, pdata);
if (unlikely(ret)) {
return ret;
}
ret = drv_baro_bosch_bmp280_compensate_baro(pdata);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_baro_bosch_bmp280_comp_temp(temperature_data_t *pdata)
{
int v_x1_u32r = 0;
int v_x2_u32r = 0;
v_x1_u32r =
((((pdata->t >> BMP280_SHIFT_BY_03_BITS) -
((int)g_bmp280_calib_table.dig_T1 << BMP280_SHIFT_BY_01_BIT))) *
((int)g_bmp280_calib_table.dig_T2)) >>
BMP280_SHIFT_BY_11_BITS;
v_x2_u32r = (((((pdata->t >> BMP280_SHIFT_BY_04_BITS) -
((int)g_bmp280_calib_table.dig_T1)) *
((pdata->t >> BMP280_SHIFT_BY_04_BITS) -
((int)g_bmp280_calib_table.dig_T1))) >>
BMP280_SHIFT_BY_12_BITS) *
((int)g_bmp280_calib_table.dig_T3)) >>
BMP280_SHIFT_BY_14_BITS;
g_bmp280_calib_table.t_fine = v_x1_u32r + v_x2_u32r;
pdata->t =
(g_bmp280_calib_table.t_fine * 5 + 128) >> BMP280_SHIFT_BY_08_BITS;
return 0;
}
static int drv_baro_bosch_bmp280_cali_temp(i2c_dev_t *drv)
{
int ret = 0;
uint8_t data[BMP280_TEMPERATURE_DATA_SIZE] = { 0 };
temperature_data_t temp;
ret = sensor_i2c_read(drv, BMP280_TEMPERATURE_MSB_REG, data,
BMP280_TEMPERATURE_DATA_SIZE, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
temp.t = (int)((((uint32_t)(data[BMP280_TEMPERATURE_MSB_DATA]))
<< BMP280_SHIFT_BY_12_BITS) |
(((uint32_t)(data[BMP280_TEMPERATURE_LSB_DATA]))
<< BMP280_SHIFT_BY_04_BITS) |
((uint32_t)data[BMP280_TEMPERATURE_XLSB_DATA] >>
BMP280_SHIFT_BY_04_BITS));
ret = drv_baro_bosch_bmp280_comp_temp(&temp);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static void drv_baro_bosch_bmp280_irq_handle(void)
{
/* no handle so far */
}
static int drv_baro_bosch_bmp280_open(void)
{
int ret = 0;
/* set the default config for the sensor here */
ret = drv_baro_bosch_bmp280_set_work_mode(&bmp280_ctx,
BMP280_ULTRA_LOW_POWER_MODE);
if (unlikely(ret)) {
return -1;
}
ret = drv_baro_bosch_bmp280_set_power_mode(&bmp280_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_baro_bosch_bmp280_close(void)
{
int ret = 0;
ret = drv_baro_bosch_bmp280_set_power_mode(&bmp280_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_baro_bosch_bmp280_read(void *buf, size_t len)
{
int ret = 0;
size_t size = 0;
barometer_data_t *pdata = (barometer_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(barometer_data_t);
if (len < size) {
return -1;
}
ret = drv_baro_bosch_bmp280_cali_temp(&bmp280_ctx);
if (unlikely(ret)) {
return -1;
}
ret = drv_baro_bosch_bmp280_read_baro(&bmp280_ctx, pdata);
if (unlikely(ret)) {
return -1;
}
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_baro_bosch_bmp280_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_baro_bosch_bmp280_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_ODR_SET: {
uint8_t odr = drv_baro_bosch_bmp280_hz2odr(arg);
ret = drv_baro_bosch_bmp280_set_odr(&bmp280_ctx, odr);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_baro_bosch_bmp280_set_power_mode(&bmp280_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMP280";
info->range_max = 1100;
info->range_min = 300;
info->unit = pa;
} break;
default:
break;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_baro_bosch_bmp280_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_BARO;
sensor.path = dev_baro_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_baro_bosch_bmp280_open;
sensor.close = drv_baro_bosch_bmp280_close;
sensor.read = drv_baro_bosch_bmp280_read;
sensor.write = drv_baro_bosch_bmp280_write;
sensor.ioctl = drv_baro_bosch_bmp280_ioctl;
sensor.irq_handle = drv_baro_bosch_bmp280_irq_handle;
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
ret = drv_baro_bosch_bmp280_validate_id(&bmp280_ctx, BMP280_CHIP_ID_VAL);
if (unlikely(ret)) {
return -1;
}
ret = drv_baro_bosch_bmp280_soft_reset(&bmp280_ctx);
if (unlikely(ret)) {
return -1;
}
ret = drv_baro_bosch_bmp280_set_default_config(&bmp280_ctx);
if (unlikely(ret)) {
return -1;
}
ret = drv_baro_bosch_bmp280_get_calib_param(&bmp280_ctx);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_baro_bosch_bmp280_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_baro_bosch_bmp280.c
|
C
|
apache-2.0
| 27,217
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
/*********************************************************************************************
*
*Copyright (C) 2016 - 2020 Bosch Sensortec GmbH
*Redistribution and use in source and binary forms, with or without
*modification, are permitted provided that the following conditions are met:
*Redistributions of source code must retain the above copyright
*notice, this list of conditions and the following disclaimer.
*Redistributions in binary form must reproduce the above copyright
*notice, this list of conditions and the following disclaimer in the
*documentation and/or other materials provided with the distribution.
*Neither the name of the copyright holder nor the names of the
*contributors may be used to endorse or promote products derived from
*this software without specific prior written permission.
*THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
*CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
*IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
*WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
*DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
*OR CONTRIBUTORS BE LIABLE FOR ANY
*DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
*OR CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED TO,
*PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
*LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
*HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
*WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
*(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
*ANY WAY OUT OF THE USE OF THIS
*SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
*The information provided is believed to be accurate and reliable.
*The copyright holder assumes no responsibility
*for the consequences of use
*of such information nor for any infringement of patents or
*other rights of third parties which may result from its use.
*No license is granted by implication or otherwise under any patent or
*patent rights of the copyright holder.
*
*
*******************************************************************************************/
#include "aos/kernel.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define BMP380_BIT(x) ((uint8_t)(x))
#define BMP380_CHIP_ID_VAL BMP380_BIT(0X50)
#define BMP380_I2C_SLAVE_ADDR_LOW (0X76)
#define BMP380_I2C_SLAVE_ADDR_HIGH (0X77)
#define BMP380_I2C_ADDR_TRANS(n) ((n)<<1)
#define BMP380_I2C_ADDR BMP380_I2C_ADDR_TRANS(BMP380_I2C_SLAVE_ADDR_LOW)
#define BMP380_DEFAULT_ODR_1HZ (1)
#define BMP380_TEMPERATURE_DATA_SIZE (3)
#define BMP380_PRESSURE_DATA_SIZE (3)
#define BMP380_TEMPERATURE_MSB_DATA (2)
#define BMP380_TEMPERATURE_LSB_DATA (1)
#define BMP380_TEMPERATURE_XLSB_DATA (0)
#define BMP380_PRESSURE_MSB_DATA (2)
#define BMP380_PRESSURE_LSB_DATA (1)
#define BMP380_PRESSURE_XLSB_DATA (0)
/* API error codes */
#define BMP380_E_NULL_PTR INT8_C(-1)
#define BMP380_E_DEV_NOT_FOUND INT8_C(-2)
#define BMP380_E_INVALID_ODR_OSR_SETTINGS INT8_C(-3)
#define BMP380_E_CMD_EXEC_FAILED INT8_C(-4)
#define BMP380_E_CONFIGURATION_ERR INT8_C(-5)
#define BMP380_E_INVALID_LEN INT8_C(-6)
#define BMP380_E_COMM_FAIL INT8_C(-7)
#define BMP380_E_FIFO_WATERMARK_NOT_REACHED INT8_C(-8)
/* Register Address */
#define BMP380_CHIP_ID_ADDR UINT8_C(0x00)
#define BMP380_ERR_REG_ADDR UINT8_C(0x02)
#define BMP380_SENS_STATUS_REG_ADDR UINT8_C(0x03)
#define BMP380_DATA_ADDR UINT8_C(0x04)
#define BMP380_TDATA_ADDR UINT8_C(0x07)
#define BMP380_EVENT_ADDR UINT8_C(0x10)
#define BMP380_INT_STATUS_REG_ADDR UINT8_C(0x11)
#define BMP380_FIFO_LENGTH_ADDR UINT8_C(0x12)
#define BMP380_FIFO_DATA_ADDR UINT8_C(0x14)
#define BMP380_FIFO_WM_ADDR UINT8_C(0x15)
#define BMP380_FIFO_CONFIG_1_ADDR UINT8_C(0x17)
#define BMP380_FIFO_CONFIG_2_ADDR UINT8_C(0x18)
#define BMP380_INT_CTRL_ADDR UINT8_C(0x19)
#define BMP380_IF_CONF_ADDR UINT8_C(0x1A)
#define BMP380_PWR_CTRL_ADDR UINT8_C(0x1B)
#define BMP380_OSR_ADDR UINT8_C(0X1C)
#define BMP380_ODR_ADDR UINT8_C(0X1D)
#define BMP380_CALIB_DATA_ADDR UINT8_C(0x31)
#define BMP380_CMD_ADDR UINT8_C(0x7E)
#define BMP380_CALIB_DATA_ADDR UINT8_C(0x31)
#define BMP380_CALIB_DATA_LEN UINT8_C(21)
#define BMP380_CALIB_DATA_SIZE UINT8_C(21)
#define BMP380_ULTRA_LOW_POWER_MODE (0x00)
#define BMP380_LOW_POWER_MODE (0x01)
#define BMP380_STANDARD_RESOLUTION_MODE (0x02)
#define BMP380_HIGH_RESOLUTION_MODE (0x03)
#define BMP380_ULTRA_HIGH_RESOLUTION_MODE (0x04)
#define BMP380_HIGHEST_RESOLUTION_MODE (0x05)
/* Over sampling macros */
#define BMP380_NO_OVERSAMPLING UINT8_C(0x00)
#define BMP380_OVERSAMPLING_2X UINT8_C(0x01)
#define BMP380_OVERSAMPLING_4X UINT8_C(0x02)
#define BMP380_OVERSAMPLING_8X UINT8_C(0x03)
#define BMP380_OVERSAMPLING_16X UINT8_C(0x04)
#define BMP380_OVERSAMPLING_32X UINT8_C(0x05)
/* Odr setting macros */
#define BMP380_ODR_200_HZ UINT8_C(0x00)
#define BMP380_ODR_100_HZ UINT8_C(0x01)
#define BMP380_ODR_50_HZ UINT8_C(0x02)
#define BMP380_ODR_25_HZ UINT8_C(0x03)
#define BMP380_ODR_12_5_HZ UINT8_C(0x04)
#define BMP380_ODR_6_25_HZ UINT8_C(0x05)
#define BMP380_ODR_3_1_HZ UINT8_C(0x06)
#define BMP380_ODR_1_5_HZ UINT8_C(0x07)
#define BMP380_ODR_0_78_HZ UINT8_C(0x08)
#define BMP380_ODR_0_39_HZ UINT8_C(0x09)
#define BMP380_ODR_0_2_HZ UINT8_C(0x0A)
#define BMP380_ODR_0_1_HZ UINT8_C(0x0B)
#define BMP380_ODR_0_05_HZ UINT8_C(0x0C)
#define BMP380_ODR_0_02_HZ UINT8_C(0x0D)
#define BMP380_ODR_0_01_HZ UINT8_C(0x0E)
#define BMP380_ODR_0_006_HZ UINT8_C(0x0F)
#define BMP380_ODR_0_003_HZ UINT8_C(0x10)
#define BMP380_ODR_0_001_HZ UINT8_C(0x11)
#define BMP380_PRESS_ENABLED UINT8_C(0x01)
#define BMP380_TEMP_ENABLED UINT8_C(0x01)
/* CMD definition */
#define BMP380_SOFT_RST_CMD UINT8_C(0xB6)
/* Status macros */
#define BMP380_CMD_RDY UINT8_C(0x10)
#define BMP380_DRDY_PRESS UINT8_C(0x20)
#define BMP380_DRDY_TEMP UINT8_C(0x40)
/* Error status macros */
#define BMP380_FATAL_ERR UINT8_C(0x01)
#define BMP380_CMD_ERR UINT8_C(0x02)
#define BMP380_CONF_ERR UINT8_C(0x04)
/* Power mode macros */
#define BMP380_SLEEP_MODE UINT8_C(0x00)
#define BMP380_FORCED_MODE UINT8_C(0x01)
#define BMP380_NORMAL_MODE UINT8_C(0x03)
#define BMP380_PRESS_OS_MSK UINT8_C(0x07)
#define BMP380_PRESS_OS_POS UINT8_C(0x00)
#define BMP380_TEMP_OS_MSK UINT8_C(0x38)
#define BMP380_TEMP_OS_POS UINT8_C(0x03)
#define BMP380_OP_MODE_MSK UINT8_C(0x30)
#define BMP380_OP_MODE_POS UINT8_C(0x04)
#define BMP380_ODR_MSK UINT8_C(0x1F)
#define BMP380_ODR_POS UINT8_C(0x00)
#define BMP380_PRESS_EN_MSK UINT8_C(0x01)
#define BMP380_PRESS_EN_POS UINT8_C(0x00)
#define BMP380_TEMP_EN_MSK UINT8_C(0x02)
#define BMP380_TEMP_EN_POS UINT8_C(0x01)
#define BMP380_SHIFT_BY_01_BIT (1)
#define BMP380_SHIFT_BY_02_BITS (2)
#define BMP380_SHIFT_BY_03_BITS (3)
#define BMP380_SHIFT_BY_04_BITS (4)
#define BMP380_SHIFT_BY_05_BITS (5)
#define BMP380_SHIFT_BY_08_BITS (8)
#define BMP380_SHIFT_BY_11_BITS (11)
#define BMP380_SHIFT_BY_12_BITS (12)
#define BMP380_SHIFT_BY_13_BITS (13)
#define BMP380_SHIFT_BY_14_BITS (14)
#define BMP380_SHIFT_BY_15_BITS (15)
#define BMP380_SHIFT_BY_16_BITS (16)
#define BMP380_SHIFT_BY_17_BITS (17)
#define BMP380_SHIFT_BY_18_BITS (18)
#define BMP380_SHIFT_BY_19_BITS (19)
#define BMP380_SHIFT_BY_25_BITS (25)
#define BMP380_SHIFT_BY_31_BITS (31)
#define BMP380_SHIFT_BY_33_BITS (33)
#define BMP380_SHIFT_BY_35_BITS (35)
#define BMP380_SHIFT_BY_47_BITS (47)
/* Macro to combine two 8 bit data's to form a 16 bit data */
#define BMP380_CONCAT_BYTES(msb, lsb) (((uint16_t)msb << 8) | (uint16_t)lsb)
#define BMP380_SET_BITSLICE(reg_data, bitname, data) \
((reg_data & ~(bitname##_MSK)) | \
((data << bitname##_POS) & bitname##_MSK))
#define BMP380_GET_BITSLICE(reg_data, bitname) \
((reg_data & (bitname##_MSK)) >> \
(bitname##_POS))
#define BMP380_GET_LSB(var) (uint8_t)(var & BMA4_SET_LOW_BYTE)
#define BMP380_GET_MSB(var) (uint8_t)((var & BMA4_SET_HIGH_BYTE) >> 8)
typedef struct bmp380_calib_param_t {
uint16_t dig_T1;
uint16_t dig_T2;
int8_t dig_T3;
int16_t dig_P1;
int16_t dig_P2;
int8_t dig_P3;
int8_t dig_P4;
int16_t dig_P5;
int16_t dig_P6;
int8_t dig_P7;
int8_t dig_P8;
int16_t dig_P9;
int8_t dig_P10;
int8_t dig_P11;
int64_t t_fine;
}bmp380_calib_param_t;
static bmp380_calib_param_t g_bmp380_calib_table;
i2c_dev_t bmp380_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = BMP380_I2C_ADDR,
};
/**
* This function gets the calibration param
*
* @param[in] drv pointer to the i2c dev
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_get_calib_param(i2c_dev_t* drv)
{
int ret = 0;
uint8_t a_data_u8[BMP380_CALIB_DATA_SIZE] = {0};
ret = sensor_i2c_read(drv,BMP380_CALIB_DATA_ADDR,
a_data_u8,BMP380_CALIB_DATA_LEN,I2C_OP_RETRIES);
if (unlikely(ret) != 0) {
return ret;
}
g_bmp380_calib_table.dig_T1 = BMP380_CONCAT_BYTES(a_data_u8[1], a_data_u8[0]);
g_bmp380_calib_table.dig_T2 = BMP380_CONCAT_BYTES(a_data_u8[3], a_data_u8[2]);
g_bmp380_calib_table.dig_T3 = (int8_t)a_data_u8[4];
g_bmp380_calib_table.dig_P1 = (int16_t)BMP380_CONCAT_BYTES(a_data_u8[6], a_data_u8[5]);
g_bmp380_calib_table.dig_P2 = (int16_t)BMP380_CONCAT_BYTES(a_data_u8[8], a_data_u8[7]);
g_bmp380_calib_table.dig_P3 = (int8_t)a_data_u8[9];
g_bmp380_calib_table.dig_P4 = (int8_t)a_data_u8[10];
g_bmp380_calib_table.dig_P5 = BMP380_CONCAT_BYTES(a_data_u8[12], a_data_u8[11]);
g_bmp380_calib_table.dig_P6 = BMP380_CONCAT_BYTES(a_data_u8[14], a_data_u8[13]);
g_bmp380_calib_table.dig_P7 = (int8_t)a_data_u8[15];
g_bmp380_calib_table.dig_P8 = (int8_t)a_data_u8[16];
g_bmp380_calib_table.dig_P9 = (int16_t)BMP380_CONCAT_BYTES(a_data_u8[18], a_data_u8[17]);
g_bmp380_calib_table.dig_P10 = (int8_t)a_data_u8[19];
g_bmp380_calib_table.dig_P11 = (int8_t)a_data_u8[20];
return 0;
}
/**
* This function validates the chip ID of device
*
* @param[in] drv pointer to the i2c dev
* @param[in] id_value the expected CHIPID
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
int ret = 0;
uint8_t value = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, BMP380_CHIP_ID_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret) != 0) {
return ret;
}
if (id_value != value) {
return -1;
}
return 0;
}
/**
* This function sets the baro workmode
*
* @param[in] drv pointer to the i2c dev
* @param[in] mode the workmode to be setted
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_set_work_mode(i2c_dev_t* drv,uint8_t mode)
{
uint8_t ret = 0;
uint8_t value = 0;
uint8_t temp = 0;
uint8_t baro = 0;
switch (mode) {
case BMP380_ULTRA_LOW_POWER_MODE:
temp = BMP380_NO_OVERSAMPLING;
baro = BMP380_NO_OVERSAMPLING;
break;
case BMP380_LOW_POWER_MODE:
temp = BMP380_OVERSAMPLING_2X;
baro = BMP380_OVERSAMPLING_2X;
break;
case BMP380_STANDARD_RESOLUTION_MODE:
temp = BMP380_OVERSAMPLING_4X;
baro = BMP380_OVERSAMPLING_4X;
break;
case BMP380_HIGH_RESOLUTION_MODE:
temp = BMP380_OVERSAMPLING_8X;
baro = BMP380_OVERSAMPLING_8X;
break;
case BMP380_ULTRA_HIGH_RESOLUTION_MODE:
temp = BMP380_OVERSAMPLING_16X;
baro = BMP380_OVERSAMPLING_16X;
break;
case BMP380_HIGHEST_RESOLUTION_MODE:
temp = BMP380_OVERSAMPLING_32X;
baro = BMP380_OVERSAMPLING_32X;
break;
default:
return -1;
}
ret = sensor_i2c_read(drv, BMP380_OSR_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret) != 0) {
return ret;
}
value = BMP380_SET_BITSLICE(value,BMP380_PRESS_OS,baro);
value = BMP380_SET_BITSLICE(value,BMP380_TEMP_OS,temp);
ret = sensor_i2c_write(drv, BMP380_OSR_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
aos_msleep(2);
if (unlikely(ret) != 0) {
return ret;
}
return ret;
}
/**
* This function sets the baro powermode
*
* @param[in] drv pointer to the i2c dev
* @param[in] mode the powermode to be setted
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t dev_mode;
switch(mode){
case DEV_POWER_OFF:
case DEV_SLEEP:{
dev_mode = (uint8_t)BMP380_SLEEP_MODE;
break;
}
case DEV_POWER_ON:{
dev_mode = (uint8_t)BMP380_NORMAL_MODE;
break;
}
default:return -1;
}
ret = sensor_i2c_read(drv, BMP380_PWR_CTRL_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret) != 0) {
return ret;
}
value = BMP380_SET_BITSLICE(value,BMP380_OP_MODE,dev_mode);
ret = sensor_i2c_write(drv, BMP380_PWR_CTRL_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
aos_msleep(2);
if (unlikely(ret) != 0) {
return ret;
}
return 0;
}
/**
* This function enables the pressure sensor and temperature sensor
*
* @param[in] drv pointer to the i2c dev
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_enable_pressure_temp(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, BMP380_PWR_CTRL_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret) != 0) {
return ret;
}
value = BMP380_SET_BITSLICE(value,BMP380_PRESS_EN,BMP380_PRESS_ENABLED);
value = BMP380_SET_BITSLICE(value,BMP380_TEMP_EN,BMP380_TEMP_ENABLED);
ret = sensor_i2c_write(drv, BMP380_PWR_CTRL_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
aos_msleep(2);
if (unlikely(ret) != 0) {
return ret;
}
return 0;
}
/**
* This function gets the baro ODR according to HZ
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the frequency required
* @return the conrresponding baro ODR
*/
static uint8_t drv_baro_bosch_bmp380_hz2odr(int hz)
{
if (hz > 100)
return BMP380_ODR_200_HZ;
else if (hz > 50)
return BMP380_ODR_100_HZ;
else if (hz > 25)
return BMP380_ODR_50_HZ;
else if (hz > 12)
return BMP380_ODR_25_HZ;
else if (hz > 6)
return BMP380_ODR_12_5_HZ;
else if (hz > 3)
return BMP380_ODR_6_25_HZ;
else if (hz > 1)
return BMP380_ODR_3_1_HZ;
else
return BMP380_ODR_1_5_HZ;
}
/**
* This function sets the baro ODR
*
* @param[in] drv pointer to the i2c dev
* @param[in] hz the frequency required
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_set_odr(i2c_dev_t* drv, uint8_t odr)
{
int ret = 0;
uint8_t v_data_u8 = 0;
ret = sensor_i2c_read(drv,BMP380_ODR_ADDR,
&v_data_u8,I2C_DATA_LEN,I2C_OP_RETRIES);
if (unlikely(ret) != 0) {
return ret;
}
v_data_u8 = BMP380_SET_BITSLICE(v_data_u8,BMP380_ODR,odr);
ret = sensor_i2c_write(drv,BMP380_ODR_ADDR,
&v_data_u8,I2C_DATA_LEN,I2C_OP_RETRIES);
aos_msleep(2);
if (unlikely(ret) != 0) {
return ret;
}
return ret;
}
/**
* This function does the soft reset
*
* @param[in] drv pointer to the i2c dev
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t cmd_rdy_status;
uint8_t cmd_err_status;
uint8_t v_data_u8 = BMP380_SOFT_RST_CMD;
ret = sensor_i2c_read(drv, BMP380_SENS_STATUS_REG_ADDR, &cmd_rdy_status, I2C_DATA_LEN, I2C_OP_RETRIES);
if ((cmd_rdy_status & BMP380_CMD_RDY) && (!unlikely(ret))) {
ret = sensor_i2c_write(drv,BMP380_CMD_ADDR,
&v_data_u8,I2C_DATA_LEN,I2C_OP_RETRIES);
aos_msleep(2);
if (!unlikely(ret) != 0) {
ret = sensor_i2c_read(drv, BMP380_ERR_REG_ADDR, &cmd_err_status, I2C_DATA_LEN, I2C_OP_RETRIES);
if ((cmd_err_status & BMP380_CMD_ERR) || (unlikely(ret))) {
ret = BMP380_E_CMD_EXEC_FAILED;
}
}
} else {
ret = BMP380_E_CMD_EXEC_FAILED;
}
if (unlikely(ret) != 0) {
return ret;
}
return ret;
}
/**
* This function sets the sensor to default
*
* @param[in] drv pointer to the i2c dev
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
ret = drv_baro_bosch_bmp380_enable_pressure_temp(drv);
if (unlikely(ret) != 0) {
return ret;
}
ret = drv_baro_bosch_bmp380_set_power_mode(drv, DEV_SLEEP);
if (unlikely(ret) != 0) {
return ret;
}
ret = drv_baro_bosch_bmp380_set_odr(drv, BMP380_DEFAULT_ODR_1HZ);
if (unlikely(ret) != 0) {
return ret;
}
return 0;
}
/**
* This function reads the uncompensated baro data
*
* @param[in] drv pointer to the i2c dev
* @param[in out] pdata pointer to the baro data
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_read_uncomp_baro(i2c_dev_t* drv, barometer_data_t* pdata)
{
int ret = 0;
uint8_t data[BMP380_PRESSURE_DATA_SIZE] = {0};
ret = sensor_i2c_read(drv, BMP380_DATA_ADDR, data, BMP380_PRESSURE_DATA_SIZE, I2C_OP_RETRIES);
if (unlikely(ret) != 0) {
return ret;
}
pdata->p = ((((uint32_t)(data[BMP380_PRESSURE_MSB_DATA]))<< BMP380_SHIFT_BY_16_BITS)
| (((uint32_t)(data[BMP380_PRESSURE_LSB_DATA]))<< BMP380_SHIFT_BY_08_BITS)
| ((uint32_t)data[BMP380_PRESSURE_XLSB_DATA]));
return ret;
}
/**
* This function compensates the uncompensated baro data
*
* @param[in out] pdata pointer to the baro data
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_compensate_baro( barometer_data_t* pdata)
{
int64_t partial_data1;
int64_t partial_data2;
int64_t partial_data3;
int64_t partial_data4;
int64_t partial_data5;
int64_t partial_data6;
int64_t offset;
int64_t sensitivity;
uint64_t comp_press;
uint32_t comp_baro = 0;
partial_data1 = g_bmp380_calib_table.t_fine * g_bmp380_calib_table.t_fine;
partial_data2 = partial_data1 / 64;
partial_data3 = (partial_data2 * g_bmp380_calib_table.t_fine) / 256;
partial_data4 = (g_bmp380_calib_table.dig_P8 * partial_data3) / 32;
partial_data5 = (g_bmp380_calib_table.dig_P7 * partial_data1) * 16;
partial_data6 = (g_bmp380_calib_table.dig_P6 * g_bmp380_calib_table.t_fine) * 4194304;
offset = (g_bmp380_calib_table.dig_P5 * 140737488355328) + partial_data4 + partial_data5 + partial_data6;
partial_data2 = (g_bmp380_calib_table.dig_P4 * partial_data3) / 32;
partial_data4 = (g_bmp380_calib_table.dig_P3 * partial_data1) * 4;
partial_data5 = (g_bmp380_calib_table.dig_P2 - 16384) * g_bmp380_calib_table.t_fine * 2097152;
sensitivity = ((g_bmp380_calib_table.dig_P1 - 16384) * 70368744177664) + partial_data2 + partial_data4 + partial_data5;
partial_data1 = (sensitivity / 16777216) * pdata->p;
partial_data2 = g_bmp380_calib_table.dig_P10 * g_bmp380_calib_table.t_fine;
partial_data3 = partial_data2 + (65536 * g_bmp380_calib_table.dig_P9);
partial_data4 = (partial_data3 * pdata->p) / 8192;
partial_data5 = (partial_data4 * pdata->p) / 512;
partial_data6 = (int64_t)((uint64_t)pdata->p * (uint64_t)pdata->p);
partial_data2 = (g_bmp380_calib_table.dig_P11 * partial_data6) / 65536;
partial_data3 = (partial_data2 * pdata->p) / 128;
partial_data4 = (offset / 4) + partial_data1 + partial_data5 + partial_data3;
comp_press = (((uint64_t)partial_data4 * 25) / (uint64_t)1099511627776);
comp_baro = (uint32_t)(comp_press) / 100;
pdata->p = comp_baro;
return 0;
}
/**
* This function reads the baro data and reports the data
*
* @param[in out] buf buffer for acc data
* @param[in out] len length of data
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_read_baro(i2c_dev_t* drv, barometer_data_t* pdata)
{
int ret = 0;
ret = drv_baro_bosch_bmp380_read_uncomp_baro(drv, pdata);
if (unlikely(ret) != 0) {
return ret;
}
ret = drv_baro_bosch_bmp380_compensate_baro(pdata);
if (unlikely(ret) != 0) {
return ret;
}
return 0;
}
/**
* This function compensates the uncompensated temp data
*
* @param[in out] pdata pointer to the baro data
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_comp_temp(temperature_data_t* pdata)
{
uint64_t partial_data1;
uint64_t partial_data2;
uint64_t partial_data3;
int64_t partial_data4;
int64_t partial_data5;
int64_t partial_data6;
int64_t comp_temp;
partial_data1 = pdata->t - (256 * g_bmp380_calib_table.dig_T1);
partial_data2 = g_bmp380_calib_table.dig_T2 * partial_data1;
partial_data3 = partial_data1 * partial_data1;
partial_data4 = (int64_t)partial_data3 * g_bmp380_calib_table.dig_T3;
partial_data5 = ((int64_t)(partial_data2 * 262144) + partial_data4);
partial_data6 = partial_data5 / 4294967296;
/* Store t_lin in dev. structure for pressure calculation */
g_bmp380_calib_table.t_fine = partial_data6;
comp_temp = (int64_t)((partial_data6 * 25) / 16384);
pdata->t = (int32_t)(comp_temp);
return 0;
}
/**
* This function calibrate the uncompensated temp data
*
* @param[in] drv pointer to the i2c dev
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_cali_temp(i2c_dev_t* drv)
{
int ret = 0;
uint8_t data[BMP380_TEMPERATURE_DATA_SIZE] = {0};
temperature_data_t temp;
ret = sensor_i2c_read(drv, BMP380_TDATA_ADDR, data, BMP380_TEMPERATURE_DATA_SIZE, I2C_OP_RETRIES);
if(unlikely(ret) != 0){
return ret;
}
temp.t = ((((uint32_t)(data[BMP380_TEMPERATURE_MSB_DATA]))<< BMP380_SHIFT_BY_16_BITS)
| (((uint32_t)(data[BMP380_TEMPERATURE_LSB_DATA]))<< BMP380_SHIFT_BY_08_BITS)
| ((uint32_t)data[BMP380_TEMPERATURE_XLSB_DATA]));
ret = drv_baro_bosch_bmp380_comp_temp(&temp);
if(unlikely(ret) != 0){
return ret;
}
return 0;
}
/**
* This function is the ISR
*
* @return
*/
static void drv_baro_bosch_bmp380_irq_handle(void)
{
/* no handle so far */
}
/**
* This function opens the baro
*
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_open(void)
{
int ret = 0;
/* set the default config for the sensor here */
ret = drv_baro_bosch_bmp380_set_work_mode(&bmp380_ctx,BMP380_ULTRA_LOW_POWER_MODE);
if (unlikely(ret) != 0) {
return -1;
}
ret = drv_baro_bosch_bmp380_enable_pressure_temp(&bmp380_ctx);
if (unlikely(ret) != 0) {
return ret;
}
ret = drv_baro_bosch_bmp380_set_power_mode(&bmp380_ctx, DEV_POWER_ON);
if (unlikely(ret) != 0) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
/**
* This function closes the baro
*
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_close(void)
{
int ret = 0;
ret = drv_baro_bosch_bmp380_set_power_mode(&bmp380_ctx, DEV_POWER_OFF);
if (unlikely(ret) != 0) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
/**
* This function reads the baro data and reports the data
*
* @param[in out] buf buffer for baro data
* @param[in out] len length of data
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_read(void *buf, size_t len)
{
int ret = 0;
size_t size = 0;
barometer_data_t* pdata = (barometer_data_t*)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(barometer_data_t);
if (len < size) {
return -1;
}
ret = drv_baro_bosch_bmp380_cali_temp(&bmp380_ctx);
if (unlikely(ret) != 0) {
return -1;
}
ret = drv_baro_bosch_bmp380_read_baro(&bmp380_ctx, pdata);
if (unlikely(ret) != 0) {
return -1;
}
pdata->timestamp = aos_now_ms();
return (int)size;
}
/**
* This function writess the baro
*
* @param[in out] buf buffer for written data
* @param[in out] len length of data
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
/**
* This function is for the baro ioctl
*
* @param[in] cmd the ioctl command
* @param[in] arg the correspondding parameter
* @return the operation status, 0 is OK, others is error
*/
static int drv_baro_bosch_bmp380_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
uint8_t odr = drv_baro_bosch_bmp380_hz2odr(arg);
ret = drv_baro_bosch_bmp380_set_odr(&bmp380_ctx, odr);
if (unlikely(ret) != 0) {
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_baro_bosch_bmp380_set_power_mode(&bmp380_ctx, arg);
if (unlikely(ret) != 0) {
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMP380";
info->range_max = 1100;
info->range_min = 300;
info->unit = pa;
}break;
default:break;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
/**
* This function is for the baro initialization
*
* @return the operation status, 0 is OK, others is error
*/
int drv_baro_bosch_bmp380_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_BARO;
sensor.path = dev_baro_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_baro_bosch_bmp380_open;
sensor.close = drv_baro_bosch_bmp380_close;
sensor.read = drv_baro_bosch_bmp380_read;
sensor.write = drv_baro_bosch_bmp380_write;
sensor.ioctl = drv_baro_bosch_bmp380_ioctl;
sensor.irq_handle = drv_baro_bosch_bmp380_irq_handle;
ret = sensor_create_obj(&sensor);
if (unlikely(ret) != 0) {
return -1;
}
ret = drv_baro_bosch_bmp380_validate_id(&bmp380_ctx, BMP380_CHIP_ID_VAL);
if (unlikely(ret) != 0) {
return -1;
}
ret = drv_baro_bosch_bmp380_soft_reset(&bmp380_ctx);
if (unlikely(ret) != 0) {
return -1;
}
ret = drv_baro_bosch_bmp380_set_default_config(&bmp380_ctx);
if (unlikely(ret) != 0) {
return -1;
}
ret = drv_baro_bosch_bmp380_get_calib_param(&bmp380_ctx);
if (unlikely(ret) != 0) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_baro_bosch_bmp380_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_baro_bosch_bmp38x.c
|
C
|
apache-2.0
| 28,974
|
/* The MIT License
Copyright(c) 2018 Infineon Technologies AG
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 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "ulog/ulog.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define DPS310_I2C_SLAVE_ADDR_HIGH (0X77)
#define DPS310_I2C_ADDR_TRANS(n) ((n) << 1)
#define DPS310_I2C_ADDR DPS310_I2C_ADDR_TRANS(DPS310_I2C_SLAVE_ADDR_HIGH)
// general Constants
#define DPS310__PROD_ID 0U
#define DPS310__STD_SLAVE_ADDRESS 0x77U
#define DPS310__SPI_WRITE_CMD 0x00U
#define DPS310__SPI_READ_CMD 0x80U
#define DPS310__SPI_RW_MASK 0x80U
#define DPS310__SPI_MAX_FREQ 100000U
#define DPS310__LSB 0x01U
#define DPS310__TEMP_STD_MR 2U
#define DPS310__TEMP_STD_OSR 3U
#define DPS310__PRS_STD_MR 2U
#define DPS310__PRS_STD_OSR 3U
#define DPS310__OSR_SE 3U
// we use 0.1 mS units for time calculations, so 10 units are one millisecond
#define DPS310__BUSYTIME_SCALING 10U
// DPS310 has 10 milliseconds of spare time for each synchronous measurement /
// per second for asynchronous measurements this is for error prevention on
// friday-afternoon-products :D you can set it to 0 if you dare, but there is no
// warranty that it will still work
#define DPS310__BUSYTIME_FAILSAFE 10U
#define DPS310__MAX_BUSYTIME \
((1000U - DPS310__BUSYTIME_FAILSAFE) * DPS310__BUSYTIME_SCALING)
#define DPS310__NUM_OF_SCAL_FACTS 8
#define DPS310__SUCCEEDED 0
#define DPS310__FAIL_UNKNOWN -1
#define DPS310__FAIL_INIT_FAILED -2
#define DPS310__FAIL_TOOBUSY -3
#define DPS310__FAIL_UNFINISHED -4
// Constants for register manipulation
// SPI mode (3 or 4 wire)
#define DPS310__REG_ADR_SPI3W 0x09U
#define DPS310__REG_CONTENT_SPI3W 0x01U
// product id
#define DPS310__REG_INFO_PROD_ID \
DPS310__REG_ADR_PROD_ID, DPS310__REG_MASK_PROD_ID, DPS310__REG_SHIFT_PROD_ID
#define DPS310__REG_ADR_PROD_ID 0x0DU
#define DPS310__REG_MASK_PROD_ID 0x0FU
#define DPS310__REG_SHIFT_PROD_ID 0U
// revision id
#define DPS310__REG_INFO_REV_ID \
DPS310__REG_ADR_REV_ID, DPS310__REG_MASK_REV_ID, DPS310__REG_SHIFT_REV_ID
#define DPS310__REG_ADR_REV_ID 0x0DU
#define DPS310__REG_MASK_REV_ID 0xF0U
#define DPS310__REG_SHIFT_REV_ID 4U
// operating mode
#define DPS310__REG_INFO_OPMODE \
DPS310__REG_ADR_OPMODE, DPS310__REG_MASK_OPMODE, DPS310__REG_SHIFT_OPMODE
#define DPS310__REG_ADR_OPMODE 0x08U
#define DPS310__REG_MASK_OPMODE 0x07U
#define DPS310__REG_SHIFT_OPMODE 0U
// temperature measure rate
#define DPS310__REG_INFO_TEMP_MR \
DPS310__REG_ADR_TEMP_MR, DPS310__REG_MASK_TEMP_MR, DPS310__REG_SHIFT_TEMP_MR
#define DPS310__REG_ADR_TEMP_MR 0x07U
#define DPS310__REG_MASK_TEMP_MR 0x70U
#define DPS310__REG_SHIFT_TEMP_MR 4U
// temperature oversampling rate
#define DPS310__REG_INFO_TEMP_OSR \
DPS310__REG_ADR_TEMP_OSR, DPS310__REG_MASK_TEMP_OSR, \
DPS310__REG_SHIFT_TEMP_OSR
#define DPS310__REG_ADR_TEMP_OSR 0x07U
#define DPS310__REG_MASK_TEMP_OSR 0x07U
#define DPS310__REG_SHIFT_TEMP_OSR 0U
// temperature sensor
#define DPS310__REG_INFO_TEMP_SENSOR \
DPS310__REG_ADR_TEMP_SENSOR, DPS310__REG_MASK_TEMP_SENSOR, \
DPS310__REG_SHIFT_TEMP_SENSOR
#define DPS310__REG_ADR_TEMP_SENSOR 0x07U
#define DPS310__REG_MASK_TEMP_SENSOR 0x80U
#define DPS310__REG_SHIFT_TEMP_SENSOR 7U
// temperature sensor recommendation
#define DPS310__REG_INFO_TEMP_SENSORREC \
DPS310__REG_ADR_TEMP_SENSORREC, DPS310__REG_MASK_TEMP_SENSORREC, \
DPS310__REG_SHIFT_TEMP_SENSORREC
#define DPS310__REG_ADR_TEMP_SENSORREC 0x28U
#define DPS310__REG_MASK_TEMP_SENSORREC 0x80U
#define DPS310__REG_SHIFT_TEMP_SENSORREC 7U
// temperature shift enable (if temp_osr>3)
#define DPS310__REG_INFO_TEMP_SE \
DPS310__REG_ADR_TEMP_SE, DPS310__REG_MASK_TEMP_SE, DPS310__REG_SHIFT_TEMP_SE
#define DPS310__REG_ADR_TEMP_SE 0x09U
#define DPS310__REG_MASK_TEMP_SE 0x08U
#define DPS310__REG_SHIFT_TEMP_SE 3U
// pressure measure rate
#define DPS310__REG_INFO_PRS_MR \
DPS310__REG_ADR_PRS_MR, DPS310__REG_MASK_PRS_MR, DPS310__REG_SHIFT_PRS_MR
#define DPS310__REG_ADR_PRS_MR 0x06U
#define DPS310__REG_MASK_PRS_MR 0x70U
#define DPS310__REG_SHIFT_PRS_MR 4U
// pressure oversampling rate
#define DPS310__REG_INFO_PRS_OSR \
DPS310__REG_ADR_PRS_OSR, DPS310__REG_MASK_PRS_OSR, DPS310__REG_SHIFT_PRS_OSR
#define DPS310__REG_ADR_PRS_OSR 0x06U
#define DPS310__REG_MASK_PRS_OSR 0x07U
#define DPS310__REG_SHIFT_PRS_OSR 0U
// pressure shift enable (if prs_osr>3)
#define DPS310__REG_INFO_PRS_SE \
DPS310__REG_ADR_PRS_SE, DPS310__REG_MASK_PRS_SE, DPS310__REG_SHIFT_PRS_SE
#define DPS310__REG_ADR_PRS_SE 0x09U
#define DPS310__REG_MASK_PRS_SE 0x04U
#define DPS310__REG_SHIFT_PRS_SE 2U
// temperature ready flag
#define DPS310__REG_INFO_TEMP_RDY \
DPS310__REG_ADR_TEMP_RDY, DPS310__REG_MASK_TEMP_RDY, \
DPS310__REG_SHIFT_TEMP_RDY
#define DPS310__REG_ADR_TEMP_RDY 0x08U
#define DPS310__REG_MASK_TEMP_RDY 0x20U
#define DPS310__REG_SHIFT_TEMP_RDY 5U
// pressure ready flag
#define DPS310__REG_INFO_PRS_RDY \
DPS310__REG_ADR_PRS_RDY, DPS310__REG_MASK_PRS_RDY, DPS310__REG_SHIFT_PRS_RDY
#define DPS310__REG_ADR_PRS_RDY 0x08U
#define DPS310__REG_MASK_PRS_RDY 0x10U
#define DPS310__REG_SHIFT_PRS_RDY 4U
// pressure value
#define DPS310__REG_ADR_PRS 0x00U
#define DPS310__REG_LEN_PRS 3U
// temperature value
#define DPS310__REG_ADR_TEMP 0x03U
#define DPS310__REG_LEN_TEMP 3U
// compensation coefficients
#define DPS310__REG_ADR_COEF 0x10U
#define DPS310__REG_LEN_COEF 18
// FIFO enable
#define DPS310__REG_INFO_FIFO_EN \
DPS310__REG_ADR_FIFO_EN, DPS310__REG_MASK_FIFO_EN, DPS310__REG_SHIFT_FIFO_EN
#define DPS310__REG_ADR_FIFO_EN 0x09U
#define DPS310__REG_MASK_FIFO_EN 0x02U
#define DPS310__REG_SHIFT_FIFO_EN 1U
// FIFO flush
#define DPS310__REG_INFO_FIFO_FL \
DPS310__REG_ADR_FIFO_EN, DPS310__REG_MASK_FIFO_EN, DPS310__REG_SHIFT_FIFO_EN
#define DPS310__REG_ADR_FIFO_FL 0x0CU
#define DPS310__REG_MASK_FIFO_FL 0x80U
#define DPS310__REG_SHIFT_FIFO_FL 7U
// FIFO empty
#define DPS310__REG_INFO_FIFO_EMPTY \
DPS310__REG_ADR_FIFO_EMPTY, DPS310__REG_MASK_FIFO_EMPTY, \
DPS310__REG_SHIFT_FIFO_EMPTY
#define DPS310__REG_ADR_FIFO_EMPTY 0x0BU
#define DPS310__REG_MASK_FIFO_EMPTY 0x01U
#define DPS310__REG_SHIFT_FIFO_EMPTY 0U
// FIFO full
#define DPS310__REG_INFO_FIFO_FULL \
DPS310__REG_ADR_FIFO_FULL, DPS310__REG_MASK_FIFO_FULL, \
DPS310__REG_SHIFT_FIFO_FULL
#define DPS310__REG_ADR_FIFO_FULL 0x0BU
#define DPS310__REG_MASK_FIFO_FULL 0x02U
#define DPS310__REG_SHIFT_FIFO_FULL 1U
// INT HL
#define DPS310__REG_INFO_INT_HL \
DPS310__REG_ADR_INT_HL, DPS310__REG_MASK_INT_HL, DPS310__REG_SHIFT_INT_HL
#define DPS310__REG_ADR_INT_HL 0x09U
#define DPS310__REG_MASK_INT_HL 0x80U
#define DPS310__REG_SHIFT_INT_HL 7U
// INT FIFO enable
#define DPS310__REG_INFO_INT_EN_FIFO \
DPS310__REG_ADR_INT_EN_FIFO, DPS310__REG_MASK_INT_EN_FIFO, \
DPS310__REG_SHIFT_INT_EN_FIFO
#define DPS310__REG_ADR_INT_EN_FIFO 0x09U
#define DPS310__REG_MASK_INT_EN_FIFO 0x40U
#define DPS310__REG_SHIFT_INT_EN_FIFO 6U
// INT TEMP enable
#define DPS310__REG_INFO_INT_EN_TEMP \
DPS310__REG_ADR_INT_EN_TEMP, DPS310__REG_MASK_INT_EN_TEMP, \
DPS310__REG_SHIFT_INT_EN_TEMP
#define DPS310__REG_ADR_INT_EN_TEMP 0x09U
#define DPS310__REG_MASK_INT_EN_TEMP 0x20U
#define DPS310__REG_SHIFT_INT_EN_TEMP 5U
// INT PRS enable
#define DPS310__REG_INFO_INT_EN_PRS \
DPS310__REG_ADR_INT_EN_PRS, DPS310__REG_MASK_INT_EN_PRS, \
DPS310__REG_SHIFT_INT_EN_PRS
#define DPS310__REG_ADR_INT_EN_PRS 0x09U
#define DPS310__REG_MASK_INT_EN_PRS 0x10U
#define DPS310__REG_SHIFT_INT_EN_PRS 4U
// INT FIFO flag
#define DPS310__REG_INFO_INT_FLAG_FIFO \
DPS310__REG_ADR_INT_FLAG_FIFO, DPS310__REG_MASK_INT_FLAG_FIFO, \
DPS310__REG_SHIFT_INT_FLAG_FIFO
#define DPS310__REG_ADR_INT_FLAG_FIFO 0x0AU
#define DPS310__REG_MASK_INT_FLAG_FIFO 0x04U
#define DPS310__REG_SHIFT_INT_FLAG_FIFO 2U
// INT TMP flag
#define DPS310__REG_INFO_INT_FLAG_TEMP \
DPS310__REG_ADR_INT_FLAG_TEMP, DPS310__REG_MASK_INT_FLAG_TEMP, \
DPS310__REG_SHIFT_INT_FLAG_TEMP
#define DPS310__REG_ADR_INT_FLAG_TEMP 0x0AU
#define DPS310__REG_MASK_INT_FLAG_TEMP 0x02U
#define DPS310__REG_SHIFT_INT_FLAG_TEMP 1U
// INT PRS flag
#define DPS310__REG_INFO_INT_FLAG_PRS \
DPS310__REG_ADR_INT_FLAG_PRS, DPS310__REG_MASK_INT_FLAG_PRS, \
DPS310__REG_SHIFT_INT_FLAG_PRS
#define DPS310__REG_ADR_INT_FLAG_PRS 0x0AU
#define DPS310__REG_MASK_INT_FLAG_PRS 0x01U
#define DPS310__REG_SHIFT_INT_FLAG_PRS 0U
typedef enum _Mode
{
IDLE = 0x00,
CMD_PRS = 0x01,
CMD_TEMP = 0x02,
INVAL_OP_CMD_BOTH = 0x03, // invalid
INVAL_OP_CONT_NONE = 0x04, // invalid
CONT_PRS = 0x05,
CONT_TMP = 0x06,
CONT_BOTH = 0x07
} Mode;
typedef struct
{
i2c_dev_t i2c;
Mode m_opMode;
// flags
uint8_t m_initFail;
uint8_t m_productID;
uint8_t m_revisionID;
// settings
uint8_t m_tempMr;
uint8_t m_tempOsr;
uint8_t m_prsMr;
uint8_t m_prsOsr;
uint8_t m_tempSensor;
// compensation coefficients
int32_t m_c0Half;
int32_t m_c1;
int32_t m_c00;
int32_t m_c10;
int32_t m_c01;
int32_t m_c11;
int32_t m_c20;
int32_t m_c21;
int32_t m_c30;
// last measured scaled temperature
//(necessary for pressure compensation)
double m_lastTempScal;
} dps310_t;
const int32_t scaling_facts[DPS310__NUM_OF_SCAL_FACTS] = {
524288, 1572864, 3670016, 7864320, 253952, 516096, 1040384, 2088960
};
dps310_t dps310_ctx = { .i2c.port = 3,
.i2c.config.address_width = 8,
.i2c.config.freq = 200000,
.i2c.config.dev_addr = DPS310_I2C_ADDR,
.m_prsMr = 0,
.m_prsOsr = 0 };
/**
* reads a block from dps310
*
* regAdress: Address that has to be read
* length: Length of data block
* buffer: Buffer where data will be stored
* returns: number of bytes that have been read successfully
* NOTE! This is not always equal to length
* due to rx-Buffer overflow etc.
*/
int16_t readBlock(uint8_t regAddress, uint8_t length, uint8_t *buffer)
{
// do not read if there is no buffer
int ret;
if (buffer == NULL) {
return 0; // 0 bytes read successfully
}
ret = sensor_i2c_read(&(dps310_ctx.i2c), regAddress, buffer, length,
I2C_OP_RETRIES);
if (ret != 0) {
return 0;
}
return length;
}
/**
* writes a given byte to a given register of dps310
*
* regAdress: Address of the register that has to be updated
* data: Byte that will be written to the register
* check: If this is true, register content will be read after writing
* to check if update was successful
* return: 0 if byte was written successfully
* or -1 on fail
*/
int16_t writeByte(uint8_t regAddress, uint8_t data)
{
if (sensor_i2c_write(&(dps310_ctx.i2c), regAddress, &data, 1,
AOS_WAIT_FOREVER) == 0) {
return DPS310__SUCCEEDED;
} else {
return DPS310__FAIL_UNKNOWN;
}
}
/**
* reads a byte from dps310
*
* regAdress: Address that has to be read
* returns: register content or -1 on fail
*/
int16_t readByte(uint8_t regAddress)
{
uint8_t data;
int ret =
sensor_i2c_read(&(dps310_ctx.i2c), regAddress, &data, 1, I2C_OP_RETRIES);
if (ret == 0)
return data;
else
return -1;
}
/**
* updates some given bits of a given register of dps310
*
* regAdress: Address of the register that has to be updated
* data: BitValues that will be written to the register
* shift: Amount of bits the data byte is shifted (left) before being
* masked mask: Masks the bits of the register that have to be updated
* Bits with value 1 are updated
* Bits with value 0 are not changed
* check: enables/disables check after writing
* 0 disables check
* if check fails, -1 will be returned
* return: 0 if byte was written successfully
* or -1 on fail
*/
int16_t writeByteBitfield(uint8_t data, uint8_t regAddress, uint8_t mask,
uint8_t shift)
{
int16_t old = readByte(regAddress);
if (old < 0) {
// fail while reading
return old;
}
return writeByte(regAddress,
((uint8_t)old & ~mask) | ((data << shift) & mask));
}
/**
* Configures pressure measurement
*
* prsMr: the new measure rate for pressure
* This can be a value from 0U to 7U.
* Actual measure rate will be 2^prs_mr,
* so this will be a value from 1 to 128.
* prsOs: the new oversampling rate for temperature
* This can be a value from 0U to 7U.
* Actual measure rate will be 2^prsOsr,
* so this will be a value from 1 to 128.
* returns: 0 normally or -1 on fail
*/
int16_t configPressure(uint8_t prsMr, uint8_t prsOsr)
{
uint8_t toWrite;
int16_t ret;
// mask parameters
prsMr &= DPS310__REG_MASK_PRS_MR >> DPS310__REG_SHIFT_PRS_MR;
prsOsr &= DPS310__REG_MASK_PRS_OSR >> DPS310__REG_SHIFT_PRS_OSR;
// set config register according to parameters
toWrite = prsMr << DPS310__REG_SHIFT_PRS_MR;
toWrite |= prsOsr << DPS310__REG_SHIFT_PRS_OSR;
ret = writeByte(DPS310__REG_ADR_PRS_MR, toWrite);
// abort immediately on fail
if (ret != DPS310__SUCCEEDED) {
return DPS310__FAIL_UNKNOWN;
}
// set PM SHIFT ENABLE if oversampling rate higher than eight(2^3)
if (prsOsr > DPS310__OSR_SE) {
ret = writeByteBitfield(1U, DPS310__REG_INFO_PRS_SE);
} else {
ret = writeByteBitfield(0U, DPS310__REG_INFO_PRS_SE);
}
if (ret == DPS310__SUCCEEDED) { // save new settings
dps310_ctx.m_prsMr = prsMr;
dps310_ctx.m_prsOsr = prsOsr;
} else { // try to rollback on fail avoiding endless recursion
// this is to make sure that shift enable and oversampling rate
// are always consistent
if (prsMr != dps310_ctx.m_prsMr || prsOsr != dps310_ctx.m_prsOsr) {
configPressure(dps310_ctx.m_prsMr, dps310_ctx.m_prsOsr);
}
}
return ret;
}
/**
* Calculates a scaled and compensated pressure value from raw data
* raw: raw pressure value read from Dps310
* returns: pressure value in Pa
*/
int32_t calcPressure(int32_t raw)
{
double prs = raw;
// scale pressure according to scaling table and oversampling
prs /= scaling_facts[dps310_ctx.m_prsOsr];
// Calculate compensated pressure
prs =
dps310_ctx.m_c00 +
prs *
(dps310_ctx.m_c10 + prs * (dps310_ctx.m_c20 + prs * dps310_ctx.m_c30)) +
dps310_ctx.m_lastTempScal *
(dps310_ctx.m_c01 + prs * (dps310_ctx.m_c11 + prs * dps310_ctx.m_c21));
// return pressure
return (int32_t)prs;
}
/**
* Gets the next pressure measurement result in Pa
*
* result: address where the result will be written
* returns: 0 on success
* -1 on fail;
*/
int16_t getPressure(int32_t *result)
{
uint8_t buffer[3] = { 0 };
// read raw pressure data to buffer
int16_t i = readBlock(DPS310__REG_ADR_PRS, DPS310__REG_LEN_PRS, buffer);
if (i != DPS310__REG_LEN_PRS) {
// something went wrong
// negative pressure is not allowed
return DPS310__FAIL_UNKNOWN;
}
// compose raw pressure value from buffer
int32_t prs = (uint32_t)buffer[0] << 16 | (uint32_t)buffer[1] << 8 |
(uint32_t)buffer[2];
// recognize non-32-bit negative numbers
// and convert them to 32-bit negative numbers using 2's complement
if (prs & ((uint32_t)1 << 23)) {
prs -= (uint32_t)1 << 24;
}
*result = calcPressure(prs);
return DPS310__SUCCEEDED;
}
/**
* Sets the Operation Mode of the Dps310
*
* opMode: the new OpMode that has to be set
* return: 0 on success, -1 on fail
*
* NOTE!
* You cannot set background to 1 without setting temperature and pressure
* You cannot set both temperature and pressure when background mode is disabled
*/
int16_t setOpMode(uint8_t opMode)
{
// Filter irrelevant bits
opMode &= DPS310__REG_MASK_OPMODE >> DPS310__REG_SHIFT_OPMODE;
// Filter invalid OpModes
if (opMode == INVAL_OP_CMD_BOTH || opMode == INVAL_OP_CONT_NONE) {
return DPS310__FAIL_UNKNOWN;
}
// Set OpMode
if (writeByte(DPS310__REG_ADR_OPMODE, opMode)) {
return DPS310__FAIL_UNKNOWN;
}
dps310_ctx.m_opMode = (Mode)opMode;
return DPS310__SUCCEEDED;
}
/**
* Sets the Operation Mode of the Dps310
*
* background: determines the general behavior of the Dps310
* 0 enables command mode (only measure on commands)
* 1 enables background mode (continuous work in background)
* temperature: set 1 to measure temperature
* pressure: set 1 to measure pressure
* return: 0 on success, -1 on fail
*
* NOTE!
* You cannot set background to 1 without setting temperature and pressure
* You cannot set both temperature and pressure when background mode is disabled
*/
int16_t setOpMode_3param(uint8_t background, uint8_t temperature,
uint8_t pressure)
{
uint8_t opMode = (background & DPS310__LSB) << 2U |
(temperature & DPS310__LSB) << 1U |
(pressure & DPS310__LSB);
return setOpMode(opMode);
}
/**
* Sets the Dps310 to standby mode
*
* returns: 0 on success
* -2 if object initialization failed
* -1 on other fail
*/
int16_t standby(void)
{
// abort if initialization failed
if (dps310_ctx.m_initFail) {
return DPS310__FAIL_INIT_FAILED;
}
// set device to idling mode
int16_t ret = setOpMode(IDLE);
if (ret != DPS310__SUCCEEDED) {
return ret;
}
// flush the FIFO
ret = writeByteBitfield(1U, DPS310__REG_INFO_FIFO_FL);
if (ret < 0) {
return ret;
}
// disable the FIFO
ret = writeByteBitfield(0U, DPS310__REG_INFO_FIFO_EN);
return ret;
}
/**
* reads some given bits of a given register of dps310
*
* regAdress: Address of the register that has to be updated
* mask: Masks the bits of the register that have to be updated
* Bits masked with value 1 are read
* Bits masked with value 0 are set 0
* shift: Amount of bits the data byte is shifted (right) after being
* masked return: read and processed bits or -1 on fail
*/
int16_t readByteBitfield(uint8_t regAddress, uint8_t mask, uint8_t shift)
{
int16_t ret = readByte(regAddress);
if (ret < 0) {
return ret;
}
return (((uint8_t)ret) & mask) >> shift;
}
/**
* calculates the time that the DPS310 needs for 2^mr measurements
* with an oversampling rate of 2^osr
*
* mr: Measure rate for temperature or pressure
* osr: Oversampling rate for temperature or pressure
* returns: time that the DPS310 needs for this measurement
* a value of 10000 equals 1 second
* NOTE! The measurement time for temperature and pressure
* in sum must not be more than 1 second!
* Timing behavior of pressure and temperature sensors
* can be considered as equal.
*/
uint16_t calcBusyTime(uint16_t mr, uint16_t osr)
{
// mask parameters first
mr &= DPS310__REG_MASK_TEMP_MR >> DPS310__REG_SHIFT_TEMP_MR;
osr &= DPS310__REG_MASK_TEMP_OSR >> DPS310__REG_SHIFT_TEMP_OSR;
// formula from datasheet (optimized)
return ((uint32_t)20U << mr) + ((uint32_t)16U << (osr + mr));
}
static void delay(int ms)
{
aos_msleep(ms);
}
/**
* Calculates a scaled and compensated pressure value from raw data
* raw: raw temperature value read from Dps310
* returns: temperature value in °C
*/
int32_t calcTemp(int32_t raw)
{
double temp = raw;
// scale temperature according to scaling table and oversampling
temp /= scaling_facts[dps310_ctx.m_tempOsr];
// update last measured temperature
// it will be used for pressure compensation
dps310_ctx.m_lastTempScal = temp;
// Calculate compensated temperature
temp = dps310_ctx.m_c0Half + dps310_ctx.m_c1 * temp;
// return temperature
return (int32_t)temp;
}
/**
* starts a single pressure measurement
* The desired precision can be set with oversamplingRate
*
* oversamplingRate: a value from 0 to 7 that decides about the precision
* of the measurement
* If this value equals n, the DPS310 will perform
* 2^n measurements and combine the results
* returns: 0 on success
* -3 if the DPS310 is already busy
* -2 if the object initialization failed
* -1 on other fail
*/
int16_t startMeasurePressureOnce(uint8_t oversamplingRate)
{
// abort if initialization failed
if (dps310_ctx.m_initFail) {
return DPS310__FAIL_INIT_FAILED;
}
// abort if device is not in idling mode
if (dps310_ctx.m_opMode != IDLE) {
return DPS310__FAIL_TOOBUSY;
}
// configuration of oversampling rate, lowest measure rate to avoid
// conflicts
if (oversamplingRate != dps310_ctx.m_prsOsr) {
if (configPressure(0U, oversamplingRate)) {
return DPS310__FAIL_UNKNOWN;
}
}
// set device to pressure measuring mode
return setOpMode_3param(0U, 0U, 1U);
}
/**
* Gets the next temperature measurement result in degrees of Celsius
*
* result: address where the result will be written
* returns: 0 on success
* -1 on fail;
*/
int16_t getTemp(int32_t *result)
{
uint8_t buffer[3] = { 0 };
// read raw pressure data to buffer
int16_t i = readBlock(DPS310__REG_ADR_TEMP, DPS310__REG_LEN_TEMP, buffer);
if (i != DPS310__REG_LEN_TEMP) {
// something went wrong
return DPS310__FAIL_UNKNOWN;
}
// compose raw temperature value from buffer
int32_t temp = (uint32_t)buffer[0] << 16 | (uint32_t)buffer[1] << 8 |
(uint32_t)buffer[2];
// recognize non-32-bit negative numbers
// and convert them to 32-bit negative numbers using 2's complement
if (temp & ((uint32_t)1 << 23)) {
temp -= (uint32_t)1 << 24;
}
// return temperature
*result = calcTemp(temp);
return DPS310__SUCCEEDED;
}
/**
* gets the result a single temperature or pressure measurement in °C or Pa
*
* &result: reference to a 32-Bit signed Integer value where the result will
* be written returns: 0 on success -4 if the DPS310 is still busy -3 if the
* DPS310 is not in command mode -2 if the object initialization failed -1 on
* other fail
*/
int16_t getSingleResult(int32_t *result)
{
// abort if initialization failed
if (dps310_ctx.m_initFail) {
return DPS310__FAIL_INIT_FAILED;
}
// read finished bit for current opMode
int16_t rdy;
switch (dps310_ctx.m_opMode) {
case CMD_TEMP: // temperature
rdy = readByteBitfield(DPS310__REG_INFO_TEMP_RDY);
break;
case CMD_PRS: // pressure
rdy = readByteBitfield(DPS310__REG_INFO_PRS_RDY);
break;
default: // DPS310 not in command mode
return DPS310__FAIL_TOOBUSY;
}
// read new measurement result
switch (rdy) {
case DPS310__FAIL_UNKNOWN: // could not read ready flag
return DPS310__FAIL_UNKNOWN;
case 0: // ready flag not set, measurement still in progress
return DPS310__FAIL_UNFINISHED;
case 1: // measurement ready, expected case
{
Mode oldMode = dps310_ctx.m_opMode;
dps310_ctx.m_opMode =
IDLE; // opcode was automatically reseted by DPS310
switch (oldMode) {
case CMD_TEMP: // temperature
return getTemp(
result); // get and calculate the temperature value
case CMD_PRS: // pressure
return getPressure(
result); // get and calculate the pressure value
default:
return DPS310__FAIL_UNKNOWN; // should already be filtered
// above
}
}
}
return DPS310__FAIL_UNKNOWN;
}
/**
* Configures temperature measurement
*
* tempMr: the new measure rate for temperature
* This can be a value from 0U to 7U.
* Actual measure rate will be 2^tempMr,
* so this will be a value from 1 to 128.
* tempOsr: the new oversampling rate for temperature
* This can be a value from 0U to 7U.
* Actual measure rate will be 2^tempOsr,
* so this will be a value from 1 to 128.
* returns: 0 normally or -1 on fail
*/
int16_t configTemp(uint8_t tempMr, uint8_t tempOsr)
{
// mask parameters
tempMr &= DPS310__REG_MASK_TEMP_MR >> DPS310__REG_SHIFT_TEMP_MR;
tempOsr &= DPS310__REG_MASK_TEMP_OSR >> DPS310__REG_SHIFT_TEMP_OSR;
// set config register according to parameters
uint8_t toWrite = tempMr << DPS310__REG_SHIFT_TEMP_MR;
toWrite |= tempOsr << DPS310__REG_SHIFT_TEMP_OSR;
// using recommended temperature sensor
toWrite |= DPS310__REG_MASK_TEMP_SENSOR &
(dps310_ctx.m_tempSensor << DPS310__REG_SHIFT_TEMP_SENSOR);
int16_t ret = writeByte(DPS310__REG_ADR_TEMP_MR, toWrite);
// abort immediately on fail
if (ret != DPS310__SUCCEEDED) {
return DPS310__FAIL_UNKNOWN;
}
// set TEMP SHIFT ENABLE if oversampling rate higher than eight(2^3)
if (tempOsr > DPS310__OSR_SE) {
ret = writeByteBitfield(1U, DPS310__REG_INFO_TEMP_SE);
} else {
ret = writeByteBitfield(0U, DPS310__REG_INFO_TEMP_SE);
}
if (ret == DPS310__SUCCEEDED) { // save new settings
dps310_ctx.m_tempMr = tempMr;
dps310_ctx.m_tempOsr = tempOsr;
} else {
// try to rollback on fail avoiding endless recursion
// this is to make sure that shift enable and oversampling rate
// are always consistent
if (tempMr != dps310_ctx.m_tempMr || tempOsr != dps310_ctx.m_tempOsr) {
configTemp(dps310_ctx.m_tempMr, dps310_ctx.m_tempOsr);
}
}
return ret;
}
/**
* starts a single temperature measurement
* The desired precision can be set with oversamplingRate
*
* oversamplingRate: a value from 0 to 7 that decides about the precision
* of the measurement
* If this value equals n, the DPS310 will perform
* 2^n measurements and combine the results
* returns: 0 on success
* -3 if the DPS310 is already busy
* -2 if the object initialization failed
* -1 on other fail
*/
int16_t startMeasureTempOnce(uint8_t oversamplingRate)
{
// abort if initialization failed
if (dps310_ctx.m_initFail) {
return DPS310__FAIL_INIT_FAILED;
}
// abort if device is not in idling mode
if (dps310_ctx.m_opMode != IDLE) {
return DPS310__FAIL_TOOBUSY;
}
if (oversamplingRate != dps310_ctx.m_tempOsr) {
// configuration of oversampling rate
if (configTemp(0U, oversamplingRate) != DPS310__SUCCEEDED) {
return DPS310__FAIL_UNKNOWN;
}
}
// set device to temperature measuring mode
return setOpMode_3param(0U, 1U, 0U);
}
/**
* performs one temperature measurement and writes result to the given address
* the desired precision can be set with oversamplingRate
*
* &result: reference to a 32-Bit signed Integer where the result
* will be written It will not be written if result==NULL oversamplingRate: a
* value from 0 to 7 that decides about the precision of the measurement If this
* value equals n, the DPS310 will perform 2^n measurements and combine the
* results returns: 0 on success -4 if the DPS310 is could not
* finish its measurement in time -3 if the DPS310 is already busy -2 if the
* object initialization failed -1 on other fail
*/
int16_t measureTempOnce(int32_t *result, uint8_t oversamplingRate)
{
// Start measurement
int16_t ret = startMeasureTempOnce(oversamplingRate);
if (ret != DPS310__SUCCEEDED) {
return ret;
}
// wait until measurement is finished
delay(calcBusyTime(0U, dps310_ctx.m_tempOsr) / DPS310__BUSYTIME_SCALING);
delay(DPS310__BUSYTIME_FAILSAFE);
ret = getSingleResult(result);
if (ret != DPS310__SUCCEEDED) {
standby();
}
return ret;
}
/**
* performs one pressure measurement and writes result to the given address
* the desired precision can be set with oversamplingRate
*
* &result: reference to a 32-Bit signed Integer where the result
* will be written It will not be written if result==NULL oversamplingRate: a
* value from 0 to 7 that decides about the precision of the measurement If this
* value equals n, the DPS310 will perform 2^n measurements and combine the
* results returns: 0 on success -4 if the DPS310 is could not
* finish its measurement in time -3 if the DPS310 is already busy -2 if the
* object initialization failed -1 on other fail
*/
int16_t measurePressureOnce(int32_t *result, uint8_t oversamplingRate)
{
// start the measurement
int16_t ret = startMeasurePressureOnce(oversamplingRate);
if (ret != DPS310__SUCCEEDED) {
return ret;
}
// wait until measurement is finished
delay(calcBusyTime(0U, dps310_ctx.m_prsOsr) / DPS310__BUSYTIME_SCALING);
delay(DPS310__BUSYTIME_FAILSAFE);
ret = getSingleResult(result);
if (ret != DPS310__SUCCEEDED) {
standby();
}
return ret;
}
/**
* performs one temperature measurement and writes result to the given address
*
* &result: reference to a 32-Bit signed Integer value where the result will
* be written It will not be written if result==NULL returns: 0 on success -4
* if the DPS310 is could not finish its measurement in time -3 if the DPS310 is
* already busy -2 if the object initialization failed -1 on other fail
*/
int16_t measureTempOnce_1param(int32_t *result)
{
return measureTempOnce(result, dps310_ctx.m_tempOsr);
}
/**
* reads the compensation coefficients from the DPS310
* this is called once from init(), which is called from begin()
*
* returns: 0 on success, -1 on fail
*/
int16_t readcoeffs(void)
{
uint8_t buffer[DPS310__REG_LEN_COEF];
// read COEF registers to buffer
int16_t ret = readBlock(DPS310__REG_ADR_COEF, DPS310__REG_LEN_COEF, buffer);
// abort if less than REG_LEN_COEF bytes were read
if (ret < DPS310__REG_LEN_COEF) {
return DPS310__FAIL_UNKNOWN;
}
// compose coefficients from buffer content
dps310_ctx.m_c0Half =
((uint32_t)buffer[0] << 4) | (((uint32_t)buffer[1] >> 4) & 0x0F);
// this construction recognizes non-32-bit negative numbers
// and converts them to 32-bit negative numbers with 2's complement
if (dps310_ctx.m_c0Half & ((uint32_t)1 << 11)) {
dps310_ctx.m_c0Half -= (uint32_t)1 << 12;
}
// c0 is only used as c0*0.5, so c0_half is calculated immediately
dps310_ctx.m_c0Half = dps310_ctx.m_c0Half / 2U;
// now do the same thing for all other coefficients
dps310_ctx.m_c1 = (((uint32_t)buffer[1] & 0x0F) << 8) | (uint32_t)buffer[2];
if (dps310_ctx.m_c1 & ((uint32_t)1 << 11)) {
dps310_ctx.m_c1 -= (uint32_t)1 << 12;
}
dps310_ctx.m_c00 = ((uint32_t)buffer[3] << 12) |
((uint32_t)buffer[4] << 4) |
(((uint32_t)buffer[5] >> 4) & 0x0F);
if (dps310_ctx.m_c00 & ((uint32_t)1 << 19)) {
dps310_ctx.m_c00 -= (uint32_t)1 << 20;
}
dps310_ctx.m_c10 = (((uint32_t)buffer[5] & 0x0F) << 16) |
((uint32_t)buffer[6] << 8) | (uint32_t)buffer[7];
if (dps310_ctx.m_c10 & ((uint32_t)1 << 19)) {
dps310_ctx.m_c10 -= (uint32_t)1 << 20;
}
dps310_ctx.m_c01 = ((uint32_t)buffer[8] << 8) | (uint32_t)buffer[9];
if (dps310_ctx.m_c01 & ((uint32_t)1 << 15)) {
dps310_ctx.m_c01 -= (uint32_t)1 << 16;
}
dps310_ctx.m_c11 = ((uint32_t)buffer[10] << 8) | (uint32_t)buffer[11];
if (dps310_ctx.m_c11 & ((uint32_t)1 << 15)) {
dps310_ctx.m_c11 -= (uint32_t)1 << 16;
}
dps310_ctx.m_c20 = ((uint32_t)buffer[12] << 8) | (uint32_t)buffer[13];
if (dps310_ctx.m_c20 & ((uint32_t)1 << 15)) {
dps310_ctx.m_c20 -= (uint32_t)1 << 16;
}
dps310_ctx.m_c21 = ((uint32_t)buffer[14] << 8) | (uint32_t)buffer[15];
if (dps310_ctx.m_c21 & ((uint32_t)1 << 15)) {
dps310_ctx.m_c21 -= (uint32_t)1 << 16;
}
dps310_ctx.m_c30 = ((uint32_t)buffer[16] << 8) | (uint32_t)buffer[17];
if (dps310_ctx.m_c30 & ((uint32_t)1 << 15)) {
dps310_ctx.m_c30 -= (uint32_t)1 << 16;
}
return DPS310__SUCCEEDED;
}
/**
* Function to fix a hardware problem on some devices
* You have this problem if you measure a temperature which is too high (e.g.
* 60°C when temperature is around 20°C) Call correctTemp() directly after
* begin() to fix this issue
*/
int16_t correctTemp(void)
{
if (dps310_ctx.m_initFail) {
return DPS310__FAIL_INIT_FAILED;
}
writeByte(0x0E, 0xA5);
writeByte(0x0F, 0x96);
writeByte(0x62, 0x02);
writeByte(0x0E, 0x00);
writeByte(0x0F, 0x00);
// perform a first temperature measurement (again)
// the most recent temperature will be saved internally
// and used for compensation when calculating pressure
int32_t trash;
measureTempOnce_1param(&trash);
return DPS310__SUCCEEDED;
}
/**
* Initializes the sensor.
* This function has to be called from begin()
* and requires a valid bus initialization.
*/
void init(void)
{
int16_t prodId = readByteBitfield(DPS310__REG_INFO_PROD_ID);
if (prodId != DPS310__PROD_ID) {
// Connected device is not a Dps310
dps310_ctx.m_initFail = 1U;
return;
}
dps310_ctx.m_productID = prodId;
int16_t revId = readByteBitfield(DPS310__REG_INFO_REV_ID);
if (revId < 0) {
dps310_ctx.m_initFail = 1U;
return;
}
dps310_ctx.m_revisionID = revId;
// find out which temperature sensor is calibrated with coefficients...
int16_t sensor = readByteBitfield(DPS310__REG_INFO_TEMP_SENSORREC);
if (sensor < 0) {
dps310_ctx.m_initFail = 1U;
return;
}
//...and use this sensor for temperature measurement
dps310_ctx.m_tempSensor = sensor;
if (writeByteBitfield((uint8_t)sensor, DPS310__REG_INFO_TEMP_SENSOR) < 0) {
dps310_ctx.m_initFail = 1U;
return;
}
// read coefficients
if (readcoeffs() < 0) {
dps310_ctx.m_initFail = 1U;
return;
}
// set to standby for further configuration
standby();
// set measurement precision and rate to standard values;
configTemp(DPS310__TEMP_STD_MR, DPS310__TEMP_STD_OSR);
configPressure(DPS310__PRS_STD_MR, DPS310__PRS_STD_OSR);
// perform a first temperature measurement
// the most recent temperature will be saved internally
// and used for compensation when calculating pressure
int32_t trash;
measureTempOnce(&trash, dps310_ctx.m_tempOsr);
// make sure the DPS310 is in standby after initialization
standby();
// Fix IC with a fuse bit problem, which lead to a wrong temperature
// Should not affect ICs without this problem
correctTemp();
}
static int drv_baro_ifx_dps310_open(void)
{
init();
return 0;
}
static int drv_baro_ifx_dps310_close(void)
{
return 0;
}
static int drv_baro_ifx_dps310_read(void *buf, size_t len)
{
int32_t pressure = 0;
// int32_t temp = 0;
size_t size;
barometer_data_t *pdata = (barometer_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(barometer_data_t);
if (len < size) {
return -1;
}
{
// measureTempOnce(&temp, 7);
// printf("temp: %d\r\n", temp);
measurePressureOnce(&pressure, 7);
//printf("pressure: %d\r\n", pressure);
}
pdata->p = pressure;
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_baro_ifx_dps310_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_baro_ifx_dps310_ioctl(int cmd, unsigned long arg)
{
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static void drv_baro_ifx_dps310_irq_handle(void)
{
/* no handle so far */
}
int drv_baro_ifx_dps310_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_BARO;
sensor.path = dev_baro_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_baro_ifx_dps310_open;
sensor.close = drv_baro_ifx_dps310_close;
sensor.read = drv_baro_ifx_dps310_read;
sensor.write = drv_baro_ifx_dps310_write;
sensor.ioctl = drv_baro_ifx_dps310_ioctl;
sensor.irq_handle = drv_baro_ifx_dps310_irq_handle;
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_baro_ifx_dps310_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_baro_ifx_dps310.c
|
C
|
apache-2.0
| 38,441
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
* Edit wanjiang-yan 2018-6-24
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
//1.8V offset=0,2.8v offset= -0.6
//#define VALUE_OFFSET //modify by laoyan
#ifdef VALUE_OFFSET
#define PRESSURE_VALUES_OFFSET 0.6 //modify by laoyan
#endif
//For Get_Attrib Function
#define PRESS_SENSOR_POWER_VAL (650)
#define PRESS_SENSOR_LOW_POWER_VAL (30)
#define PRESS_SENSOR_ACTIVE_TIME (1300)
#define PRESS_SENSOR_DATA_TIME (147000)
#define PRESS_SENSOR_RANGE_MIN (0)
#define PRESS_SENSOR_RANGE_MAX (1)
#define PRESS_SENSOR_ODR_SIZE (7)
#define PRESS_SENSOR_RES_DECIMAL (11)
#define PRESS_SENSOR_RES_INTEGER (11)
#define PRESS_SENSOR_DATA_BYTE (3)
#define PRESS_SENSOR_INIT_ODR (6)
/******************************************************************************
define name for IC
*****************************************************************************/
/* Address */
/* Compear ID */
#define BM1383A_ID1_VALUE (0xE0)
#define BM1383A_ID2_VALUE (0x32)
/* Power Down */
#define BM1383A_POWER_OFF (0x00)
#define BM1383A_POWER_ON (0x01)
/* Reset */
#define BM1383A_SW_RESET_VALUE (1 << 7)
#define BM1383A_INT_RESET_VALUE (1 << 6)
/* Sleep value */
#define BM1383A_SLEEP_RELEASE (0x00)
#define BM1383A_SLEEP_ACTIVE (0x01)
/* AVE_NUM */
#define BM1383A_AVE_NUM_VALUE_1_TIMES (0x0 << 5) /*000: single */
#define BM1383A_AVE_NUM_VALUE_30_TIMES (0x3 << 5) /*001: average of 30 times */
#define BM1383A_AVE_NUM_VALUE_60_TIMES (0x4 << 5) /*001: average of 60 times*/ //50ms
#define BM1383A_AVE_NUM_VALUE_120_TIMES (0x5 << 5) /*101: average of 120 times*/ //100ms
#define BM1383A_AVE_NUM_VALUE_240_TIMES (0x6 << 5) /*110: average of 240 times*/ //200ms
#define BM1383A_MODE_VALUE_STANDBY (0x0) /* 00 stand by */
#define BM1383A_MODE_VALUE_ONE_SHOT (0x1) /* 01 One shot */
#define BM1383A_MODE_VALUE_CONTINOUS (0x2) /* 10 Continuous */
#define BM1383A_MODE_VALUE_PROHIBITION (0x3) /* 11 Prohibition */
#define BM1383A_INT_ENABLE_DREG (0x1>>4) //DRDY pin Enable
#define BM1383A_INT_DISABLE_DREG (0x0>>4) //DRDY pin Disable
#define BM1383A_MODE_RECV (0x2>>2) //Refer to Operation mode transition
#define BM1383A_INT_CLS_VALUE (0x1 << 6) /* Clear interrupt */
/* ROHM SENSOR REGISTER MAP */
#define BM1383A_BIT(x) ((uint8_t)x)
#define BM1383A_REG_ID1 (0x0F)
#define BM1383A_REG_ID2 (0x10)
#define BM1383A_REG_POWER_DOWN (0x12)
#define BM1383A_REG_RESET_CONTROL (0x13)
#define BM1383A_REG_MODE_CONTROL (0x14)
#define BM1383A_REG_STATUS (0x19)
#define BM1383A_REG_PRESSURE_MSB_H (0x1A)
#define BM1383A_REG_PRESSURE_LSB_M (0x1B)
#define BM1383A_REG_PRESSURE_LSB_L (0x1C)
#define BM1383A_REG_TEMPERATURE_MSB (0x1D)
#define BM1383A_REG_TEMPERATURE_LSB (0x1E)
#define BM1383A_I2C_ADDR (0x5D)
#define BM1383A_I2C_ADDR_TRANS(n) ((n)<<1)
#define BM1383A_I2C_ADDR2 BM1383A_I2C_ADDR_TRANS(BM1383A_I2C_ADDR)
#define BM1383A_ODR_MASK (uint8_t)0x1c
typedef enum {
BM1383A_ODR_ONE_SHOT = (uint8_t)0x01, /*!< Output Data Rate: one shot */
BM1383A_ODR_1HZ = (uint8_t)0xc2, /*!< Output Data Rate: 1Hz */
BM1383A_ODR_5HZ = (uint8_t)0xa2, /*!< Output Data Rate: 4Hz */
BM1383A_ODR_10HZ = (uint8_t)0x82, /*!< Output Data Rate: 8Hz */
BM1383A_ODR_20HZ = (uint8_t)0x62, /*!< Output Data Rate: 15Hz */
} bm1383a_odr_e;
typedef enum {
BM1383A_BDU_CONTINUOUS_UPDATE = (uint8_t)0x00, /*!< Data updated continuously */
BM1383A_BDU_NO_UPDATE = (uint8_t)0x02 /*!< Data updated after a read operation */
} bm1383a_bdu_e;
i2c_dev_t bm1383a_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = BM1383A_I2C_ADDR2,
};
static bm1383a_odr_e drv_baro_rohm_bm1383a_hz2odr(int hz)
{
if(hz > 10)
return BM1383A_ODR_20HZ;
else if(hz > 5)
return BM1383A_ODR_10HZ;
else if(hz > 1)
return BM1383A_ODR_5HZ;
else
return BM1383A_ODR_1HZ;
}
//��֤оƬ�������Ĵ����Ƿ���Ĭ�ϵļĴ�������
static int drv_baro_rohm_bm1383a_validate_id(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, BM1383A_REG_ID1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (BM1383A_ID1_VALUE != value){
return -1;
}
ret = sensor_i2c_read(drv, BM1383A_REG_ID2, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (BM1383A_ID2_VALUE != value){
return -1;
}
return 0;
}
static int drv_baro_rohm_bm1383a_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
//ret = sensor_i2c_read(drv, BM1383A_RES_CONF_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
//if(unlikely(ret)){
// return ret;
//}
switch(mode){
case DEV_POWER_ON:{
value = BM1383A_POWER_ON;
ret = sensor_i2c_write(drv, BM1383A_REG_POWER_DOWN, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
//It must wait 2ms (i2c)
aos_msleep(2);
value = BM1383A_SLEEP_ACTIVE;
ret = sensor_i2c_write(drv, BM1383A_REG_RESET_CONTROL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = BM1383A_AVE_NUM_VALUE_60_TIMES|BM1383A_MODE_VALUE_CONTINOUS;
ret = sensor_i2c_write(drv, BM1383A_REG_MODE_CONTROL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
aos_msleep(100);
}break;
case DEV_POWER_OFF:{
//sleep status
value = BM1383A_SLEEP_RELEASE;
ret = sensor_i2c_write(drv, BM1383A_REG_RESET_CONTROL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
//power off
value = BM1383A_POWER_OFF;
ret = sensor_i2c_write(drv, BM1383A_REG_POWER_DOWN, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static int drv_baro_rohm_bm1383a_set_odr(i2c_dev_t* drv, bm1383a_odr_e odr)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, BM1383A_REG_MODE_CONTROL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value &= ~BM1383A_ODR_MASK;
value |= (uint8_t)odr;
ret = sensor_i2c_write(drv, BM1383A_REG_MODE_CONTROL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
//
static int drv_baro_rohm_bm1383a_set_bdu(i2c_dev_t* drv, bm1383a_bdu_e bdu)
{
/*
ret = sensor_i2c_read(drv, BM1383A_REG_MODE_CONTROL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value &= ~BM1383A_BDU_MASK;
value |= (uint8_t)bdu;
ret = sensor_i2c_write(drv, BM1383A_REG_MODE_CONTROL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
*/
return 0;
}
static int drv_baro_rohm_bm1383a_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
ret = drv_baro_rohm_bm1383a_set_power_mode(drv, DEV_POWER_OFF);
if(unlikely(ret)){
return ret;
}
ret = drv_baro_rohm_bm1383a_set_odr(drv, BM1383A_ODR_20HZ);
if(unlikely(ret)){
return ret;
}
ret = drv_baro_rohm_bm1383a_set_bdu(drv, BM1383A_BDU_NO_UPDATE);
if(unlikely(ret)){
return ret;
}
/* you also can set the low-pass filter and cut off config here */
return 0;
}
static void drv_baro_rohm_bm1383a_irq_handle(void)
{
/* no handle so far */
}
static int drv_baro_rohm_bm1383a_open(void)
{
int ret = 0;
ret = drv_baro_rohm_bm1383a_set_power_mode(&bm1383a_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_baro_rohm_bm1383a_close(void)
{
int ret = 0;
ret = drv_baro_rohm_bm1383a_set_power_mode(&bm1383a_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_baro_rohm_bm1383a_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t data[3];
barometer_data_t* pdata = (barometer_data_t*)buf;
if(buf == NULL){
return -1;
}
size = sizeof(barometer_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&bm1383a_ctx, BM1383A_REG_PRESSURE_LSB_L, &data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bm1383a_ctx, BM1383A_REG_PRESSURE_LSB_M, &data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bm1383a_ctx, BM1383A_REG_PRESSURE_MSB_H, &data[2], I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
/* hatch the baro data here*/
for(int i=0; i<3; i++){
pdata->p |= (((uint32_t)data[i]) << (8*i));
}
// left 2 bit
//pdata->p = pdata->p >> 2;
/* convert the 2's complement 24 bit to 2's complement 32 bit */
if((pdata->p & 0x00800000) != 0){
pdata->p |= 0xFF000000;
}
pdata->p = (pdata->p * 25)/2048;
//pdata->p = pdata->p/100;
#ifdef VALUE_OFFSET
pdata->p -= PRESSURE_VALUES_OFFSET;
#endif
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_baro_rohm_bm1383a_write(const void *buf, size_t len)
{
return 0;
}
static int drv_baro_rohm_bm1383a_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
bm1383a_odr_e odr = drv_baro_rohm_bm1383a_hz2odr(arg);
ret = drv_baro_rohm_bm1383a_set_odr(&bm1383a_ctx, odr);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_baro_rohm_bm1383a_set_power_mode(&bm1383a_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BM1383A";
info->range_max = 110000;
info->range_min = 30000;
info->unit = pa;
}break;
default:break;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_baro_rohm_bm1383a_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_BARO;
sensor.path = dev_baro_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_baro_rohm_bm1383a_open;
sensor.close = drv_baro_rohm_bm1383a_close;
sensor.read = drv_baro_rohm_bm1383a_read;
sensor.write = drv_baro_rohm_bm1383a_write;
sensor.ioctl = drv_baro_rohm_bm1383a_ioctl;
sensor.irq_handle = drv_baro_rohm_bm1383a_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_baro_rohm_bm1383a_validate_id(&bm1383a_ctx);
if(unlikely(ret)){
return -1;
}
/* set the default config for the sensor here */
ret = drv_baro_rohm_bm1383a_set_default_config(&bm1383a_ctx);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_baro_rohm_bm1383a_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_baro_rohm_bm1383a.c
|
C
|
apache-2.0
| 12,134
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
/* ST BARO SENSOR REGISTER MAP */
#define LPS22HB_BIT(x) ((uint8_t)x)
#define LPS22HB_ADDRESS (uint8_t)0xB8
#define LPS22HB_DriverVersion_Major (uint8_t)1
#define LPS22HB_DriverVersion_Minor (uint8_t)0
#define LPS22HB_DriverVersion_Point (uint8_t)0
#define LPS22HB_WHO_AM_I_REG (uint8_t)0x0F
#define LPS22HB_WHO_AM_I_VAL (uint8_t)0xB1
#define LPS22HB_REF_P_XL_REG (uint8_t)0x15
#define LPS22HB_REF_P_L_REG (uint8_t)0x16
#define LPS22HB_REF_P_H_REG (uint8_t)0x17
#define LPS22HB_RES_CONF_REG (uint8_t)0x1A
#define LPS22HB_RES_CONF_REG (uint8_t)0x1A
#define LPS22HB_RES_CONF_REG (uint8_t)0x1A
#define LPS22HB_LCEN_MASK (uint8_t)0x01
#define LPS22HB_LCEN_POWERON (uint8_t)0x00
#define LPS22HB_LCEN_LOWPOWER (uint8_t)0x01
#define LPS22HB_CTRL_REG1 (uint8_t)0x10
#define LPS22HB_ODR_MASK (uint8_t)0x70
#define LPS22HB_LPFP_MASK (uint8_t)0x08
#define LPS22HB_LPFP_CUTOFF_MASK (uint8_t)0x04
#define LPS22HB_BDU_MASK (uint8_t)0x02
#define LPS22HB_SIM_MASK (uint8_t)0x01
#define LPS22HB_LPFP_BIT LPS22HB_BIT(3)
#define LPS22HB_CTRL_REG2 (uint8_t)0x11
#define LPS22HB_BOOT_BIT LPS22HB_BIT(7)
#define LPS22HB_FIFO_EN_BIT LPS22HB_BIT(6)
#define LPS22HB_WTM_EN_BIT LPS22HB_BIT(5)
#define LPS22HB_ADD_INC_BIT LPS22HB_BIT(4)
#define LPS22HB_I2C_BIT LPS22HB_BIT(3)
#define LPS22HB_SW_RESET_BIT LPS22HB_BIT(2)
#define LPS22HB_FIFO_EN_MASK (uint8_t)0x40
#define LPS22HB_WTM_EN_MASK (uint8_t)0x20
#define LPS22HB_ADD_INC_MASK (uint8_t)0x10
#define LPS22HB_I2C_MASK (uint8_t)0x08
#define LPS22HB_ONE_SHOT_MASK (uint8_t)0x01
#define LPS22HB_CTRL_REG3 (uint8_t)0x12
#define LPS22HB_PP_OD_BIT LPS22HB_BIT(6)
#define LPS22HB_FIFO_FULL_BIT LPS22HB_BIT(5)
#define LPS22HB_FIFO_FTH_BIT LPS22HB_BIT(4)
#define LPS22HB_FIFO_OVR_BIT LPS22HB_BIT(3)
#define LPS22HB_DRDY_BIT LPS22HB_BIT(2)
#define LPS22HB_INT_H_L_MASK (uint8_t)0x80
#define LPS22HB_PP_OD_MASK (uint8_t)0x40
#define LPS22HB_FIFO_FULL_MASK (uint8_t)0x20
#define LPS22HB_FIFO_FTH_MASK (uint8_t)0x10
#define LPS22HB_FIFO_OVR_MASK (uint8_t)0x08
#define LPS22HB_DRDY_MASK (uint8_t)0x04
#define LPS22HB_INT_S12_MASK (uint8_t)0x03
#define LPS22HB_INTERRUPT_CFG_REG (uint8_t)0x0B
#define LPS22HB_DIFF_EN_BIT LPS22HB_BIT(3)
#define LPS22HB_LIR_BIT LPS22HB_BIT(2)
#define LPS22HB_PLE_BIT LPS22HB_BIT(1)
#define LPS22HB_PHE_BIT LPS22HB_BIT(0)
#define LPS22HB_AUTORIFP_MASK (uint8_t)0x80
#define LPS22HB_RESET_ARP_MASK (uint8_t)0x40
#define LPS22HB_AUTOZERO_MASK (uint8_t)0x20
#define LPS22HB_RESET_AZ_MASK (uint8_t)0x10
#define LPS22HB_DIFF_EN_MASK (uint8_t)0x08
#define LPS22HB_LIR_MASK (uint8_t)0x04
#define LPS22HB_PLE_MASK (uint8_t)0x02
#define LPS22HB_PHE_MASK (uint8_t)0x01
#define LPS22HB_INTERRUPT_SOURCE_REG (uint8_t)0x25
#define LPS22HB_BOOT_STATUS_BIT LPS22HB_BIT(7)
#define LPS22HB_IA_BIT LPS22HB_BIT(2)
#define LPS22HB_PL_BIT LPS22HB_BIT(1)
#define LPS22HB_PH_BIT LPS22HB_BIT(0)
#define LPS22HB_BOOT_STATUS_MASK (uint8_t)0x80
#define LPS22HB_IA_MASK (uint8_t)0x04
#define LPS22HB_PL_MASK (uint8_t)0x02
#define LPS22HB_PH_MASK (uint8_t)0x01
#define LPS22HB_STATUS_REG (uint8_t)0x27
#define LPS22HB_TOR_BIT LPS22HB_BIT(5)
#define LPS22HB_POR_BIT LPS22HB_BIT(4)
#define LPS22HB_TDA_BIT LPS22HB_BIT(1)
#define LPS22HB_PDA_BIT LPS22HB_BIT(0)
#define LPS22HB_TOR_MASK (uint8_t)0x20
#define LPS22HB_POR_MASK (uint8_t)0x10
#define LPS22HB_TDA_MASK (uint8_t)0x02
#define LPS22HB_PDA_MASK (uint8_t)0x01
#define LPS22HB_PRESS_OUT_XL_REG (uint8_t)0x28
#define LPS22HB_PRESS_OUT_L_REG (uint8_t)0x29
#define LPS22HB_PRESS_OUT_H_REG (uint8_t)0x2A
#define LPS22HB_TEMP_OUT_L_REG (uint8_t)0x2B
#define LPS22HBH_TEMP_OUT_H_REG (uint8_t)0x2C
#define LPS22HB_THS_P_LOW_REG (uint8_t)0x0C
#define LPS22HB_THS_P_HIGH_REG (uint8_t)0x0D
#define LPS22HB_CTRL_FIFO_REG (uint8_t)0x14
#define LPS22HB_FIFO_MODE_MASK (uint8_t)0xE0
#define LPS22HB_WTM_POINT_MASK (uint8_t)0x1F
#define LPS22HB_STATUS_FIFO_REG (uint8_t)0x26
#define LPS22HB_FTH_FIFO_BIT LPS22HB_BIT(7)
#define LPS22HB_OVR_FIFO_BIT LPS22HB_BIT(6)
#define LPS22HB_FTH_FIFO_MASK (uint8_t)0x80
#define LPS22HB_OVR_FIFO_MASK (uint8_t)0x40
#define LPS22HB_LEVEL_FIFO_MASK (uint8_t)0x3F
#define LPS22HB_FIFO_EMPTY (uint8_t)0x00
#define LPS22HB_FIFO_FULL (uint8_t)0x18
#define LPS22HB_RPDS_H_REG (uint8_t)0x19
#define LPS22HB_CLOCK_TREE_CONFIG (uint8_t)0x43
#define LPS22HB_CTE_MASK (uint8_t)0x20
#define LPS22HB_I2C_ADDR1_R (uint8_t)0xB9
#define LPS22HB_I2C_ADDR1_W (uint8_t)0xB8
#define LPS22HB_I2C_ADDR2_R (uint8_t)0xBB
#define LPS22HB_I2C_ADDR2_W (uint8_t)0xBZ
#define LPS22HB_I2C_ADDR1 (0x5C)
#define LPS22HB_I2C_ADDR2 (0x5D)
#define LPS22HB_I2C_ADDR_TRANS(n) ((n) << 1)
#define LPS22HB_I2C_ADDR LPS22HB_I2C_ADDR_TRANS(LPS22HB_I2C_ADDR2)
typedef enum
{
LPS22HB_ODR_ONE_SHOT = (uint8_t)0x00, /*!< Output Data Rate: one shot */
LPS22HB_ODR_1HZ = (uint8_t)0x10, /*!< Output Data Rate: 1Hz */
LPS22HB_ODR_10HZ = (uint8_t)0x20, /*!< Output Data Rate: 10Hz */
LPS22HB_ODR_25HZ = (uint8_t)0x30, /*!< Output Data Rate: 25Hz */
LPS22HB_ODR_50HZ = (uint8_t)0x40, /*!< Output Data Rate: 50Hz */
LPS22HB_ODR_75HZ = (uint8_t)0x50 /*!< Output Data Rate: 75Hz */
} lps22hb_odr_e;
typedef enum
{
LPS22HB_BDU_CONTINUOUS_UPDATE =
(uint8_t)0x00, /*!< Data updated continuously */
LPS22HB_BDU_NO_UPDATE =
(uint8_t)0x02 /*!< Data updated after a read operation */
} lps22hb_bdu_e;
i2c_dev_t lps22hb_ctx = {
.port = 1,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LPS22HB_I2C_ADDR,
};
static lps22hb_odr_e drv_baro_st_lps22hb_hz2odr(int hz)
{
if (hz > 50)
return LPS22HB_ODR_75HZ;
else if (hz > 25)
return LPS22HB_ODR_50HZ;
else if (hz > 10)
return LPS22HB_ODR_25HZ;
else if (hz > 1)
return LPS22HB_ODR_10HZ;
else
return LPS22HB_ODR_1HZ;
}
static int drv_baro_st_lps22hb_validate_id(i2c_dev_t *drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, LPS22HB_WHO_AM_I_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (id_value != value) {
return -1;
}
return 0;
}
static int drv_baro_st_lps22hb_set_power_mode(i2c_dev_t * drv,
dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LPS22HB_RES_CONF_REG, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_ON: {
value &= ~LPS22HB_LCEN_MASK;
value |= LPS22HB_LCEN_POWERON;
ret = sensor_i2c_write(drv, LPS22HB_RES_CONF_REG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
case DEV_POWER_OFF: {
value |= LPS22HB_LCEN_LOWPOWER;
ret = sensor_i2c_write(drv, LPS22HB_RES_CONF_REG, &value,
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
} break;
default:
break;
}
return 0;
}
static int drv_baro_st_lps22hb_set_odr(i2c_dev_t *drv, lps22hb_odr_e odr)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LPS22HB_CTRL_REG1, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value &= ~LPS22HB_ODR_MASK;
value |= (uint8_t)odr;
ret = sensor_i2c_write(drv, LPS22HB_CTRL_REG1, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_baro_st_lps22hb_set_bdu(i2c_dev_t *drv, lps22hb_bdu_e bdu)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LPS22HB_CTRL_REG1, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value &= ~LPS22HB_BDU_MASK;
value |= (uint8_t)bdu;
ret = sensor_i2c_write(drv, LPS22HB_CTRL_REG1, &value, I2C_DATA_LEN,
I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_baro_st_lps22hb_set_default_config(i2c_dev_t *drv)
{
int ret = 0;
ret = drv_baro_st_lps22hb_set_power_mode(drv, DEV_POWER_OFF);
if (unlikely(ret)) {
return ret;
}
ret = drv_baro_st_lps22hb_set_odr(drv, LPS22HB_ODR_25HZ);
if (unlikely(ret)) {
return ret;
}
ret = drv_baro_st_lps22hb_set_bdu(drv, LPS22HB_BDU_NO_UPDATE);
if (unlikely(ret)) {
return ret;
}
/* you also can set the low-pass filter and cut off config here */
return 0;
}
static void drv_baro_st_lps22hb_irq_handle(void)
{
/* no handle so far */
}
static int drv_baro_st_lps22hb_open(void)
{
int ret = 0;
ret = drv_baro_st_lps22hb_set_power_mode(&lps22hb_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_baro_st_lps22hb_close(void)
{
int ret = 0;
ret = drv_baro_st_lps22hb_set_power_mode(&lps22hb_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_baro_st_lps22hb_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t data[3];
barometer_data_t *pdata = (barometer_data_t *)buf;
if (buf == NULL) {
return -1;
}
size = sizeof(barometer_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(&lps22hb_ctx, LPS22HB_PRESS_OUT_XL_REG, &data[0],
I2C_DATA_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lps22hb_ctx, LPS22HB_PRESS_OUT_L_REG, &data[1],
I2C_DATA_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lps22hb_ctx, LPS22HB_PRESS_OUT_H_REG, &data[2],
I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
/* hatch the baro data here*/
for (int i = 0; i < 3; i++) {
pdata->p |= (((uint32_t)data[i]) << (8 * i));
}
/* convert the 2's complement 24 bit to 2's complement 32 bit */
if ((pdata->p & 0x00800000) != 0) {
pdata->p |= 0xFF000000;
}
pdata->p = ((pdata->p) * 100) / 4096;
// pdata->p = pdata->p/100;
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_baro_st_lps22hb_write(const void *buf, size_t len)
{
return 0;
}
static int drv_baro_st_lps22hb_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_ODR_SET: {
lps22hb_odr_e odr = drv_baro_st_lps22hb_hz2odr(arg);
ret = drv_baro_st_lps22hb_set_odr(&lps22hb_ctx, odr);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_SET_POWER: {
ret = drv_baro_st_lps22hb_set_power_mode(&lps22hb_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LPS22HB";
info->range_max = 1260;
info->range_min = 260;
info->unit = pa;
} break;
default:
break;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_baro_st_lps22hb_init(void)
{
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_BARO;
sensor.path = dev_baro_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_baro_st_lps22hb_open;
sensor.close = drv_baro_st_lps22hb_close;
sensor.read = drv_baro_st_lps22hb_read;
sensor.write = drv_baro_st_lps22hb_write;
sensor.ioctl = drv_baro_st_lps22hb_ioctl;
sensor.irq_handle = drv_baro_st_lps22hb_irq_handle;
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
ret = drv_baro_st_lps22hb_validate_id(&lps22hb_ctx, LPS22HB_WHO_AM_I_VAL);
if (unlikely(ret)) {
return -1;
}
/* set the default config for the sensor here */
ret = drv_baro_st_lps22hb_set_default_config(&lps22hb_ctx);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_baro_st_lps22hb_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_baro_st_lps22hb.c
|
C
|
apache-2.0
| 13,144
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
/* ST BARO SENSOR REGISTER MAP */
#define LPS33HB_BIT(x) ((uint8_t)x)
#define LPS33HB_ADDRESS (uint8_t)0xB8
#define LPS33HB_DriverVersion_Major (uint8_t)1
#define LPS33HB_DriverVersion_Minor (uint8_t)0
#define LPS33HB_DriverVersion_Point (uint8_t)0
#define LPS33HB_WHO_AM_I_REG (uint8_t)0x0F
#define LPS33HB_WHO_AM_I_VAL (uint8_t)0xB1
#define LPS33HB_REF_P_XL_REG (uint8_t)0x15
#define LPS33HB_REF_P_L_REG (uint8_t)0x16
#define LPS33HB_REF_P_H_REG (uint8_t)0x17
#define LPS33HB_RES_CONF_REG (uint8_t)0x1A
#define LPS33HB_RES_CONF_REG (uint8_t)0x1A
#define LPS33HB_RES_CONF_REG (uint8_t)0x1A
#define LPS33HB_LCEN_MASK (uint8_t)0x01
#define LPS33HB_LCEN_POWERON (uint8_t)0x00
#define LPS33HB_LCEN_LOWPOWER (uint8_t)0x01
#define LPS33HB_CTRL_REG1 (uint8_t)0x10
#define LPS33HB_ODR_MASK (uint8_t)0x70
#define LPS33HB_LPFP_MASK (uint8_t)0x08
#define LPS33HB_LPFP_CUTOFF_MASK (uint8_t)0x04
#define LPS33HB_BDU_MASK (uint8_t)0x02
#define LPS33HB_SIM_MASK (uint8_t)0x01
#define LPS33HB_LPFP_BIT LPS33HB_BIT(3)
#define LPS33HB_CTRL_REG2 (uint8_t)0x11
#define LPS33HB_BOOT_BIT LPS33HB_BIT(7)
#define LPS33HB_FIFO_EN_BIT LPS33HB_BIT(6)
#define LPS33HB_WTM_EN_BIT LPS33HB_BIT(5)
#define LPS33HB_ADD_INC_BIT LPS33HB_BIT(4)
#define LPS33HB_I2C_BIT LPS33HB_BIT(3)
#define LPS33HB_SW_RESET_BIT LPS33HB_BIT(2)
#define LPS33HB_FIFO_EN_MASK (uint8_t)0x40
#define LPS33HB_WTM_EN_MASK (uint8_t)0x20
#define LPS33HB_ADD_INC_MASK (uint8_t)0x10
#define LPS33HB_I2C_MASK (uint8_t)0x08
#define LPS33HB_ONE_SHOT_MASK (uint8_t)0x01
#define LPS33HB_CTRL_REG3 (uint8_t)0x12
#define LPS33HB_PP_OD_BIT LPS33HB_BIT(6)
#define LPS33HB_FIFO_FULL_BIT LPS33HB_BIT(5)
#define LPS33HB_FIFO_FTH_BIT LPS33HB_BIT(4)
#define LPS33HB_FIFO_OVR_BIT LPS33HB_BIT(3)
#define LPS33HB_DRDY_BIT LPS33HB_BIT(2)
#define LPS33HB_INT_H_L_MASK (uint8_t)0x80
#define LPS33HB_PP_OD_MASK (uint8_t)0x40
#define LPS33HB_FIFO_FULL_MASK (uint8_t)0x20
#define LPS33HB_FIFO_FTH_MASK (uint8_t)0x10
#define LPS33HB_FIFO_OVR_MASK (uint8_t)0x08
#define LPS33HB_DRDY_MASK (uint8_t)0x04
#define LPS33HB_INT_S12_MASK (uint8_t)0x03
#define LPS33HB_INTERRUPT_CFG_REG (uint8_t)0x0B
#define LPS33HB_DIFF_EN_BIT LPS33HB_BIT(3)
#define LPS33HB_LIR_BIT LPS33HB_BIT(2)
#define LPS33HB_PLE_BIT LPS33HB_BIT(1)
#define LPS33HB_PHE_BIT LPS33HB_BIT(0)
#define LPS33HB_AUTORIFP_MASK (uint8_t)0x80
#define LPS33HB_RESET_ARP_MASK (uint8_t)0x40
#define LPS33HB_AUTOZERO_MASK (uint8_t)0x20
#define LPS33HB_RESET_AZ_MASK (uint8_t)0x10
#define LPS33HB_DIFF_EN_MASK (uint8_t)0x08
#define LPS33HB_LIR_MASK (uint8_t)0x04
#define LPS33HB_PLE_MASK (uint8_t)0x02
#define LPS33HB_PHE_MASK (uint8_t)0x01
#define LPS33HB_INTERRUPT_SOURCE_REG (uint8_t)0x25
#define LPS33HB_BOOT_STATUS_BIT LPS33HB_BIT(7)
#define LPS33HB_IA_BIT LPS33HB_BIT(2)
#define LPS33HB_PL_BIT LPS33HB_BIT(1)
#define LPS33HB_PH_BIT LPS33HB_BIT(0)
#define LPS33HB_BOOT_STATUS_MASK (uint8_t)0x80
#define LPS33HB_IA_MASK (uint8_t)0x04
#define LPS33HB_PL_MASK (uint8_t)0x02
#define LPS33HB_PH_MASK (uint8_t)0x01
#define LPS33HB_STATUS_REG (uint8_t)0x27
#define LPS33HB_TOR_BIT LPS33HB_BIT(5)
#define LPS33HB_POR_BIT LPS33HB_BIT(4)
#define LPS33HB_TDA_BIT LPS33HB_BIT(1)
#define LPS33HB_PDA_BIT LPS33HB_BIT(0)
#define LPS33HB_TOR_MASK (uint8_t)0x20
#define LPS33HB_POR_MASK (uint8_t)0x10
#define LPS33HB_TDA_MASK (uint8_t)0x02
#define LPS33HB_PDA_MASK (uint8_t)0x01
#define LPS33HB_PRESS_OUT_XL_REG (uint8_t)0x28
#define LPS33HB_PRESS_OUT_L_REG (uint8_t)0x29
#define LPS33HB_PRESS_OUT_H_REG (uint8_t)0x2A
#define LPS33HB_TEMP_OUT_L_REG (uint8_t)0x2B
#define LPS33HBH_TEMP_OUT_H_REG (uint8_t)0x2C
#define LPS33HB_THS_P_LOW_REG (uint8_t)0x0C
#define LPS33HB_THS_P_HIGH_REG (uint8_t)0x0D
#define LPS33HB_CTRL_FIFO_REG (uint8_t)0x14
#define LPS33HB_FIFO_MODE_MASK (uint8_t)0xE0
#define LPS33HB_WTM_POINT_MASK (uint8_t)0x1F
#define LPS33HB_STATUS_FIFO_REG (uint8_t)0x26
#define LPS33HB_FTH_FIFO_BIT LPS33HB_BIT(7)
#define LPS33HB_OVR_FIFO_BIT LPS33HB_BIT(6)
#define LPS33HB_FTH_FIFO_MASK (uint8_t)0x80
#define LPS33HB_OVR_FIFO_MASK (uint8_t)0x40
#define LPS33HB_LEVEL_FIFO_MASK (uint8_t)0x3F
#define LPS33HB_FIFO_EMPTY (uint8_t)0x00
#define LPS33HB_FIFO_FULL (uint8_t)0x18
#define LPS33HB_RPDS_H_REG (uint8_t)0x19
#define LPS33HB_CLOCK_TREE_CONFIG (uint8_t)0x43
#define LPS33HB_CTE_MASK (uint8_t)0x20
#define LPS33HB_I2C_ADDR1_R (uint8_t)0xB9
#define LPS33HB_I2C_ADDR1_W (uint8_t)0xB8
#define LPS33HB_I2C_ADDR2_R (uint8_t)0xBB
#define LPS33HB_I2C_ADDR2_W (uint8_t)0xBZ
#define LPS33HB_I2C_ADDR1 (0x5C)
#define LPS33HB_I2C_ADDR2 (0x5D)
#define LPS33HB_I2C_ADDR_TRANS(n) ((n)<<1)
#define LPS33HB_I2C_ADDR LPS33HB_I2C_ADDR_TRANS(LPS33HB_I2C_ADDR2)
typedef enum {
LPS33HB_ODR_ONE_SHOT = (uint8_t)0x00, /*!< Output Data Rate: one shot */
LPS33HB_ODR_1HZ = (uint8_t)0x10, /*!< Output Data Rate: 1Hz */
LPS33HB_ODR_10HZ = (uint8_t)0x20, /*!< Output Data Rate: 10Hz */
LPS33HB_ODR_25HZ = (uint8_t)0x30, /*!< Output Data Rate: 25Hz */
LPS33HB_ODR_50HZ = (uint8_t)0x40, /*!< Output Data Rate: 50Hz */
LPS33HB_ODR_75HZ = (uint8_t)0x50 /*!< Output Data Rate: 75Hz */
} lps33hb_odr_e;
typedef enum {
LPS33HB_BDU_CONTINUOUS_UPDATE = (uint8_t)0x00, /*!< Data updated continuously */
LPS33HB_BDU_NO_UPDATE = (uint8_t)0x02 /*!< Data updated after a read operation */
} lps33hb_bdu_e;
i2c_dev_t lps33hb_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LPS33HB_I2C_ADDR,
};
static lps33hb_odr_e drv_baro_st_lps33hb_hz2odr(int hz)
{
if(hz > 50)
return LPS33HB_ODR_75HZ;
else if(hz > 25)
return LPS33HB_ODR_50HZ;
else if(hz > 10)
return LPS33HB_ODR_25HZ;
else if(hz > 1)
return LPS33HB_ODR_10HZ;
else
return LPS33HB_ODR_1HZ;
}
static int drv_baro_st_lps33hb_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, LPS33HB_WHO_AM_I_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_baro_st_lps33hb_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LPS33HB_RES_CONF_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value &= ~LPS33HB_LCEN_MASK;
value |= LPS33HB_LCEN_POWERON;
ret = sensor_i2c_write(drv, LPS33HB_RES_CONF_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value |= LPS33HB_LCEN_LOWPOWER;
ret = sensor_i2c_write(drv, LPS33HB_RES_CONF_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static int drv_baro_st_lps33hb_set_odr(i2c_dev_t* drv, lps33hb_odr_e odr)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LPS33HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value &= ~LPS33HB_ODR_MASK;
value |= (uint8_t)odr;
ret = sensor_i2c_write(drv, LPS33HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_baro_st_lps33hb_enable_lpf(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LPS33HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LPS33HB_LPFP_MASK | LPS33HB_LPFP_CUTOFF_MASK;
ret = sensor_i2c_write(drv, LPS33HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_baro_st_lps33hb_set_bdu(i2c_dev_t* drv, lps33hb_bdu_e bdu)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LPS33HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value &= ~LPS33HB_BDU_MASK;
value |= (uint8_t)bdu;
ret = sensor_i2c_write(drv, LPS33HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_baro_st_lps33hb_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
ret = drv_baro_st_lps33hb_set_power_mode(drv, DEV_POWER_OFF);
if(unlikely(ret)){
return ret;
}
ret = drv_baro_st_lps33hb_set_odr(drv, LPS33HB_ODR_25HZ);
if(unlikely(ret)){
return ret;
}
ret = drv_baro_st_lps33hb_enable_lpf(drv);
if(unlikely(ret)){
return ret;
}
ret = drv_baro_st_lps33hb_set_bdu(drv, LPS33HB_BDU_NO_UPDATE);
if(unlikely(ret)){
return ret;
}
/* you also can set the low-pass filter and cut off config here */
return 0;
}
static void drv_baro_st_lps33hb_irq_handle(void)
{
/* no handle so far */
}
static int drv_baro_st_lps33hb_open(void)
{
int ret = 0;
ret = drv_baro_st_lps33hb_set_power_mode(&lps33hb_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_baro_st_lps33hb_close(void)
{
int ret = 0;
ret = drv_baro_st_lps33hb_set_power_mode(&lps33hb_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_baro_st_lps33hb_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t data[3];
barometer_data_t* pdata = (barometer_data_t*)buf;
if(buf == NULL){
return -1;
}
size = sizeof(barometer_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lps33hb_ctx, LPS33HB_PRESS_OUT_XL_REG, &data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lps33hb_ctx, LPS33HB_PRESS_OUT_L_REG, &data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lps33hb_ctx, LPS33HB_PRESS_OUT_H_REG, &data[2], I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
/* hatch the baro data here*/
for(int i=0; i<3; i++){
pdata->p |= (((uint32_t)data[i]) << (8*i));
}
/* convert the 2's complement 24 bit to 2's complement 32 bit */
if((pdata->p & 0x00800000) != 0){
pdata->p |= 0xFF000000;
}
pdata->p = ((pdata->p)*100)/4096;
//pdata->p = pdata->p/100;
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_baro_st_lps33hb_write(const void *buf, size_t len)
{
return 0;
}
static int drv_baro_st_lps33hb_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
lps33hb_odr_e odr = drv_baro_st_lps33hb_hz2odr(arg);
ret = drv_baro_st_lps33hb_set_odr(&lps33hb_ctx, odr);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_baro_st_lps33hb_set_power_mode(&lps33hb_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LPS33HB";
info->range_max = 1260;
info->range_min = 260;
info->unit = pa;
}break;
default:break;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_baro_st_lps33hb_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_BARO;
sensor.path = dev_baro_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_baro_st_lps33hb_open;
sensor.close = drv_baro_st_lps33hb_close;
sensor.read = drv_baro_st_lps33hb_read;
sensor.write = drv_baro_st_lps33hb_write;
sensor.ioctl = drv_baro_st_lps33hb_ioctl;
sensor.irq_handle = drv_baro_st_lps33hb_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_baro_st_lps33hb_validate_id(&lps33hb_ctx, LPS33HB_WHO_AM_I_VAL);
if(unlikely(ret)){
return -1;
}
/* set the default config for the sensor here */
ret = drv_baro_st_lps33hb_set_default_config(&lps33hb_ctx);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_baro_st_lps33hb_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_baro_st_lps33hb.c
|
C
|
apache-2.0
| 14,059
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
/* ST BARO SENSOR REGISTER MAP */
#define LPS35HB_BIT(x) ((uint8_t)x)
#define LPS35HB_ADDRESS (uint8_t)0xB8
#define LPS35HB_DriverVersion_Major (uint8_t)1
#define LPS35HB_DriverVersion_Minor (uint8_t)0
#define LPS35HB_DriverVersion_Point (uint8_t)0
#define LPS35HB_WHO_AM_I_REG (uint8_t)0x0F
#define LPS35HB_WHO_AM_I_VAL (uint8_t)0xB1
#define LPS35HB_REF_P_XL_REG (uint8_t)0x15
#define LPS35HB_REF_P_L_REG (uint8_t)0x16
#define LPS35HB_REF_P_H_REG (uint8_t)0x17
#define LPS35HB_RES_CONF_REG (uint8_t)0x1A
#define LPS35HB_RES_CONF_REG (uint8_t)0x1A
#define LPS35HB_RES_CONF_REG (uint8_t)0x1A
#define LPS35HB_LCEN_MASK (uint8_t)0x01
#define LPS35HB_LCEN_POWERON (uint8_t)0x00
#define LPS35HB_LCEN_LOWPOWER (uint8_t)0x01
#define LPS35HB_CTRL_REG1 (uint8_t)0x10
#define LPS35HB_ODR_MASK (uint8_t)0x70
#define LPS35HB_LPFP_MASK (uint8_t)0x08
#define LPS35HB_LPFP_CUTOFF_MASK (uint8_t)0x04
#define LPS35HB_BDU_MASK (uint8_t)0x02
#define LPS35HB_SIM_MASK (uint8_t)0x01
#define LPS35HB_LPFP_BIT LPS35HB_BIT(3)
#define LPS35HB_CTRL_REG2 (uint8_t)0x11
#define LPS35HB_BOOT_BIT LPS35HB_BIT(7)
#define LPS35HB_FIFO_EN_BIT LPS35HB_BIT(6)
#define LPS35HB_WTM_EN_BIT LPS35HB_BIT(5)
#define LPS35HB_ADD_INC_BIT LPS35HB_BIT(4)
#define LPS35HB_I2C_BIT LPS35HB_BIT(3)
#define LPS35HB_SW_RESET_BIT LPS35HB_BIT(2)
#define LPS35HB_FIFO_EN_MASK (uint8_t)0x40
#define LPS35HB_WTM_EN_MASK (uint8_t)0x20
#define LPS35HB_ADD_INC_MASK (uint8_t)0x10
#define LPS35HB_I2C_MASK (uint8_t)0x08
#define LPS35HB_ONE_SHOT_MASK (uint8_t)0x01
#define LPS35HB_CTRL_REG3 (uint8_t)0x12
#define LPS35HB_PP_OD_BIT LPS35HB_BIT(6)
#define LPS35HB_FIFO_FULL_BIT LPS35HB_BIT(5)
#define LPS35HB_FIFO_FTH_BIT LPS35HB_BIT(4)
#define LPS35HB_FIFO_OVR_BIT LPS35HB_BIT(3)
#define LPS35HB_DRDY_BIT LPS35HB_BIT(2)
#define LPS35HB_INT_H_L_MASK (uint8_t)0x80
#define LPS35HB_PP_OD_MASK (uint8_t)0x40
#define LPS35HB_FIFO_FULL_MASK (uint8_t)0x20
#define LPS35HB_FIFO_FTH_MASK (uint8_t)0x10
#define LPS35HB_FIFO_OVR_MASK (uint8_t)0x08
#define LPS35HB_DRDY_MASK (uint8_t)0x04
#define LPS35HB_INT_S12_MASK (uint8_t)0x03
#define LPS35HB_INTERRUPT_CFG_REG (uint8_t)0x0B
#define LPS35HB_DIFF_EN_BIT LPS35HB_BIT(3)
#define LPS35HB_LIR_BIT LPS35HB_BIT(2)
#define LPS35HB_PLE_BIT LPS35HB_BIT(1)
#define LPS35HB_PHE_BIT LPS35HB_BIT(0)
#define LPS35HB_AUTORIFP_MASK (uint8_t)0x80
#define LPS35HB_RESET_ARP_MASK (uint8_t)0x40
#define LPS35HB_AUTOZERO_MASK (uint8_t)0x20
#define LPS35HB_RESET_AZ_MASK (uint8_t)0x10
#define LPS35HB_DIFF_EN_MASK (uint8_t)0x08
#define LPS35HB_LIR_MASK (uint8_t)0x04
#define LPS35HB_PLE_MASK (uint8_t)0x02
#define LPS35HB_PHE_MASK (uint8_t)0x01
#define LPS35HB_INTERRUPT_SOURCE_REG (uint8_t)0x25
#define LPS35HB_BOOT_STATUS_BIT LPS35HB_BIT(7)
#define LPS35HB_IA_BIT LPS35HB_BIT(2)
#define LPS35HB_PL_BIT LPS35HB_BIT(1)
#define LPS35HB_PH_BIT LPS35HB_BIT(0)
#define LPS35HB_BOOT_STATUS_MASK (uint8_t)0x80
#define LPS35HB_IA_MASK (uint8_t)0x04
#define LPS35HB_PL_MASK (uint8_t)0x02
#define LPS35HB_PH_MASK (uint8_t)0x01
#define LPS35HB_STATUS_REG (uint8_t)0x27
#define LPS35HB_TOR_BIT LPS35HB_BIT(5)
#define LPS35HB_POR_BIT LPS35HB_BIT(4)
#define LPS35HB_TDA_BIT LPS35HB_BIT(1)
#define LPS35HB_PDA_BIT LPS35HB_BIT(0)
#define LPS35HB_TOR_MASK (uint8_t)0x20
#define LPS35HB_POR_MASK (uint8_t)0x10
#define LPS35HB_TDA_MASK (uint8_t)0x02
#define LPS35HB_PDA_MASK (uint8_t)0x01
#define LPS35HB_PRESS_OUT_XL_REG (uint8_t)0x28
#define LPS35HB_PRESS_OUT_L_REG (uint8_t)0x29
#define LPS35HB_PRESS_OUT_H_REG (uint8_t)0x2A
#define LPS35HB_TEMP_OUT_L_REG (uint8_t)0x2B
#define LPS35HBH_TEMP_OUT_H_REG (uint8_t)0x2C
#define LPS35HB_THS_P_LOW_REG (uint8_t)0x0C
#define LPS35HB_THS_P_HIGH_REG (uint8_t)0x0D
#define LPS35HB_CTRL_FIFO_REG (uint8_t)0x14
#define LPS35HB_FIFO_MODE_MASK (uint8_t)0xE0
#define LPS35HB_WTM_POINT_MASK (uint8_t)0x1F
#define LPS35HB_STATUS_FIFO_REG (uint8_t)0x26
#define LPS35HB_FTH_FIFO_BIT LPS35HB_BIT(7)
#define LPS35HB_OVR_FIFO_BIT LPS35HB_BIT(6)
#define LPS35HB_FTH_FIFO_MASK (uint8_t)0x80
#define LPS35HB_OVR_FIFO_MASK (uint8_t)0x40
#define LPS35HB_LEVEL_FIFO_MASK (uint8_t)0x3F
#define LPS35HB_FIFO_EMPTY (uint8_t)0x00
#define LPS35HB_FIFO_FULL (uint8_t)0x18
#define LPS35HB_RPDS_H_REG (uint8_t)0x19
#define LPS35HB_CLOCK_TREE_CONFIG (uint8_t)0x43
#define LPS35HB_CTE_MASK (uint8_t)0x20
#define LPS35HB_I2C_ADDR1_R (uint8_t)0xB9
#define LPS35HB_I2C_ADDR1_W (uint8_t)0xB8
#define LPS35HB_I2C_ADDR2_R (uint8_t)0xBB
#define LPS35HB_I2C_ADDR2_W (uint8_t)0xBZ
#define LPS35HB_I2C_ADDR1 (0x5C)
#define LPS35HB_I2C_ADDR2 (0x5D)
#define LPS35HB_I2C_ADDR_TRANS(n) ((n)<<1)
#define LPS35HB_I2C_ADDR LPS35HB_I2C_ADDR_TRANS(LPS35HB_I2C_ADDR2)
typedef enum {
LPS35HB_ODR_ONE_SHOT = (uint8_t)0x00, /*!< Output Data Rate: one shot */
LPS35HB_ODR_1HZ = (uint8_t)0x10, /*!< Output Data Rate: 1Hz */
LPS35HB_ODR_10HZ = (uint8_t)0x20, /*!< Output Data Rate: 10Hz */
LPS35HB_ODR_25HZ = (uint8_t)0x30, /*!< Output Data Rate: 25Hz */
LPS35HB_ODR_50HZ = (uint8_t)0x40, /*!< Output Data Rate: 50Hz */
LPS35HB_ODR_75HZ = (uint8_t)0x50 /*!< Output Data Rate: 75Hz */
} lps35hb_odr_e;
typedef enum {
LPS35HB_BDU_CONTINUOUS_UPDATE = (uint8_t)0x00, /*!< Data updated continuously */
LPS35HB_BDU_NO_UPDATE = (uint8_t)0x02 /*!< Data updated after a read operation */
} lps35hb_bdu_e;
i2c_dev_t lps35hb_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LPS35HB_I2C_ADDR,
};
static lps35hb_odr_e drv_baro_st_lps35hb_hz2odr(int hz)
{
if(hz > 50)
return LPS35HB_ODR_75HZ;
else if(hz > 25)
return LPS35HB_ODR_50HZ;
else if(hz > 10)
return LPS35HB_ODR_25HZ;
else if(hz > 1)
return LPS35HB_ODR_10HZ;
else
return LPS35HB_ODR_1HZ;
}
static int drv_baro_st_lps35hb_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, LPS35HB_WHO_AM_I_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_baro_st_lps35hb_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LPS35HB_RES_CONF_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value &= ~LPS35HB_LCEN_MASK;
value |= LPS35HB_LCEN_POWERON;
ret = sensor_i2c_write(drv, LPS35HB_RES_CONF_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value |= LPS35HB_LCEN_LOWPOWER;
ret = sensor_i2c_write(drv, LPS35HB_RES_CONF_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static int drv_baro_st_lps35hb_set_odr(i2c_dev_t* drv, lps35hb_odr_e odr)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LPS35HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value &= ~LPS35HB_ODR_MASK;
value |= (uint8_t)odr;
ret = sensor_i2c_write(drv, LPS35HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_baro_st_lps35hb_enable_lpf(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LPS35HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LPS35HB_LPFP_MASK | LPS35HB_LPFP_CUTOFF_MASK;
ret = sensor_i2c_write(drv, LPS35HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_baro_st_lps35hb_set_bdu(i2c_dev_t* drv, lps35hb_bdu_e bdu)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LPS35HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value &= ~LPS35HB_BDU_MASK;
value |= (uint8_t)bdu;
ret = sensor_i2c_write(drv, LPS35HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_baro_st_lps35hb_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
ret = drv_baro_st_lps35hb_set_power_mode(drv, DEV_POWER_OFF);
if(unlikely(ret)){
return ret;
}
ret = drv_baro_st_lps35hb_set_odr(drv, LPS35HB_ODR_25HZ);
if(unlikely(ret)){
return ret;
}
ret = drv_baro_st_lps35hb_enable_lpf(drv);
if(unlikely(ret)){
return ret;
}
ret = drv_baro_st_lps35hb_set_bdu(drv, LPS35HB_BDU_NO_UPDATE);
if(unlikely(ret)){
return ret;
}
/* you also can set the low-pass filter and cut off config here */
return 0;
}
static void drv_baro_st_lps35hb_irq_handle(void)
{
/* no handle so far */
}
static int drv_baro_st_lps35hb_open(void)
{
int ret = 0;
ret = drv_baro_st_lps35hb_set_power_mode(&lps35hb_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_baro_st_lps35hb_close(void)
{
int ret = 0;
ret = drv_baro_st_lps35hb_set_power_mode(&lps35hb_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_baro_st_lps35hb_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t data[3];
barometer_data_t* pdata = (barometer_data_t*)buf;
if(buf == NULL){
return -1;
}
size = sizeof(barometer_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lps35hb_ctx, LPS35HB_PRESS_OUT_XL_REG, &data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lps35hb_ctx, LPS35HB_PRESS_OUT_L_REG, &data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lps35hb_ctx, LPS35HB_PRESS_OUT_H_REG, &data[2], I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
/* hatch the baro data here*/
for(int i=0; i<3; i++){
pdata->p |= (((uint32_t)data[i]) << (8*i));
}
/* convert the 2's complement 24 bit to 2's complement 32 bit */
if((pdata->p & 0x00800000) != 0){
pdata->p |= 0xFF000000;
}
pdata->p = ((pdata->p)*100)/4096;
//pdata->p = pdata->p/100;
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_baro_st_lps35hb_write(const void *buf, size_t len)
{
return 0;
}
static int drv_baro_st_lps35hb_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
lps35hb_odr_e odr = drv_baro_st_lps35hb_hz2odr(arg);
ret = drv_baro_st_lps35hb_set_odr(&lps35hb_ctx, odr);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_baro_st_lps35hb_set_power_mode(&lps35hb_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LPS35HB";
info->range_max = 1260;
info->range_min = 260;
info->unit = pa;
}break;
default:break;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_baro_st_lps35hb_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_BARO;
sensor.path = dev_baro_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_baro_st_lps35hb_open;
sensor.close = drv_baro_st_lps35hb_close;
sensor.read = drv_baro_st_lps35hb_read;
sensor.write = drv_baro_st_lps35hb_write;
sensor.ioctl = drv_baro_st_lps35hb_ioctl;
sensor.irq_handle = drv_baro_st_lps35hb_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_baro_st_lps35hb_validate_id(&lps35hb_ctx, LPS35HB_WHO_AM_I_VAL);
if(unlikely(ret)){
return -1;
}
/* set the default config for the sensor here */
ret = drv_baro_st_lps35hb_set_default_config(&lps35hb_ctx);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_baro_st_lps35hb_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_baro_st_lps35hb.c
|
C
|
apache-2.0
| 14,058
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_hal.h"
#define LSM6DSL_ACC_MUL 1000
#define MPU9250_GYRO_SENSITIVITY_2000DPS 70000
static int32_t cur_acc_factor = 61;
static int32_t cur_gyro_factor = MPU9250_GYRO_SENSITIVITY_2000DPS;
extern void CAN1_dataReceive(void* rxDataBuffer, uint8_t dataLen);
static int drv_canbus_acc_inv_mpu9250_open(void)
{
return 0;
}
static int drv_canbus_acc_inv_mpu9250_read(void *buf, size_t len)
{
size_t size;
short rxAccData[6] = {0};
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
CAN1_dataReceive(rxAccData, 6);
accel->data[DATA_AXIS_X] = rxAccData[0];
accel->data[DATA_AXIS_Y] = rxAccData[1];
accel->data[DATA_AXIS_Z] = rxAccData[2];
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = (accel->data[DATA_AXIS_X] * cur_acc_factor)/LSM6DSL_ACC_MUL;
accel->data[DATA_AXIS_Y] = (accel->data[DATA_AXIS_Y] * cur_acc_factor)/LSM6DSL_ACC_MUL;
accel->data[DATA_AXIS_Z] = (accel->data[DATA_AXIS_Z] * cur_acc_factor)/LSM6DSL_ACC_MUL;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
int drv_canbus_acc_inv_mpu9250_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = CAN_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_canbus_acc_inv_mpu9250_open;
sensor.close = NULL;
sensor.read = drv_canbus_acc_inv_mpu9250_read;
sensor.write = NULL;
sensor.ioctl = NULL;
sensor.irq_handle = NULL;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
//gyro
static int drv_canbus_gyro_inv_mpu9250_open(void)
{
return 0;
}
static int drv_canbus_gyro_inv_mpu9250_read(void *buf, size_t len)
{
size_t size;
short rxGyroData[6] = {0};
gyro_data_t *gyro = (gyro_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(gyro_data_t);
if(len < size){
return -1;
}
CAN1_dataReceive(rxGyroData, 6);
gyro->data[DATA_AXIS_X] = rxGyroData[3];
gyro->data[DATA_AXIS_Y] = rxGyroData[4];
gyro->data[DATA_AXIS_Z] = rxGyroData[5];
if(cur_gyro_factor != 0){
gyro->data[DATA_AXIS_X] = (gyro->data[DATA_AXIS_X] * cur_gyro_factor);
gyro->data[DATA_AXIS_Y] = (gyro->data[DATA_AXIS_Y] * cur_gyro_factor);
gyro->data[DATA_AXIS_Z] = (gyro->data[DATA_AXIS_Z] * cur_gyro_factor);
}
gyro->timestamp = aos_now_ms();
return (int)size;
}
int drv_canbus_gyro_inv_mpu9250_init(void){
int ret = 0;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = CAN_PORT;
sensor.tag = TAG_DEV_GYRO;
sensor.path = dev_gyro_path;
sensor.open = drv_canbus_gyro_inv_mpu9250_open;
sensor.close = NULL;
sensor.read = drv_canbus_gyro_inv_mpu9250_read;
sensor.write = NULL;
sensor.ioctl = NULL;
sensor.irq_handle = NULL;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_canbus_acc_inv_mpu9250_init);
SENSOR_DRV_ADD(drv_canbus_gyro_inv_mpu9250_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_canbus_inv_mpu9250.c
|
C
|
apache-2.0
| 3,679
|
/*
* Copyright (C) 2018 Sensirion Inc.
* Author: Johannes Winkelmann, jwi@sensirion.com
*
* Driver for SCD30
* Based on SGP30 driver, and arduino-scd library
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define POLYNOMIAL 0x131
#define SCD30_I2C_SLAVE_ADDR 0x61
#define SCD30_ADDR_TRANS(n) ((n) << 1)
#define SCD30_I2C_ADDR SCD30_ADDR_TRANS(SCD30_I2C_SLAVE_ADDR)
#define CMD_CONT_MEASUREMENT_LEN 5
static uint8_t CMD_CONT_MEASUREMENT[CMD_CONT_MEASUREMENT_LEN] = {
0x00, 0x10, 0x00, 0x00, 0x81
};
// Note: in this library, we're hardcoding the interval to 2 seconds
#define CMD_SET_INTERVAL_LEN 5
static uint8_t CMD_SET_INTERVAL[CMD_SET_INTERVAL_LEN] = { 0x46, 0x00,
0x00, 0x01,
0xE3 };
#define CMD_STOP_MEASUREMENT_LEN 2
static const uint8_t CMD_STOP_MEASUREMENT[CMD_STOP_MEASUREMENT_LEN] = { 0x01,
0x04 };
#define CMD_READ_MEASUREMENT_LEN 2
#define CMD_READ_MEASUREMENT_RESULT_LEN 18
static uint8_t CMD_READ_MEASUREMENT[CMD_READ_MEASUREMENT_LEN] = { 0x03,
0x00 };
#define CMD_DATA_READY_LEN 2
#define CMD_DATA_READY_RESULT_LEN 4
static uint8_t CMD_DATA_READY[CMD_DATA_READY_LEN] = { 0x02, 0x02 };
/*
* default port = 3
* Use "GLOBAL_DEFINES += SENSIRION_SCD30_PORT=2" in a Makefile to override
*/
#ifndef SENSIRION_SCD30_PORT
#define SENSIRION_SCD30_PORT 3
#endif /* SENSIRION_SCD30_PORT */
i2c_dev_t scd30_ctx = {
.port = SENSIRION_SCD30_PORT,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr = SCD30_I2C_ADDR,
};
static float g_scd30_most_recent_value = 0;
static uint8_t SCD30_CalcCrc(uint8_t data[], uint8_t nbrOfBytes)
{
uint8_t bit; // bit mask
uint8_t crc = 0xFF; // calculated checksum
uint8_t byteCtr; // byte counter
// calculates 8-Bit checksum with given polynomial
for(byteCtr = 0; byteCtr < nbrOfBytes; byteCtr++)
{
crc ^= (data[byteCtr]);
for(bit = 8; bit > 0; --bit)
{
if(crc & 0x80) crc = (crc << 1) ^ POLYNOMIAL;
else crc = (crc << 1);
}
}
return crc;
}
static float scd30_convert_to_float(uint8_t *data)
{
void* addr;
uint32_t val = (((uint32_t)data[0] << 24) | ((uint32_t)data[1] << 16) |
((uint32_t)data[3] << 8) | ((uint32_t)data[4]));
addr = (void*)(&val);
return *(float *)addr;
}
static void scd30_delay_ms(uint32_t delay_time)
{
// TODO: krhino_task_sleep is currently blocking; therefore, I implemented
// a busy wait loop
//
// krhino_task_sleep(krhino_ms_to_ticks(delay_time));
uint32_t start_ms = aos_now_ms();
while (aos_now_ms() - start_ms < delay_time) {
// idle
}
}
static int drv_scd30_cmd_write(i2c_dev_t* drv, uint8_t* cmd, uint8_t len)
{
return hal_i2c_master_send(drv, drv->config.dev_addr, cmd, len, AOS_WAIT_FOREVER);
}
static int drv_scd30_result_read(i2c_dev_t* drv, uint8_t *data, uint16_t size)
{
if (data == NULL || size == 0)
return -1;
return hal_i2c_master_recv(drv, drv->config.dev_addr, data, size, AOS_WAIT_FOREVER);
}
static int scd30_check_data_ready(i2c_dev_t* drv)
{
bool dataReady = false;
int ret = drv_scd30_cmd_write(drv, CMD_DATA_READY, CMD_DATA_READY_LEN);
if (ret != 0) {
return 1;
} else {
uint8_t buf[CMD_DATA_READY_RESULT_LEN] = { 0 };
ret = drv_scd30_result_read(drv, buf, CMD_DATA_READY_RESULT_LEN);
if (ret != 0) {
return 2;
} else {
dataReady = (buf[1] == 1);
}
}
return dataReady;
}
static int drv_scd30_read_raw_data(i2c_dev_t *drv, integer_data_t *pdata)
{
int ret = 0;
uint8_t data[CMD_READ_MEASUREMENT_RESULT_LEN] = {0};
ret = scd30_check_data_ready(drv);
if (ret) {
ret = drv_scd30_cmd_write(drv, CMD_READ_MEASUREMENT, CMD_READ_MEASUREMENT_LEN);
if (unlikely(ret)) {
return ret;
}
ret = drv_scd30_result_read(drv, data, CMD_READ_MEASUREMENT_RESULT_LEN);
if (unlikely(ret)) {
return ret;
}
g_scd30_most_recent_value = scd30_convert_to_float(data);
}
pdata->data = g_scd30_most_recent_value;
return ret;
}
static int drv_scd30_init_sensor(i2c_dev_t* drv)
{
int ret = 0;
CMD_SET_INTERVAL[4] = SCD30_CalcCrc(&CMD_SET_INTERVAL[2],2);
ret = drv_scd30_cmd_write(drv, CMD_SET_INTERVAL, CMD_SET_INTERVAL_LEN);
if (unlikely(ret)) {
return ret;
}
// workaround for firmware bug in early samples
scd30_delay_ms(100);
CMD_CONT_MEASUREMENT[4] = SCD30_CalcCrc(&CMD_CONT_MEASUREMENT[2],2);
return drv_scd30_cmd_write(drv, CMD_CONT_MEASUREMENT, CMD_CONT_MEASUREMENT_LEN);
}
static void drv_co2_sensirion_scd30_irq_handle(void)
{
/* no handle so far */
}
static int drv_co2_sensirion_scd30_open(void)
{
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_co2_sensirion_scd30_close(void)
{
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_co2_sensirion_scd30_read(void *buf, size_t len)
{
int ret = 0;
const size_t size = sizeof(integer_data_t);
integer_data_t * pdata = (integer_data_t *)buf;
if (buf == NULL){
return -1;
}
if (len < size){
return -1;
}
ret = drv_scd30_read_raw_data(&scd30_ctx, pdata);
if (ret != 0)
return -1;
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_co2_sensirion_scd30_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_co2_sensirion_scd30_ioctl(int cmd, unsigned long arg)
{
switch (cmd) {
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "SCD30";
//info->unit = ppm;
}break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_co2_sensirion_scd30_init(void)
{
int ret = 0;
sensor_obj_t sensor_temp;
memset(&sensor_temp, 0, sizeof(sensor_temp));
ret = drv_scd30_init_sensor(&scd30_ctx);
if (unlikely(ret)) {
return -1;
}
/* fill the sensor_temp obj parameters here */
sensor_temp.tag = TAG_DEV_CO2;
sensor_temp.path = dev_co2_path;
sensor_temp.io_port = I2C_PORT;
sensor_temp.open = drv_co2_sensirion_scd30_open;
sensor_temp.close = drv_co2_sensirion_scd30_close;
sensor_temp.read = drv_co2_sensirion_scd30_read;
sensor_temp.write = drv_co2_sensirion_scd30_write;
sensor_temp.ioctl = drv_co2_sensirion_scd30_ioctl;
sensor_temp.irq_handle = drv_co2_sensirion_scd30_irq_handle;
ret = sensor_create_obj(&sensor_temp);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_co2_sensirion_scd30_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_co2_sensirion_scd30.c
|
C
|
apache-2.0
| 7,278
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define ADPD188GG_I2C_ADDR1 (0x64)
#define ADPD188GG_I2C_ADDR_TRANS(n) ((n)<<1)
#define ADPD188GG_I2C_ADDR ADPD188GG_I2C_ADDR_TRANS(ADPD188GG_I2C_ADDR1)
#define ADPD188GG_STATUS 0x00
#define ADPD188GG_INT_MASK 0x01
#define ADPD188GG_FIFOTHRESH 0x06
#define ADPD188GG_DEVID 0x08
#define ADPD188GG_SW_RESET 0x0F
#define ADPD188GG_MODE 0x10
#define ADPD188GG_SLOT_EN 0x11
#define ADPD188GG_FSAMPLE 0x12
#define ADPD188GG_PDLED_SEL 0x14
#define ADPD188GG_NUM_AVG 0x15
#define ADPD188GG_SLOTA_CH1_OFFSET 0x18
#define ADPD188GG_SLOTA_CH2_OFFSET 0x19
#define ADPD188GG_SLOTA_CH3_OFFSET 0x1A
#define ADPD188GG_SLOTA_CH4_OFFSET 0x1B
#define ADPD188GG_SLOTB_CH1_OFFSET 0x1E
#define ADPD188GG_SLOTB_CH2_OFFSET 0x1F
#define ADPD188GG_SLOTB_CH3_OFFSET 0x20
#define ADPD188GG_SLOTB_CH4_OFFSET 0x21
#define ADPD188GG_LED3_COARSE 0x22
#define ADPD188GG_LED1_COARSE 0x23
#define ADPD188GG_LED2_COARSE 0x24
#define ADPD188GG_LED_FINE 0x25
#define ADPD188GG_SLOTA_LED_PULSE 0x30
#define ADPD188GG_SLOTA_NUMPULSES 0x31
#define ADPD188GG_LED_DISABLE 0x34
#define ADPD188GG_SLOTB_LED_PULSE 0x35
#define ADPD188GG_SLOTB_NUMPULSES 0x36
#define ADPD188GG_SLOTA_AFE_WINDOW 0x39
#define ADPD188GG_SLOTB_AFE_WINDOW 0x3B
#define ADPD188GG_AFE_POWER_CFG1 0x3C
#define ADPD188GG_SLOTB_FLOAT_LED 0x3F
#define ADPD188GG_SLOTA_TIA_CFG 0x42
#define ADPD188GG_SLOTA_AFE_CFG 0x43
#define ADPD188GG_SLOTB_TIA_CFG 0x44
#define ADPD188GG_SLOTB_AFE_CFG 0x45
#define ADPD188GG_SAMPLE_CLOCK 0x4B
#define ADPD188GG_CLK32_ADJUST 0x4D
#define ADPD188GG_XXXX 0x4E
#define ADPD188GG_AFE_POWER_CFG2 0x54
#define ADPD188GG_MATH 0x58
#define ADPD188GG_FLT_CONGIG_B 0x59
#define ADPD188GG_FLT_LED_FIRE 0x5A
#define ADPD188GG_FIFO_ACCESS 0x60
#define ADPD188GG_MEASURE_MODE 0x02
#define ADPD188GG_STAND_BY_MODE 0x00
#define ADPD188GG_DEVICE_ID_VALUE 0x160A
#define ADPD188GG_SOFT_RESET_VALUE 0x01
#define ADPD188GG_DEFAULT_ODR_100HZ 20
i2c_dev_t adpd188gg_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = ADPD188GG_I2C_ADDR,
};
static int drv_ecg_adi_adpd188gg_validate_id(i2c_dev_t* drv, uint16_t id_value)
{
uint16_t value;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, ADPD188GG_DEVID, (uint8_t *)(&value), I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_ecg_adi_adpd188gg_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value[2] = {0x00, ADPD188GG_SOFT_RESET_VALUE};
ret = sensor_i2c_write(drv, ADPD188GG_SW_RESET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_ecg_adi_adpd188gg_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value[2];
int ret = 0;
ret = sensor_i2c_read(drv, ADPD188GG_MODE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value[0]= 0x00;
value[1]= ADPD188GG_MEASURE_MODE;
ret = sensor_i2c_write(drv, ADPD188GG_MODE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value[0] = 0x00;
value[1] = ADPD188GG_STAND_BY_MODE;
ret = sensor_i2c_write(drv, ADPD188GG_MODE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static int drv_ecg_adi_adpd188gg_set_odr(i2c_dev_t* drv, uint16_t odr)
{
int ret = 0;
uint8_t value[2];
uint16_t odr_val = 2000 / odr;
value[0] = (uint8_t) ((odr_val & 0xFF00)>>8);
value[1] = (uint8_t) (odr_val & 0x00FF);
ret = sensor_i2c_write(drv, ADPD188GG_FSAMPLE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x09, value[1] = 0x00;
ret = sensor_i2c_write(drv, ADPD188GG_FIFOTHRESH, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x02, value[1] = 0x20;
ret = sensor_i2c_write(drv, ADPD188GG_NUM_AVG, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_ecg_adi_adpd188gg_set_offset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value[2];
value[0] = 0x30, value[1] = 0x60;
ret = sensor_i2c_write(drv, ADPD188GG_SLOT_EN, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x01, value[1] = 0x14;
ret = sensor_i2c_write(drv, ADPD188GG_PDLED_SEL, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
//SLOT_A_OFFSET
value[0] = 0x1F, value[1] = 0x80;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_CH1_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x3F, value[1] = 0xFF;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_CH2_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x3F, value[1] = 0xFF;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_CH3_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x3F, value[1] = 0xFF;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_CH4_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
//SLOT_B_OFFSET
value[0] = 0x1F, value[1] = 0x80;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_CH1_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x3F, value[1] = 0xFF;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_CH2_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x3F, value[1] = 0xFF;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_CH3_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x3F, value[1] = 0xFF;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_CH4_OFFSET, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_ecg_adi_adpd188gg_set_led_coarse(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value[2];
value[0] = 0x10, value[1] = 0x33;
ret = sensor_i2c_write(drv, ADPD188GG_LED3_COARSE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x10, value[1] = 0x3e;
ret = sensor_i2c_write(drv, ADPD188GG_LED1_COARSE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x10, value[1] = 0x30;
ret = sensor_i2c_write(drv, ADPD188GG_LED2_COARSE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x63, value[1] = 0x0F;
ret = sensor_i2c_write(drv, ADPD188GG_LED_FINE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_ecg_adi_adpd188gg_set_led(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value[2];
value[0] = 0x03, value[1] = 0x19;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_LED_PULSE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x01, value[1] = 0x0B;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_NUMPULSES, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x01, value[1] = 0x00;
ret = sensor_i2c_write(drv, ADPD188GG_LED_DISABLE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x03, value[1] = 0x19;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_LED_PULSE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x08, value[1] = 0x0B;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_NUMPULSES, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_ecg_adi_adpd188gg_set_afe_tia(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value[2];
value[0] = 0x22, value[1] = 0x1C;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_AFE_WINDOW, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x22, value[1] = 0x1C;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_AFE_WINDOW, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x31, value[1] = 0xC6;
ret = sensor_i2c_write(drv, ADPD188GG_AFE_POWER_CFG1, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x1C, value[1] = 0x35;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_TIA_CFG, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0xAD, value[1] = 0xA5;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTA_AFE_CFG, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x1C, value[1] = 0x34;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_TIA_CFG, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0xAD, value[1] = 0xA5;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_AFE_CFG, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x70, value[1] = 0x40;
ret = sensor_i2c_write(drv, ADPD188GG_XXXX, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x0A, value[1] = 0xA0;
ret = sensor_i2c_write(drv, ADPD188GG_AFE_POWER_CFG2, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_ecg_adi_adpd188gg_set_flt(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value[2];
value[0] = 0x03, value[1] = 0x20;
ret = sensor_i2c_write(drv, ADPD188GG_SLOTB_FLOAT_LED, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x00, value[1] = 0x00;
ret = sensor_i2c_write(drv, ADPD188GG_MATH, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x08, value[1] = 0x08;
ret = sensor_i2c_write(drv, ADPD188GG_FLT_CONGIG_B, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x00, value[1] = 0x10;
ret = sensor_i2c_write(drv, ADPD188GG_FLT_LED_FIRE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_ecg_adi_adpd188gg_set_program(i2c_dev_t* drv)
{
uint8_t ret;
uint8_t value[2];
value[0] = 0x00, value[1] = 0x01;
ret = sensor_i2c_write(drv, ADPD188GG_MODE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x80, value[1] = 0xFF;
ret = sensor_i2c_write(drv, ADPD188GG_STATUS, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x00, value[1] = 0xFF;
ret = sensor_i2c_write(drv, ADPD188GG_INT_MASK, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x26, value[1] = 0x9A;
ret = sensor_i2c_write(drv, ADPD188GG_SAMPLE_CLOCK, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value[0] = 0x00, value[1] = 0x90;
ret = sensor_i2c_write(drv, ADPD188GG_CLK32_ADJUST, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static void drv_ecg_adi_adpd188gg_irq_handle(void)
{
/* no handle so far */
}
static int drv_ecg_adi_adpd188gg_open(void)
{
int ret = 0;
ret = drv_ecg_adi_adpd188gg_set_power_mode(&adpd188gg_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_ecg_adi_adpd188gg_close(void)
{
int ret = 0;
ret = drv_ecg_adi_adpd188gg_set_power_mode(&adpd188gg_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_ecg_adi_adpd188gg_read(void *buf, size_t len)
{
int ret = 0;
uint8_t value[2];
size_t size;
ecg_data_t *ecg = (ecg_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(ecg_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&adpd188gg_ctx, ADPD188GG_STATUS, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
ret = sensor_i2c_read(&adpd188gg_ctx, ADPD188GG_FIFO_ACCESS, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
ecg->raw_data = (uint16_t)(value[0]<<8 | value[1]);
ecg->timestamp = aos_now_ms();
return (int)size;
}
static int drv_ecg_adi_adpd188gg_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_ecg_adi_adpd188gg_set_odr(&adpd188gg_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_ecg_adi_adpd188gg_set_power_mode(&adpd188gg_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
info->model = "ADPD188GG";
info->range_max = 150;
info->range_min = 1;
info->unit = bpm;
}break;
default:break;
}
return 0;
}
int drv_ecg_adi_adpd188gg_init(void){
int ret = 0;
uint8_t value[2];
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_HR;
sensor.path = dev_hr_path;
sensor.open = drv_ecg_adi_adpd188gg_open;
sensor.close = drv_ecg_adi_adpd188gg_close;
sensor.read = drv_ecg_adi_adpd188gg_read;
sensor.write = NULL;
sensor.ioctl = drv_ecg_adi_adpd188gg_ioctl;
sensor.irq_handle = drv_ecg_adi_adpd188gg_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_ecg_adi_adpd188gg_validate_id(&adpd188gg_ctx, ADPD188GG_DEVICE_ID_VALUE);
if(unlikely(ret)){
return -1;
}
ret = drv_ecg_adi_adpd188gg_soft_reset(&adpd188gg_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_ecg_adi_adpd188gg_set_program(&adpd188gg_ctx);
if(unlikely(ret)){
return -1;
}
//set odr is 100hz, and will update
ret = drv_ecg_adi_adpd188gg_set_odr(&adpd188gg_ctx, ADPD188GG_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
ret = drv_ecg_adi_adpd188gg_set_offset(&adpd188gg_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_ecg_adi_adpd188gg_set_led_coarse(&adpd188gg_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_ecg_adi_adpd188gg_set_led(&adpd188gg_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_ecg_adi_adpd188gg_set_afe_tia(&adpd188gg_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_ecg_adi_adpd188gg_set_flt(&adpd188gg_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_ecg_adi_adpd188gg_set_power_mode(&adpd188gg_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = sensor_i2c_read(&adpd188gg_ctx, ADPD188GG_MODE, value, I2C_DATA_LEN*2, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_ecg_adi_adpd188gg_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_ecg_adi_adpd188gg.c
|
C
|
apache-2.0
| 16,626
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include "gps_parse.h"
#include "sensor_hal.h"
#ifdef AOS_ATCMD
#include <at/at.h>
#endif
#define GPS_EV_UDATA (0x40)
#define GPS_DEV_READ (1)
#define GPS_DEV_PROC (2)
#define GPS_DEV_SEND (3)
#define SIM868_AT_CMD_SUCCESS_RSP "OK"
#define SIM868_AT_CMD_FAIL_RSP "ERROR"
#define SIM868_AT_CMD_GPS_POWER_OFF "AT+CGNSPWR=0"
#define SIM868_AT_CMD_GPS_POWER_ON "AT+CGNSPWR=1"
#define SIM868_AT_CMD_GPS_POWER_CHECK "AT+CGNSPWR?"
#define SIM868_AT_CMD_GPS_LASTPARSE_SET "AT+CGNSSEQ=\"RMC\""
#define SIM868_AT_CMD_GPS_LASTPARSE_CHECK "AT+CGNSSEQ?"
#define SIM868_AT_CMD_GPS_POSITION_GET "AT+CGNSINF"
#define SIM868_AT_CMD_GPS_INTERVAL_SET "AT+CGNSURC=100"
#define SIM868_AT_CMD_GPS_INTERVAL_CLOSE "AT+CGNSURC=0"
#define SIM868_AT_CMD_GPS_INTERVAL_CHECK "AT+CGNSURC?"
#define SIM868_AT_CMD_GPS_SEND_MODE_SET "AT+CGNSTST=0"
#define SIM868_AT_CMD_GPS_SEND_MODE_CHECK "AT+CGNSTST?"
#define SIM868_GPS_HEAD_LOOP "\n+UGNSINF:"
#define SIM868_GPS_TAIL_LOOP "\r\n"
#define SIM868_GPS_HEAD_POLL "\n+CGNSINF:"
#define SIM868_GPS_TAIL_POLL "\r\n"
#define SIM868_GPS_DEFAULT_CMD_LEN (64)
#define SIM868_GPS_DEFAULT_RSP_LEN (256)
typedef enum{
AT_CB_ON,
AT_CB_OFF,
AT_CB_INVLID,
}at_cb_mode_e;
typedef enum{
NONINF = 0x0000,
UGNSINF = 0x0001,
CGNSINF = 0x0002
}en_gnsinf_type;
typedef struct _gps_sim868
{
char name[GPS_TYPE_NAME_LEN];
int run_stat;
int fix_stat;
gps_time_t utc;
float lat;
float lon;
float elv;
float speed;
float course;
int fix_mode;
int rev1;
float HDOP;
float PDOP;
float VDOP;
int rev2;
int gps_sat_num;
int gnss_sat_num;
int glo_sat_num;
int rev3;
int cn0_max;
float HPA;
float VPA;
} gps_sim868_t;
#define GPS_SIM868_T_PARA_NUM (22)
typedef struct sim868_inernel_data_stu{
gps_sim868_t data_sim868;
}sim868_inernel_data_t;
static sim868_inernel_data_t g_sim868value;
static int g_sim868typebitmap = CGNSINF;
static at_cb_mode_e g_sim868_mode = AT_CB_OFF;
static char g_gps_sim868_addr[GPS_RCV_DATA_LEN];
static gps_data_t g_gps_sim868_data;
static char g_gps_recv_buf[GPS_RCV_DATA_LEN];
extern int at_dev_fd;
static void drv_gps_simcom_sim868_para_set(test_gps_data_t sim868_index[], gps_sim868_t* sim868_para)
{
sim868_index[0].type = GPS_TYPE_STR;
sim868_index[0].addr = &(sim868_para->name[0]);
sim868_index[1].type = GPS_TYPE_INT32;
sim868_index[1].addr = &(sim868_para->run_stat);
sim868_index[2].type = GPS_TYPE_INT32;
sim868_index[2].addr = &(sim868_para->fix_stat);
sim868_index[3].type = GPS_TYPE_UTC;
sim868_index[3].addr = &(sim868_para->utc);
sim868_index[4].type = GPS_TYPE_FLOAT;
sim868_index[4].addr = &(sim868_para->lat);
sim868_index[5].type = GPS_TYPE_FLOAT;
sim868_index[5].addr = &(sim868_para->lon);
sim868_index[6].type = GPS_TYPE_FLOAT;
sim868_index[6].addr = &(sim868_para->elv);
sim868_index[7].type = GPS_TYPE_FLOAT;
sim868_index[7].addr = &(sim868_para->speed);
sim868_index[8].type = GPS_TYPE_FLOAT;
sim868_index[8].addr = &(sim868_para->course);
sim868_index[9].type = GPS_TYPE_INT32;
sim868_index[9].addr = &(sim868_para->fix_mode);
sim868_index[10].type = GPS_TYPE_INT32;
sim868_index[10].addr = &(sim868_para->rev1);
sim868_index[11].type = GPS_TYPE_FLOAT;
sim868_index[11].addr = &(sim868_para->HDOP);
sim868_index[12].type = GPS_TYPE_FLOAT;
sim868_index[12].addr = &(sim868_para->PDOP);
sim868_index[13].type = GPS_TYPE_FLOAT;
sim868_index[13].addr = &(sim868_para->VDOP);
sim868_index[14].type = GPS_TYPE_INT32;
sim868_index[14].addr = &(sim868_para->rev2);
sim868_index[15].type = GPS_TYPE_INT32;
sim868_index[15].addr = &(sim868_para->gps_sat_num);
sim868_index[16].type = GPS_TYPE_INT32;
sim868_index[16].addr = &(sim868_para->gnss_sat_num);
sim868_index[17].type = GPS_TYPE_INT32;
sim868_index[17].addr = &(sim868_para->glo_sat_num);
sim868_index[18].type = GPS_TYPE_INT32;
sim868_index[18].addr = &(sim868_para->rev3);
sim868_index[19].type = GPS_TYPE_INT32;
sim868_index[19].addr = &(sim868_para->cn0_max);
sim868_index[20].type = GPS_TYPE_FLOAT;
sim868_index[20].addr = &(sim868_para->HPA);
sim868_index[21].type = GPS_TYPE_FLOAT;
sim868_index[21].addr = &(sim868_para->VPA);
}
static int drv_gps_simcom_sim868_data_parse(char *str, int len, gps_sim868_t *result)
{
int i = 0;
char data[GPS_RCV_DATA_LEN];
char* prt0;
char* prt1 = &data[0];
test_gps_data_t index[GPS_SIM868_T_PARA_NUM];
if((NULL == str) || (0 == result)){
return -1;
}
memcpy(data,str,len);
data[len] = '\0';
memset(result, 0, sizeof(gps_sim868_t));
drv_gps_simcom_sim868_para_set(index,result);
prt0 = gps_strtok(prt1,&prt1,':',strlen(prt1));
gps_data_conv(prt0,strlen(prt0),index[i].addr,index[i].type);
i++;
for(; (i < 22) &&(NULL!=prt0); i++){
prt0 = gps_strtok(prt1,&prt1,',',strlen(prt1));
gps_data_conv(prt0,strlen(prt0),index[i].addr,index[i].type);
}
return 0;
}
static int drv_gps_simcom_sim868_data_get(gps_sim868_t *result,gps_data_t* pgpsdata)
{
if((NULL == result) || (0 == pgpsdata)){
return -1;
}
pgpsdata->utc.year = result->utc.year;
pgpsdata->utc.mon = result->utc.mon;
pgpsdata->utc.day = result->utc.day;
pgpsdata->utc.hour = result->utc.hour;
pgpsdata->utc.min = result->utc.min;
pgpsdata->utc.sec = result->utc.sec;
pgpsdata->utc.hsec = result->utc.hsec;
pgpsdata->lat = result->lat;
pgpsdata->lon = result->lon;
pgpsdata->elv = result->elv;
return 0;
}
static int drv_gps_simcom_sim868_type_get(const char *buf, int size)
{
static const char *pheads[] = {
"\n+UGNSINF",
"\n+CGNSINF"
};
if(0 == buf){
return -1;
}
if(size < 8)
return NONINF;
else if(0 == memcmp(buf, pheads[0], 5))
return UGNSINF;
else if(0 == memcmp(buf, pheads[1], 5))
return CGNSINF;
return NONINF;
}
UNUSED static bool drv_gps_simcom_sim868_type_filter(const char *buf, int size)
{
int ret = drv_gps_simcom_sim868_type_get(buf,size);
return (g_sim868typebitmap&ret) ? 1:0;
}
static int drv_gps_simcom_sim868_parse(char* str, int len, gps_data_t* pgpsdata)
{
int ret;
int ptype;
ptype = drv_gps_simcom_sim868_type_get(str,len);
switch(ptype){
case UGNSINF:
case CGNSINF:{
ret = drv_gps_simcom_sim868_data_parse(str, len,&(g_sim868value.data_sim868));
if(0 != ret){
return -1;
}
ret = drv_gps_simcom_sim868_data_get(&(g_sim868value.data_sim868), pgpsdata);
if(0 != ret){
return -1;
}
break;
}
default:
break;
}
return 0;
}
static int drv_gps_simcom_sim868_proc(const char* str, gps_data_t* pgpsdata)
{
int ret;
int len;
if(0 == str){
return -1;
}
if(0 == pgpsdata){
return -1;
}
len = strlen(str);
if(len >= GPS_RCV_DATA_LEN){
return -1;
}
ret = drv_gps_simcom_sim868_parse((char*)str,len, pgpsdata);
if(0 != ret){
return -1;
}
return 0;
}
static int drv_gps_simcom_sim868_power_on(at_cb_mode_e mode)
{
int ret = 0;
char rsp[SIM868_GPS_DEFAULT_RSP_LEN] = {0};
if(mode >= AT_CB_INVLID){
LOG("func:%s line: %d para: %d error\n",__func__, __LINE__,mode);
return -1;
}
memset(rsp, 0, SIM868_GPS_DEFAULT_RSP_LEN);
ret = at_send_wait_reply(at_dev_fd, SIM868_AT_CMD_GPS_POWER_ON, strlen(SIM868_AT_CMD_GPS_POWER_ON),
true, NULL, 0, rsp, SIM868_GPS_DEFAULT_RSP_LEN, NULL);
if ((0 != ret) || (strstr(rsp, SIM868_AT_CMD_SUCCESS_RSP) == NULL)) {
LOG("%s %d failed rsp %s errno %d\r\n", __func__, __LINE__, rsp,ret);
return -1;
}
memset(rsp, 0, SIM868_GPS_DEFAULT_RSP_LEN);
ret = at_send_wait_reply(at_dev_fd, SIM868_AT_CMD_GPS_LASTPARSE_SET, strlen(SIM868_AT_CMD_GPS_LASTPARSE_SET),
true, NULL, 0, rsp, SIM868_GPS_DEFAULT_RSP_LEN, NULL);
if ((0 != ret) || (strstr(rsp, SIM868_AT_CMD_SUCCESS_RSP) == NULL)) {
LOG("%s %d failed rsp %s errno %d\r\n", __func__, __LINE__, rsp,ret);
return -1;
}
memset(rsp, 0, SIM868_GPS_DEFAULT_RSP_LEN);
if(AT_CB_OFF == mode){
ret = at_send_wait_reply(at_dev_fd, SIM868_AT_CMD_GPS_INTERVAL_CLOSE, strlen(SIM868_AT_CMD_GPS_INTERVAL_CLOSE),
true, NULL, 0, rsp, SIM868_GPS_DEFAULT_RSP_LEN, NULL);
}
else{
ret = at_send_wait_reply(at_dev_fd, SIM868_AT_CMD_GPS_INTERVAL_SET, strlen(SIM868_AT_CMD_GPS_INTERVAL_SET),
true, NULL, 0, rsp, SIM868_GPS_DEFAULT_RSP_LEN, NULL);
}
if ((0 != ret) || (strstr(rsp, SIM868_AT_CMD_SUCCESS_RSP) == NULL)) {
LOG("%s %d failed rsp %s errno %d\r\n", __func__, __LINE__, rsp,ret);
return -1;
}
memset(rsp, 0, SIM868_GPS_DEFAULT_RSP_LEN);
ret = at_send_wait_reply(at_dev_fd, SIM868_AT_CMD_GPS_SEND_MODE_SET, strlen(SIM868_AT_CMD_GPS_SEND_MODE_SET),
true, NULL, 0, rsp, SIM868_GPS_DEFAULT_RSP_LEN, NULL);
if ((0 != ret) || (strstr(rsp, SIM868_AT_CMD_SUCCESS_RSP) == NULL)) {
LOG("%s %d failed rsp %s errno %d\r\n", __func__, __LINE__, rsp,ret);
return -1;
}
return 0;
}
static int drv_gps_simcom_sim868_power_off()
{
int ret = 0;
char rsp[SIM868_GPS_DEFAULT_RSP_LEN] = {0};
memset(rsp, 0, SIM868_GPS_DEFAULT_RSP_LEN);
ret = at_send_wait_reply(at_dev_fd, SIM868_AT_CMD_GPS_POWER_OFF, strlen(SIM868_AT_CMD_GPS_POWER_OFF),
true, NULL, 0, rsp, SIM868_GPS_DEFAULT_RSP_LEN, NULL);
if ((0 != ret) || (strstr(rsp, SIM868_AT_CMD_SUCCESS_RSP) == NULL)) {
LOG("%s %d failed rsp %s errno %d\r\n", __func__, __LINE__, rsp,ret);
return -1;
}
return 0;
}
static int drv_gps_simcom_sim868_check(void)
{
int ret = 0;
char rsp[SIM868_GPS_DEFAULT_RSP_LEN] = {0};
memset(rsp, 0, SIM868_GPS_DEFAULT_RSP_LEN);
ret = at_send_wait_reply(at_dev_fd, SIM868_AT_CMD_GPS_POWER_CHECK, strlen(SIM868_AT_CMD_GPS_POWER_CHECK),
true, NULL, 0, rsp, SIM868_GPS_DEFAULT_RSP_LEN, NULL);
if ((0 != ret) || (strstr(rsp, SIM868_AT_CMD_SUCCESS_RSP) == NULL)) {
LOG("%s %d failed rsp %s errno %d\r\n", __func__, __LINE__, rsp,ret);
return -1;
}
LOG("GPS power check %s \r\n", rsp);
memset(rsp, 0, SIM868_GPS_DEFAULT_RSP_LEN);
ret = at_send_wait_reply(at_dev_fd, SIM868_AT_CMD_GPS_LASTPARSE_CHECK, strlen(SIM868_AT_CMD_GPS_LASTPARSE_CHECK),
true, NULL, 0, rsp, SIM868_GPS_DEFAULT_RSP_LEN, NULL);
if ((0 != ret) || (strstr(rsp, SIM868_AT_CMD_SUCCESS_RSP) == NULL)) {
LOG("%s %d failed rsp %s errno %d\r\n", __func__, __LINE__, rsp,ret);
return -1;
}
LOG("GPS LAST PARSE %s \r\n", rsp);
memset(rsp, 0, SIM868_GPS_DEFAULT_RSP_LEN);
ret = at_send_wait_reply(at_dev_fd, SIM868_AT_CMD_GPS_POSITION_GET, strlen(SIM868_AT_CMD_GPS_POSITION_GET),
true, NULL, 0, rsp, SIM868_GPS_DEFAULT_RSP_LEN, NULL);
if ((0 != ret) || (strstr(rsp, SIM868_AT_CMD_SUCCESS_RSP) == NULL)) {
LOG("%s %d failed rsp %s errno %d\r\n", __func__, __LINE__, rsp,ret);
return -1;
}
LOG("GPS POSITION %s \r\n", rsp);
memset(rsp, 0, SIM868_GPS_DEFAULT_RSP_LEN);
ret = at_send_wait_reply(at_dev_fd, SIM868_AT_CMD_GPS_INTERVAL_CHECK, strlen(SIM868_AT_CMD_GPS_INTERVAL_CHECK),
true, NULL, 0, rsp, SIM868_GPS_DEFAULT_RSP_LEN, NULL);
if ((0 != ret) || (strstr(rsp, SIM868_AT_CMD_SUCCESS_RSP) == NULL)) {
LOG("%s %d failed rsp %s errno %d\r\n", __func__, __LINE__, rsp,ret);
return -1;
}
LOG("GPS INVERVAL %s \r\n", rsp);
memset(rsp, 0, SIM868_GPS_DEFAULT_RSP_LEN);
ret = at_send_wait_reply(at_dev_fd, SIM868_AT_CMD_GPS_SEND_MODE_CHECK, strlen(SIM868_AT_CMD_GPS_SEND_MODE_CHECK),
true, NULL, 0, rsp, SIM868_GPS_DEFAULT_RSP_LEN, NULL);
if ((0 != ret) || (strstr(rsp, SIM868_AT_CMD_SUCCESS_RSP) == NULL)) {
LOG("%s %d failed rsp %s errno %d\r\n", __func__, __LINE__, rsp,ret);
return -1;
}
LOG("GPS send mode %s \r\n", rsp);
return 0;
}
static int drv_gps_simcom_sim868_config(at_cb_mode_e mode)
{
int ret;
ret = drv_gps_simcom_sim868_power_off();
if(0 != ret)
{
return ret;
}
ret = drv_gps_simcom_sim868_power_on(mode);
if(0 != ret)
{
return ret;
}
return drv_gps_simcom_sim868_check();
}
static int drv_gps_simcom_sim868_poll_read(char* rsp)
{
int ret = 0;
memset(rsp, 0, SIM868_GPS_DEFAULT_RSP_LEN);
ret = at_send_wait_reply(at_dev_fd, SIM868_AT_CMD_GPS_POSITION_GET, strlen(SIM868_AT_CMD_GPS_POSITION_GET),
true, NULL, 0, rsp, SIM868_GPS_DEFAULT_RSP_LEN, NULL);
if ((strstr(rsp, SIM868_AT_CMD_SUCCESS_RSP) == NULL) || (ret != 0)) {
LOG("%s %d failed rsp %s\r\n", __func__, __LINE__, rsp);
return -1;
}
return (int)strlen(rsp);
}
static void drv_gps_simcom_sim868_ood_cb(void *arg, char* buf, int size)
{
int ret;
char* str;
if((NULL == buf) || (0 == size) || (size >= GPS_RCV_DATA_LEN-1)){
return;
}
str = &g_gps_sim868_addr[0];
memcpy(str,(void*)buf,size);
str[size] = '\0';
ret = drv_gps_simcom_sim868_proc(str,&g_gps_sim868_data);
if(unlikely(ret)){
return;
}
}
static int drv_gps_simcom_sim868_ood_cb_reg(at_cb_mode_e mode)
{
if(AT_CB_ON == mode){
at_register_callback(at_dev_fd, SIM868_GPS_HEAD_LOOP, SIM868_GPS_TAIL_LOOP, g_gps_recv_buf, GPS_RCV_DATA_LEN-1, drv_gps_simcom_sim868_ood_cb, NULL);
}
else{
LOG("func : %s no need\n",__func__);
}
return 0;
}
static int drv_gps_simcom_sim868_cb_unreg(void)
{
/*unreg uart callback, ref to at.oob*/
return 0;
}
static int drv_gps_simcom_sim868_open(void)
{
int ret;
ret = drv_gps_simcom_sim868_ood_cb_reg(g_sim868_mode);
if(0 != ret){
return -1;
}
ret = drv_gps_simcom_sim868_config(g_sim868_mode);
if(0 != ret){
return -1;
}
return 0;
}
static int drv_gps_simcom_sim868_close(void)
{
int ret;
ret = drv_gps_simcom_sim868_power_off();
if(0 != ret){
return -1;
}
ret = drv_gps_simcom_sim868_cb_unreg();
if(0 != ret){
return -1;
}
return 0;
}
static int drv_gps_simcom_sim868_data_read()
{
int ret = 0;
char rsp[SIM868_GPS_DEFAULT_RSP_LEN] ={0};
ret = drv_gps_simcom_sim868_poll_read(rsp);
if((ret <= 0) || (ret >= SIM868_GPS_DEFAULT_RSP_LEN))
{
return -1;
}
ret = drv_gps_simcom_sim868_proc(rsp,&g_gps_sim868_data);
if(0 != ret){
return -1;
}
return 0;
}
static int drv_gps_simcom_sim868_read(void *buf, size_t len)
{
int ret;
size_t size = 0;
gps_data_t* gps = buf;
if(0 == buf){
return -1;
}
size = sizeof(gps_data_t);
if(len < size){
return -1;
}
if(AT_CB_OFF == g_sim868_mode){
ret = drv_gps_simcom_sim868_data_read();
if(0 != ret){
return -1;
}
}
memcpy(&(gps->utc),&(g_gps_sim868_data.utc),sizeof(g_gps_sim868_data.utc));
gps->lat = g_gps_sim868_data.lat;
gps->lon = g_gps_sim868_data.lon;
gps->elv = g_gps_sim868_data.elv;
gps->timestamp = aos_now_ms();
return (int)size;
}
static void drv_gps_simcom_sim868_irq_handle(void)
{
/* no handle so far */
}
static int drv_gps_simcom_sim868_ioctl(int cmd, unsigned long arg)
{
return 0;
}
int drv_gps_simcom_sim868_init(void)
{
int ret = 0;
sensor_obj_t gpsobj;
/* fill the gps obj parameters here */
gpsobj.io_port = UART_PORT;
gpsobj.tag = TAG_DEV_GPS;
gpsobj.instance = 0;
gpsobj.path = dev_gps_path;
gpsobj.mode = DEV_POLLING;
gpsobj.open = drv_gps_simcom_sim868_open;
gpsobj.close = drv_gps_simcom_sim868_close;
gpsobj.read = drv_gps_simcom_sim868_read;
gpsobj.write = NULL;
gpsobj.ioctl = drv_gps_simcom_sim868_ioctl;
gpsobj.irq_handle = drv_gps_simcom_sim868_irq_handle;
ret = sensor_create_obj(&gpsobj);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", GPS_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_gps_simcom_sim868_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_gps_simcom_sim868.c
|
C
|
apache-2.0
| 17,396
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
#define LTR91100_I2C_SLAVE_ADDR 0x23
#define LTR91100_CTRL 0x80 /* SW reset control */
#define LTR91100_PS_CTRL 0x81 /* PS operation mode */
#define LTR91100_GS_CTRL 0x82 /* GS operation mode */
#define LTR91100_PS_LED 0x88 /* LED pulse freq, current duty, peak current */
#define LTR91100_PS_MEAS_RATE 0x89 /* measurement rate*/
#define LTR91100_PS_XTALK_NE_LSB 0x8B /* Crosstalk correction on PS north-east detector, lower byte */
#define LTR91100_PS_XTALK_NE_MSB 0xCB /* Crosstalk correction on PS north-east detector, upper byte */
#define LTR91100_PS_XTALK_SW_LSB 0x8C /* Crosstalk correction on PS south-west detector, lower byte */
#define LTR91100_PS_XTALK_SW_MSB 0xCC /* Crosstalk correction on PS south-west detector, upper byte */
#define LTR91100_PS_THRES_UP_LSB 0x8D /* PS interrupt upper threshold, lower byte */
#define LTR91100_PS_THRES_UP_MSB 0xCD /* PS interrupt upper threshold, upper byte */
#define LTR91100_PS_THRES_LOW_LSB 0x8E /* PS interrupt lower threshold, lower byte */
#define LTR91100_PS_THRES_LOW_MSB 0xCE /* PS interrupt lower threshold, upper byte */
#define LTR91100_INTR_PRST 0x8F /* PS interrupt persist setting */
#define LTR91100_GS_LED 0x90 /* GS LED setting */
#define LTR91100_GS_WAIT 0x91 /* GS wait time setting */
#define LTR91100_GS_PRST 0x92 /* GS interrupt persist setting */
#define LTR91100_GS_ENTRY_LSB 0x93 /* GS entry threshold value (1st entry), lower byte */
#define LTR91100_GS_ENTRY_MSB 0xC3 /* GS entry threshold value (1st entry), upper byte */
#define LTR91100_GS_EXIT 0x94 /* GS exit threshold value */
#define LTR91100_GS_GATE 0x95 /* GS gate after the 1st entry */
#define LTR91100_GS_XTALK_N 0x96 /* GS crosstalk correction on north detector */
#define LTR91100_GS_XTALK_S 0x97 /* GS crosstalk correction on south detector */
#define LTR91100_GS_XTALK_E 0x98 /* GS crosstalk correction on east detector */
#define LTR91100_GS_XTALK_W 0x99 /* GS crosstalk correction on west detector */
#define LTR91100_PART_ID 0x9A
#define LTR91100_MANUFAC_ID 0x9B
#define LTR91100_PS_STATUS 0x9D
#define LTR91100_GS_STATUS 0x9E
#define LTR91100_PS_DATA_LSB 0xB0
#define LTR91100_PS_DATA_MSB 0xB1
#define LTR91100_GS_FIFO_ADDR 0xB2 /* GS FIFO address pointer */
#define LTR91100_GS_FIFO_ACCESS_N 0xB3 /* GS north data */
#define LTR91100_GS_FIFO_ACCESS_S 0xB4 /* GS south data */
#define LTR91100_GS_FIFO_ACCESS_E 0xB5 /* GS east data */
#define LTR91100_GS_FIFO_ACCESS_W 0xB6 /* GS west data */
#define LTR91100_ADDR_TRANS(n) ((n) << 1)
#define LTR91100_I2C_ADDR LTR91100_ADDR_TRANS(LTR91100_I2C_SLAVE_ADDR)
#define LTR91100_PART_ID_VAL 0xC1
#define LTR91100_MANUFAC_ID_VAL 0x05
#define LTR91100_CTRL_REG_SW_RESET__POS (1)
#define LTR91100_CTRL_REG_SW_RESET__MSK (0x02)
#define LTR91100_CTRL_REG_SW_RESET__REG (LTR91100_CTRL)
#define LTR91100_PS_CTRL_REG_PS_INT__POS (0)
#define LTR91100_PS_CTRL_REG_PS_INT__MSK (0x01)
#define LTR91100_PS_CTRL_REG_PS_INT__REG (LTR91100_PS_CTRL)
#define LTR91100_PS_CTRL_REG_PS_MODE__POS (1)
#define LTR91100_PS_CTRL_REG_PS_MODE__MSK (0x02)
#define LTR91100_PS_CTRL_REG_PS_MODE__REG (LTR91100_PS_CTRL)
#define LTR91100_PS_CTRL_REG_PS_GAIN__POS (2)
#define LTR91100_PS_CTRL_REG_PS_GAIN__MSK (0x0C)
#define LTR91100_PS_CTRL_REG_PS_GAIN__REG (LTR91100_PS_CTRL)
#define LTR91100_PS_CTRL_REG_PS_OFFSET_EN__POS (4)
#define LTR91100_PS_CTRL_REG_PS_OFFSET_EN__MSK (0x10)
#define LTR91100_PS_CTRL_REG_PS_OFFSET_EN__REG (LTR91100_PS_CTRL)
#define LTR91100_PS_CTRL_REG_NEAR_FAR_STATUS_EN__POS (7)
#define LTR91100_PS_CTRL_REG_NEAR_FAR_STATUS_EN__MSK (0x80)
#define LTR91100_PS_CTRL_REG_NEAR_FAR_STATUS_EN__REG (LTR91100_PS_CTRL)
#define LTR91100_GS_CTRL_REG_GS_INT__POS (0)
#define LTR91100_GS_CTRL_REG_GS_INT__MSK (0x01)
#define LTR91100_GS_CTRL_REG_GS_INT__REG (LTR91100_GS_CTRL)
#define LTR91100_GS_CTRL_REG_GS_MODE__POS (1)
#define LTR91100_GS_CTRL_REG_GS_MODE__MSK (0x02)
#define LTR91100_GS_CTRL_REG_GS_MODE__REG (LTR91100_GS_CTRL)
#define LTR91100_GS_CTRL_REG_GS_GAIN__POS (2)
#define LTR91100_GS_CTRL_REG_GS_GAIN__MSK (0x0C)
#define LTR91100_GS_CTRL_REG_GS_GAIN__REG (LTR91100_GS_CTRL)
#define LTR91100_GS_CTRL_REG_GS_OFFSET_EN__POS (4)
#define LTR91100_GS_CTRL_REG_GS_OFFSET_EN__MSK (0x10)
#define LTR91100_GS_CTRL_REG_GS_OFFSET_EN__REG (LTR91100_GS_CTRL)
#define LTR91100_GS_CTRL_REG_GS_FIFO_RESET__POS (5)
#define LTR91100_GS_CTRL_REG_GS_FIFO_RESET__MSK (0x20)
#define LTR91100_GS_CTRL_REG_GS_FIFO_RESET__REG (LTR91100_GS_CTRL)
#define LTR91100_GS_CTRL_REG_GS_FORCE_START__POS (6)
#define LTR91100_GS_CTRL_REG_GS_FORCE_START__MSK (0x40)
#define LTR91100_GS_CTRL_REG_GS_FORCE_START__REG (LTR91100_GS_CTRL)
#define LTR91100_PS_LED_REG_PLED_DRIVE__POS (0)
#define LTR91100_PS_LED_REG_PLED_DRIVE__MSK (0x03)
#define LTR91100_PS_LED_REG_PLED_DRIVE__REG (LTR91100_PS_LED)
#define LTR91100_PS_LED_REG_PLED_BOOST__POS (2)
#define LTR91100_PS_LED_REG_PLED_BOOST__MSK (0x0C)
#define LTR91100_PS_LED_REG_PLED_BOOST__REG (LTR91100_PS_LED)
#define LTR91100_PS_MEAS_RATE_REG_PULSES__POS (0)
#define LTR91100_PS_MEAS_RATE_REG_PULSES__MSK (0x0F)
#define LTR91100_PS_MEAS_RATE_REG_PULSES__REG (LTR91100_PS_MEAS_RATE)
#define LTR91100_PS_MEAS_RATE_REG_MEAS_RATE__POS (5)
#define LTR91100_PS_MEAS_RATE_REG_MEAS_RATE__MSK (0x0E)
#define LTR91100_PS_MEAS_RATE_REG_MEAS_RATE__REG (LTR91100_PS_MEAS_RATE)
#define LTR91100_INTR_PRST_REG_PS_PERSIST__POS (4)
#define LTR91100_INTR_PRST_REG_PS_PERSIST__MSK (0xF0)
#define LTR91100_INTR_PRST_REG_PS_PERSIST__REG (LTR91100_INTR_PRST)
#define LTR91100_GS_LED_REG_GLED_DRIVE__POS (0)
#define LTR91100_GS_LED_REG_GLED_DRIVE__MSK (0x03)
#define LTR91100_GS_LED_REG_GLED_DRIVE__REG (LTR91100_GS_LED)
#define LTR91100_GS_LED_REG_GLED_BOOST__POS (2)
#define LTR91100_GS_LED_REG_GLED_BOOST__MSK (0x0C)
#define LTR91100_GS_LED_REG_GLED_BOOST__REG (LTR91100_GS_LED)
#define LTR91100_GS_WAIT_REG_PULSES__POS (0)
#define LTR91100_GS_WAIT_REG_PULSES__MSK (0x0F)
#define LTR91100_GS_WAIT_REG_PULSES__REG (LTR91100_GS_WAIT)
#define LTR91100_GS_WAIT_REG_WAIT_TIME__POS (4)
#define LTR91100_GS_WAIT_REG_WAIT_TIME__MSK (0x70)
#define LTR91100_GS_WAIT_REG_WAIT_TIME__REG (LTR91100_GS_WAIT)
#define LTR91100_GS_PRST_REG_GS_PERSIST__POS (2)
#define LTR91100_GS_PRST_REG_GS_PERSIST__MSK (0x0C)
#define LTR91100_GS_PRST_REG_GS_PERSIST__REG (LTR91100_GS_PRST)
#define LTR91100_PS_STATUS_REG_PS_DATA_STATUS__POS (0)
#define LTR91100_PS_STATUS_REG_PS_DATA_STATUS__MSK (0x01)
#define LTR91100_PS_STATUS_REG_PS_DATA_STATUS__REG (LTR91100_PS_STATUS)
#define LTR91100_PS_STATUS_REG_PS_INT_STATUS__POS (1)
#define LTR91100_PS_STATUS_REG_PS_INT_STATUS__MSK (0x02)
#define LTR91100_PS_STATUS_REG_PS_INT_STATUS__REG (LTR91100_PS_STATUS)
#define LTR91100_PS_STATUS_REG_PS_DATA_VALIDITY__POS (2)
#define LTR91100_PS_STATUS_REG_PS_DATA_VALIDITY__MSK (0x04)
#define LTR91100_PS_STATUS_REG_PS_DATA_VALIDITY__REG (LTR91100_PS_STATUS)
#define LTR91100_PS_STATUS_REG_FAR_STATUS__POS (3)
#define LTR91100_PS_STATUS_REG_FAR_STATUS__MSK (0x08)
#define LTR91100_PS_STATUS_REG_FAR_STATUS__REG (LTR91100_PS_STATUS)
#define LTR91100_PS_STATUS_REG_NEAR_STATUS__POS (4)
#define LTR91100_PS_STATUS_REG_NEAR_STATUS__MSK (0x10)
#define LTR91100_PS_STATUS_REG_NEAR_STATUS__REG (LTR91100_PS_STATUS)
#define LTR91100_GS_STATUS_REG_GS_DATA_STATUS__POS (3)
#define LTR91100_GS_STATUS_REG_GS_DATA_STATUS__MSK (0x08)
#define LTR91100_GS_STATUS_REG_GS_DATA_STATUS__REG (LTR91100_GS_STATUS)
#define LTR91100_GS_STATUS_REG_GS_INT_STATUS__POS (4)
#define LTR91100_GS_STATUS_REG_GS_INT_STATUS__MSK (0x10)
#define LTR91100_GS_STATUS_REG_GS_INT_STATUS__REG (LTR91100_GS_STATUS)
#define LTR91100_GS_STATUS_REG_GS_DATA_VALIDITY__POS (5)
#define LTR91100_GS_STATUS_REG_GS_DATA_VALIDITY__MSK (0x20)
#define LTR91100_GS_STATUS_REG_GS_DATA_VALIDITY__REG (LTR91100_GS_STATUS)
#define LTR91100_GS_STATUS_REG_GS_FIFO_FULL__POS (6)
#define LTR91100_GS_STATUS_REG_GS_FIFO_FULL__MSK (0x40)
#define LTR91100_GS_STATUS_REG_GS_FIFO_FULL__REG (LTR91100_GS_STATUS)
#define LTR91100_GS_STATUS_REG_GS_FIFO_EMPTY__POS (7)
#define LTR91100_GS_STATUS_REG_GS_FIFO_EMPTY__MSK (0x80)
#define LTR91100_GS_STATUS_REG_GS_FIFO_EMPTY__REG (LTR91100_GS_STATUS)
#define LTR91100_GET_BITSLICE(regvar, bitname) ((regvar & LTR91100_##bitname##__MSK) >> LTR91100_##bitname##__POS)
#define LTR91100_SET_BITSLICE(regvar, bitname, val) ((regvar & ~LTR91100_##bitname##__MSK) | ((val<<LTR91100_##bitname##__POS)<R91100_##bitname##__MSK))
#define LTR91100_WAIT_TIME_PER_CHECK (10)
#define LTR91100_WAIT_TIME_TOTAL (100)
typedef enum {
LTR91100_SW_RESET_FALSE = 0x00,
LTR91100_SW_RESET_TRUE = 0x01,
} LTR91100_CFG_SW_RESET;
typedef enum {
LTR91100_PS_INT_DISABLE = 0x00,
LTR91100_PS_INT_ENABLE = 0x01,
} LTR91100_CFG_PS_INT;
typedef enum {
LTR91100_PS_STANDBY = 0x00,
LTR91100_PS_ACTIVE = 0x01,
} LTR91100_CFG_PS_MODE;
typedef enum {
LTR91100_PS_GAIN_1X = 0x00,
} LTR91100_CFG_PS_GAIN;
typedef enum {
LTR91100_PS_OFFSET_DISABLE = 0x00,
LTR91100_PS_OFFSET_ENABLE = 0x01,
} LTR91100_CFG_PS_OFFSET_EN;
typedef enum {
LTR91100_NEAR_FAR_STATUS_DISABLE = 0x00,
LTR91100_NEAR_FAR_STATUS_ENABLE = 0x01,
} LTR91100_CFG_NEAR_FAR_STATUS_EN;
typedef enum {
LTR91100_GS_INT_DISABLE = 0x00,
LTR91100_GS_INT_ENABLE = 0x01,
} LTR91100_CFG_GS_INT;
typedef enum {
LTR91100_GS_STANDBY = 0x00,
LTR91100_GS_ACTIVE = 0x01,
} LTR91100_CFG_GS_MODE;
typedef enum {
LTR91100_GS_GAIN_1X = 0x00,
} LTR91100_CFG_GS_GAIN;
typedef enum {
LTR91100_GS_OFFSET_DISABLE = 0x00,
LTR91100_GS_OFFSET_ENABLE = 0x01,
} LTR91100_CFG_GS_OFFSET_EN;
typedef enum {
LTR91100_GS_FIFO_RESET_FALSE = 0x00,
LTR91100_GS_FIFO_RESET_TRUE = 0x01,
} LTR91100_CFG_GS_FIFO_RESET;
typedef enum {
LTR91100_GS_FORCE_START_DISABLE = 0x00,
LTR91100_GS_FORCE_START_ENABLE = 0x01,
} LTR91100_CFG_GS_FORCE_START;
typedef enum {
LTR91100_PLED_DRIVE_100mA = 0x00,
LTR91100_PLED_DRIVE_50mA = 0x01,
LTR91100_PLED_DRIVE_25mA = 0x02,
LTR91100_PLED_DRIVE_12_5mA = 0x03,
} LTR91100_CFG_PLED_DRIVE;
typedef enum {
LTR91100_PLED_BOOST_1X = 0x00,
LTR91100_PLED_BOOST_1_5X = 0x01,
LTR91100_PLED_BOOST_2X = 0x02,
LTR91100_PLED_BOOST_3X = 0x03,
} LTR91100_CFG_PLED_BOOST;
typedef enum {
LTR91100_PS_MEAS_RATE_6_125 = 0x00, /* GS Measurement Repeat Rate = 6.125ms */
LTR91100_PS_MEAS_RATE_50 = 0x01, /* GS Measurement Repeat Rate = 50ms */
LTR91100_PS_MEAS_RATE_100 = 0x02, /* GS Measurement Repeat Rate = 100ms (default) */
LTR91100_PS_MEAS_RATE_200 = 0x03, /* GS Measurement Repeat Rate = 200ms */
LTR91100_PS_MEAS_RATE_400 = 0x04, /* GS Measurement Repeat Rate = 400ms */
LTR91100_PS_MEAS_RATE_800 = 0x05, /* GS Measurement Repeat Rate = 800ms */
LTR91100_PS_MEAS_RATE_12_5 = 0x06, /* GS Measurement Repeat Rate = 12.5ms */
LTR91100_PS_MEAS_RATE_25 = 0x07, /* GS Measurement Repeat Rate = 25ms */
} LTR91100_CFG_PS_MEAS_RATE;
typedef enum {
LTR91100_GLED_DRIVE_100mA = 0x00,
LTR91100_GLED_DRIVE_50mA = 0x01,
LTR91100_GLED_DRIVE_25mA = 0x02,
LTR91100_GLED_DRIVE_12_5mA = 0x03,
} LTR91100_CFG_GLED_DRIVE;
typedef enum {
LTR91100_GLED_BOOST_1X = 0x00,
LTR91100_GLED_BOOST_1_5X = 0x01,
LTR91100_GLED_BOOST_2X = 0x02,
LTR91100_GLED_BOOST_3X = 0x03,
} LTR91100_CFG_GLED_BOOST;
typedef enum {
LTR91100_GS_WAIT_TIME_0ms = 0x00,
LTR91100_GS_WAIT_TIME_2ms = 0x01,
LTR91100_GS_WAIT_TIME_4ms = 0x02,
LTR91100_GS_WAIT_TIME_6ms = 0x03,
LTR91100_GS_WAIT_TIME_10ms = 0x04,
LTR91100_GS_WAIT_TIME_14ms = 0x05,
LTR91100_GS_WAIT_TIME_18ms = 0x06,
LTR91100_GS_WAIT_TIME_22ms = 0x07,
} LTR91100_CFG_GS_WAIT_TIME;
typedef enum {
LTR91100_GS_PERSIST_1st = 0x00, /* 1st gesture exit occurrence will exit gesture detections */
LTR91100_GS_PERSIST_2nd = 0x01, /* 2nd gesture exit occurrence will exit gesture detections */
LTR91100_GS_PERSIST_3rd = 0x02, /* 3rd gesture exit occurrence will exit gesture detections */
LTR91100_GS_PERSIST_4th = 0x03, /* 4th gesture exit occurrence will exit gesture detections */
} LTR91100_CFG_GS_PERSIST;
typedef enum {
LTR91100_PS_DATA_STATUS_OLD = 0x00,
LTR91100_PS_DATA_STATUS_NEW = 0x01,
} LTR91100_CFG_PS_DATA_STATUS;
typedef enum {
LTR91100_PS_INT_STATUS_INACTIVE = 0x00,
LTR91100_PS_INT_STATUS_ACTIVE = 0x01,
} LTR91100_CFG_PS_INT_STATUS;
typedef enum {
LTR91100_PS_DATA_VALID = 0x00,
LTR91100_PS_DATA_INVALID = 0x01,
} LTR91100_CFG_PS_DATA_VALIDITY;
typedef enum {
LTR91100_PS_FAR_STATUS_FALSE = 0x00,
LTR91100_PS_FAR_STATUS_TRUE = 0x01,
} LTR91100_CFG_PS_FAR_STATUS;
typedef enum {
LTR91100_PS_NEAR_STATUS_FALSE = 0x00,
LTR91100_PS_NEAR_STATUS_TRUE = 0x01,
} LTR91100_CFG_PS_NEAR_STATUS;
typedef enum {
LTR91100_GS_DATA_STATUS_OLD = 0x00,
LTR91100_GS_DATA_STATUS_NEW = 0x01,
} LTR91100_CFG_GS_DATA_STATUS;
typedef enum {
LTR91100_GS_INT_STATUS_INACTIVE = 0x00,
LTR91100_GS_INT_STATUS_ACTIVE = 0x01,
} LTR91100_CFG_GS_INT_STATUS;
typedef enum {
LTR91100_GS_DATA_VALID = 0x00,
LTR91100_GS_DATA_INVALID = 0x01,
} LTR91100_CFG_GS_DATA_VALIDITY;
typedef enum {
LTR91100_GS_FIFO_FULL_FALSE = 0x00,
LTR91100_GS_FIFO_FULL_TRUE = 0x01,
} LTR91100_CFG_GS_FIFO_FULL;
typedef enum {
LTR91100_GS_FIFO_EMPTY_TRUE = 0x00,
LTR91100_GS_FIFO_EMPTY_FALSE = 0x01,
} LTR91100_CFG_GS_FIFO_EMPTY;
i2c_dev_t ltr91100_ctx = {
.port = 3,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr = LTR91100_I2C_ADDR,
};
static uint8_t g_init_bitwise = 0;
static int drv_gs_liteon_ltr91100_validate_id(i2c_dev_t* drv, uint8_t part_id, uint8_t manufac_id)
{
int ret = 0;
uint8_t part_id_value = 0;
uint8_t manufac_id_value = 0;
if (drv == NULL) {
return -1;
}
ret = sensor_i2c_read(drv, LTR91100_PART_ID, &part_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, LTR91100_MANUFAC_ID, &manufac_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (part_id_value != part_id || manufac_id_value != manufac_id) {
return -1;
}
return 0;
}
static int drv_gs_liteon_ltr91100_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t ps_dev_mode = 0, gs_dev_mode = 0;
uint8_t ps_value = 0, gs_value = 0;
ret = sensor_i2c_read(drv, LTR91100_PS_CTRL, &ps_value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, LTR91100_GS_CTRL, &gs_value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch (mode) {
case DEV_POWER_OFF:
case DEV_SLEEP:
ps_dev_mode = LTR91100_SET_BITSLICE(ps_value, PS_CTRL_REG_PS_MODE, LTR91100_PS_STANDBY);
gs_dev_mode = LTR91100_SET_BITSLICE(gs_value, GS_CTRL_REG_GS_MODE, LTR91100_GS_STANDBY);
break;
case DEV_POWER_ON:
ps_dev_mode = LTR91100_SET_BITSLICE(ps_value, PS_CTRL_REG_PS_MODE, LTR91100_PS_ACTIVE);
gs_dev_mode = LTR91100_SET_BITSLICE(gs_value, GS_CTRL_REG_GS_MODE, LTR91100_GS_ACTIVE);
break;
default:
return -1;
}
ret = sensor_i2c_write(drv, LTR91100_PS_CTRL, &ps_dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_write(drv, LTR91100_GS_CTRL, &gs_dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
UNUSED static int drv_gs_liteon_ltr91100_is_ready(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR91100_GS_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return 0;
}
ret = (LTR91100_GET_BITSLICE(value, GS_STATUS_REG_GS_DATA_STATUS) == LTR91100_GS_DATA_STATUS_NEW) ? 1 : 0;
return ret;
}
static int drv_gs_liteon_ltr91100_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR91100_PS_CTRL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = LTR91100_SET_BITSLICE(value, PS_CTRL_REG_PS_INT, LTR91100_PS_INT_DISABLE);
value = LTR91100_SET_BITSLICE(value, PS_CTRL_REG_PS_GAIN, LTR91100_PS_GAIN_1X);
value = LTR91100_SET_BITSLICE(value, PS_CTRL_REG_PS_OFFSET_EN, LTR91100_PS_OFFSET_DISABLE);
value = LTR91100_SET_BITSLICE(value, PS_CTRL_REG_NEAR_FAR_STATUS_EN, LTR91100_NEAR_FAR_STATUS_DISABLE);
ret = sensor_i2c_write(drv, LTR91100_PS_CTRL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, LTR91100_GS_CTRL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = LTR91100_SET_BITSLICE(value, GS_CTRL_REG_GS_INT, LTR91100_GS_INT_DISABLE);
value = LTR91100_SET_BITSLICE(value, GS_CTRL_REG_GS_GAIN, LTR91100_GS_GAIN_1X);
value = LTR91100_SET_BITSLICE(value, GS_CTRL_REG_GS_OFFSET_EN, LTR91100_GS_OFFSET_DISABLE);
value = LTR91100_SET_BITSLICE(value, GS_CTRL_REG_GS_FIFO_RESET, LTR91100_GS_FIFO_RESET_FALSE);
value = LTR91100_SET_BITSLICE(value, GS_CTRL_REG_GS_FORCE_START, LTR91100_GS_FORCE_START_ENABLE);
ret = sensor_i2c_write(drv, LTR91100_GS_CTRL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR91100_SET_BITSLICE(value, PS_LED_REG_PLED_DRIVE, LTR91100_PLED_DRIVE_100mA);
value = LTR91100_SET_BITSLICE(value, PS_LED_REG_PLED_BOOST, LTR91100_PLED_BOOST_1X);
ret = sensor_i2c_write(drv, LTR91100_PS_LED, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR91100_SET_BITSLICE(value, PS_MEAS_RATE_REG_PULSES, 10);
value = LTR91100_SET_BITSLICE(value, PS_MEAS_RATE_REG_MEAS_RATE, LTR91100_PS_MEAS_RATE_100);
ret = sensor_i2c_write(drv, LTR91100_PS_MEAS_RATE, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR91100_SET_BITSLICE(value, GS_LED_REG_GLED_DRIVE, LTR91100_GLED_DRIVE_100mA);
value = LTR91100_SET_BITSLICE(value, GS_LED_REG_GLED_BOOST, LTR91100_GLED_BOOST_1X);
ret = sensor_i2c_write(drv, LTR91100_GS_LED, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR91100_SET_BITSLICE(value, GS_WAIT_REG_PULSES, 10);
value = LTR91100_SET_BITSLICE(value, GS_WAIT_REG_WAIT_TIME, LTR91100_GS_WAIT_TIME_0ms);
ret = sensor_i2c_write(drv, LTR91100_GS_WAIT, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static void drv_gs_liteon_ltr91100_irq_handle(void)
{
/* no handle so far */
}
static int drv_gs_liteon_ltr91100_open(void)
{
int ret = 0;
ret = drv_gs_liteon_ltr91100_set_power_mode(<r91100_ctx, DEV_POWER_ON);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_gs_liteon_ltr91100_close(void)
{
int ret = 0;
ret = drv_gs_liteon_ltr91100_set_power_mode(<r91100_ctx, DEV_POWER_OFF);
if (unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_gs_liteon_ltr91100_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t gs_ndata = 0, gs_sdata = 0, gs_edata = 0, gs_wdata = 0;
uint8_t ps_data[2] = { 0 };
proximity_data_t * pdata = (proximity_data_t *) buf;
if (buf == NULL) {
return -1;
}
size = sizeof(proximity_data_t);
if (len < size) {
return -1;
}
ret = sensor_i2c_read(<r91100_ctx, LTR91100_PS_DATA_LSB, &ps_data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r91100_ctx, LTR91100_PS_DATA_MSB, &ps_data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r91100_ctx, LTR91100_GS_FIFO_ACCESS_N, &gs_ndata, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r91100_ctx, LTR91100_GS_FIFO_ACCESS_S, &gs_sdata, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r91100_ctx, LTR91100_GS_FIFO_ACCESS_E, &gs_edata, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(<r91100_ctx, LTR91100_GS_FIFO_ACCESS_W, &gs_wdata, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->present = gs_ndata;
pdata->timestamp = aos_now_ms();
return (int) size;
}
static int drv_gs_liteon_ltr91100_write(const void *buf, size_t len)
{
(void) buf;
(void) len;
return 0;
}
static int drv_gs_liteon_ltr91100_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
ret = drv_gs_liteon_ltr91100_set_power_mode(<r91100_ctx, arg);
if (unlikely(ret)) {
return -1;
}
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *) arg;
info->vendor = DEV_SENSOR_VENDOR_LITEON;
info->model = "LTR91100";
info->unit = cm;
} break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_gs_liteon_ltr91100_init(void)
{
int ret = 0;
sensor_obj_t sensor_gs;
memset(&sensor_gs, 0, sizeof(sensor_gs));
if (!g_init_bitwise) {
ret = drv_gs_liteon_ltr91100_validate_id(<r91100_ctx, LTR91100_PART_ID_VAL, LTR91100_MANUFAC_ID_VAL);
if (unlikely(ret)) {
return -1;
}
}
if (!g_init_bitwise) {
/* fill the sensor_gs obj parameters here */
sensor_gs.tag = TAG_DEV_GS;
sensor_gs.path = dev_gs_path;
sensor_gs.io_port = I2C_PORT;
sensor_gs.mode = DEV_POLLING;
sensor_gs.power = DEV_POWER_OFF;
sensor_gs.open = drv_gs_liteon_ltr91100_open;
sensor_gs.close = drv_gs_liteon_ltr91100_close;
sensor_gs.read = drv_gs_liteon_ltr91100_read;
sensor_gs.write = drv_gs_liteon_ltr91100_write;
sensor_gs.ioctl = drv_gs_liteon_ltr91100_ioctl;
sensor_gs.irq_handle = drv_gs_liteon_ltr91100_irq_handle;
ret = sensor_create_obj(&sensor_gs);
if (unlikely(ret)) {
return -1;
}
ret = drv_gs_liteon_ltr91100_set_default_config(<r91100_ctx);
if (unlikely(ret)) {
return -1;
}
g_init_bitwise = 1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
SENSOR_DRV_ADD(drv_gs_liteon_ltr91100_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_gs_liteon_ltr91100.c
|
C
|
apache-2.0
| 25,727
|
/*
* Copyright (C) 2015-2018 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "sensor_drv_api.h"
#include "sensor_hal.h"
//#include "soc_init.h"
#define PAJ7620_SLAVE_ADDRESS (0x73 << 1)
#define BIT(x) 1 << x
// REGISTER DESCRIPTION
#define PAJ7620_VAL(val, maskbit) ( val << maskbit )
#define PAJ7620_ADDR_BASE 0x00
// REGISTER BANK SELECT
#define PAJ7620_REGITER_BANK_SEL (PAJ7620_ADDR_BASE + 0xEF) //W
// REGISTER BANK 0
#define PAJ7620_ADDR_SUSPEND_CMD (PAJ7620_ADDR_BASE + 0x3) //W
#define PAJ7620_ADDR_GES_PS_DET_MASK_0 (PAJ7620_ADDR_BASE + 0x41) //RW
#define PAJ7620_ADDR_GES_PS_DET_MASK_1 (PAJ7620_ADDR_BASE + 0x42) //RW
#define PAJ7620_ADDR_GES_PS_DET_FLAG_0 (PAJ7620_ADDR_BASE + 0x43) //R
#define PAJ7620_ADDR_GES_PS_DET_FLAG_1 (PAJ7620_ADDR_BASE + 0x44) //R
#define PAJ7620_ADDR_STATE_INDICATOR (PAJ7620_ADDR_BASE + 0x45) //R
#define PAJ7620_ADDR_PS_HIGH_THRESHOLD (PAJ7620_ADDR_BASE + 0x69) //RW
#define PAJ7620_ADDR_PS_LOW_THRESHOLD (PAJ7620_ADDR_BASE + 0x6A) //RW
#define PAJ7620_ADDR_PS_APPROACH_STATE (PAJ7620_ADDR_BASE + 0x6B) //R
#define PAJ7620_ADDR_PS_RAW_DATA (PAJ7620_ADDR_BASE + 0x6C) //R
// REGISTER BANK 1
#define PAJ7620_ADDR_PS_GAIN (PAJ7620_ADDR_BASE + 0x44) //RW
#define PAJ7620_ADDR_IDLE_S1_STEP_0 (PAJ7620_ADDR_BASE + 0x67) //RW
#define PAJ7620_ADDR_IDLE_S1_STEP_1 (PAJ7620_ADDR_BASE + 0x68) //RW
#define PAJ7620_ADDR_IDLE_S2_STEP_0 (PAJ7620_ADDR_BASE + 0x69) //RW
#define PAJ7620_ADDR_IDLE_S2_STEP_1 (PAJ7620_ADDR_BASE + 0x6A) //RW
#define PAJ7620_ADDR_OP_TO_S1_STEP_0 (PAJ7620_ADDR_BASE + 0x6B) //RW
#define PAJ7620_ADDR_OP_TO_S1_STEP_1 (PAJ7620_ADDR_BASE + 0x6C) //RW
#define PAJ7620_ADDR_OP_TO_S2_STEP_0 (PAJ7620_ADDR_BASE + 0x6D) //RW
#define PAJ7620_ADDR_OP_TO_S2_STEP_1 (PAJ7620_ADDR_BASE + 0x6E) //RW
#define PAJ7620_ADDR_OPERATION_ENABLE (PAJ7620_ADDR_BASE + 0x72) //RW
// PAJ7620_REGITER_BANK_SEL
#define PAJ7620_BANK0 PAJ7620_VAL(0,0)
#define PAJ7620_BANK1 PAJ7620_VAL(1,0)
// PAJ7620_ADDR_SUSPEND_CMD
#define PAJ7620_I2C_WAKEUP PAJ7620_VAL(1,0)
#define PAJ7620_I2C_SUSPEND PAJ7620_VAL(0,0)
// PAJ7620_ADDR_OPERATION_ENABLE
#define PAJ7620_ENABLE PAJ7620_VAL(1,0)
#define PAJ7620_DISABLE PAJ7620_VAL(0,0)
enum {
BANK0 = 0,
BANK1,
};
#define GES_RIGHT_FLAG PAJ7620_VAL(1,0)
#define GES_LEFT_FLAG PAJ7620_VAL(1,1)
#define GES_UP_FLAG PAJ7620_VAL(1,2)
#define GES_DOWN_FLAG PAJ7620_VAL(1,3)
#define GES_FORWARD_FLAG PAJ7620_VAL(1,4)
#define GES_BACKWARD_FLAG PAJ7620_VAL(1,5)
#define GES_CLOCKWISE_FLAG PAJ7620_VAL(1,6)
#define GES_COUNT_CLOCKWISE_FLAG PAJ7620_VAL(1,7)
#define GES_WAVE_FLAG PAJ7620_VAL(1,0)
enum {
GESTURE_INVALID = 0,
GESTURE_UP,
GESTURE_DOWN,
GESTURE_LEFT,
GESTURE_RIGHT,
GESTURE_FORWARD,
GESTURE_BACKWARD,
GESTURE_CLOCKWISE,
GESTURE_ANTICLOCKWISE,
GESTURE_WAVE,
};
static unsigned char paj7620_init_regs[][2] = {
{0xEF,0x00},
{0x32,0x29},
{0x33,0x01},
{0x34,0x00},
{0x35,0x01},
{0x36,0x00},
{0x37,0x07},
{0x38,0x17},
{0x39,0x06},
{0x3A,0x12},
{0x3F,0x00},
{0x40,0x02},
{0x41,0xFF},
{0x42,0x01},
{0x46,0x2D},
{0x47,0x0F},
{0x48,0x3C},
{0x49,0x00},
{0x4A,0x1E},
{0x4B,0x00},
{0x4C,0x20},
{0x4D,0x00},
{0x4E,0x1A},
{0x4F,0x14},
{0x50,0x00},
{0x51,0x10},
{0x52,0x00},
{0x5C,0x02},
{0x5D,0x00},
{0x5E,0x10},
{0x5F,0x3F},
{0x60,0x27},
{0x61,0x28},
{0x62,0x00},
{0x63,0x03},
{0x64,0xF7},
{0x65,0x03},
{0x66,0xD9},
{0x67,0x03},
{0x68,0x01},
{0x69,0xC8},
{0x6A,0x40},
{0x6D,0x04},
{0x6E,0x00},
{0x6F,0x00},
{0x70,0x80},
{0x71,0x00},
{0x72,0x00},
{0x73,0x00},
{0x74,0xF0},
{0x75,0x00},
{0x80,0x42},
{0x81,0x44},
{0x82,0x04},
{0x83,0x20},
{0x84,0x20},
{0x85,0x00},
{0x86,0x10},
{0x87,0x00},
{0x88,0x05},
{0x89,0x18},
{0x8A,0x10},
{0x8B,0x01},
{0x8C,0x37},
{0x8D,0x00},
{0x8E,0xF0},
{0x8F,0x81},
{0x90,0x06},
{0x91,0x06},
{0x92,0x1E},
{0x93,0x0D},
{0x94,0x0A},
{0x95,0x0A},
{0x96,0x0C},
{0x97,0x05},
{0x98,0x0A},
{0x99,0x41},
{0x9A,0x14},
{0x9B,0x0A},
{0x9C,0x3F},
{0x9D,0x33},
{0x9E,0xAE},
{0x9F,0xF9},
{0xA0,0x48},
{0xA1,0x13},
{0xA2,0x10},
{0xA3,0x08},
{0xA4,0x30},
{0xA5,0x19},
{0xA6,0x10},
{0xA7,0x08},
{0xA8,0x24},
{0xA9,0x04},
{0xAA,0x1E},
{0xAB,0x1E},
{0xCC,0x19},
{0xCD,0x0B},
{0xCE,0x13},
{0xCF,0x64},
{0xD0,0x21},
{0xD1,0x0F},
{0xD2,0x88},
{0xE0,0x01},
{0xE1,0x04},
{0xE2,0x41},
{0xE3,0xD6},
{0xE4,0x00},
{0xE5,0x0C},
{0xE6,0x0A},
{0xE7,0x00},
{0xE8,0x00},
{0xE9,0x00},
{0xEE,0x07},
{0xEF,0x01},
{0x00,0x1E},
{0x01,0x1E},
{0x02,0x0F},
{0x03,0x10},
{0x04,0x02},
{0x05,0x00},
{0x06,0xB0},
{0x07,0x04},
{0x08,0x0D},
{0x09,0x0E},
{0x0A,0x9C},
{0x0B,0x04},
{0x0C,0x05},
{0x0D,0x0F},
{0x0E,0x02},
{0x0F,0x12},
{0x10,0x02},
{0x11,0x02},
{0x12,0x00},
{0x13,0x01},
{0x14,0x05},
{0x15,0x07},
{0x16,0x05},
{0x17,0x07},
{0x18,0x01},
{0x19,0x04},
{0x1A,0x05},
{0x1B,0x0C},
{0x1C,0x2A},
{0x1D,0x01},
{0x1E,0x00},
{0x21,0x00},
{0x22,0x00},
{0x23,0x00},
{0x25,0x01},
{0x26,0x00},
{0x27,0x39},
{0x28,0x7F},
{0x29,0x08},
{0x30,0x03},
{0x31,0x00},
{0x32,0x1A},
{0x33,0x1A},
{0x34,0x07},
{0x35,0x07},
{0x36,0x01},
{0x37,0xFF},
{0x38,0x36},
{0x39,0x07},
{0x3A,0x00},
{0x3E,0xFF},
{0x3F,0x00},
{0x40,0x77},
{0x41,0x40},
{0x42,0x00},
{0x43,0x30},
{0x44,0xA0},
{0x45,0x5C},
{0x46,0x00},
{0x47,0x00},
{0x48,0x58},
{0x4A,0x1E},
{0x4B,0x1E},
{0x4C,0x00},
{0x4D,0x00},
{0x4E,0xA0},
{0x4F,0x80},
{0x50,0x00},
{0x51,0x00},
{0x52,0x00},
{0x53,0x00},
{0x54,0x00},
{0x57,0x80},
{0x59,0x10},
{0x5A,0x08},
{0x5B,0x94},
{0x5C,0xE8},
{0x5D,0x08},
{0x5E,0x3D},
{0x5F,0x99},
{0x60,0x45},
{0x61,0x40},
{0x63,0x2D},
{0x64,0x02},
{0x65,0x96},
{0x66,0x00},
{0x67,0x97},
{0x68,0x01},
{0x69,0xCD},
{0x6A,0x01},
{0x6B,0xB0},
{0x6C,0x04},
{0x6D,0x2C},
{0x6E,0x01},
{0x6F,0x32},
{0x71,0x00},
{0x72,0x01},
{0x73,0x35},
{0x74,0x00},
{0x75,0x33},
{0x76,0x31},
{0x77,0x01},
{0x7C,0x84},
{0x7D,0x03},
{0x7E,0x01},
};
static i2c_dev_t paj7620_client = {
.port = 3,
.config.dev_addr = PAJ7620_SLAVE_ADDRESS,
};
uint8_t gesture_action;
static int paj7620_reg_write(uint8_t reg, uint8_t val)
{
if (sensor_i2c_write(&paj7620_client, reg, &val, 1, 200)) {
printf("%s: write failed !\n", __func__);
return 1;
}
return 0;
}
static int paj7620_reg_read(uint8_t reg, uint8_t *val)
{
if (sensor_i2c_read(&paj7620_client, reg, val, 1, 200)) {
//printf("%s: read failed !\n", __func__);
return 1;
}
return 0;
}
static int paj7620_bank_select(int bank)
{
switch (bank) {
case BANK0:
paj7620_reg_write(PAJ7620_REGITER_BANK_SEL, PAJ7620_BANK0);
break;
case BANK1:
paj7620_reg_write(PAJ7620_REGITER_BANK_SEL, PAJ7620_BANK1);
break;
default:
break;
}
return 0;
}
static uint8_t paj7620_gesture(uint8_t gesture)
{
uint8_t data = 0;
uint8_t data1 = 0;
uint8_t rc = 0;
switch (gesture) {
case GES_RIGHT_FLAG:
aos_msleep(1);
paj7620_reg_read(PAJ7620_ADDR_GES_PS_DET_FLAG_0, &data);
if (data == GES_FORWARD_FLAG) {
rc = GESTURE_FORWARD;
aos_msleep(1);
} else if (data == GES_BACKWARD_FLAG) {
rc = GESTURE_BACKWARD;
aos_msleep(1);
} else {
rc = GESTURE_RIGHT;
}
break;
case GES_LEFT_FLAG:
aos_msleep(1);
paj7620_reg_read(PAJ7620_ADDR_GES_PS_DET_FLAG_0, &data);
if (data == GES_FORWARD_FLAG) {
rc = GESTURE_FORWARD;
aos_msleep(1);
} else if(data == GES_BACKWARD_FLAG) {
rc = GESTURE_BACKWARD;
aos_msleep(1);
} else {
rc = GESTURE_LEFT;
}
break;
case GES_UP_FLAG:
aos_msleep(1);
paj7620_reg_read(PAJ7620_ADDR_GES_PS_DET_FLAG_0, &data);
if (data == GES_FORWARD_FLAG) {
rc = GESTURE_FORWARD;
aos_msleep(1);
} else if(data == GES_BACKWARD_FLAG) {
rc = GESTURE_BACKWARD;
aos_msleep(1);
} else {
rc = GESTURE_UP;
}
break;
case GES_DOWN_FLAG:
aos_msleep(1);
paj7620_reg_read(PAJ7620_ADDR_GES_PS_DET_FLAG_0, &data);
if(data == GES_FORWARD_FLAG) {
rc = GESTURE_FORWARD;
aos_msleep(1);
} else if(data == GES_BACKWARD_FLAG) {
rc = GESTURE_BACKWARD;
aos_msleep(1);
} else {
rc = GESTURE_DOWN;
}
break;
case GES_FORWARD_FLAG:
rc = GESTURE_FORWARD;
aos_msleep(1);
break;
case GES_BACKWARD_FLAG:
rc = GESTURE_BACKWARD;
aos_msleep(1);
break;
case GES_CLOCKWISE_FLAG:
rc = GESTURE_CLOCKWISE;
break;
case GES_COUNT_CLOCKWISE_FLAG:
rc = GESTURE_ANTICLOCKWISE;
break;
default:
paj7620_reg_read(PAJ7620_ADDR_GES_PS_DET_FLAG_1, &data1);
if (data1 == GES_WAVE_FLAG)
rc = GESTURE_WAVE;
break;
}
return rc;
}
int paj7620_poll(void)
{
uint8_t gesture = 0;
while (1) {
aos_msleep(5);
paj7620_reg_read(PAJ7620_ADDR_GES_PS_DET_FLAG_0, &gesture);
paj7620_gesture(gesture);
}
return 0;
}
static uint8_t paj7620_gesture_get(uint8_t gesture)
{
uint8_t data = 0;
uint8_t data1 = 0;
uint8_t rc = 0;
switch (gesture) {
case GES_RIGHT_FLAG:
aos_msleep(1);
paj7620_reg_read(PAJ7620_ADDR_GES_PS_DET_FLAG_0, &data);
if (data == GES_FORWARD_FLAG) {
rc = GS_SENSOR_INVALID;
aos_msleep(1);
} else if (data == GES_BACKWARD_FLAG) {
rc = GS_SENSOR_INVALID;
aos_msleep(1);
} else {
rc = GS_SENSOR_RIGHT;
}
break;
case GES_LEFT_FLAG:
aos_msleep(1);
paj7620_reg_read(PAJ7620_ADDR_GES_PS_DET_FLAG_0, &data);
if (data == GES_FORWARD_FLAG) {
rc = GS_SENSOR_INVALID;
aos_msleep(1);
} else if(data == GES_BACKWARD_FLAG) {
rc = GS_SENSOR_INVALID;
aos_msleep(1);
} else {
rc = GS_SENSOR_LEFT;
}
break;
case GES_UP_FLAG:
aos_msleep(1);
paj7620_reg_read(PAJ7620_ADDR_GES_PS_DET_FLAG_0, &data);
if (data == GES_FORWARD_FLAG) {
rc = GS_SENSOR_INVALID;
aos_msleep(1);
} else if(data == GES_BACKWARD_FLAG) {
rc = GS_SENSOR_INVALID;
aos_msleep(1);
} else {
rc = GS_SENSOR_UP;
}
break;
case GES_DOWN_FLAG:
aos_msleep(1);
paj7620_reg_read(PAJ7620_ADDR_GES_PS_DET_FLAG_0, &data);
if(data == GES_FORWARD_FLAG) {
rc = GS_SENSOR_INVALID;
aos_msleep(1);
} else if(data == GES_BACKWARD_FLAG) {
rc = GS_SENSOR_INVALID;
aos_msleep(1);
} else {
rc = GS_SENSOR_DOWN;
}
break;
case GES_FORWARD_FLAG:
rc = GS_SENSOR_INVALID;
aos_msleep(1);
break;
case GES_BACKWARD_FLAG:
rc = GS_SENSOR_INVALID;
aos_msleep(1);
break;
case GES_CLOCKWISE_FLAG:
rc = GS_SENSOR_CLOCKWISE;
break;
case GES_COUNT_CLOCKWISE_FLAG:
rc = GS_SENSOR_ANTICLOCKWISE;
break;
default:
paj7620_reg_read(PAJ7620_ADDR_GES_PS_DET_FLAG_1, &data1);
if (data1 == GES_WAVE_FLAG)
rc = GS_SENSOR_WAVE;
break;
}
return rc;
}
static int drv_gs_pixart_paj7620_open(void)
{
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_gs_pixart_paj7620_close(void)
{
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_gs_pixart_paj7620_read(void *buf, size_t len)
{
uint8_t gesture = 0;
size_t size = sizeof(gs_data_t);
gs_data_t* gs_data = (gs_data_t*)buf;
if(NULL == buf){
return -1;
}
if(len <= size){
return -1;
}
paj7620_reg_read(PAJ7620_ADDR_GES_PS_DET_FLAG_0, &gesture);
gs_data->gs_type = (gs_type_e)paj7620_gesture_get(gesture);
gs_data->timestamp = aos_now_ms();
return (int) size;
}
static int drv_gs_pixart_paj7620_write(const void *buf, size_t len)
{
(void) buf;
(void) len;
return 0;
}
static int drv_gs_pixart_paj7620_ioctl(int cmd, unsigned long arg)
{
switch (cmd) {
case SENSOR_IOCTL_SET_POWER: {
} break;
case SENSOR_IOCTL_GET_INFO: {
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *) arg;
info->model = "paj7620";
} break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_gs_pixart_paj7620_init(void)
{
int ret;
uint8_t data0 = 1;
uint8_t data1 = 2;
int i;
sensor_obj_t sensor;
memset(&sensor, 0, sizeof(sensor));
/* fill the sensor_gs obj parameters here */
sensor.tag = TAG_DEV_GS;
sensor.path = dev_gs_path;
sensor.io_port = I2C_PORT;
sensor.mode = DEV_POLLING;
sensor.power = DEV_POWER_OFF;
sensor.open = drv_gs_pixart_paj7620_open;
sensor.close = drv_gs_pixart_paj7620_close;
sensor.read = drv_gs_pixart_paj7620_read;
sensor.write = drv_gs_pixart_paj7620_write;
sensor.ioctl = drv_gs_pixart_paj7620_ioctl;
sensor.irq_handle = NULL;
ret = sensor_create_obj(&sensor);
if (unlikely(ret)) {
return -1;
}
aos_msleep(10);
paj7620_bank_select(BANK0);
paj7620_bank_select(BANK0);
paj7620_reg_read(0, &data0);
paj7620_reg_read(1, &data1);
if (data0 != 0x20 || data1 != 0x76) {
printf("%s: paj7620 check failed!\n", __func__);
return 1;
}
if (data0 == 0x20)
printf("%s: paj7620 wakeup\n", __func__);
for (i = 0; i < sizeof(paj7620_init_regs)/sizeof(paj7620_init_regs[0]); i++) {
paj7620_reg_write(paj7620_init_regs[i][0], paj7620_init_regs[i][1]);
}
paj7620_bank_select(BANK0);
aos_msleep(100);
uint8_t gesture;
paj7620_reg_read(PAJ7620_ADDR_GES_PS_DET_FLAG_0, &gesture);
paj7620_reg_read(PAJ7620_ADDR_GES_PS_DET_FLAG_1, &gesture);
printf("%s: paj7620 init success\n", __func__);
return 0;
}
SENSOR_DRV_ADD(drv_gs_pixart_paj7620_init);
|
YifuLiu/AliOS-Things
|
components/sensor/drv/drv_gs_pixart_paj7620.c
|
C
|
apache-2.0
| 15,478
|