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
|
|---|---|---|---|---|---|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
`HaaS Python as608`
====================================================
A driver for the AS608 finger print module
* Author(s): HaaS Group
Implementation Notes
--------------------
**Hardware:**
* HaaS Python as608
https://haas.iot.aliyun.com/solution/detail/hardware
**Software and Dependencies:**
* HaaS Python API documents:
https://haas.iot.aliyun.com/haasapi/index.html#/
* HaaS Python Driver Libraries:
https://github.com/alibaba/AliOS-Things/tree/master/haas_lib_bundles/python/libraries
"""
import utime
import ustruct
from micropython import const
from driver import UART
# check passwoard: 4 byte 0000
cmdVerifyPasswoard = b'\xEF\x01\xFF\xFF\xFF\xFF\x01\x00\x07\x13\x00\x00\x00\x00\x00\x1B'
# 采集图片
cmdGetImage = b'\xEF\x01\xFF\xFF\xFF\xFF\x01\x00\x03\x01\x00\x05'
# 生成指纹图片对应的特征值
cmdImage2Char = b'\xEF\x01\xFF\xFF\xFF\xFF'
cmdSaveimage2Char = b'\x01\x00\x04\x02'
# 创建指纹模板
cmdCreateModel = b'\xEF\x01\xFF\xFF\xFF\xFF\x01\x00\x03\x05\x00\x09'
# 保存指纹模板
cmdStoreModel = b'\xEF\x01\xFF\xFF\xFF\xFF'
cmdSaveStoreModel = b'\x01\x00\x06\x06\x01'
#指纹匹配指令
cmdMatch = b'\xEF\x01\xFF\xFF\xFF\xFF\x01\x00\x03\x03\x00\x07'
#指纹搜索指令
cmdSearch = b'\xEF\x01\xFF\xFF\xFF\xFF\x01\x00\x08\x04\x01\x00\x00\x00\x7F\x00\x8D'
# 读取索引表
cmdReadIndexTable = b'\xEF\x01\xFF\xFF\xFF\xFF\x01\x00\x04\x1F\x00\x00\x24'
#删除指纹记录
cmdDeleteModel = b'\xEF\x01\xFF\xFF\xFF\xFF'
cmdSaveDeleteModel = b'\x01\x00\x07\x0c\x00'
# 清除数据库中的指纹信息
cmdEmptyDatabase = b'\xEF\x01\xFF\xFF\xFF\xFF\x01\x00\x03\x0D\x00\x11'
# 获取指纹图片信息
cmdGetFPImage = b'\xEF\x01\xFF\xFF\xFF\xFF\x01\x00\x03\x0a\x00\x0e'
# 获取指纹特征值信息
cmdGetFPChar = b'\xEF\x01\xFF\xFF\xFF\xFF\x01\x00\x04\x08\x00\x00\x00'
SUCCESS = const(0)
FAIL = const(-1)
NO_FINGER = const(2)
DATABASE_CAPABILITY = const(300)
CMD_RSP_TIMEOUT_MS = const(500) # 单条指令超时时间
CMD_RSP_WAIT_TIME_MS = const(10) # 目前指令的response最多44个byte，44*(1+8+2+1)/57600 ~= 9.9ms
class AS608:
def __init__(self, *args, **kargs):
self._uartDev = None
if not isinstance(args[0], UART):
raise ValueError("parameter is not an UART object")
#实例化和AS608通信所用串口
self._uartDev=args[0]
#接收指令执行结果
def getCmdResult(self):
cnt = 0
len = 12
rx = bytearray(len * b'5')
# 检查UART接收缓冲区中是否有足够的数据
l = self._uartDev.any()
while(l < len):
# print('uart.any:', l)
cnt += 1
if cnt > CMD_RSP_TIMEOUT_MS/CMD_RSP_WAIT_TIME_MS: # 等待超时时间后退出
break
utime.sleep_ms(CMD_RSP_WAIT_TIME_MS)
l = self._uartDev.any()
self._uartDev.read(rx)
return rx
def matchCmdResult(self):
cnt = 0
len = 14
rx = bytearray(len * b'5')
# 检查UART接收缓冲区中是否有足够的数据
l = self._uartDev.any()
while(l < len):
# print('uart.any:', l)
cnt += 1
if cnt > CMD_RSP_TIMEOUT_MS/CMD_RSP_WAIT_TIME_MS: # 等待超时时间后退出
break
utime.sleep_ms(CMD_RSP_WAIT_TIME_MS)
l = self._uartDev.any()
self._uartDev.read(rx)
return rx
#接收指纹图像数据
def getLongResult(self):
cnt = 0
rx = bytearray(0)
# 检查UART接收缓冲区中是否有足够的数据
while(cnt < 5):
utime.sleep_ms(30)
buf = bytearray(512)
l = self._uartDev.any()
# 检查UART中是否有数据
if l > 0:
# 从UART读取数据
l = self._uartDev.read(buf)
#print(l)
if l > 0:
# 合并UART返回结果
rx += buf[0:l]
cnt = 0
else:
cnt += 1
return rx
# 接收搜索指令结果
def searchCmdResult(self):
cnt = 0
len = 16
rx = bytearray(len * b'5')
l = self._uartDev.any()
while(l < len):
# print('uart.any:', l)
cnt += 1
if cnt > CMD_RSP_TIMEOUT_MS/CMD_RSP_WAIT_TIME_MS: # 等待超时时间后退出
break
utime.sleep_ms(CMD_RSP_WAIT_TIME_MS)
l = self._uartDev.any()
self._uartDev.read(rx)
return rx
# 接收索引表结果
def readIndexCmdResult(self):
cnt = 0
len = 44
rx = bytearray(len * b'5')
l = self._uartDev.any()
while(l < len):
# print('uart.any:', l)
cnt += 1
if cnt > CMD_RSP_TIMEOUT_MS/CMD_RSP_WAIT_TIME_MS: # 等待超时时间后退出
break
utime.sleep_ms(CMD_RSP_WAIT_TIME_MS)
l = self._uartDev.any()
self._uartDev.read(rx)
return rx
# 验证密码
def verifyPassword(self):
self._uartDev.write(cmdVerifyPasswoard)
rsp = self.getCmdResult()
# 检查命令是否执行成功
if rsp[-3] == 0:
return SUCCESS
else:
return FAIL
'''
Confirm code=00H shows OK;
Confirm Code=01H shows receiving packet error;
Confirm Code=13H shows password incorrect;
Confirm Code=21H shows Must verify password first;
'''
# 录入指纹图像
def getImage(self):
self._uartDev.write(cmdGetImage)
rsp = self.getCmdResult()
# print(rsp)
# 检查命令是否执行成功
if rsp[9] == 0:
return SUCCESS
elif rsp[9] == 2:
return NO_FINGER
else:
return FAIL
'''
Confirm Code=00H - 录入成功
Confirm Code=01H - 收包错误
Confirm Code=02H - 传感器上无手指
Confirm Code=03H - 指纹录入失败
'''
# 生成指纹对应的特征值， slot代表Buffer缓冲区ID
def image2Character(self, slot = 1):
sumImage2Char = cmdSaveimage2Char + bytearray([slot, 0, slot + 0x7])
self._uartDev.write(cmdImage2Char)
self._uartDev.write(sumImage2Char)
rsp = self.getCmdResult()
# 检查命令是否执行成功
if rsp[9] == 0:
return SUCCESS
else:
return FAIL
'''
Confirm Code=00H - 生成特征值成功
Confirm Code=01H - 收包错误
Confirm Code=06H - 指纹图像太乱，生成特征值失败
Confirm Code=07H - 特征点太少，生成特征值失败
feature;
Confirm Code=15H - 图像缓冲区内没有有效原始图，生成特征值失败
'''
# 合并特征并生成模板
def createModel(self):
self._uartDev.write(cmdCreateModel)
rsp = self.getCmdResult()
# 检查命令是否执行成功
if rsp[9] == 0:
return SUCCESS
else:
return FAIL
'''
Confirm Code=00H - 合并成功
Confirm Code=01H - 收包错误
Confirm Code=0aH - 合并失败（两枚指纹不属于同一手指）
'''
# 将模板文件存储到PageID中，默认存储缓冲区1中的模板
def storeModel(self, id):
#sumStoreModel = cmdSaveStoreModel + bytearray([id, 0, id + 0x0E])
payload = cmdSaveStoreModel + bytearray([(id >> 8) & 0xff, id & 0xff])
s = sum(payload)
sumStoreModel = cmdStoreModel + payload + bytearray([(s >> 8) & 0xff, s & 0xff])
self._uartDev.write(sumStoreModel)
rsp = self.getCmdResult()
# 检查命令是否执行成功
if rsp[9] == 0:
return SUCCESS
else:
return FAIL
'''
Confirm Code=00H - 储存成功
Confirm Code=01H - 收包错误
Confirm Code=0bH - pageID超出范围
Confirm Code=18H - 写Flash操作出错
'''
# 精确比对两枚指纹特征
def match(self):
self._uartDev.write(cmdMatch)
rsp = self.matchCmdResult()
# 检查命令是否执行成功
if rsp[9] == 0:
return SUCCESS
else:
return FAIL
'''
Confirm Code=00H - 指纹匹配
Confirm Code=01H - 收包错误
Confirm Code=08H - 指纹不匹配
'''
# 以缓冲区1或缓冲区2中的特征文件搜索整个或部分指纹库，若搜索到，返回页码
def search(self):
result = FAIL
fingerId = -1
confidence = 0
self._uartDev.write(cmdSearch)
rsp = self.searchCmdResult()
# print(rsp)
# 检查命令是否执行成功
if rsp[9] == 0:
result = SUCCESS
fingerId, confidence = ustruct.unpack(">HH", bytes(rsp[10:14]))
else:
fingerId, confidence = -1, 0
# print (result, fingerId, confidence)
return result, fingerId, confidence
'''
Confirm Code=00H - 搜索成功
Confirm Code=01H - 收包错误
Confirm Code=09H - 没有搜索到，此时fingerId和confidence均为0
'''
# 删除Flash指纹库中的一个特征文件
def deleteModel(self, id):
if id >= DATABASE_CAPABILITY or id < 0:
return FAIL
deleteModel = cmdSaveDeleteModel + bytearray([id, 0, 1, 0, id + 0x15])
self._uartDev.write(cmdDeleteModel)
self._uartDev.write(deleteModel)
rsp = self.getCmdResult()
# 检查命令是否执行成功
if rsp[9] == 0:
return SUCCESS
else:
return FAIL
'''
Confirm Code=00H - 删除模板成功
Confirm Code=01H - 收包错误
Confirm Code=10H - 删除模板失败
'''
# 删除flash数据库中的所有指纹模板
def emptyDatabase(self):
self._uartDev.write(cmdEmptyDatabase)
rsp = self.getCmdResult()
# 检查命令是否执行成功
if rsp[9] == 0:
return SUCCESS
else:
return FAIL
'''
Confirm Code=00H - 清空指纹模板成功
Confirm Code=01H - 收包错误
Confirm Code=11H - 清空指纹模板失败
'''
# 获取指纹特征值
def getFPCharacter(self, slot = 1):
# 获取指纹特征值信息
cmd = bytearray(cmdGetFPChar)
cmd[10] = slot
s = sum(cmd[6:11])
cmd[11] = (s >> 8) & 0xff
cmd[12] = s & 0xff
self._uartDev.write(cmd)
rsp = self.getLongResult()
# 检查命令是否执行成功
if rsp[9] == 0:
return SUCCESS, rsp[12:len(rsp)]
else:
return FAIL, []
'''
Confirm Code=00H - 清空指纹模板成功
Confirm Code=01H - 收包错误
Confirm Code=0dH - 指纹执行失败
'''
# 获取指纹图像
def getFPImage(self):
self._uartDev.write(cmdGetFPImage)
rsp = self.getLongResult()
# 检查命令是否执行成功
if rsp[9] == 0:
return SUCCESS, rsp[12:len(rsp)]
else:
return FAIL, []
'''
Confirm Code=00H - 清空指纹模板成功
Confirm Code=01H - 收包错误
Confirm Code=0fH - bu不能发送后续数据包
'''
def getEmptyPosition(self):
for i in range(4):
cmdReadIndexTable = b'\xEF\x01\xFF\xFF\xFF\xFF\x01\x00\x04\x1F\x00\x00\x24'
s = sum(cmdReadIndexTable[6:10]) + i
cmd = cmdReadIndexTable[0:10] + bytearray([i]) + bytearray([(s >> 8) & 0xff, s & 0xff])
self._uartDev.write(cmd)
rsp = self.readIndexCmdResult()
# print(rsp)
# 检查命令是否执行成功
if rsp[9] == 0:
index = rsp[10:41]
for j in range(len(index)):
for m in range(8):
if not (index[j] & (1 << m)):
return i * 32 + j * 8 + m
return FAIL
# 指纹录入
def fingerEnroll(self, id):
p = FAIL
if id >= DATABASE_CAPABILITY or id < 0:
return FAIL
print('wait for finger print on the pannel')
while p != NO_FINGER:
p = self.getImage()
# 开始采集指纹
while p != SUCCESS:
p = self.getImage()
print('finger detected')
# 指纹图片转化为特征值
p = self.image2Character(1)
if p != SUCCESS:
print('image to text failed, exit')
return 0
# 再录制一次
print('take off your finger, please')
#Take off your finger
p = 0
while p != NO_FINGER:
p = self.getImage()
# put on again
# Get image again
print('put on your finger again, please')
while p != SUCCESS:
p = self.getImage()
# 指纹图片转化为特征值
p = self.image2Character(2)
if p != SUCCESS:
return 0
print('creating finger model')
# 创建指纹模板
p = self.createModel()
if p != SUCCESS:
print('creating model failed')
return 0
print('store finger model')
# 存储指纹模板
p = self.storeModel(id)
if p != SUCCESS:
# fingerrecordfail
print('store finger model failed')
return FAIL
print('store finger model success')
return SUCCESS
# 指纹识别
def fingerSearch(self):
p = FAIL
print('search finger')
print('wait for finger print on the pannel')
while p != NO_FINGER:
p = self.getImage()
while p != SUCCESS:
p = self.getImage()
print('finger detected')
p = self.image2Character(1)
if p != SUCCESS:
# 指纹图片转换为特征值失败
print('image to text failed, exit')
return -1
# 在指纹库中搜索指纹
p, id, confidence = self.search()
if p == SUCCESS:
# 搜索成功
print('finger id:', id, ' confidence:', confidence)
return SUCCESS, id
else:
# 搜索失败
print('no match finger found')
return FAIL, -1
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/as608/as608.py
|
Python
|
apache-2.0
| 14,632
|
"""
Copyright (C) 2015-2022 Alibaba Group Holding Limited
MicroPython's drive for BH1750
Author: HaaS
Date: 2022/03/22
"""
import utime
from driver import I2C
class BH1750(object):
MT_HIGH_MAX = 180 # ms
MT_LOW_MAX = 24 # ms
MT_HIGH_TYP = 120 # ms
MT_LOW_TYP = 16 # ms
# Continuously high resolution mode 1/2, low resolution mode
CMD_CONT_H_MODE = 0b0001_0000 # 1lx resolution
CMD_CONT_H_MODE2 = 0b0001_0001 # 0.5lx resolution
CMD_CONT_L_MODE = 0b0001_0011 # 4lx resolution
# One time high resolution mode 1/2, low resolution mode
CMD_ONE_H_MODE = 0b0010_0000 # 1lx
CMD_ONE_H_MODE2 = 0b0010_0001 # 0.5lx
CMD_ONE_L_MODE = 0b0010_0011 # 4lx
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
self._i2cDev = i2cDev
# 获取高分辨率照度，模式1，分辨率为 1lx
def oneHighRes(self):
if not self._i2cWriteBytes(self.CMD_ONE_H_MODE):
return 0
utime.sleep_ms(self.MT_HIGH_MAX)
buf = self._i2cReadBytes(2)
if buf is None:
return 0
# else parse result
return self._parseLx(buf)
# 获取高分辨率照度，模式2，分辨率为 0.5lx
def oneHighRes2(self):
if not self._i2cWriteBytes(self.CMD_ONE_H_MODE2):
return 0
utime.sleep_ms(self.MT_HIGH_MAX)
buf = self._i2cReadBytes(2)
if buf is None:
return 0
# else parse result
return self._parseLx(buf)
# 获取低分辨率照度，分辨率为 4lx
def oneLowRes(self):
if not self._i2cWriteBytes(self.CMD_ONE_L_MODE):
return 0
utime.sleep_ms(self.MT_LOW_MAX)
buf = self._i2cReadBytes(2)
if buf is None:
return 0
# else parse result
return self._parseLx(buf)
def getLuminance(self):
return self.oneLowRes()
def _contRead(self, cb, cmd, mtMax, mtTyp):
if not self._i2cWriteBytes(cmd):
return False
utime.sleep_ms(mtMax)
# else parse result
while True:
buf = self._i2cReadBytes(2)
if buf is None:
return False
val = self._parseLx(buf)
if cb(val):
break
utime.sleep_ms(mtTyp)
return True
# 连续获取光照度，高分辨率，通过 cb(val) 传递值
def contHighRes(self, cb):
return self._contRead(cb, self.CMD_CONT_H_MODE, self.MT_HIGH_MAX, self.MT_HIGH_TYP)
# 连续获取光照度，高分辨率模式2，通过 cb(val) 传递值
def contHighRes2(self, cb):
return self._contRead(cb, self.CMD_CONT_H_MODE2, self.MT_HIGH_MAX, self.MT_HIGH_TYP)
# 连续获取光照度，低分辨率，通过 cb(val) 传递值
def contLowRes(self, cb):
return self._contRead(cb, self.CMD_CONT_L_MODE, self.MT_LOW_MAX, self.MT_LOW_TYP)
def _parseLx(self, buf):
#print(buf)
return (buf[0] << 8 | buf[1]) / 1.2
def _i2cWriteBytes(self, *args):
buf = bytearray(args)
ret = self._i2cDev.write(buf)
if ret != len(buf):
print('write failed, ret %s, expect %s', (ret, len(buf)))
return False
return True
def _i2cReadBytes(self, byteNum):
buf = bytearray(byteNum)
ret = self._i2cDev.read(buf)
if ret != byteNum:
print('read failed, ret %s, expect %s' % (ret, byteNum))
return None
return buf
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/bh1750/bh1750.py
|
Python
|
apache-2.0
| 3,613
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for BMP280
Author: HaaS
Date: 2022/03/15
"""
from driver import I2C
from utime import sleep_ms
from micropython import const
import math
BSP280_CHIP_ID = const(0x58)
BMP280_REGISTER_DIG_T1 = const(0x88)
BMP280_REGISTER_DIG_T2 = const(0x8A)
BMP280_REGISTER_DIG_T3 = const(0x8C)
BMP280_REGISTER_DIG_P1 = const(0x8E)
BMP280_REGISTER_DIG_P2 = const(0x90)
BMP280_REGISTER_DIG_P3 = const(0x92)
BMP280_REGISTER_DIG_P4 = const(0x94)
BMP280_REGISTER_DIG_P5 = const(0x96)
BMP280_REGISTER_DIG_P6 = const(0x98)
BMP280_REGISTER_DIG_P7 = const(0x9A)
BMP280_REGISTER_DIG_P8 = const(0x9C)
BMP280_REGISTER_DIG_P9 = const(0x9E)
BMP280_REGISTER_CHIPID = const(0xD0)
BMP280_REGISTER_VERSION = const(0xD1)
BMP280_REGISTER_SOFTRESET = const(0xE0)
BMP280_REGISTER_CAL26 = const(0xE1)
BMP280_REGISTER_CONTROL = const(0xF4)
BMP280_REGISTER_CONFIG = const(0xF5)
BMP280_REGISTER_PRESSUREDATA = const(0xF7)
BMP280_REGISTER_TEMPDATA = const(0xFA)
class bmp280Error(Exception):
def __init__(self, value=0, msg="bmp280 common error"):
self.value = value
self.msg = msg
def __str__(self):
return "Error code:%d, Error message: %s" % (self.value, str(self.msg))
__repr__ = __str__
class BMP280(object):
"""
This class implements bmp280 chip's defs.
"""
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make BMP280's internal object points to i2cDev
self._i2cDev = i2cDev
self.dig_T1 = 0
self.dig_T2 = 0
self.dig_T3 = 0
self.dig_P1 = 0
self.dig_P2 = 0
self.dig_P3 = 0
self.dig_P4 = 0
self.dig_P5 = 0
self.dig_P6 = 0
self.dig_P7 = 0
self.dig_P8 = 0
self.dig_P9 = 0
self.init()
self.readCoefficients()
self.writeReg(BMP280_REGISTER_CONTROL, 0x3f)
self.t_fine = 0
def readCoefficients(self):
self.dig_T1 = self.readReg16(BMP280_REGISTER_DIG_T1)
self.dig_T2 = self.readReg16_INT16(BMP280_REGISTER_DIG_T2)
self.dig_T3 = self.readReg16_INT16(BMP280_REGISTER_DIG_T3)
self.dig_P1 = self.readReg16(BMP280_REGISTER_DIG_P1)
self.dig_P2 = self.readReg16_INT16(BMP280_REGISTER_DIG_P2)
self.dig_P3 = self.readReg16_INT16(BMP280_REGISTER_DIG_P3)
self.dig_P4 = self.readReg16_INT16(BMP280_REGISTER_DIG_P4)
self.dig_P5 = self.readReg16_INT16(BMP280_REGISTER_DIG_P5)
self.dig_P6 = self.readReg16_INT16(BMP280_REGISTER_DIG_P6)
self.dig_P7 = self.readReg16_INT16(BMP280_REGISTER_DIG_P7)
self.dig_P8 = self.readReg16_INT16(BMP280_REGISTER_DIG_P8)
self.dig_P9 = self.readReg16_INT16(BMP280_REGISTER_DIG_P9)
#写寄存器
def writeReg(self, addr, value):
Reg = bytearray([addr, value])
self._i2cDev.write(Reg)
#print("--> write addr " + hex(addr) + ", value = " + hex(value))
return 0
#读寄存器
def readReg(self, addr, len):
Reg = bytearray([addr])
self._i2cDev.write(Reg)
sleep_ms(2)
tmp = bytearray(len)
self._i2cDev.read(tmp)
#print("<-- read addr " + hex(addr) + ", value = " + hex(tmp[0]))
return tmp
def readReg16(self, addr):
tmp = self.readReg(addr, 2)
data = (tmp[1] << 8) + tmp[0]
return data
def readReg16_BE(self, addr):
tmp = self.readReg(addr, 2)
data = (tmp[0] << 8) + tmp[1]
return data
def readReg8(self, addr):
tmp = self.readReg(addr, 1)
data = tmp[0]
return data
def int16(self, dat):
if dat > 32767:
return dat - 65536
else:
return dat
def int32(self, dat):
if dat > (1 << 31):
return dat - (1 << 32)
else:
return dat
def readReg16_INT16(self, addr):
tmp = self.readReg(addr, 2)
data = (tmp[1] << 8) + tmp[0]
data = self.int16(data)
return data
def deviceCheck(self):
ret = self.readReg(BMP280_REGISTER_CHIPID, 1)[0]
if (ret == BSP280_CHIP_ID):
return 0
else:
return 1
def getTemperature(self):
adc_T = self.readReg16_BE(BMP280_REGISTER_TEMPDATA)
adc_T <<= 8
adc_T |= self.readReg8(BMP280_REGISTER_TEMPDATA + 2)
adc_T >>= 4
var1 = ((adc_T >> 3) - (self.dig_T1 << 1)) * (self.dig_T2) >> 11
var2 = (((((adc_T >> 4) - self.dig_T1) *
((adc_T >> 4) - self.dig_T1)) >> 12) * (self.dig_T3)) >> 14
self.t_fine = var1 + var2
t = ((self.t_fine * 5) + 128) >> 8
return t / 100
def getPressure(self):
# before get pressure, needs to get temperature.
self.getTemperature()
adc_P = self.readReg16_BE(BMP280_REGISTER_PRESSUREDATA)
adc_P <<= 8
adc_P |= self.readReg8(BMP280_REGISTER_PRESSUREDATA + 2)
adc_P >>= 4
var1 = self.t_fine - 128000
var2 = var1 * var1 * self.dig_P6
var2 = (var2) + (((var1 * self.dig_P5)) << 17)
var2 = var2 + (self.dig_P4 << 35)
var1 = ((var1 * var1 * self.dig_P3) >> 8) + (
(var1 * self.dig_P2) << 12)
var1 = (((1 << 47) + var1) * (self.dig_P1)) >> 33
p = 1048576 - adc_P
p = (((p << 31) - var2) * 3125) / var1
var1 = ((self.dig_P9) * (p / (1 << 13)) * (p / (1 << 13))) / (1 << 25)
var2 = (self.dig_P8 * p) / (1 << 19)
p = ((p + var1 + var2) / (1 << 8)) + (self.dig_P7 << 4)
return p / 256
def init(self):
ret = self.deviceCheck()
if (ret != 0):
print("bmp280 init fail")
return 0
else:
pass
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/bmp280/bmp280.py
|
Python
|
apache-2.0
| 5,883
|
"""
HaaSPython PWM driver for buzzer
"""
from driver import PWM
class BUZZER(object):
def __init__(self, pwmObj):
self.pwmObj = None
if not isinstance(pwmObj, PWM):
raise ValueError("parameter is not an PWM object")
self.pwmObj = pwmObj
def setOptionDuty(self,data):
if self.pwmObj is None:
raise ValueError("invalid PWM object")
self.pwmObj.setOption(data)
def close(self):
if self.pwmObj is None:
raise ValueError("invalid PWM object")
self.pwmObj.close()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/buzzer/buzzer.py
|
Python
|
apache-2.0
| 570
|
from driver import I2C
CSS811_STATUS = 0x00
CSS811_MEAS_MODE = 0x01
CSS811_ALG_RESULT_DATA = 0x02
CSS811_RAW_DATA = 0x03
CSS811_ENV_DATA = 0x05
CSS811_NTC = 0x06
CSS811_THRESHOLDS = 0x10
CSS811_BASELINE = 0x11
CSS811_HW_ID = 0x20
CSS811_HW_VERSION = 0x21
CSS811_FW_BOOT_VERSION = 0x23
CSS811_FW_APP_VERSION = 0x24
CSS811_ERROR_ID = 0xE0
CSS811_APP_START = 0xF4
CSS811_SW_RESET = 0xFF
class CCS811:
def __init__(self,i2cDev):
self._i2c = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
self._i2c = i2cDev
self.tVOC = 0
self.CO2 = 0
self.setup()
def print_error(self):
buf = bytearray(1)
self._i2c.memRead(buf,CSS811_ERROR_ID,8)
error = buf[0]
message = 'Error: '
if error & 1 << 5:
message += 'HeaterSupply '
elif error & 1 << 4:
message += 'HeaterFault '
elif error & 1 << 3:
message += 'MaxResistance '
elif error & 1 << 2:
message += 'MeasModeInvalid '
elif error & 1 << 1:
message += 'ReadRegInvalid '
elif error & 1 << 0:
message += 'MsgInvalid '
print(message)
def check_for_error(self):
buf = bytearray(1)
self._i2c.memRead(buf,CSS811_STATUS,8)
value = buf[0]
return value & 1 << 0
def app_valid(self):
buf = bytearray(1)
self._i2c.memRead(buf,CSS811_STATUS,8)
value = buf[0]
return value & 1 << 4
def set_drive_mode(self, mode):
if mode > 4:
mode = 4
setting = bytearray(1)
self._i2c.memRead(setting,CSS811_MEAS_MODE,8)
setting[0] &= ~(0b00000111 << 4)
setting[0] |= (mode << 4)
self._i2c.memWrite(setting,CSS811_MEAS_MODE,8)
def configure_ccs811(self):
hardware_id = bytearray(1)
self._i2c.memRead(hardware_id,CSS811_HW_ID,8)
if hardware_id[0] != 0x81:
raise ValueError('CCS811 not found. Please check wiring.',hardware_id[0])
if self.check_for_error():
self.print_error()
raise ValueError('Error at Startup.')
if not self.app_valid():
raise ValueError('Error: App not valid.')
buf = bytearray(1)
buf[0] = CSS811_APP_START
self._i2c.write(buf)
if self.check_for_error():
self.print_error()
raise ValueError('Error at AppStart.')
self.set_drive_mode(1)
if self.check_for_error():
self.print_error()
raise ValueError('Error at setDriveMode.')
def setup(self):
self.configure_ccs811()
def get_base_line(self):
b = bytearray(2)
self._i2c.memRead(b,CSS811_BASELINE,8)
baselineMSB = b[0]
baselineLSB = b[1]
baseline = (baselineMSB << 8) | baselineLSB
return baseline
def data_available(self):
buf = bytearray(1)
self._i2c.memRead(buf,CSS811_STATUS,8)
value = buf[0]
return value & 1 << 3
def read_logorithm_results(self):
d = bytearray(4)
self._i2c.memRead(d,CSS811_ALG_RESULT_DATA,8)
co2MSB = d[0]
co2LSB = d[1]
tvocMSB = d[2]
tvocLSB = d[3]
self.CO2 = (co2MSB << 8) | co2LSB
self.tVOC = (tvocMSB << 8) | tvocLSB
def geteCO2(self):
if self.data_available():
d = bytearray(4)
self._i2c.memRead(d,CSS811_ALG_RESULT_DATA,8)
co2MSB = d[0]
co2LSB = d[1]
tvocMSB = d[2]
tvocLSB = d[3]
self.CO2 = (co2MSB << 8) | co2LSB
self.tVOC = (tvocMSB << 8) | tvocLSB
return 1,self.CO2
else:
return 0,0
def getTVOC(self):
if self.data_available():
d = bytearray(4)
self._i2c.memRead(d,CSS811_ALG_RESULT_DATA,8)
co2MSB = d[0]
co2LSB = d[1]
tvocMSB = d[2]
tvocLSB = d[3]
self.CO2 = (co2MSB << 8) | co2LSB
self.tVOC = (tvocMSB << 8) | tvocLSB
return 1,self.tVOC
else:
return 0,0
def geteCO2TVOC(self):
if self.data_available():
d = bytearray(4)
self._i2c.memRead(d,CSS811_ALG_RESULT_DATA,8)
co2MSB = d[0]
co2LSB = d[1]
tvocMSB = d[2]
tvocLSB = d[3]
self.CO2 = (co2MSB << 8) | co2LSB
self.tVOC = (tvocMSB << 8) | tvocLSB
return 1,self.CO2,self.tVOC
else:
return 0,0,0
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/ccs811/ccs811.py
|
Python
|
apache-2.0
| 4,661
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for CHT8305
Author: HaaS
Date: 2021/09/14
"""
from micropython import const
from utime import sleep_ms
from driver import I2C
CHT8305_REG_TEMP = 0x00
CHT8305_REG_HUMI = 0x01
# The register address in CHT8305 controller.
class CHT8305Error(Exception):
def __init__(self, value=0, msg="cht8305 common error"):
self.value = value
self.msg = msg
def __str__(self):
return "Error code:%d, Error message: %s" % (self.value, str(self.msg))
__repr__ = __str__
class CHT8305(object):
"""
This class implements cht8305 chip's functions.
"""
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make CHT8305's internal object points to i2cDev
self._i2cDev = i2cDev
def getTemperature(self):
"""Get temperature."""
# make sure CHT8305's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# send temperature register to CHT8305
reg = bytearray([CHT8305_REG_TEMP])
self._i2cDev.write(reg)
# wait for 30ms
sleep_ms(30)
readData = bytearray(2)
# read temperature from CHT8305
self._i2cDev.read(readData)
# convert the temperature data to actual value
value = (readData[0] << 8) | readData[1]
if (value & 0xFFFC):
temperature = (165.0 * float(value)) / 65536.0 - 40.0
else:
raise CHT8305Error("failed to get temperature.")
return temperature
def getHumidity(self):
"""Get humidity."""
# make sure CHT8305's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# send humidity register to CHT8305
reg = bytearray([CHT8305_REG_HUMI])
self._i2cDev.write(reg)
sleep_ms(30)
# read humidity from CHT8305
readData = bytearray(2)
self._i2cDev.read(readData)
# convert the humidity data to actual value
value = (readData[0] << 8) | readData[1]
if (value & 0xFFFE):
humidity = ((125.0 * float(value)) / 65535.0) - 6.0
else:
raise CHT8305Error("failed to get humidity.")
return humidity
def getTempHumidity(self):
"""Get temperature and humidity."""
# make sure CHT8305's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
temphumidity = [0, 1]
# send temperature register to CHT8305
reg = bytearray([CHT8305_REG_TEMP])
self._i2cDev.write(reg)
sleep_ms(30)
# 4 bytes means read temperature and humidity back in one read operation
readData = bytearray(4)
self._i2cDev.read(readData)
#print("rawdata %d-%d-%d-%d" %(readData[0],readData[1],readData[2],readData[3]))
# convert the temperature and humidity data to actual value
value = (readData[0] << 8) | readData[1]
if (value & 0xFFFC):
temphumidity[0] = (165.0 * float(value)) / 65536.0 - 40.0
else:
raise CHT8305Error("failed to get temperature.")
value = (readData[2] << 8) | readData[3]
if (value & 0xFFFE):
temphumidity[1] = ((125.0 * float(value)) / 65535.0) - 6.0
else:
raise CHT8305Error("failed to get humidity.")
return temphumidity
if __name__ == "__main__":
'''
The below i2c configuration is needed in your board.json.
"cht8305": {
"type": "I2C",
"port": 1,
"addrWidth": 7,
"freq": 400000,
"mode": "master",
"devAddr": 64
}
'''
print("Testing cht8305 ...")
i2cDev = I2C()
i2cDev.open("cht8305")
cht8305Dev = CHT8305(i2cDev)
temperature = cht8305Dev.getTemperature()
print("The temperature is: %f" % temperature)
humidity = cht8305Dev.getHumidity()
print("The humidity is: %f" % humidity)
i2cDev.close()
print("Test cht8305 done!")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/cht8305/cht8305.py
|
Python
|
apache-2.0
| 4,277
|
from driver import GPIO
class DCMOTOR(object):
def __init__(self, gpioObj):
self.gpioObj = None
if not isinstance(gpioObj, GPIO):
raise ValueError("parameter is not a GPIO object")
self.gpioObj = gpioObj
def ctrl(self,value):
if self.gpioObj is None:
raise ValueError("invalid GPIO object")
self.gpioObj.write(value)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/dcmotor/dcmotor.py
|
Python
|
apache-2.0
| 392
|
import modbus
import math
import struct
def bytes2float(bytes):
ba = bytearray()
ba.append(bytes[1])
ba.append(bytes[0])
ba.append(bytes[3])
ba.append(bytes[2])
return struct.unpack("!f",ba)[0]
class DDS5188(object):
def __init__(self, node, slave_addr):
if modbus.init(node) != 0:
raise ValueError("Error: Modbus init error.")
self.slave_addr = slave_addr
def __del__(self):
modbus.deinit()
def getKWh(self):
rx_buf = bytearray(4)
code = modbus.readInputRegisters(self.slave_addr, 0x0100, 2, rx_buf, 200)
if code[0] == 0:
data = bytes2float(rx_buf)
else:
data = 0.0
return code[0], data
def getVoltage(self):
rx_buf = bytearray(4)
code = modbus.readInputRegisters(self.slave_addr, 0x00, 2, rx_buf, 200)
if code[0] == 0:
data = bytes2float(rx_buf)
else:
data = 0.0
return code[0], data
def getCurrent(self):
rx_buf = bytearray(4)
code = modbus.readInputRegisters(self.slave_addr, 0x08, 2, rx_buf, 200)
if code[0] == 0:
data = bytes2float(rx_buf)
else:
data = 0.0
return code[0], data
def getActivePower(self):
rx_buf = bytearray(4)
code = modbus.readInputRegisters(self.slave_addr, 0x12, 2, rx_buf, 200)
if code[0] == 0:
data = bytes2float(rx_buf)
else:
data = 0.0
return code[0], data
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/dds5188/dds5188.py
|
Python
|
apache-2.0
| 1,534
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for CHT8305
Author: HaaS
Date: 2022/05/11
"""
import lvgl as lv
import lvgl_display
print("display_driver init")
if not lv.is_initialized():
#print("lv.init")
lv.init()
if not lvgl_display.is_initialized():
#print("lvgl_display.init")
lvgl_display.init()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/display_driver/display_driver.py
|
Python
|
apache-2.0
| 369
|
class DRV8833():
def __init__(self, Int1x, Int2x,freq):
self.int1x = Int1x
self.int2x = Int2x
if freq == None:
self.mode = 0
else:
self.mode = 1
self.freq = freq
def run(self, status, rate):
if self.mode == 0 :
if status == 1:
self.int1x.write(0)
self.int2x.write(1)
elif status == 2:
self.int1x.write(1)
self.int2x.write(0)
elif self.mode == 1:
return
def stop(self):
if self.mode == 0 :
self.int1x.write(1)
self.int2x.write(1)
elif self.mode == 1:
return
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/drv8833/drv8833.py
|
Python
|
apache-2.0
| 708
|
from driver import GPIO
DS1302_REG_SECOND = (0x80)
DS1302_REG_MINUTE = (0x82)
DS1302_REG_HOUR = (0x84)
DS1302_REG_DAY = (0x86)
DS1302_REG_MONTH = (0x88)
DS1302_REG_WEEKDAY= (0x8A)
DS1302_REG_YEAR = (0x8C)
DS1302_REG_WP = (0x8E)
DS1302_REG_CTRL = (0x90)
DS1302_REG_RAM = (0xC0)
class DS1302:
def __init__(self, o_clk, o_rst, b_di, b_do):
self.clk = o_clk
self.cs = o_rst
self.di = b_di
self.do = b_do
self.gpiodio = GPIO()
self.gpiodio.open(self.do)
def _dectohex(self, dat):
return (dat//10) * 16 + (dat % 10)
def _hextodec(self, dat):
return (dat//16) * 10 + (dat % 16)
def _writeByte(self, dat):
for i in range(8):
self.gpiodio.write((dat >> i) & 1)
self.clk.write(1)
self.clk.write(0)
def _readByte(self):
d = 0
self.gpiodio.close()
self.gpiodio.open(self.di)
for i in range(8):
d = d | (self.gpiodio.read() << i)
self.clk.write(1)
self.clk.write(0)
self.gpiodio.close()
self.gpiodio.open(self.do)
return d
def _getReg(self, reg):
self.cs.write(1)
self._writeByte(reg)
t = self._readByte()
self.cs.write(0)
return t
def _setReg(self, reg, dat):
self.cs.write(1)
self._writeByte(reg)
self._writeByte(dat)
self.cs.write(0)
def _wr(self, reg, dat):
self._setReg(DS1302_REG_WP, 0)
self._setReg(reg, dat)
self._setReg(DS1302_REG_WP, 0x80)
def start(self):
t = self._getReg(DS1302_REG_SECOND + 1)
self._wr(DS1302_REG_SECOND, t & 0x7f)
def stop(self):
t = self._getReg(DS1302_REG_SECOND + 1)
self._wr(DS1302_REG_SECOND, t | 0x80)
def second(self, second=None):
if second == None:
return self._hextodec(self._getReg(DS1302_REG_SECOND+1)) % 60
else:
self._wr(DS1302_REG_SECOND, self._dectohex(second % 60))
def minute(self, minute=None):
if minute == None:
return self._hextodec(self._getReg(DS1302_REG_MINUTE+1))
else:
self._wr(DS1302_REG_MINUTE, self._dectohex(minute % 60))
def hour(self, hour=None):
if hour == None:
return self._hextodec(self._getReg(DS1302_REG_HOUR+1))
else:
self._wr(DS1302_REG_HOUR, self._dectohex(hour % 24))
def weekday(self, weekday=None):
if weekday == None:
return self._hextodec(self._getReg(DS1302_REG_WEEKDAY+1))
else:
self._wr(DS1302_REG_WEEKDAY, self._dectohex(weekday % 8))
def day(self, day=None):
if day == None:
return self._hextodec(self._getReg(DS1302_REG_DAY+1))
else:
self._wr(DS1302_REG_DAY, self._dectohex(day % 32))
def month(self, month=None):
if month == None:
return self._hextodec(self._getReg(DS1302_REG_MONTH+1))
else:
self._wr(DS1302_REG_MONTH, self._dectohex(month % 13))
def year(self, year=None):
if year == None:
return self._hextodec(self._getReg(DS1302_REG_YEAR+1)) + 2000
else:
self._wr(DS1302_REG_YEAR, self._dectohex(year % 100))
def getDatetime(self):
return [self.year(), self.month(), self.day(), self.hour(), self.minute(), self.second(),self.weekday()]
def setDatetime(self, data):
if data is None:
raise ValueError("invalid data")
else:
self.year(data[0])
self.month(data[1])
self.day(data[2])
self.hour(data[3])
self.minute(data[4])
self.second(data[5])
self.weekday(data[6])
def ram(self, reg, dat=None):
if dat == None:
return self._getReg(DS1302_REG_RAM + 1 + (reg % 31)*2)
else:
self._wr(DS1302_REG_RAM + (reg % 31)*2, dat)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/ds1302/ds1302.py
|
Python
|
apache-2.0
| 3,977
|
from driver import GPIO
from onewire import OneWire
from machine import Pin
import time
class DS18B20():
def __init__(self, gpioObj, resolution=12):
self.pin = None
if not isinstance(gpioObj, GPIO):
raise ValueError("parameter is not a GPIO object")
self.pin = gpioObj.port()
self.no_addr=0
self.addr=self.getaddr()
self.unit='c'
self.res=resolution
def getaddr(self):
ow=OneWire(Pin(self.pin))
a=ow.scan()
for i in a:
self.no_addr+=1
return a
def getTemperature(self):
if self.no_addr==0:
print ("no sensors detected")
if self.no_addr>=1:
temp = self._request(self.addr[0])
return temp
def _request(self, addr):
self._res(addr)
ow=OneWire(Pin(self.pin))
ow.reset()
ow.select_rom(addr)
ow.writebyte(0x44) #command to take reading
if self.res==12: #the resolution determines the amount of time needed
time.sleep_ms(1000)
if self.res==11:
time.sleep_ms(400)
if self.res==10:
time.sleep_ms(200)
if self.res==9:
time.sleep_ms(100)
ow.reset() #reset required for data
ow.select_rom(addr)
ow.writebyte(0xBE)
LSB=ow.readbyte()
MSB=ow.readbyte()
ow.readbyte()
ow.readbyte()
ow.readbyte()
ow.readbyte()
ow.readbyte()
ow.readbyte()
ow.readbyte()
ow.reset()
d_LSB=float(0)
d_MSB=float(0)
count=0
b=bin(LSB)
b2=bin(MSB)
b3=""
l=10-len(b2)
for i in range(l):
if len(b2)<10:
b3+="0"
b2=b3+b2
b4=""
l=10-len(b)
for i in range(l):
if len(b)<10:
b4+="0"
b5=b4+b
for i in b5:
if count == 2:
if i=='1':
d_LSB+=2**3
if count == 3:
if i=='1':
d_LSB+=2**2
if count == 4:
if i=='1':
d_LSB+=2**1
if count == 5:
if i=='1':
d_LSB+=2**0
if count == 6:
if i=='1':
d_LSB+=2**-1
if count == 7:
if i=='1':
d_LSB+=2**-2
if count == 8:
if i=='1':
d_LSB+=2**-3
if count == 9:
if i=='1':
d_LSB+=2**-4
count+=1
count=0
sign=1
for i in b2:
if count == 6:
if i=='1':
sign=-1
if count == 7:
if i=='1':
d_MSB+=2**6
if count == 8:
if i=='1':
d_MSB+=2**5
if count == 9:
if i=='1':
d_MSB+=2**4
count+=1
temp=(d_LSB+d_MSB)*sign
# if self.unit=='c'or self.unit=='C':
# print("TEMP is: "+str(temp)+" degrees C")
if self.unit=='f'or self.unit=='F':
temp=(temp*9/5)+32
# print("TEMP F is: "+str(temp))
return temp
def _res(self,addr):
ow=OneWire(Pin(self.pin))
ow.reset()
ow.select_rom(addr)
ow.writebyte(0x4E)
if self.res==12:
ow.writebyte(0x7F)
ow.writebyte(0x7F)
ow.writebyte(0x7F)
if self.res==11:
ow.writebyte(0x5F)
ow.writebyte(0x5F)
ow.writebyte(0x5F)
if self.res==10:
ow.writebyte(0x3F)
ow.writebyte(0x3F)
ow.writebyte(0x3F)
if self.res==9:
ow.writebyte(0x1F)
ow.writebyte(0x1F)
ow.writebyte(0x1F)
ow.reset()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/ds18b20/ds18b20.py
|
Python
|
apache-2.0
| 3,959
|
from driver import GPIO
import utime
class Hx711(object):
def __init__(self, clkObj, dataObj):
self.clkObj = None
self.dataObj = None
if not isinstance(clkObj, GPIO):
raise ValueError("parameter is not an GPIO object")
if not isinstance(dataObj, GPIO):
raise ValueError("parameter is not an GPIO object")
self.clkObj = clkObj
self.dataObj = dataObj
def getValue(self):
if self.clkObj is None:
raise ValueError("invalid GPIO object")
if self.dataObj is None:
raise ValueError("invalid GPIO object")
count = 0
self.dataObj.write(1)
self.clkObj.write(0)
while(self.dataObj.read()):
utime.sleep_ms(1)
for i in range(24):
self.clkObj.write(1)
count = count<<1
self.clkObj.write(0)
if(self.dataObj.read()):
count += 1
self.clkObj.write(1)
count ^= 0x800000
self.clkObj.write(0)
return count
class EleScale(Hx711):
# capValue = 429.5是理论值，可通过调整该参数进行校准，
# 如果测量值偏大则适当增大capValue，如果测量值偏小则减小该值。
def __init__(self, clkObj, dataObj, capValue = 429.5):
Hx711.__init__(self, clkObj, dataObj)
self.noLoadOffset = self.__hx711Read(10)
self.capValue = capValue
def __hx711Read(self, times = 3):
# times必须 >= 3
cnt = 3 if (times <= 3) else times
idx = 0
data = [0] * cnt
while (idx < cnt):
data[idx] = self.getValue()
idx += 1
data.sort()
# 去掉最大最小值后的平均值作为结果返回
return round(sum(data[1:-1]) / (len(data) - 2))
def getWeight(self):
data = self.__hx711Read() - self.noLoadOffset
if (data <= 0):
weight = 0.0
else:
weight = data / self.capValue
return weight
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/ele_scale/ele_scale.py
|
Python
|
apache-2.0
| 2,032
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
HaaS Python driver for fheartbeat
Author: HaaS
Date: 2022/05/15
"""
from driver import ADC
class FHEARTBEAT(object):
"""
This class implements FHEARTBEAT chip's defs.
"""
def __init__(self, adcObj):
self._adcObj = None
if not isinstance(adcObj, ADC):
raise ValueError("parameter is not an adcObj object")
self._adcObj = adcObj
def getVoltage(self):
if self._adcObj is None:
raise ValueError("invalid ADC object")
value = self._adcObj.readVoltage()
return value
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/fheartbeat/fheartbeat.py
|
Python
|
apache-2.0
| 631
|
from driver import ADC
class FIRE(object):
def __init__(self, adcObj):
self.adcObj = None
if not isinstance(adcObj, ADC):
raise ValueError("parameter is not an ADC object")
self.adcObj = adcObj
def getVoltage(self):
if self.adcObj is None:
raise ValueError("invalid ADC object")
value = self.adcObj.readVoltage()
return value
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/fire/fire.py
|
Python
|
apache-2.0
| 409
|
from driver import SPI, GPIO
# register address map for each GC7219 (opCodes)
OP_NOOP = 0
OP_DIGIT0 = 1 # == one row (byte)
OP_DIGIT1 = 2
OP_DIGIT2 = 3
OP_DIGIT3 = 4
OP_DIGIT4 = 5
OP_DIGIT5 = 6
OP_DIGIT6 = 7
OP_DIGIT7 = 8
OP_DECODEMODE = 9 # no decode == 0 (useful only for 7-segment display)
OP_INTENSITY = 10 # 0 - 15 (different steps for each GC7219)
OP_SCANLIMIT = 11 # all rows == 7 (sets number of active rows / digits)
OP_SHUTDOWN = 12 # turn display on == 1
OP_DISPLAYTEST = 15 # turn all LEDs on == 1
ALL_DISPLAYS = -1
class Bitmap(object):
def __init__(self, width=8, height=8):
self.width = width
self.height = height
self.array = [0] * (width * height // 8)
def setPixel(self, x, y, val=True):
ret = self.containsPixel(x, y)
if not ret:
return
(bytePos, posInByte) = ret
if val:
self.array[bytePos] |= 128 >> posInByte
else:
self.array[bytePos] &= ~(128 >> posInByte)
def getPixel(self, x, y):
ret = self.containsPixel(x, y)
if not ret:
return 0
(bytePos, posInByte) = ret
return self.array[bytePos] & (128 >> posInByte)
def containsPixel(self, x, y):
if x >= self.width or y >= self.height or x < 0 or y < 0:
return None
pos1D = self.width * y + x
posInByte = pos1D % 8
bytePos = pos1D // 8
return (bytePos, posInByte)
class Matrix(object):
# = 8x8 matrix / one chip
def __init__(self, x, y, rotation, mirrorX, mirrorY):
# 0, 90, 180, 270
self.rotation = rotation
self.mirrorX = mirrorX
self.mirrorY = mirrorY
# pixel [0, 0] is [firstX, firstY] for the main bitmap
self.firstX = x
self.firstY = y
# bitmap 8x8 - it's a copy of the part of the main bitmap
# before transforming and flushing
self.bitmap = Bitmap(8, 8)
class MatrixRender(object):
def __init__(self, horizDisplays, vertDisplays, rotation, mirrorX, mirrorY):
self.horizDisplays = horizDisplays
self.vertDisplays = vertDisplays
self.matrixList = []
for row in range(self.horizDisplays):
for col in range(self.vertDisplays):
self.matrixList.append(Matrix(row*8, col*8, rotation, mirrorX, mirrorY))
@property
def matrixCount(self):
return len(self.matrixList)
def flushBitmap(self, bitmap):
for index, matrix in enumerate(self.matrixList):
self.transform(bitmap, index, matrix)
def transform(self, bitmap, index, matrix):
xx = x = matrix.firstX
yy = y = matrix.firstY
for i in range(8):
for j in range(8):
val = bitmap.getPixel(x, y)
if matrix.rotation == 90:
xx = 7-j
yy = i
elif matrix.rotation == 180:
xx = 7-i
yy = 7-j
elif matrix.rotation == 270:
xx = j
yy = 7-i
# 0 and invalid values
else:
xx = i
yy = j
if matrix.mirrorX:
xx = 7-xx
if matrix.mirrorY:
yy = 7-yy
matrix.bitmap.setPixel(xx, yy, val)
y += 1
# increase x before next loop
x += 1
y = 0
class GC7219(object):
def __init__(self, DIN, CS, horizDisplays=4, vertDisplays=1, rotation=0, mirrorX=False, mirrorY=False):
self.DIN = None
self.CS = None
if not isinstance(DIN, SPI):
raise ValueError('parameter DIN is not an SPI object')
if not isinstance(CS, GPIO):
raise ValueError('parameter CS should be GPIO object')
self.DIN = DIN
self.CS = CS
# the self.bitmap will transform to self.render.matrixList
self.render = MatrixRender(horizDisplays, vertDisplays, rotation, mirrorX, mirrorY)
self.bitmap = Bitmap(horizDisplays*8, vertDisplays*8)
self.init()
def init(self):
# deactivate displaytest
self.spiTransfer(OP_DISPLAYTEST, 0)
# activate all rows
self.spiTransfer(OP_SCANLIMIT, 7)
# we don't use 7-segment display
self.spiTransfer(OP_DECODEMODE, 0)
# average light intensity
self.spiTransfer(OP_INTENSITY, 7)
# turn off all LEDs
for i in range(8):
self.spiTransfer(OP_DIGIT0 + i, 0)
# activate displays
self.spiTransfer(OP_SHUTDOWN, 1)
# 1 则点亮所有 LED，0 则进入正常显示模式
def displayTest(self, enable):
self.spiTransfer(OP_DISPLAYTEST, enable)
# 0 则关闭所有 LED，1 则正常显示
def display(self, on):
self.spiTransfer(OP_SHUTDOWN, on)
# 设置 LED 亮度，0-15
def setIntensity(self, intensity):
intensity = max(0, min(15, intensity))
self.spiTransfer(OP_INTENSITY, intensity)
# 将 bitmap 中的点阵数据刷到 LED 面板上
def flush(self):
self.render.flushBitmap(self.bitmap)
for index, matrix in enumerate(self.render.matrixList):
self.sendMatrix(matrix, index)
def sendMatrix(self, matrix, index):
for i, byte in enumerate(matrix.bitmap.array):
self.spiTransfer(OP_DIGIT0 + i, byte, index)
# SPI 底层传输函数
# byte opCode, byte data, int display
def spiTransfer(self, opCode, data, display=ALL_DISPLAYS):
# begin writing
self.CS.write(0)
for i in range(self.render.matrixCount, -1, -1):
# send opcode and data or only no-op (skip display)?
write = display == ALL_DISPLAYS or display == i
buf = bytearray((write and opCode or OP_NOOP, write and data or OP_NOOP))
self.DIN.write(buf)
# stop writing - let chips process new commands
self.CS.write(1)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/gc7219/gc7219.py
|
Python
|
apache-2.0
| 6,051
|
from driver import UART
from micropyGNSS import MicropyGNSS
class GNSS(object):
def __init__(self, uartObj):
self.uartObj = None
if not isinstance(uartObj, UART):
raise ValueError("parameter is not a GPIO object")
# 初始化定位模组串口
self.uartObj = uartObj
self.gnss = MicropyGNSS(location_formatting='dd')
def getLocation(self):
if self.uartObj is None:
raise ValueError("invalid UART object")
# 创建定位信息解析器
sentence = bytearray(100)
recvsize = self.uartObj.read(sentence)
if(recvsize):
# print(sentence)
# 解析地理位置信息
for c in sentence:
self.gnss.update(chr(c))
print(self.gnss.longitude, self.gnss.latitude, self.gnss.altitude)
return self.gnss
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/gnss/gnss.py
|
Python
|
apache-2.0
| 875
|
"""
# MicropyGPS - a GPS NMEA sentence parser for Micropython/Python 3.X
# Copyright (c) 2017 Michael Calvin McCoy (calvin.mccoy@protonmail.com)
# The MIT License (MIT) - see LICENSE file
"""
"""
MIT License
Copyright (c) 2017 Calvin McCoy
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.
"""
# TODO:
# Time Since First Fix
# Distance/Time to Target
# More Helper Functions
# Dynamically limit sentences types to parse
from math import floor, modf
# Import utime or time for fix time handling
try:
# Assume running on MicroPython
import utime
except ImportError:
# Otherwise default to time module for non-embedded implementations
# Should still support millisecond resolution.
import time
class MicropyGNSS(object):
"""NMEA Sentence Parser. Creates object that stores all relevant GPS data and statistics.
Parses sentences one character at a time using update(). """
# Max Number of Characters a valid sentence can be (based on GGA sentence)
SENTENCE_LIMIT = 90
__HEMISPHERES = ('N', 'S', 'E', 'W')
__NO_FIX = 1
__FIX_2D = 2
__FIX_3D = 3
__DIRECTIONS = ('N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 'SSW', 'SW', 'WSW', 'W',
'WNW', 'NW', 'NNW')
__MONTHS = ('January', 'February', 'March', 'April', 'May',
'June', 'July', 'August', 'September', 'October',
'November', 'December')
def __init__(self, local_offset=0, location_formatting='ddm'):
"""
Setup GPS Object Status Flags, Internal Data Registers, etc
local_offset (int): Timzone Difference to UTC
location_formatting (str): Style For Presenting Longitude/Latitude:
Decimal Degree Minute (ddm) - 40° 26.767′ N
Degrees Minutes Seconds (dms) - 40° 26′ 46″ N
Decimal Degrees (dd) - 40.446° N
"""
#####################
# Object Status Flags
self.sentence_active = False
self.active_segment = 0
self.process_crc = False
self.gps_segments = []
self.crc_xor = 0
self.char_count = 0
self.fix_time = 0
#####################
# Sentence Statistics
self.crc_fails = 0
self.clean_sentences = 0
self.parsed_sentences = 0
#####################
# Logging Related
self.log_handle = None
self.log_en = False
#####################
# Data From Sentences
# Time
self.timestamp = [0, 0, 0]
self.date = [0, 0, 0]
self.local_offset = local_offset
# Position/Motion
self._latitude = [0, 0.0, 'N']
self._longitude = [0, 0.0, 'W']
self.coord_format = location_formatting
self.speed = [0.0, 0.0, 0.0]
self.course = 0.0
self.altitude = 0.0
self.geoid_height = 0.0
# GPS Info
self.satellites_in_view = 0
self.satellites_in_use = 0
self.satellites_used = []
self.last_sv_sentence = 0
self.total_sv_sentences = 0
self.satellite_data = dict()
self.hdop = 0.0
self.pdop = 0.0
self.vdop = 0.0
self.valid = False
self.fix_stat = 0
self.fix_type = 1
########################################
# Coordinates Translation Functions
########################################
@property
def latitude(self):
"""Format Latitude Data Correctly"""
if self.coord_format == 'dd':
decimal_degrees = self._latitude[0] + (self._latitude[1] / 60)
return [decimal_degrees, self._latitude[2]]
elif self.coord_format == 'dms':
minute_parts = modf(self._latitude[1])
seconds = round(minute_parts[0] * 60)
return [self._latitude[0], int(minute_parts[1]), seconds, self._latitude[2]]
else:
return self._latitude
@property
def longitude(self):
"""Format Longitude Data Correctly"""
if self.coord_format == 'dd':
decimal_degrees = self._longitude[0] + (self._longitude[1] / 60)
return [decimal_degrees, self._longitude[2]]
elif self.coord_format == 'dms':
minute_parts = modf(self._longitude[1])
seconds = round(minute_parts[0] * 60)
return [self._longitude[0], int(minute_parts[1]), seconds, self._longitude[2]]
else:
return self._longitude
########################################
# Logging Related Functions
########################################
def start_logging(self, target_file, mode="append"):
"""
Create GPS data log object
"""
# Set Write Mode Overwrite or Append
mode_code = 'w' if mode == 'new' else 'a'
try:
self.log_handle = open(target_file, mode_code)
except AttributeError:
print("Invalid FileName")
return False
self.log_en = True
return True
def stop_logging(self):
"""
Closes the log file handler and disables further logging
"""
try:
self.log_handle.close()
except AttributeError:
print("Invalid Handle")
return False
self.log_en = False
return True
def write_log(self, log_string):
"""Attempts to write the last valid NMEA sentence character to the active file handler
"""
try:
self.log_handle.write(log_string)
except TypeError:
return False
return True
########################################
# Sentence Parsers
########################################
def gprmc(self):
"""Parse Recommended Minimum Specific GPS/Transit data (RMC)Sentence.
Updates UTC timestamp, latitude, longitude, Course, Speed, Date, and fix status
"""
# UTC Timestamp
try:
utc_string = self.gps_segments[1]
if utc_string: # Possible timestamp found
hours = (int(utc_string[0:2]) + self.local_offset) % 24
minutes = int(utc_string[2:4])
seconds = float(utc_string[4:])
self.timestamp = (hours, minutes, seconds)
else: # No Time stamp yet
self.timestamp = (0, 0, 0)
except ValueError: # Bad Timestamp value present
return False
# Date stamp
try:
date_string = self.gps_segments[9]
# Date string printer function assumes to be year >=2000,
# date_string() must be supplied with the correct century argument to display correctly
if date_string: # Possible date stamp found
day = int(date_string[0:2])
month = int(date_string[2:4])
year = int(date_string[4:6])
self.date = (day, month, year)
else: # No Date stamp yet
self.date = (0, 0, 0)
except ValueError: # Bad Date stamp value present
return False
# Check Receiver Data Valid Flag
if self.gps_segments[2] == 'A': # Data from Receiver is Valid/Has Fix
# Longitude / Latitude
try:
# Latitude
l_string = self.gps_segments[3]
lat_degs = int(l_string[0:2])
lat_mins = float(l_string[2:])
lat_hemi = self.gps_segments[4]
# Longitude
l_string = self.gps_segments[5]
lon_degs = int(l_string[0:3])
lon_mins = float(l_string[3:])
lon_hemi = self.gps_segments[6]
except ValueError:
return False
if lat_hemi not in self.__HEMISPHERES:
return False
if lon_hemi not in self.__HEMISPHERES:
return False
# Speed
try:
spd_knt = float(self.gps_segments[7])
except ValueError:
return False
# Course
try:
if self.gps_segments[8]:
course = float(self.gps_segments[8])
else:
course = 0.0
except ValueError:
return False
# TODO - Add Magnetic Variation
# Update Object Data
self._latitude = [lat_degs, lat_mins, lat_hemi]
self._longitude = [lon_degs, lon_mins, lon_hemi]
# Include mph and hm/h
self.speed = [spd_knt, spd_knt * 1.151, spd_knt * 1.852]
self.course = course
self.valid = True
# Update Last Fix Time
self.new_fix_time()
else: # Clear Position Data if Sentence is 'Invalid'
self._latitude = [0, 0.0, 'N']
self._longitude = [0, 0.0, 'W']
self.speed = [0.0, 0.0, 0.0]
self.course = 0.0
self.valid = False
return True
def gpgll(self):
"""Parse Geographic Latitude and Longitude (GLL)Sentence. Updates UTC timestamp, latitude,
longitude, and fix status"""
# UTC Timestamp
try:
utc_string = self.gps_segments[5]
if utc_string: # Possible timestamp found
hours = (int(utc_string[0:2]) + self.local_offset) % 24
minutes = int(utc_string[2:4])
seconds = float(utc_string[4:])
self.timestamp = (hours, minutes, seconds)
else: # No Time stamp yet
self.timestamp = (0, 0, 0)
except ValueError: # Bad Timestamp value present
return False
# Check Receiver Data Valid Flag
if self.gps_segments[6] == 'A': # Data from Receiver is Valid/Has Fix
# Longitude / Latitude
try:
# Latitude
l_string = self.gps_segments[1]
lat_degs = int(l_string[0:2])
lat_mins = float(l_string[2:])
lat_hemi = self.gps_segments[2]
# Longitude
l_string = self.gps_segments[3]
lon_degs = int(l_string[0:3])
lon_mins = float(l_string[3:])
lon_hemi = self.gps_segments[4]
except ValueError:
return False
if lat_hemi not in self.__HEMISPHERES:
return False
if lon_hemi not in self.__HEMISPHERES:
return False
# Update Object Data
self._latitude = [lat_degs, lat_mins, lat_hemi]
self._longitude = [lon_degs, lon_mins, lon_hemi]
self.valid = True
# Update Last Fix Time
self.new_fix_time()
else: # Clear Position Data if Sentence is 'Invalid'
self._latitude = [0, 0.0, 'N']
self._longitude = [0, 0.0, 'W']
self.valid = False
return True
def gpvtg(self):
"""Parse Track Made Good and Ground Speed (VTG) Sentence. Updates speed and course"""
try:
course = float(self.gps_segments[1])
spd_knt = float(self.gps_segments[5])
except ValueError:
return False
# Include mph and km/h
self.speed = (spd_knt, spd_knt * 1.151, spd_knt * 1.852)
self.course = course
return True
def gpgga(self):
"""Parse Global Positioning System Fix Data (GGA) Sentence. Updates UTC timestamp, latitude, longitude,
fix status, satellites in use, Horizontal Dilution of Precision (HDOP), altitude, geoid height and fix status"""
try:
# UTC Timestamp
utc_string = self.gps_segments[1]
# Skip timestamp if receiver doesn't have on yet
if utc_string:
hours = (int(utc_string[0:2]) + self.local_offset) % 24
minutes = int(utc_string[2:4])
seconds = float(utc_string[4:])
else:
hours = 0
minutes = 0
seconds = 0.0
# Number of Satellites in Use
satellites_in_use = int(self.gps_segments[7])
# Get Fix Status
fix_stat = int(self.gps_segments[6])
except (ValueError, IndexError):
return False
try:
# Horizontal Dilution of Precision
hdop = float(self.gps_segments[8])
except (ValueError, IndexError):
hdop = 0.0
# Process Location and Speed Data if Fix is GOOD
if fix_stat:
# Longitude / Latitude
try:
# Latitude
l_string = self.gps_segments[2]
lat_degs = int(l_string[0:2])
lat_mins = float(l_string[2:])
lat_hemi = self.gps_segments[3]
# Longitude
l_string = self.gps_segments[4]
lon_degs = int(l_string[0:3])
lon_mins = float(l_string[3:])
lon_hemi = self.gps_segments[5]
except ValueError:
return False
if lat_hemi not in self.__HEMISPHERES:
return False
if lon_hemi not in self.__HEMISPHERES:
return False
# Altitude / Height Above Geoid
try:
altitude = float(self.gps_segments[9])
geoid_height = float(self.gps_segments[11])
except ValueError:
altitude = 0
geoid_height = 0
# Update Object Data
self._latitude = [lat_degs, lat_mins, lat_hemi]
self._longitude = [lon_degs, lon_mins, lon_hemi]
self.altitude = altitude
self.geoid_height = geoid_height
# Update Object Data
self.timestamp = [hours, minutes, seconds]
self.satellites_in_use = satellites_in_use
self.hdop = hdop
self.fix_stat = fix_stat
# If Fix is GOOD, update fix timestamp
if fix_stat:
self.new_fix_time()
return True
def gpgsa(self):
"""Parse GNSS DOP and Active Satellites (GSA) sentence. Updates GPS fix type, list of satellites used in
fix calculation, Position Dilution of Precision (PDOP), Horizontal Dilution of Precision (HDOP), Vertical
Dilution of Precision, and fix status"""
# Fix Type (None,2D or 3D)
try:
fix_type = int(self.gps_segments[2])
except ValueError:
return False
# Read All (up to 12) Available PRN Satellite Numbers
sats_used = []
for sats in range(12):
sat_number_str = self.gps_segments[3 + sats]
if sat_number_str:
try:
sat_number = int(sat_number_str)
sats_used.append(sat_number)
except ValueError:
return False
else:
break
# PDOP,HDOP,VDOP
try:
pdop = float(self.gps_segments[15])
hdop = float(self.gps_segments[16])
vdop = float(self.gps_segments[17])
except ValueError:
return False
# Update Object Data
self.fix_type = fix_type
# If Fix is GOOD, update fix timestamp
if fix_type > self.__NO_FIX:
self.new_fix_time()
self.satellites_used = sats_used
self.hdop = hdop
self.vdop = vdop
self.pdop = pdop
return True
def gpgsv(self):
"""Parse Satellites in View (GSV) sentence. Updates number of SV Sentences,the number of the last SV sentence
parsed, and data on each satellite present in the sentence"""
try:
num_sv_sentences = int(self.gps_segments[1])
current_sv_sentence = int(self.gps_segments[2])
sats_in_view = int(self.gps_segments[3])
except ValueError:
return False
# Create a blank dict to store all the satellite data from this sentence in:
# satellite PRN is key, tuple containing telemetry is value
satellite_dict = dict()
# Calculate Number of Satelites to pull data for and thus how many segment positions to read
if num_sv_sentences == current_sv_sentence:
# Last sentence may have 1-4 satellites; 5 - 20 positions
sat_segment_limit = (
sats_in_view - ((num_sv_sentences - 1) * 4)) * 5
else:
# Non-last sentences have 4 satellites and thus read up to position 20
sat_segment_limit = 20
# Try to recover data for up to 4 satellites in sentence
for sats in range(4, sat_segment_limit, 4):
# If a PRN is present, grab satellite data
if self.gps_segments[sats]:
try:
sat_id = int(self.gps_segments[sats])
except (ValueError, IndexError):
return False
try: # elevation can be null (no value) when not tracking
elevation = int(self.gps_segments[sats+1])
except (ValueError, IndexError):
elevation = None
try: # azimuth can be null (no value) when not tracking
azimuth = int(self.gps_segments[sats+2])
except (ValueError, IndexError):
azimuth = None
try: # SNR can be null (no value) when not tracking
snr = int(self.gps_segments[sats+3])
except (ValueError, IndexError):
snr = None
# If no PRN is found, then the sentence has no more satellites to read
else:
break
# Add Satellite Data to Sentence Dict
satellite_dict[sat_id] = (elevation, azimuth, snr)
# Update Object Data
self.total_sv_sentences = num_sv_sentences
self.last_sv_sentence = current_sv_sentence
self.satellites_in_view = sats_in_view
# For a new set of sentences, we either clear out the existing sat data or
# update it as additional SV sentences are parsed
if current_sv_sentence == 1:
self.satellite_data = satellite_dict
else:
self.satellite_data.update(satellite_dict)
return True
##########################################
# Data Stream Handler Functions
##########################################
def new_sentence(self):
"""Adjust Object Flags in Preparation for a New Sentence"""
self.gps_segments = ['']
self.active_segment = 0
self.crc_xor = 0
self.sentence_active = True
self.process_crc = True
self.char_count = 0
def update(self, new_char):
"""Process a new input char and updates GPS object if necessary based on special characters ('$', ',', '*')
Function builds a list of received string that are validate by CRC prior to parsing by the appropriate
sentence function. Returns sentence type on successful parse, None otherwise"""
valid_sentence = False
# Validate new_char is a printable char
ascii_char = ord(new_char)
if 10 <= ascii_char <= 126:
self.char_count += 1
# Write Character to log file if enabled
if self.log_en:
self.write_log(new_char)
# Check if a new string is starting ($)
if new_char == '$':
self.new_sentence()
return None
elif self.sentence_active:
# Check if sentence is ending (*)
if new_char == '*':
self.process_crc = False
self.active_segment += 1
self.gps_segments.append('')
return None
# Check if a section is ended (,), Create a new substring to feed
# characters to
elif new_char == ',':
self.active_segment += 1
self.gps_segments.append('')
# Store All Other printable character and check CRC when ready
else:
self.gps_segments[self.active_segment] += new_char
# When CRC input is disabled, sentence is nearly complete
if not self.process_crc:
if len(self.gps_segments[self.active_segment]) == 2:
try:
final_crc = int(
self.gps_segments[self.active_segment], 16)
if self.crc_xor == final_crc:
valid_sentence = True
else:
self.crc_fails += 1
except ValueError:
pass # CRC Value was deformed and could not have been correct
# Update CRC
if self.process_crc:
self.crc_xor ^= ascii_char
# If a Valid Sentence Was received and it's a supported sentence, then parse it!!
if valid_sentence:
self.clean_sentences += 1 # Increment clean sentences received
self.sentence_active = False # Clear Active Processing Flag
if self.gps_segments[0] in self.supported_sentences:
# parse the Sentence Based on the message type, return True if parse is clean
if self.supported_sentences[self.gps_segments[0]](self):
# Let host know that the GPS object was updated by returning parsed sentence type
self.parsed_sentences += 1
return self.gps_segments[0]
# Check that the sentence buffer isn't filling up with Garage waiting for the sentence to complete
if self.char_count > self.SENTENCE_LIMIT:
self.sentence_active = False
# Tell Host no new sentence was parsed
return None
def new_fix_time(self):
"""Updates a high resolution counter with current time when fix is updated. Currently only triggered from
GGA, GSA and RMC sentences"""
try:
self.fix_time = utime.ticks_ms()
except NameError:
self.fix_time = time.time()
#########################################
# User Helper Functions
# These functions make working with the GPS object data easier
#########################################
def satellite_data_updated(self):
"""
Checks if the all the GSV sentences in a group have been read, making satellite data complete
:return: boolean
"""
if self.total_sv_sentences > 0 and self.total_sv_sentences == self.last_sv_sentence:
return True
else:
return False
def unset_satellite_data_updated(self):
"""
Mark GSV sentences as read indicating the data has been used and future updates are fresh
"""
self.last_sv_sentence = 0
def satellites_visible(self):
"""
Returns a list of of the satellite PRNs currently visible to the receiver
:return: list
"""
return list(self.satellite_data.keys())
def time_since_fix(self):
"""Returns number of millisecond since the last sentence with a valid fix was parsed. Returns 0 if
no fix has been found"""
# Test if a Fix has been found
if self.fix_time == 0:
return -1
# Try calculating fix time using utime; if not running MicroPython
# time.time() returns a floating point value in secs
try:
current = utime.ticks_diff(utime.ticks_ms(), self.fix_time)
except NameError:
current = (time.time() - self.fix_time) * 1000 # ms
return current
def compass_direction(self):
"""
Determine a cardinal or inter-cardinal direction based on current course.
:return: string
"""
# Calculate the offset for a rotated compass
if self.course >= 348.75:
offset_course = 360 - self.course
else:
offset_course = self.course + 11.25
# Each compass point is separated by 22.5 degrees, divide to find lookup value
dir_index = floor(offset_course / 22.5)
final_dir = self.__DIRECTIONS[dir_index]
return final_dir
def latitude_string(self):
"""
Create a readable string of the current latitude data
:return: string
"""
if self.coord_format == 'dd':
formatted_latitude = self.latitude
lat_string = str(
formatted_latitude[0]) + '° ' + str(self._latitude[2])
elif self.coord_format == 'dms':
formatted_latitude = self.latitude
lat_string = str(formatted_latitude[0]) + '° ' + str(formatted_latitude[1]) + "' " + str(
formatted_latitude[2]) + '" ' + str(formatted_latitude[3])
else:
lat_string = str(
self._latitude[0]) + '° ' + str(self._latitude[1]) + "' " + str(self._latitude[2])
return lat_string
def longitude_string(self):
"""
Create a readable string of the current longitude data
:return: string
"""
if self.coord_format == 'dd':
formatted_longitude = self.longitude
lon_string = str(
formatted_longitude[0]) + '° ' + str(self._longitude[2])
elif self.coord_format == 'dms':
formatted_longitude = self.longitude
lon_string = str(formatted_longitude[0]) + '° ' + str(formatted_longitude[1]) + "' " + str(
formatted_longitude[2]) + '" ' + str(formatted_longitude[3])
else:
lon_string = str(
self._longitude[0]) + '° ' + str(self._longitude[1]) + "' " + str(self._longitude[2])
return lon_string
def speed_string(self, unit='kph'):
"""
Creates a readable string of the current speed data in one of three units
:param unit: string of 'kph','mph, or 'knot'
:return:
"""
if unit == 'mph':
speed_string = str(self.speed[1]) + ' mph'
elif unit == 'knot':
if self.speed[0] == 1:
unit_str = ' knot'
else:
unit_str = ' knots'
speed_string = str(self.speed[0]) + unit_str
else:
speed_string = str(self.speed[2]) + ' km/h'
return speed_string
def date_string(self, formatting='s_mdy', century='20'):
"""
Creates a readable string of the current date.
Can select between long format: Januray 1st, 2014
or two short formats:
11/01/2014 (MM/DD/YYYY)
01/11/2014 (DD/MM/YYYY)
:param formatting: string 's_mdy', 's_dmy', or 'long'
:param century: int delineating the century the GPS data is from (19 for 19XX, 20 for 20XX)
:return: date_string string with long or short format date
"""
# Long Format Januray 1st, 2014
if formatting == 'long':
# Retrieve Month string from private set
month = self.__MONTHS[self.date[1] - 1]
# Determine Date Suffix
if self.date[0] in (1, 21, 31):
suffix = 'st'
elif self.date[0] in (2, 22):
suffix = 'nd'
elif self.date[0] == (3, 23):
suffix = 'rd'
else:
suffix = 'th'
day = str(self.date[0]) + suffix # Create Day String
year = century + str(self.date[2]) # Create Year String
date_string = month + ' ' + day + ', ' + year # Put it all together
else:
# Add leading zeros to day string if necessary
if self.date[0] < 10:
day = '0' + str(self.date[0])
else:
day = str(self.date[0])
# Add leading zeros to month string if necessary
if self.date[1] < 10:
month = '0' + str(self.date[1])
else:
month = str(self.date[1])
# Add leading zeros to year string if necessary
if self.date[2] < 10:
year = '0' + str(self.date[2])
else:
year = str(self.date[2])
# Build final string based on desired formatting
if formatting == 's_dmy':
date_string = day + '/' + month + '/' + year
else: # Default date format
date_string = month + '/' + day + '/' + year
return date_string
# All the currently supported NMEA sentences
supported_sentences = {'GPRMC': gprmc, 'GLRMC': gprmc, 'BDGSA': gpgsa,
'GPGGA': gpgga, 'GLGGA': gpgga, 'BDGSV': gpgsv,
'GPVTG': gpvtg, 'GLVTG': gpvtg,
'GPGSA': gpgsa, 'GLGSA': gpgsa,
'GPGSV': gpgsv, 'GLGSV': gpgsv,
'GPGLL': gpgll, 'GLGLL': gpgll,
'GNGGA': gpgga, 'GNRMC': gprmc,
'GNVTG': gpvtg, 'GNGLL': gpgll,
'GNGSA': gpgsa,
}
if __name__ == "__main__":
pass
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/gnss/micropyGNSS.py
|
Python
|
apache-2.0
| 30,723
|
from driver import ADC,GPIO
from time import sleep_us
class GP2Y10(object):
def __init__(self, adcObj,gpioObj):
self.adcObj = None
self.gpioObj = None
if not isinstance(adcObj, ADC):
raise ValueError("parameter is not an ADC object")
if not isinstance(gpioObj, GPIO):
raise ValueError("parameter is not an GPIO object")
self.adcObj = adcObj
self.gpioObj = gpioObj
self.gpioObj.write(1)
def getVoltage(self):
if self.adcObj is None:
raise ValueError("invalid ADC object")
self.gpioObj.write(0)
sleep_us(280)
value = self.adcObj.readVoltage()
sleep_us(40)
self.gpioObj.write(1)
sleep_us(9680)
return value
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/gp2y10/gp2y10.py
|
Python
|
apache-2.0
| 773
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
"""
from driver import I2C
import kv
class HAASEDUK1(object):
def __init__(self):
self.i2cDev = None
# 获取版本号
# 返回值为1，代表k1c
# 返回值为0，代表k1
def getHWID(self):
hwId = -1
result = kv.geti("HAASEDU_NAME")
if (result != None):
if (result == 1):
print("HAASEDUK1 hw version is 1.1")
return 1
elif (result == 0):
print("HAASEDUK1 hw version is 1.0")
return 0
else:
pass
# kv中不存在HAASEDU_NAME键值对，则通过外围传感器进行判断
# 读取QMI8610传感器device identifier register的值
self.i2cDev = I2C()
self.i2cDev.open("qmi8610")
buf = bytearray(1)
buf[0] = 0
self.i2cDev.memRead(buf, 0, 8) # register address:0 - FIS device identifier register address
self.i2cDev.close()
if buf[0] == 0xfc:
hwId = 1
else:
# 读取QMI8610传感器chip id register的值
self.i2cDev.open("qmp6988")
buf[0] = 0xD1 # chip id register
self.i2cDev.write(buf)
self.i2cDev.read(buf)
self.i2cDev.close()
if buf[0] == 0x5C:
hwId = 1
else:
# 读取QMC6310传感器chip id register的值
self.i2cDev.open("qmc6310")
buf[0] = 0x00 # chip id register
self.i2cDev.write(buf)
self.i2cDev.read(buf)
self.i2cDev.close()
if buf[0] == 0x80:
hwId = 1
if hwId == 1:
kv.seti("HAASEDU_NAME", 1)
print("HAASEDUK1 hw version is 1.1")
return 1
else:
kv.seti("HAASEDU_NAME", 0)
print("HAASEDUK1 hw version is 1.0")
return 0
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/haaseduk1/code/haaseduk1.py
|
Python
|
apache-2.0
| 1,984
|
# -*- encoding: utf-8 -*-
'''
@File : main.py
@Description: 读取HaaS EDU K1硬件和固件版本号，并显示在屏幕上
@Author : ethan.lcz
@version : 1.0
'''
import uos
import utime # 延时API所在组件
from haaseduk1 import HAASEDUK1 # 引入haaseduk1库，目标用于区分K1版本
from driver import SPI
from driver import GPIO
import sh1106
import framebuf
oled = None
# OLED初始化
def oledInit():
global oled
# 字库文件存放于项目目录 font, 注意若用到了中英文字库则都需要放置
framebuf.set_font_path(framebuf.FONT_HZK12, '/data/font/HZK12')
framebuf.set_font_path(framebuf.FONT_HZK16, '/data/font/HZK16')
framebuf.set_font_path(framebuf.FONT_HZK24, '/data/font/HZK24')
framebuf.set_font_path(framebuf.FONT_HZK32, '/data/font/HZK32')
framebuf.set_font_path(framebuf.FONT_ASC12_8, '/data/font/ASC12_8')
framebuf.set_font_path(framebuf.FONT_ASC16_8, '/data/font/ASC16_8')
framebuf.set_font_path(framebuf.FONT_ASC24_12, '/data/font/ASC24_12')
framebuf.set_font_path(framebuf.FONT_ASC32_16, '/data/font/ASC32_16')
oled_spi = SPI()
oled_spi.open("oled_spi")
oled_res = GPIO()
oled_res.open("oled_res")
oled_dc = GPIO()
oled_dc.open("oled_dc")
#oled像素132*64
oled = sh1106.SH1106_SPI(132, 64, oled_spi, oled_dc, oled_res)
# OLED显示
# text:显示的文本
# x:水平坐标 y:垂直坐标
# color:颜色
# clear: True-清屏显示 False-不清屏显示
# sz:字体大小
def oledShowText(text, x, y, color, clear, sz):
global oled
if clear:
oled.fill(0) # 清屏
oled.text(text, x, y, color, size = sz)
oled.show()
if __name__ == '__main__':
fwVersion = 'K1 FW - ' + uos.version()[11:]
board = HAASEDUK1() # 新建HAASEDUK1对象
hwID = board.getHWID() # 获取开发板ID
print ("hwID:", hwID)
hwVersion = "K1 HW - v1."+'01'[hwID]
oledInit()
while True:
oledShowText(hwVersion, 6, 20, 1, True, 12)
oledShowText(fwVersion, 6, 40, 1, False, 12)
utime.sleep(10) # 每隔1秒钟进行一次温湿度信息测量和打印
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/haaseduk1/code/main.py
|
Python
|
apache-2.0
| 2,222
|
from micropython import const
import utime
import framebuf
from driver import SPI
from driver import GPIO
# register definitions
SET_SCAN_DIR = const(0xc0)
LOW_COLUMN_ADDRESS = const(0x00)
HIGH_COLUMN_ADDRESS = const(0x10)
SET_PAGE_ADDRESS = const(0xB0)
SET_CONTRAST = const(0x81)
SET_ENTIRE_ON = const(0xa4)
SET_NORM_INV = const(0xa6)
SET_DISP = const(0xae)
SET_MEM_ADDR = const(0x20)
SET_COL_ADDR = const(0x21)
SET_PAGE_ADDR = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP = const(0xa0)
SET_MUX_RATIO = const(0xa8)
SET_COM_OUT_DIR = const(0xc0)
SET_DISP_OFFSET = const(0xd3)
SET_COM_PIN_CFG = const(0xda)
SET_DISP_CLK_DIV = const(0xd5)
SET_PRECHARGE = const(0xd9)
SET_VCOM_DESEL = const(0xdb)
SET_CHARGE_PUMP = const(0x8d)
class SH1106:
def __init__(self, width, height):
self.width = width
self.height = height
self.pages = self.height // 8
self.buffer = bytearray(self.pages * self.width)
fb = framebuf.FrameBuffer(
self.buffer, self.width, self.height, framebuf.MVLSB)
self.framebuf = fb
# set shortcuts for the methods of framebuf
self.fill = fb.fill
self.fill_rect = fb.fill_rect
self.hline = fb.hline
self.vline = fb.vline
self.line = fb.line
self.rect = fb.rect
self.pixel = fb.pixel
self.scroll = fb.scroll
self.text = fb.text
self.blit = fb.blit
# print("init done")
self.init_display()
def init_display(self):
self.reset()
for cmd in (
SET_DISP | 0x00, # 关闭显示
SET_DISP_CLK_DIV, 0x80, # 设置时钟分频因子
SET_MUX_RATIO, self.height - 1, # 设置驱动路数 路数默认0x3F�?1/64�?
SET_DISP_OFFSET, 0x00, # 设置显示偏移 偏移默认�?0
SET_DISP_START_LINE | 0x00, # 设置显示开始行[5:0]
SET_CHARGE_PUMP, 0x14, # 电荷泵设�? bit2，开�?/关闭
# 设置内存地址模式 [1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10;
SET_MEM_ADDR, 0x02,
SET_SEG_REMAP | 0x01, # 段重定义设置,bit0:0,0->0;1,0->127;
# 设置COM扫描方向;bit3:0,普通模�?;1,重定义模�? COM[N-1]->COM0;N:驱动路数
SET_COM_OUT_DIR | 0x08,
SET_COM_PIN_CFG, 0x12, # 设置COM硬件引脚配置 [5:4]配置
SET_PRECHARGE, 0xf1, # 设置预充电周�? [3:0],PHASE 1;[7:4],PHASE 2;
# 设置VCOMH 电压倍率 [6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc;
SET_VCOM_DESEL, 0x30,
SET_CONTRAST, 0xff, # 对比度设�? 默认0x7F（范�?1~255，越大越亮）
SET_ENTIRE_ON, # 全局显示开�?;bit0:1,开�?;0,关闭;(白屏/黑屏)
SET_NORM_INV, # 设置显示方式;bit0:1,反相显示;0,正常显示
SET_DISP | 0x01): # 开启显�?
self.write_cmd(cmd)
self.fill(1)
self.show()
def poweroff(self):
self.write_cmd(SET_DISP | 0x00)
def poweron(self):
self.write_cmd(SET_DISP | 0x01)
def rotate(self, flag, update=True):
if flag:
self.write_cmd(SET_SEG_REMAP | 0x01) # mirror display vertically
self.write_cmd(SET_SCAN_DIR | 0x08) # mirror display hor.
else:
self.write_cmd(SET_SEG_REMAP | 0x00)
self.write_cmd(SET_SCAN_DIR | 0x00)
if update:
self.show()
def sleep(self, value):
self.write_cmd(SET_DISP | (not value))
def contrast(self, contrast):
self.write_cmd(SET_CONTRAST)
self.write_cmd(contrast)
def invert(self, invert):
self.write_cmd(SET_NORM_INV | (invert & 1))
def show(self):
for page in range(self.height // 8):
self.write_cmd(SET_PAGE_ADDRESS | page)
self.write_cmd(LOW_COLUMN_ADDRESS)
self.write_cmd(HIGH_COLUMN_ADDRESS)
page_buffer = bytearray(self.width)
for i in range(self.width):
page_buffer[i] = self.buffer[self.width * page + i]
self.write_data(page_buffer)
def set_buffer(self, buffer):
for i in range(len(buffer)):
self.buffer[i] = buffer[i]
def draw_XBM(self, x, y, w, h, bitmap):
x_byte = (w//8) + (w % 8 != 0)
for nbyte in range(len(bitmap)):
for bit in range(8):
if(bitmap[nbyte] & (0b10000000 >> bit)):
p_x = (nbyte % x_byte)*8+bit
p_y = nbyte//x_byte
self.pixel(x + p_x, y + p_y, 1)
# 以屏幕GRAM的原始制式去填充Buffer
def draw_buffer(self, x, y, w, h, bitmap):
y_byte = (h//8) + (h % 8 != 0)
for nbyte in range(len(bitmap)):
for bit in range(8):
if(bitmap[nbyte] & (1 << bit)):
p_y = (nbyte % y_byte)*8+bit
p_x = nbyte//y_byte
self.pixel(x + p_x, y + p_y, 1)
def fill_rect(self, x, y, w, h, c):
self.fill_rect(x, y, w, h, c)
def fill_circle(self, x0, y0, r, c):
x = 0
y = r
deltax = 3
deltay = 2 - r - r
d = 1 - r
#print(x)
#print(y)
#print(deltax)
#print(deltay)
#print(d)
self.pixel(x + x0, y + y0, c)
self.pixel(x + x0, -y + y0, c)
for i in range(-r + x0, r + x0):
self.pixel(i, y0, c)
while x < y:
if d < 0:
d += deltax
deltax += 2
x = x +1
else:
d += (deltax + deltay)
deltax += 2
deltay += 2
x = x +1
y = y -1
for i in range(-x + x0, x + x0):
self.pixel(i, -y + y0, c)
self.pixel(i, y + y0, c)
for i in range(-y + x0, y + x0):
self.pixel(i, -x + y0, c)
self.pixel(i, x + y0, c)
def draw_circle(self, x0, y0, r, w, c):
self.fill_circle(x0, y0, r, c)
self.fill_circle(x0, y0, r -w, 0)
def reset(self, res):
if res is not None:
res.write(1)
utime.sleep_ms(1)
res.write(0)
utime.sleep_ms(20)
res.write(1)
utime.sleep_ms(20)
class SH1106_I2C(SH1106):
def __init__(self, width, height, i2c, res=None, addr=0x3c):
self.i2c = i2c
self.addr = addr
self.res = res
self.temp = bytearray(2)
super().__init__(width, height)
def write_cmd(self, cmd):
self.temp[0] = 0x80 # Co=1, D/C#=0
self.temp[1] = cmd
self.i2c.write(self.temp)
def write_data(self, buf):
send_buf = bytearray(1 + len(buf))
send_buf[0] = 0x40
for i in range(len(buf)):
send_buf[i+1] = buf[i]
print(send_buf)
self.i2c.write(send_buf)
def reset(self):
super().reset(self.res)
class SH1106_SPI(SH1106):
def __init__(self, width, height, spi, dc, res=None, cs=None):
self.spi = spi
self.dc = dc
self.res = res
self.cs = cs
super().__init__(width, height)
def write_cmd(self, cmd):
if self.cs is not None:
self.cs.write(1)
self.dc.write(0)
self.cs.write(0)
self.spi.write(bytearray([cmd]))
self.cs.write(1)
else:
self.dc.write(0)
self.spi.write(bytearray([cmd]))
def write_data(self, buf):
if self.cs is not None:
self.cs.write(1)
self.dc.write(1)
self.cs.write(0)
self.spi.write(buf)
self.cs.write(1)
else:
self.dc.write(1)
self.spi.write(buf)
def reset(self):
super().reset(self.res)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/haaseduk1/code/sh1106.py
|
Python
|
apache-2.0
| 7,941
|
from driver import ADC
class HCHO(object):
def __init__(self, adcObj):
self.adcObj = None
if not isinstance(adcObj, ADC):
raise ValueError("parameter is not an ADC object")
self.adcObj = adcObj
def getPPM(self):
if self.adcObj is None:
raise ValueError("invalid ADC object")
min = 400
max = 0
value = 0
total = 0
i = 0
for i in range(32):
value = self.adcObj.readVoltage()
total += value
# print(value)
if (min >= value):
min = value
if (max <= value):
max = value
analogVoltage = (total - min - max) / 30
analogVoltage /= 991.0
#linear relationship(0.4V for 0 ppm and 2V for 5ppm)
ppm = 3.125 * analogVoltage - 1.25
return ppm
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/hcho/hcho.py
|
Python
|
apache-2.0
| 876
|
from time import sleep_us,ticks_us
from driver import GPIO
class HCSR04():
def __init__(self,trigObj,echoObj):
self.trig = None
self.echo = None
if not isinstance(trigObj, GPIO):
raise ValueError("parameter is not a GPIO object")
if not isinstance(echoObj, GPIO):
raise ValueError("parameter is not a GPIO object")
self.trig = trigObj
self.echo = echoObj
def measureDistance(self):
distance=0
self.trig.write(1)
sleep_us(20)
self.trig.write(0)
while self.echo.read() == 0:
pass
if self.echo.read() == 1:
ts=ticks_us() #开始时间
while self.echo.read() == 1: #等待脉冲高电平结束
pass
te=ticks_us() #结束时间
tc=te-ts #回响时间（单位us，1us=1*10^(-6)s）
distance=(tc*170)/10000 #距离计算 （单位为:cm）
return distance
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/hcsr04/hcsr04.py
|
Python
|
apache-2.0
| 1,046
|
# -*- encoding: utf-8 -*-
'''
@File : heartbeat.py
@Description: 心率传感器驱动
@Author : victor.wang
@version : 1.0
'''
from driver import ADC # ADC类，通过微处理器的ADC模块读取ADC通道输入电压
from driver import TIMER # 定时器类，用于定时调用心率传感器
from driver import GPIO
class HEARTBEAT (object):
def __init__(self, adcdev=None, rled=None, gled=None, bled=None, highBPM=150, lowBPM=100):
if (not isinstance(adcdev, ADC)):
raise ValueError("parameter is wrong")
self.adcObj = adcdev
self.rled=rled
self.bled=bled
self.gled=gled
self.highBPM=highBPM
self.lowBPM=lowBPM
self.ledexist= (rled!=None and gled!=None and bled!=None)
self.rate=[0 for _ in range(10)]
self.sampleCounter = 0 # 心跳时间
self.lastBeatTime = 0 # IBIT
self.P = 1800 # 用于确定心跳波形的最大值
self.T = 1800 # 用于确定心跳波形的最小值
self.thresh = 1800 # 用于确定心跳的瞬态值
self.amp = 150 # 心率波形的幅度
self.firstBeat = True # 第一次心跳
self.secondBeat = False # 第二次心跳
self.BPM=0; # 心率
self.Signal = 0 # 心跳信号
self.IBI = 600 # 心跳间隔
self.Pulse = False # 心跳波心是否为高
self.QS = False # 找到心跳
self.timerobj = TIMER(0) # 定时器
self.timerobj.open(period=2, mode=self.timerobj.PERIODIC, callback=self.getHeartbeat)
def getBPM(self):
return self.BPM
def getHeartbeat(self, args):
self.timerobj.stop()
self.Signal = self.adcObj.readVoltage() # 读心跳传感器
self.sampleCounter +=2.5 # 记录时间 单位（ms）(理论值为2ms 2.5ms 为校准值)
NUM = self.sampleCounter - self.lastBeatTime # 距上次心跳时间
# 确定心跳波形的波峰和波谷
if(self.Signal < self.thresh and NUM > (self.IBI/5)*3): # 去除dichrotic噪音
if (self.Signal < self.T): # self.T 是波谷值
self.T = self.Signal # 记录波谷值
if (self.Signal > self.thresh and self.Signal > self.P):
self.P = self.Signal # self.P 是波峰
if (NUM > 250):
if ((self.Signal > self.thresh) and (self.Pulse == False)):
self.Pulse = True
if self.ledexist:
if self.BPM >= self.highBPM: # 如果心率过快，点亮红灯
self.rled.write(1)
elif self.BPM <= self.lowBPM: # 如果心率过慢，点亮蓝灯
self.bled.write(1)
else: # 如果心率合适，点亮绿灯
self.gled.write(1)
self.IBI = self.sampleCounter - self.lastBeatTime # 心跳间隔
self.lastBeatTime = self.sampleCounter # 更新心跳间隔起始点
if(self.secondBeat): # 第二次心跳
self.secondBeat = False # 清除第二次心跳标识
for i in range(10):
self.rate[i] = self.IBI
if(self.firstBeat): # 第一次心跳
self.firstBeat = False # 清除第一次心跳标识
self.secondBeat = True # 置位第二次心跳标识
self.timerobj.start()
return
runningTotal = 0
for i in range(9):
self.rate[i] = self.rate[i+1] # 丢弃最老的IBI值
runningTotal = runningTotal + self.rate[i] # 求和最老的9个IBI值
self.rate[9] = self.IBI
runningTotal = runningTotal+self.rate[9]
runningTotal = runningTotal/10
self.BPM = 60000/runningTotal # 计算心率
self.QS = True
if ((self.Signal < self.thresh) and (self.Pulse == True)):
if self.ledexist:
self.rled.write(0)
self.bled.write(0)
self.gled.write(0)
self.Pulse = False
self.amp = self.P - self.T
self.thresh = self.amp/2 + self.T
self.P = self.thresh
self.T = self.thresh
if (NUM > 2500): # 如果2.5秒后还没检测到心跳
self.thresh = 1800 # thresh 设置为默认值
self.P = 1800 # P 设置为默认值
self.T = 1800 # T 设置为默认值
self.lastBeatTime = self.sampleCounter # 更新lastBeatTime
self.firstBeat = True # 置位第一次心跳标识
self.secondBeat = False # 清除第二次心跳标识
self.timerobj.start()
return
def start(self):
self.timerobj.start()
def stop(self):
self.timerobj.stop()
self.timerobj.close()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/heartrate/heartbeat.py
|
Python
|
apache-2.0
| 5,894
|
import ustruct
class HTB485(object):
def __init__(self, mbObj, devAddr):
self.mbObj = mbObj
self.devAddr = devAddr
def getHumidity(self):
if self.mbObj is None:
raise ValueError("invalid modbus object.")
value = bytearray(4)
ret = self.mbObj.readHoldingRegisters(self.devAddr, 0, 2, value, 200)
if ret[0] < 0:
raise ValueError("readHoldingRegisters failed. errno:", ret[0])
humidity = ustruct.unpack('hh',value)
return humidity[0]
def getTemperature(self):
if self.mbObj is None:
raise ValueError("invalid modbus object.")
value = bytearray(4)
ret = self.mbObj.readHoldingRegisters(self.devAddr, 0, 2, value, 200)
if ret[0] < 0:
raise ValueError("readHoldingRegisters failed. errno:", ret[0])
temperature = ustruct.unpack('hh',value)
return temperature[1]
def getBrightness(self):
if self.mbObj is None:
raise ValueError("invalid modbus object.")
value = bytearray(4)
ret = self.mbObj.readHoldingRegisters(self.devAddr, 2, 2, value, 200)
if ret[0] < 0:
raise ValueError("readHoldingRegisters failed. errno:", ret[0])
brightness = ustruct.unpack('hh',value)
return brightness[1]
def getHTB(self):
if self.mbObj is None:
raise ValueError("invalid modbus object.")
value = bytearray(10)
ret = self.mbObj.readHoldingRegisters(self.devAddr, 0, 5, value, 200)
if ret[0] < 0:
raise ValueError("readHoldingRegisters failed. errno:", ret[0])
htb = ustruct.unpack('hhhhh',value)
return htb
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/htb485/yuanda_htb485.py
|
Python
|
apache-2.0
| 1,739
|
from driver import GPIO
import utime
class HX710(object):
def __init__(self, clkObj, dataObj):
self.clkObj = None
self.dataObj = None
if not isinstance(clkObj, GPIO):
raise ValueError("parameter is not an GPIO object")
if not isinstance(dataObj, GPIO):
raise ValueError("parameter is not an GPIO object")
self.clkObj = clkObj
self.dataObj = dataObj
def getValue(self):
if self.clkObj is None:
raise ValueError("invalid GPIO object")
if self.dataObj is None:
raise ValueError("invalid GPIO object")
count = 0
self.dataObj.write(1)
self.clkObj.write(0)
while(self.dataObj.read()):
utime.sleep_ms(1)
for i in range(24):
self.clkObj.write(1)
count = count<<1
self.clkObj.write(0)
if(self.dataObj.read()):
count += 1
self.clkObj.write(1)
count ^= 0x800000
self.clkObj.write(0)
return count
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/hx710/hx710.py
|
Python
|
apache-2.0
| 1,060
|
import utime
from math import trunc
from micropython import const
from driver import I2C
class INA219(object):
RANGE_16V = const(0) # Range 0-16 volts
RANGE_32V = const(1) # Range 0-32 volts
GAIN_1_40MV = const(0) # Maximum shunt voltage 40mV
GAIN_2_80MV = const(1) # Maximum shunt voltage 80mV
GAIN_4_160MV = const(2) # Maximum shunt voltage 160mV
GAIN_8_320MV = const(3) # Maximum shunt voltage 320mV
GAIN_AUTO = const(-1) # Determine gain automatically
ADC_9BIT = const(0) # 9-bit conversion time 84us.
ADC_10BIT = const(1) # 10-bit conversion time 148us.
ADC_11BIT = const(2) # 11-bit conversion time 2766us.
ADC_12BIT = const(3) # 12-bit conversion time 532us.
ADC_2SAMP = const(9) # 2 samples at 12-bit, conversion time 1.06ms.
ADC_4SAMP = const(10) # 4 samples at 12-bit, conversion time 2.13ms.
ADC_8SAMP = const(11) # 8 samples at 12-bit, conversion time 4.26ms.
ADC_16SAMP = const(12) # 16 samples at 12-bit,conversion time 8.51ms
ADC_32SAMP = const(13) # 32 samples at 12-bit, conversion time 17.02ms.
ADC_64SAMP = const(14) # 64 samples at 12-bit, conversion time 34.05ms.
ADC_128SAMP = const(15) # 128 samples at 12-bit, conversion time 68.10ms.
__ADDRESS = 0x40
__REG_CONFIG = 0x00
__REG_SHUNTVOLTAGE = 0x01
__REG_BUSVOLTAGE = 0x02
__REG_POWER = 0x03
__REG_CURRENT = 0x04
__REG_CALIBRATION = 0x05
__RST = 15
__BRNG = 13
__PG1 = 12
__PG0 = 11
__BADC4 = 10
__BADC3 = 9
__BADC2 = 8
__BADC1 = 7
__SADC4 = 6
__SADC3 = 5
__SADC2 = 4
__SADC1 = 3
__MODE3 = 2
__MODE2 = 1
__MODE1 = 0
__OVF = 1
__CNVR = 2
__BUS_RANGE = [16, 32]
__GAIN_VOLTS = [0.04, 0.08, 0.16, 0.32]
__CONT_SH_BUS = 7
__AMP_ERR_MSG = ('Expected current %.3fA is greater '
'than max possible current %.3fA')
__RNG_ERR_MSG = ('Expected amps %.2fA, out of range, use a lower '
'value shunt resistor')
__VOLT_ERR_MSG = ('Invalid voltage range, must be one of: '
'RANGE_16V, RANGE_32V')
__SHUNT_MILLIVOLTS_LSB = 0.01 # 10uV
__BUS_MILLIVOLTS_LSB = 4 # 4mV
__CALIBRATION_FACTOR = 0.04096
__MAX_CALIBRATION_VALUE = 0xFFFE
__CURRENT_LSB_FACTOR = 32800
def __init__(self, i2cDev):
self._i2c = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
self._i2c = i2cDev
self._shunt_ohms = 0.1
self._max_expected_amps = None
self._min_device_current_lsb = self._calculate_min_current_lsb()
self._gain = None
self._auto_gain_enabled = False
self.configure()
def configure(self, voltage_range=RANGE_32V, gain=GAIN_AUTO,
bus_adc=ADC_12BIT, shunt_adc=ADC_12BIT):
self.__validate_voltage_range(voltage_range)
self._voltage_range = voltage_range
if self._max_expected_amps is not None:
if gain == self.GAIN_AUTO:
self._auto_gain_enabled = True
self._gain = self._determine_gain(self._max_expected_amps)
else:
self._gain = gain
else:
if gain != self.GAIN_AUTO:
self._gain = gain
else:
self._auto_gain_enabled = True
self._gain = self.GAIN_1_40MV
self._calibrate(
self.__BUS_RANGE[voltage_range], self.__GAIN_VOLTS[self._gain],
self._max_expected_amps)
self._configure(voltage_range, self._gain, bus_adc, shunt_adc)
def getVoltage(self):
value = self._voltage_register()
return float(value) * self.__BUS_MILLIVOLTS_LSB / 1000
def supply_voltage(self):
return self.voltage() + (float(self.shunt_voltage()) / 1000)
def getCurrent(self):
self._handle_current_overflow()
return self._current_register() * self._current_lsb * 1000
def getPower(self):
self._handle_current_overflow()
return self._power_register() * self._power_lsb * 1000
def shunt_voltage(self):
self._handle_current_overflow()
return self._shunt_voltage_register() * self.__SHUNT_MILLIVOLTS_LSB
def sleep(self):
configuration = self._read_configuration()
self._configuration_register(configuration & 0xFFF8)
def wake(self):
configuration = self._read_configuration()
self._configuration_register(configuration | 0x0007)
# 40us delay to recover from powerdown (p14 of spec)
utime.sleep_us(40)
def current_overflow(self):
return self._has_current_overflow()
def reset(self):
"""Reset the INA219 to its default configuration."""
self._configuration_register(1 << self.__RST)
def _handle_current_overflow(self):
if self._auto_gain_enabled:
while self._has_current_overflow():
self._increase_gain()
else:
if self._has_current_overflow():
raise DeviceRangeError(self.__GAIN_VOLTS[self._gain])
def _determine_gain(self, max_expected_amps):
shunt_v = max_expected_amps * self._shunt_ohms
if shunt_v > self.__GAIN_VOLTS[3]:
raise ValueError(self.__RNG_ERR_MSG % max_expected_amps)
gain = min(v for v in self.__GAIN_VOLTS if v > shunt_v)
return self.__GAIN_VOLTS.index(gain)
def _increase_gain(self):
gain = self._read_gain()
if gain < len(self.__GAIN_VOLTS) - 1:
gain = gain + 1
self._calibrate(self.__BUS_RANGE[self._voltage_range],
self.__GAIN_VOLTS[gain])
self._configure_gain(gain)
# 1ms delay required for new configuration to take effect,
# otherwise invalid current/power readings can occur.
utime.sleep_ms(1)
else:
raise DeviceRangeError(self.__GAIN_VOLTS[gain], True)
def _configure(self, voltage_range, gain, bus_adc, shunt_adc):
configuration = (
voltage_range << self.__BRNG | gain << self.__PG0 |
bus_adc << self.__BADC1 | shunt_adc << self.__SADC1 |
self.__CONT_SH_BUS)
self._configuration_register(configuration)
def _calibrate(self, bus_volts_max, shunt_volts_max,max_expected_amps=None):
max_possible_amps = shunt_volts_max / self._shunt_ohms
self._current_lsb = \
self._determine_current_lsb(max_expected_amps, max_possible_amps)
self._power_lsb = self._current_lsb * 20
max_current = self._current_lsb * 32767
max_shunt_voltage = max_current * self._shunt_ohms
calibration = trunc(self.__CALIBRATION_FACTOR /
(self._current_lsb * self._shunt_ohms))
self._calibration_register(calibration)
def _determine_current_lsb(self, max_expected_amps, max_possible_amps):
if max_expected_amps is not None:
if max_expected_amps > round(max_possible_amps, 3):
raise ValueError(self.__AMP_ERR_MSG %
(max_expected_amps, max_possible_amps))
if max_expected_amps < max_possible_amps:
current_lsb = max_expected_amps / self.__CURRENT_LSB_FACTOR
else:
current_lsb = max_possible_amps / self.__CURRENT_LSB_FACTOR
else:
current_lsb = max_possible_amps / self.__CURRENT_LSB_FACTOR
if current_lsb < self._min_device_current_lsb:
current_lsb = self._min_device_current_lsb
return current_lsb
def _configuration_register(self, register_value):
self.__write_register(self.__REG_CONFIG, register_value)
def _read_configuration(self):
return self.__read_register(self.__REG_CONFIG)
def _calculate_min_current_lsb(self):
return self.__CALIBRATION_FACTOR / \
(self._shunt_ohms * self.__MAX_CALIBRATION_VALUE)
def _read_gain(self):
configuration = self._read_configuration()
gain = (configuration & 0x1800) >> self.__PG0
return gain
def _configure_gain(self, gain):
configuration = self._read_configuration()
configuration = configuration & 0xE7FF
self._configuration_register(configuration | (gain << self.__PG0))
self._gain = gain
def _calibration_register(self, register_value):
self.__write_register(self.__REG_CALIBRATION, register_value)
def _has_current_overflow(self):
ovf = self._read_voltage_register() & self.__OVF
return (ovf == 1)
def _voltage_register(self):
register_value = self._read_voltage_register()
return register_value >> 3
def _read_voltage_register(self):
return self.__read_register(self.__REG_BUSVOLTAGE)
def _current_register(self):
return self.__read_register(self.__REG_CURRENT, True)
def _shunt_voltage_register(self):
return self.__read_register(self.__REG_SHUNTVOLTAGE, True)
def _power_register(self):
return self.__read_register(self.__REG_POWER)
def __validate_voltage_range(self, voltage_range):
if voltage_range > len(self.__BUS_RANGE) - 1:
raise ValueError(self.__VOLT_ERR_MSG)
def __write_register(self, register, register_value):
register_bytes = self.__to_bytes(register_value)
# self._i2c.writeto_mem(self._address, register, register_bytes)
self._i2c.memWrite(register_bytes,register,8)
def __to_bytes(self, register_value):
return bytearray([(register_value >> 8) & 0xFF, register_value & 0xFF])
def __read_register(self, register, negative_value_supported=False):
# register_bytes = self._i2c.readfrom_mem(self._address, register, 2)
buf=bytearray(2)
self._i2c.memRead(buf,register,8)
register_value = int.from_bytes(buf, 'big')
if negative_value_supported:
# Two's compliment
if register_value > 32767:
register_value -= 65536
return register_value
class DeviceRangeError(Exception):
__DEV_RNG_ERR = ('Current out of range (overflow), '
'for gain %.2fV')
def __init__(self, gain_volts, device_max=False):
"""Construct the class."""
msg = self.__DEV_RNG_ERR % gain_volts
if device_max:
msg = msg + ', device limit reached'
super(DeviceRangeError, self).__init__(msg)
self.gain_volts = gain_volts
self.device_limit_reached = device_max
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/ina219/ina219.py
|
Python
|
apache-2.0
| 10,625
|
from driver import GPIO
class IR(object):
def __init__(self, gpioObj):
self.gpioObj = None
if not isinstance(gpioObj, GPIO):
raise ValueError("parameter is not a GPIO object")
self.gpioObj = gpioObj
def irDetect(self):
if self.gpioObj is None:
raise ValueError("invalid GPIO object")
value = self.gpioObj.read()
return value
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/ir/ir.py
|
Python
|
apache-2.0
| 410
|
from driver import GPIO
class IRDISTANCE(object):
def __init__(self, gpioObj):
self.gpioObj = None
if not isinstance(gpioObj, GPIO):
raise ValueError("parameter is not a GPIO object")
self.gpioObj = gpioObj
def objectDetection(self):
if self.gpioObj is None:
raise ValueError("invalid GPIO object")
value = self.gpioObj.read()
return value
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/irdistance/irdistance.py
|
Python
|
apache-2.0
| 424
|
import os
import utime
import micropython
import ujson
from driver import GPIO
micropython.alloc_emergency_exception_buf(100)
class IRREMOTE(object):
CODE = {207: "1", 231: "2", 133: "3", 239: "4", 199: "5", 165: "6", 189: "7", 181: "8", 173: "9",
151: "0", 221: "PREV", 253: "NEXT", 31: "VOL-", 87: "VOL+", 103: "100+", 79: "200+", 61: "START/STOP"}
def __init__(self, gpioobj):
self.irrecv = None
if not isinstance(gpioobj, GPIO):
raise ValueError("parameter is not a GPIO object")
self.irrecv = gpioobj
self.irrecv.on(self.__irProcess)
self.ir_step = 0
self.ir_count = 0
self.buf64 = [0 for i in range(64)]
self.recived_ok = False
self.cmd = None
self.cmd_last = None
self.repeat = 0
self.repeat_last = None
self.t_ok = None
self.t_ok_last = None
self.start = 0
self.start_last = 0
self.changed = False
def __irProcess(self, source):
thisComeInTime = utime.ticks_us()
# 更新时间
curtime = utime.ticks_diff(thisComeInTime, self.start)
self.start = thisComeInTime
if curtime >= 8500 and curtime <= 9500:
print(1,curtime)
self.ir_step = 1
return
if self.ir_step == 1:
print(2,curtime)
if curtime >= 4000 and curtime <= 5000:
self.ir_step = 2
self.recived_ok = False
self.ir_count = 0
self.repeat = 0
elif curtime >= 2000 and curtime <= 3000: # 长按重复接收
self.ir_step = 3
self.repeat += 1
elif self.ir_step == 2: # 接收4个字节
self.buf64[self.ir_count] = curtime
self.ir_count += 1
if self.ir_count >= 64:
self.recived_ok = True
self.t_ok = self.start #记录最后ok的时间
self.ir_step = 0
elif self.ir_step == 3: # 重复
if curtime >= 500 and curtime <= 650:
self.repeat += 1
def __check_cmd(self):
byte4 = 0
for i in range(32):
x = i * 2
t = self.buf64[x] + self.buf64[x+1]
byte4 <<= 1
if t >= 1800 and t <= 2800:
byte4 += 1
user_code_hi = (byte4 & 0xff000000) >> 24
user_code_lo = (byte4 & 0x00ff0000) >> 16
data_code = (byte4 & 0x0000ff00) >> 8
data_code_r = byte4 & 0x000000ff
self.cmd = data_code_r
print(self.buf64)
def getRemoteObject(self):
return self.buf64
def getRemoteChar(self):
# 接收到数据
if self.recived_ok:
self.__check_cmd()
self.recived_ok = False
#数据有变化
if self.cmd != self.cmd_last:
self.changed = True
else:
self.changed = False
#更新
self.cmd_last = self.cmd
self.repeat_last = self.repeat
self.t_ok_last = self.t_ok
#对应按钮字符
s = self.CODE.get(self.cmd)
return self.changed, s
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/irremote/irremote.py
|
Python
|
apache-2.0
| 3,177
|
class L298DC():
def __init__(self, Int1x, Int2x, en=None, freq=50, name="DCMotorX"):
self.name = name
self.int1x = Int1x
self.int2x = Int2x
self.en = en
self.freq = freq
def run(self, rate=50):
if(self.en != None):
self.en.setOption({self.freq, rate if rate > 0 else -rate})
self.int1x.setOption({self.freq, 0 if rate > 0 else 100})
self.int2x.setOption({self.freq, 100 if rate > 0 else 0})
else:
self.int1x.setOption({self.freq, 0 if rate > 0 else 100})
self.int2x.setOption({self.freq, rate if rate > 0 else 0})
def stop(self):
if(self.en != None):
self.en.setOption({self.freq, 100})
self.int1x.setOption({self.freq, 0})
self.int2x.setOption({self.freq, 0})
def enable(self):
if(self.en == None):
raise SystemError("driver EN pin not specific。")
else:
self.en.setOption({self.freq, 100})
def disable(self):
if(self.en == None):
raise SystemError("driver EN pin not specific。")
else:
self.en.setOption({self.freq, 0})
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/l298/l298.py
|
Python
|
apache-2.0
| 1,181
|
import utime
# 命令标志(配合后面的参数传递)
LCD_CLEARDISPLAY = 0x01
LCD_RETURNHOME = 0x02
LCD_ENTRYMODESET = 0x04
LCD_DISPLAYCONTROL = 0x08
LCD_CURSORSHIFT = 0x10
LCD_FUNCTIONSET = 0x20
LCD_SETCGRAMADDR = 0x40
LCD_SETDDRAMADDR = 0x80
# 打印项标志
# 光标移动模式(打印时)
LCD_ENTRY_DEC = 0x00 # Decrease 模式，光标向左减少，即从右到左打印
LCD_ENTRY_INC = 0x02 # Increase 模式，光标向右增加，即从左到右打印
# 文字移动模式(打印时)
LCD_ENTRY_SHIFT = 0x01 # 文字向左移动
LCD_ENTRY_NOSHIFT = 0x00 # 文字不移动
# 显示开关、光标开关、光标闪烁开关标志
LCD_DISPLAYON = 0x04
LCD_DISPLAYOFF = 0x00
LCD_CURSORON = 0x02
LCD_CURSOROFF = 0x00
LCD_BLINKON = 0x01
LCD_BLINKOFF = 0x00
# 屏幕移动标志
LCD_DISPLAYMOVE = 0x08
LCD_MOVERIGHT = 0x04
LCD_MOVELEFT = 0x00
# 功能设置标志
LCD_8BITMODE = 0x10
LCD_4BITMODE = 0x00
LCD_2LINE = 0x08
LCD_1LINE = 0x00
LCD_5x10DOTS = 0x04
LCD_5x8DOTS = 0x00
class LCD1602(object):
def __init__(self, RS, RW, E, D4, D5, D6, D7):
self.RS = RS
self.RW = RW
self.E = E
self.D4 = D4
self.D5 = D5
self.D6 = D6
self.D7 = D7
if not self.D4 or not self.D5 or not self.D6 or not self.D7:
raise Exception('should give d4-d7 pins')
if not self.RS or not self.E:
raise Exception('should give RS E pins')
self._displayfunction = 0
self._displaycontrol = 0
self._displaymode = 0
self.init()
def init(self):
# 等待 4.5v 上电
utime.sleep_ms(50)
# 参考初始化时序，RS RW 拉低
self.RS.write(0)
self.RW.write(0)
# 第一次发送初始化指令
self.write4bits(0x03)
utime.sleep_us(4500) # 等待至少 4.1ms
# 第二次发送初始化指令
self.write4bits(0x03)
utime.sleep_us(4500) # 等待至少 100us
# 第三次发送初始化指令
self.write4bits(0x03)
utime.sleep_us(150)
# 设置屏幕为 4bits 接线模式
self.write4bits(0x02)
self._displayfunction = LCD_4BITMODE | LCD_2LINE | LCD_5x8DOTS
# 功能设置，默认4bits模式，2行，每个字符5x8点阵
self.command(LCD_FUNCTIONSET | self._displayfunction)
# 设置显示模式，默认为显示、无光标、无光标闪烁
self._displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF
self.display()
# 清空屏幕指令
self.clear()
# 设置打印项模式 LCD_ENTRY_INC 光标向右移动, LCD_ENTRY_NOSHIFT 打印文字不移动
self._displaymode = LCD_ENTRY_INC | LCD_ENTRY_NOSHIFT
# set the entry mode
self.command(LCD_ENTRYMODESET | self._displaymode)
# ## 一些简单的命令封装
# 清空屏幕，设置指针到左上角，并重置 display 左右偏移，并重置 display 方向
def clear(self):
self.command(LCD_CLEARDISPLAY)
utime.sleep_us(2000)
# 指针回到左上角起始位置，scrollDisplayLeft/Right 也会 rest
def home(self):
self.command(LCD_RETURNHOME)
utime.sleep_us(2000)
# 设置当前指针位置，支持 16x2
def setCursor(self, row, col):
rowArr = [0x00, 0x40]
if row >= 2: row = 1
if col >= 16: col = 15
self.command(LCD_SETDDRAMADDR | (col + rowArr[row]))
# 临时关闭显示，再次 display 时内容重新绘制
def noDisplay(self):
self._displaycontrol &= ~LCD_DISPLAYON
self.command(LCD_DISPLAYCONTROL | self._displaycontrol)
# 显示绘制内容
def display(self):
self._displaycontrol |= LCD_DISPLAYON
self.command(LCD_DISPLAYCONTROL | self._displaycontrol)
# 关闭光标显示
def noCursor(self):
self._displaycontrol &= ~LCD_CURSORON
self.command(LCD_DISPLAYCONTROL | self._displaycontrol)
# 开启光标显示，即一个下划线，表示下次字符绘制起始位置
def cursor(self):
self._displaycontrol |= LCD_CURSORON
self.command(LCD_DISPLAYCONTROL | self._displaycontrol)
# 关闭闪烁光标
def noBlink(self):
self._displaycontrol &= ~LCD_BLINKON
self.command(LCD_DISPLAYCONTROL | self._displaycontrol)
# 开启闪烁光标
def blink(self):
self._displaycontrol |= LCD_BLINKON
self.command(LCD_DISPLAYCONTROL | self._displaycontrol)
# 将整个屏幕显示内容向左滚动一列
def scrollDisplayLeft(self):
self.command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT)
# 将整个屏幕显示内容向右滚动一列
def scrollDisplayRight(self):
self.command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT)
# 显示模式从左到右，print字符串时会按照这个方向打印
def leftToRight(self):
self._displaymode |= LCD_ENTRY_INC
self.command(LCD_ENTRYMODESET | self._displaymode)
# 显示模式从右到左，print字符串时会按照这个方向打印
def rightToLeft(self):
self._displaymode &= ~LCD_ENTRY_INC
self.command(LCD_ENTRYMODESET | self._displaymode)
# 开启该状态后，文字打印时同时向左滚动，当前 cursor 位置保持屏幕不变
def autoscroll(self):
self._displaymode |= LCD_ENTRY_SHIFT
self.command(LCD_ENTRYMODESET | self._displaymode)
# 关闭该状态时，文字打印正常，光标向右移动
def noAutoscroll(self):
self._displaymode &= ~LCD_ENTRY_NOSHIFT
self.command(LCD_ENTRYMODESET | self._displaymode)
# 命令发送，value 为一个字节大小
def command(self, value):
self.send(value, 0)
# 数据发送，value 为一个字节大小
def write(self, value):
self.send(value, 1)
return 1 # assume success
# 发送数据，底层封装，value 为一个字节大小
def send(self, value, mode):
self.RS.write(mode)
# RW 拉低表示写
self.RW.write(0)
self.write4bits(value >> 4)
self.write4bits(value)
# 目前只支持 4 Data 线接入方法
def write4bits(self, value):
ret = 0
ret += self.D4.write(value >> 0 & 0x01)
ret += self.D5.write(value >> 1 & 0x01)
ret += self.D6.write(value >> 2 & 0x01)
ret += self.D7.write(value >> 3 & 0x01)
if ret != 0:
print('!!ERROR write4bits ret %s' % ret)
self.pulseEnable()
# E pin 产生下降沿，表示数据已准备好通知 LCD 读取
def pulseEnable(self):
self.E.write(0)
utime.sleep_us(1)
self.E.write(1)
utime.sleep_us(1) # 产生下降沿时，高电平保持(Enable Pules Width ( High level )) >450 ns
self.E.write(0)
# 数据保持时间(Data Hold Time) >10ns，但是写指令时间至少 40us （见datasheet，按照 osc 250Hz计算）
# 等待指令整体完成，这样就省略 busy flag 检查了
utime.sleep_us(100)
# 打印字符
def print(self, text):
n = 0
for idx in range(len(text)):
if self.write(ord(text[idx])): n += 1
else: break
return n
# 在指定位置打印字符
def displayString(self, row, col, text):
self.setCursor(row, col)
return self.print(text)
def main():
from driver import GPIO
print('GPIO init begin')
RS = GPIO(); RS.open('RS')
RW = GPIO(); RW.open('RW')
E = GPIO(); E.open('E')
D4 = GPIO(); D4.open('D4')
D5 = GPIO(); D5.open('D5')
D6 = GPIO(); D6.open('D6')
D7 = GPIO(); D7.open('D7')
print('GPIO init done')
drv = LCD1602(RS, RW, E, D4, D5, D6, D7)
drv.init()
utime.sleep(1)
drv.print('Hello')
drv.print(' HaaS')
return drv
if __name__ == '__main__':
main()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/lcd1602/lcd1602.py
|
Python
|
apache-2.0
| 7,937
|
from driver import GPIO
class MagnetronSensor():
def __init__(self, gpioObj):
self.gpioObj = None
if not isinstance(gpioObj, GPIO):
raise ValueError("parameter is not a GPIO object")
self.gpioObj = gpioObj
def isMagnetic(self):
if self.gpioObj is None:
raise ValueError("invalid GPIO object")
value = self.gpioObj.read()
return value
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/magnetron_sensor/magnetronSensor.py
|
Python
|
apache-2.0
| 419
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for MAX7219
Author: HaaS
Date: 2022/03/15
"""
from driver import GPIO
from utime import sleep_ms
from micropython import const
import math
digit_array_0 = bytearray([0x3c, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3c])
digit_array_1 = bytearray([0x10, 0x18, 0x14, 0x10, 0x10, 0x10, 0x10, 0x10])
digit_array_2 = bytearray([0x7E, 0x2, 0x2, 0x7E, 0x40, 0x40, 0x40, 0x7E])
digit_array_3 = bytearray([0x3E, 0x2, 0x2, 0x3E, 0x2, 0x2, 0x3E, 0x0])
digit_array_4 = bytearray([0x8, 0x18, 0x28, 0x48, 0xFE, 0x8, 0x8, 0x8])
digit_array_5 = bytearray([0x3C, 0x20, 0x20, 0x3C, 0x4, 0x4, 0x3C, 0x0])
digit_array_6 = bytearray([0x3C, 0x20, 0x20, 0x3C, 0x24, 0x24, 0x3C, 0x0])
digit_array_7 = bytearray([0x3E, 0x22, 0x4, 0x8, 0x8, 0x8, 0x8, 0x8])
digit_array_8 = bytearray([0x0, 0x3E, 0x22, 0x22, 0x3E, 0x22, 0x22, 0x3E])
digit_array_9 = bytearray([0x3E, 0x22, 0x22, 0x3E, 0x2, 0x2, 0x2, 0x3E])
digit_array_A = bytearray([0x8, 0x14, 0x22, 0x3E, 0x22, 0x22, 0x22, 0x22])
digit_array_B = bytearray([0x3C, 0x22, 0x22, 0x3E, 0x22, 0x22, 0x3C, 0x0])
digit_array_C = bytearray([0x3C, 0x40, 0x40, 0x40, 0x40, 0x40, 0x3C, 0x0])
digit_array_D = bytearray([0x7C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x7C, 0x0])
digit_array_E = bytearray([0x7C, 0x40, 0x40, 0x7C, 0x40, 0x40, 0x40, 0x7C])
digit_array_F = bytearray([0x7C, 0x40, 0x40, 0x7C, 0x40, 0x40, 0x40, 0x40])
digit_array_G = bytearray([0x3C, 0x40, 0x40, 0x40, 0x40, 0x44, 0x44, 0x3C])
digit_array_H = bytearray([0x44, 0x44, 0x44, 0x7C, 0x44, 0x44, 0x44, 0x44])
digit_array_I = bytearray([0x7C, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x7C])
digit_array_J = bytearray([0x3C, 0x8, 0x8, 0x8, 0x8, 0x8, 0x48, 0x30])
digit_array_K = bytearray([0x0, 0x24, 0x28, 0x30, 0x20, 0x30, 0x28, 0x24])
digit_array_L = bytearray([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x7C])
digit_array_M = bytearray([0x81, 0xC3, 0xA5, 0x99, 0x81, 0x81, 0x81, 0x81])
digit_array_N = bytearray([0x0, 0x42, 0x62, 0x52, 0x4A, 0x46, 0x42, 0x0])
digit_array_O = bytearray([0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C])
digit_array_P = bytearray([0x3C, 0x22, 0x22, 0x22, 0x3C, 0x20, 0x20, 0x20])
digit_array_Q = bytearray([0x1C, 0x22, 0x22, 0x22, 0x22, 0x26, 0x22, 0x1D])
digit_array_R = bytearray([0x3C, 0x22, 0x22, 0x22, 0x3C, 0x24, 0x22, 0x21])
digit_array_S = bytearray([0x0, 0x1E, 0x20, 0x20, 0x3E, 0x2, 0x2, 0x3C])
digit_array_T = bytearray([0x0, 0x3E, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8])
digit_array_U = bytearray([0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x22, 0x1C])
digit_array_V = bytearray([0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x24, 0x18])
digit_array_W = bytearray([0x0, 0x49, 0x49, 0x49, 0x49, 0x2A, 0x1C, 0x0])
digit_array_X = bytearray([0x0, 0x41, 0x22, 0x14, 0x8, 0x14, 0x22, 0x41])
digit_array_Y = bytearray([0x41, 0x22, 0x14, 0x8, 0x8, 0x8, 0x8, 0x8])
digit_array_Z = bytearray([0x0, 0x7F, 0x2, 0x4, 0x8, 0x10, 0x20, 0x7F])
digit_array = [
digit_array_0, digit_array_1, digit_array_2, digit_array_3, digit_array_4,
digit_array_5, digit_array_6, digit_array_7, digit_array_8, digit_array_9,
digit_array_A, digit_array_B, digit_array_C, digit_array_D, digit_array_E,
digit_array_F, digit_array_G, digit_array_H, digit_array_I, digit_array_G,
digit_array_K, digit_array_L, digit_array_M, digit_array_N, digit_array_O,
digit_array_P, digit_array_Q, digit_array_R, digit_array_S, digit_array_T,
digit_array_U, digit_array_V, digit_array_W, digit_array_X, digit_array_Y,
digit_array_Z
]
class MAX7219(object):
"""
This class implements max7219 chip's defs.
"""
def __init__(self, clk, cs, din):
self._clk = None
self._cs = None
self._din = None
if not isinstance(clk, GPIO):
raise ValueError("parameter is not an GPIO object")
if not isinstance(cs, GPIO):
raise ValueError("parameter is not an GPIO object")
if not isinstance(din, GPIO):
raise ValueError("parameter is not an GPIO object")
# make 74HC595's internal object points to gpio
self._clk = clk
self._cs = cs
self._din = din
self._digit_array = digit_array
def write(self, data):
self._cs.write(0)
for i in range(8):
self._clk.write(0)
if (data & 0x80) != 0:
self._din.write(1)
else:
self._din.write(0)
data <<= 1
self._clk.write(1)
def write_reg(self, address, value):
self._cs.write(0)
self.write(address)
self.write(value)
self._cs.write(1)
def outSegmentDigit(self, position, digit):
position += 1
self._cs.write(0)
self.write(position)
self.write(digit)
self._cs.write(1)
def outMatrixChar(self, digit):
if ord(digit) <= ord('9') and ord(digit) >= ord('0'):
for i in range(8):
self.write_reg(i + 1,
self._digit_array[ord(digit) - ord('0')][i])
if ord(digit) >= ord('A') and ord(digit) <= ord('Z'):
for i in range(8):
self.write_reg(
i + 1, self._digit_array[ord(digit) - ord('A') + 10][i])
def initSegmentLed(self):
self.write_reg(0x09, 0xff)
self.write_reg(0x0a, 0x03)
self.write_reg(0x0b, 0x07)
self.write_reg(0x0c, 0x01)
self.write_reg(0x0f, 0x00)
def initMatrixLed(self):
self.write_reg(0x09, 0x00)
self.write_reg(0x0a, 0x03)
self.write_reg(0x0b, 0x07)
self.write_reg(0x0c, 0x01)
self.write_reg(0x0f, 0x00)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/max7219/max7219.py
|
Python
|
apache-2.0
| 5,646
|
from driver import SPI,GPIO
class AuthenticationError(Exception):
pass
class StatusNotSuccessError(Exception):
pass
class MFRC522:
KEY = [0xFF,0xFF,0xFF,0xFF,0xFF,0xFF]
BLOCK_ADDRS = [8, 9, 10]
MAX_LEN = 16
PCD_IDLE = 0x00
PCD_AUTHENT = 0x0E
PCD_RECEIVE = 0x08
PCD_TRANSMIT = 0x04
PCD_TRANSCEIVE = 0x0C
PCD_RESETPHASE = 0x0F
PCD_CALCCRC = 0x03
PICC_REQIDL = 0x26
PICC_REQALL = 0x52
PICC_ANTICOLL = 0x93
PICC_SElECTTAG = 0x93
PICC_AUTHENT1A = 0x60
PICC_AUTHENT1B = 0x61
PICC_READ = 0x30
PICC_WRITE = 0xA0
PICC_DECREMENT = 0xC0
PICC_INCREMENT = 0xC1
PICC_RESTORE = 0xC2
PICC_TRANSFER = 0xB0
PICC_HALT = 0x50
MI_OK = 0
MI_NOTAGERR = 1
MI_ERR = 2
Reserved00 = 0x00
CommandReg = 0x01
CommIEnReg = 0x02
DivlEnReg = 0x03
CommIrqReg = 0x04
DivIrqReg = 0x05
ErrorReg = 0x06
Status1Reg = 0x07
Status2Reg = 0x08
FIFODataReg = 0x09
FIFOLevelReg = 0x0A
WaterLevelReg = 0x0B
ControlReg = 0x0C
BitFramingReg = 0x0D
CollReg = 0x0E
Reserved01 = 0x0F
Reserved10 = 0x10
ModeReg = 0x11
TxModeReg = 0x12
RxModeReg = 0x13
TxControlReg = 0x14
TxAutoReg = 0x15
TxSelReg = 0x16
RxSelReg = 0x17
RxThresholdReg = 0x18
DemodReg = 0x19
Reserved11 = 0x1A
Reserved12 = 0x1B
MifareReg = 0x1C
Reserved13 = 0x1D
Reserved14 = 0x1E
SerialSpeedReg = 0x1F
Reserved20 = 0x20
CRCResultRegM = 0x21
CRCResultRegL = 0x22
Reserved21 = 0x23
ModWidthReg = 0x24
Reserved22 = 0x25
RFCfgReg = 0x26
GsNReg = 0x27
CWGsPReg = 0x28
ModGsPReg = 0x29
TModeReg = 0x2A
TPrescalerReg = 0x2B
TReloadRegH = 0x2C
TReloadRegL = 0x2D
TCounterValueRegH = 0x2E
TCounterValueRegL = 0x2F
Reserved30 = 0x30
TestSel1Reg = 0x31
TestSel2Reg = 0x32
TestPinEnReg = 0x33
TestPinValueReg = 0x34
TestBusReg = 0x35
AutoTestReg = 0x36
VersionReg = 0x37
AnalogTestReg = 0x38
TestDAC1Reg = 0x39
TestDAC2Reg = 0x3A
TestADCReg = 0x3B
Reserved31 = 0x3C
Reserved32 = 0x3D
Reserved33 = 0x3E
Reserved34 = 0x3F
serNum = []
def __init__(self, spiDev, select_gpio, reset_gpio):
"""
Sets up an instance of the MFRC522 Reader over SPI
"""
self._spiDev = None
if not isinstance(spiDev, SPI):
raise ValueError("parameter is not an SPI object")
if not isinstance(select_gpio, GPIO):
raise ValueError("parameter is not an GPIO object")
if not isinstance(reset_gpio, GPIO):
raise ValueError("parameter is not an GPIO object")
self._spiDev = spiDev
self.reset_pin = reset_gpio
self.select_pin = select_gpio
self.reset_pin.write(1)
self.MFRC522_Init()
def MFRC522_Reset(self):
self.Write_MFRC522(self.CommandReg, self.PCD_RESETPHASE)
def Write_MFRC522(self, addr, val):
self.select_pin.write(0)
self._spiDev.write(b'%c' % int(0xff & ((addr << 1) & 0x7e)))
self._spiDev.write(b'%c' % int(0xff & val))
self.select_pin.write(1)
def Read_MFRC522(self, addr):
self.select_pin.write(0)
self._spiDev.write(b'%c' % int(0xff & (((addr << 1) & 0x7e) | 0x80)))
buf = bytearray(1)
self._spiDev.read(buf)
self.select_pin.write(1)
return buf[0]
def Close_MFRC522(self):
self._spiDev.close()
def SetBitMask(self, reg, mask):
tmp = self.Read_MFRC522(reg)
self.Write_MFRC522(reg, tmp | mask)
def ClearBitMask(self, reg, mask):
tmp = self.Read_MFRC522(reg)
self.Write_MFRC522(reg, tmp & (~mask))
def AntennaOn(self):
temp = self.Read_MFRC522(self.TxControlReg)
if (~(temp & 0x03)):
self.SetBitMask(self.TxControlReg, 0x03)
def AntennaOff(self):
self.ClearBitMask(self.TxControlReg, 0x03)
def MFRC522_ToCard(self, command, sendData):
backData = []
backLen = 0
status = self.MI_ERR
irqEn = 0x00
waitIRq = 0x00
lastBits = None
n = 0
if command == self.PCD_AUTHENT:
irqEn = 0x12
waitIRq = 0x10
if command == self.PCD_TRANSCEIVE:
irqEn = 0x77
waitIRq = 0x30
self.Write_MFRC522(self.CommIEnReg, irqEn | 0x80)
self.ClearBitMask(self.CommIrqReg, 0x80)
self.SetBitMask(self.FIFOLevelReg, 0x80)
self.Write_MFRC522(self.CommandReg, self.PCD_IDLE)
for i in range(len(sendData)):
self.Write_MFRC522(self.FIFODataReg, sendData[i])
self.Write_MFRC522(self.CommandReg, command)
if command == self.PCD_TRANSCEIVE:
self.SetBitMask(self.BitFramingReg, 0x80)
i = 2000
while True:
n = self.Read_MFRC522(self.CommIrqReg)
i -= 1
if ~((i != 0) and ~(n & 0x01) and ~(n & waitIRq)):
break
self.ClearBitMask(self.BitFramingReg, 0x80)
if i != 0:
if (self.Read_MFRC522(self.ErrorReg) & 0x1B) == 0x00:
status = self.MI_OK
if n & irqEn & 0x01:
status = self.MI_NOTAGERR
if command == self.PCD_TRANSCEIVE:
n = self.Read_MFRC522(self.FIFOLevelReg)
lastBits = self.Read_MFRC522(self.ControlReg) & 0x07
if lastBits != 0:
backLen = (n - 1) * 8 + lastBits
else:
backLen = n * 8
if n == 0:
n = 1
if n > self.MAX_LEN:
n = self.MAX_LEN
for i in range(n):
backData.append(self.Read_MFRC522(self.FIFODataReg))
else:
status = self.MI_ERR
return (status, backData, backLen)
def MFRC522_Request(self, reqMode):
status = None
backBits = None
TagType = []
self.Write_MFRC522(self.BitFramingReg, 0x07)
TagType.append(reqMode)
(status, backData, backBits) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, TagType)
if ((status != self.MI_OK) | (backBits != 0x10)):
status = self.MI_ERR
return (status, backBits)
def MFRC522_Anticoll(self):
backData = []
serNumCheck = 0
serNum = []
self.Write_MFRC522(self.BitFramingReg, 0x00)
serNum.append(self.PICC_ANTICOLL)
serNum.append(0x20)
(status, backData, backBits) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, serNum)
if (status == self.MI_OK):
i = 0
if len(backData) == 5:
for i in range(4):
serNumCheck = serNumCheck ^ backData[i]
if serNumCheck != backData[4]:
status = self.MI_ERR
else:
status = self.MI_ERR
return (status, backData)
def CalulateCRC(self, pIndata):
self.ClearBitMask(self.DivIrqReg, 0x04)
self.SetBitMask(self.FIFOLevelReg, 0x80)
for i in range(len(pIndata)):
self.Write_MFRC522(self.FIFODataReg, pIndata[i])
self.Write_MFRC522(self.CommandReg, self.PCD_CALCCRC)
i = 0xFF
while True:
n = self.Read_MFRC522(self.DivIrqReg)
i -= 1
if not ((i != 0) and not (n & 0x04)):
break
pOutData = []
pOutData.append(self.Read_MFRC522(self.CRCResultRegL))
pOutData.append(self.Read_MFRC522(self.CRCResultRegM))
return pOutData
def MFRC522_SelectTag(self, serNum):
backData = []
buf = []
buf.append(self.PICC_SElECTTAG)
buf.append(0x70)
for i in range(5):
buf.append(serNum[i])
pOut = self.CalulateCRC(buf)
buf.append(pOut[0])
buf.append(pOut[1])
(status, backData, backLen) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, buf)
if (status == self.MI_OK) and (backLen == 0x18):
print("Size: " + str(backData[0]))
return backData[0]
else:
return 0
def MFRC522_Auth(self, authMode, BlockAddr, Sectorkey, serNum):
buff = []
# First byte should be the authMode (A or B)
buff.append(authMode)
# Second byte is the trailerBlock (usually 7)
buff.append(BlockAddr)
# Now we need to append the authKey which usually is 6 bytes of 0xFF
for i in range(len(Sectorkey)):
buff.append(Sectorkey[i])
# Next we append the first 4 bytes of the UID
for i in range(4):
buff.append(serNum[i])
# Now we start the authentication itself
(status, backData, backLen) = self.MFRC522_ToCard(self.PCD_AUTHENT, buff)
# Check if an error occurred
if not (status == self.MI_OK):
raise AuthenticationError("AUTH ERROR!!")
if not (self.Read_MFRC522(self.Status2Reg) & 0x08) != 0:
raise AuthenticationError("AUTH ERROR(status2reg & 0x08) != 0")
# Return the status
return status
def MFRC522_StopCrypto1(self):
self.ClearBitMask(self.Status2Reg, 0x08)
def MFRC522_Read(self, blockAddr):
recvData = []
recvData.append(self.PICC_READ)
recvData.append(blockAddr)
pOut = self.CalulateCRC(recvData)
recvData.append(pOut[0])
recvData.append(pOut[1])
(status, backData, backLen) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, recvData)
if not (status == self.MI_OK):
raise StatusNotSuccessError("Error while reading!")
if len(backData) == 16:
print("Sector " + str(blockAddr) + " " + str(backData))
return backData
else:
return None
def MFRC522_Write(self, blockAddr, writeData):
buff = []
buff.append(self.PICC_WRITE)
buff.append(blockAddr)
crc = self.CalulateCRC(buff)
buff.append(crc[0])
buff.append(crc[1])
(status, backData, backLen) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, buff)
if not (status == self.MI_OK) or not (backLen == 4) or not ((backData[0] & 0x0F) == 0x0A):
status = self.MI_ERR
print("%s backdata &0x0F == 0x0A %s" % (backLen, backData[0] & 0x0F))
if status == self.MI_OK:
buf = []
for i in range(16):
buf.append(writeData[i])
crc = self.CalulateCRC(buf)
buf.append(crc[0])
buf.append(crc[1])
(status, backData, backLen) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, buf)
if not (status == self.MI_OK) or not (backLen == 4) or not ((backData[0] & 0x0F) == 0x0A):
raise StatusNotSuccessError("Error while writing")
if status == self.MI_OK:
print("Data written")
def MFRC522_DumpClassic1K(self, key, uid):
for i in range(64):
status = self.MFRC522_Auth(self.PICC_AUTHENT1A, i, key, uid)
# Check if authenticated
if status == self.MI_OK:
self.MFRC522_Read(i)
else:
raise AuthenticationError("Authentication error")
def MFRC522_Init(self):
self.MFRC522_Reset()
self.Write_MFRC522(self.TModeReg, 0x8D)
self.Write_MFRC522(self.TPrescalerReg, 0x3E)
self.Write_MFRC522(self.TReloadRegL, 30)
self.Write_MFRC522(self.TReloadRegH, 0)
self.Write_MFRC522(self.TxAutoReg, 0x40)
self.Write_MFRC522(self.ModeReg, 0x3D)
self.AntennaOn()
def readText(self):
id, text = self.read_no_block()
while not id:
id, text = self.read_no_block()
return id, text
def readCardID(self):
id = self.read_id_no_block()
while not id:
id = self.read_id_no_block()
return id
def read_id_no_block(self):
(status, TagType) = self.MFRC522_Request(self.PICC_REQIDL)
if status != self.MI_OK:
return None
(status, uid) = self.MFRC522_Anticoll()
if status != self.MI_OK:
return None
return self.uid_to_num(uid)
def read_no_block(self):
(status, TagType) = self.MFRC522_Request(self.PICC_REQIDL)
if status != self.MI_OK:
return None, None
(status, uid) = self.MFRC522_Anticoll()
if status != self.MI_OK:
return None, None
id = self.uid_to_num(uid)
self.MFRC522_SelectTag(uid)
status = self.MFRC522_Auth(self.PICC_AUTHENT1A, 11, self.KEY, uid)
data = []
text_read = ''
if status == self.MI_OK:
for block_num in self.BLOCK_ADDRS:
block = self.MFRC522_Read(block_num)
if block:
data += block
if data:
text_read = ''.join(chr(i) for i in data)
self.MFRC522_StopCrypto1()
return id, text_read
def write(self, text):
id, text_in = self.write_no_block(text)
while not id:
id, text_in = self.write_no_block(text)
return id, text_in
def write_no_block(self, text):
(status, TagType) = self.MFRC522_Request(self.PICC_REQIDL)
if status != self.MI_OK:
return None, None
(status, uid) = self.MFRC522_Anticoll()
if status != self.MI_OK:
return None, None
id = self.uid_to_num(uid)
self.MFRC522_SelectTag(uid)
status = self.MFRC522_Auth(self.PICC_AUTHENT1A, 11, self.KEY, uid)
self.MFRC522_Read(11)
if status == self.MI_OK:
data = bytearray()
data.extend(bytearray(text.ljust(len(self.BLOCK_ADDRS) * 16).encode('ascii')))
i = 0
for block_num in self.BLOCK_ADDRS:
self.MFRC522_Write(block_num, data[(i*16):(i+1)*16])
i += 1
self.MFRC522_StopCrypto1()
return id, text[0:(len(self.BLOCK_ADDRS) * 16)]
def uid_to_num(self, uid):
n = 0
for i in range(0, 5):
n = n * 256 + uid[i]
return n
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/mfrc522/mfrc522.py
|
Python
|
apache-2.0
| 14,352
|
"""
HaaSPython I2C driver for mlx90614 IR Temperature
"""
import ustruct
from driver import I2C
class SensorBase:
def read16(self, register):
data=bytearray(2)
self._i2cDev.memRead(data,register,8)
return ustruct.unpack('<H', data)[0]
def read_temp(self, register):
temp = self.read16(register)
# apply measurement resolution (0.02 degrees per LSB)
temp *= .02
temp -= 273.15
return temp
def read_ambient_temp(self):
return self.read_temp(self._REGISTER_TA)
def read_object_temp(self):
return self.read_temp(self._REGISTER_TOBJ1)
def read_object2_temp(self):
if self.dual_zone:
return self.read_temp(self._REGISTER_TOBJ2)
else:
raise RuntimeError("Device only has one thermopile")
@property
def ambient_temp(self):
return self.read_ambient_temp()
@property
def object_temp(self):
return self.read_object_temp()
@property
def object2_temp(self):
return self.read_object2_temp()
class MLX90614(SensorBase):
_REGISTER_TA = 0x06
_REGISTER_TOBJ1 = 0x07
_REGISTER_TOBJ2 = 0x08
def __init__(self, i2cDev, address=0x5a):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
self._i2cDev = i2cDev
_config1=bytearray(2)
self._i2cDev.memRead(_config1,0x25,8)
_dz = ustruct.unpack('<H', _config1)[0] & (1<<6)
self.dual_zone = True if _dz else False
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/mlx90614/mlx90614.py
|
Python
|
apache-2.0
| 1,572
|
ITER_NUM = 50
ACCELERATION_LOW_THREADHOLD = 4 # 加速度变化下限阈值，越大越灵敏
ACCELERATION_UP_THREADHOLD = 12 # 加速度变化上限阈值，越小越灵敏
ANGULAR_VELOCITY_LOW_THREADHOLD = 1 # 角速度变化下限阈值，越小越灵敏
ANGULAR_VELOCITY_UP_THREADHOLD = 40 # 角速度变化下限阈值，越大越灵敏
class fall_detection:
def __init__(self, getData):
self.ax_offset = 0.0
self.ay_offset = 0.0
self.az_offset = 0.0
self.gx_offset = 0.0
self.gy_offset = 0.0
self.gz_offset = 0.0
self.trigger1count = 0
self.trigger2count = 0
self.trigger1 = False
self.trigger2 = False
self.getData = getData
self.calibrate()
def calibrate(self):
ax_sum = 0.0
ay_sum = 0.0
az_sum = 0.0
gx_sum = 0.0
gy_sum = 0.0
gz_sum = 0.0
for num in range(0, ITER_NUM):
data = self.getData() # 读取传感器信息值
ax_sum += data[0][0]
ay_sum += data[0][1]
az_sum += data[0][2]
gx_sum += data[1][0]
gy_sum += data[1][1]
gz_sum += data[1][2]
self.ax_offset = ax_sum/ITER_NUM
self.ay_offset = ay_sum/ITER_NUM
self.az_offset = az_sum/ITER_NUM
self.gx_offset = gx_sum/ITER_NUM
self.gy_offset = gy_sum/ITER_NUM
self.gz_offset = gz_sum/ITER_NUM
print('Now you can start fall detection!')
def detect(self):
global ACCELERATION_LOW_THREADHOLD
global ACCELERATION_UP_THREADHOLD
global ANGULAR_VELOCITY_LOW_THREADHOLD
global ANGULAR_VELOCITY_UP_THREADHOLD
fall = False
data = self.getData() # 读取传感器信息值
AcX = data[0][0]
AcY = data[0][1]
AcZ = data[0][2]
GyX = data[1][0]
GyY = data[1][1]
GyZ = data[1][2]
ax = (AcX-self.ax_offset)
ay = (AcY-self.ay_offset)
az = (AcZ-self.az_offset)
gx = (GyX-self.gx_offset)
gy = (GyY-self.gy_offset)
gz = (GyZ-self.gz_offset)
if hasattr(self, 'sensitivity'):
if 'ACCELERATION_LOW_THREADHOLD' in self.sensitivity:
ACCELERATION_LOW_THREADHOLD = float(self.sensitivity['ACCELERATION_LOW_THREADHOLD'])
if 'ACCELERATION_UP_THREADHOLD' in self.sensitivity:
ACCELERATION_UP_THREADHOLD = float(self.sensitivity['ACCELERATION_UP_THREADHOLD'])
if 'ANGULAR_VELOCITY_LOW_THREADHOLD' in self.sensitivity:
ANGULAR_VELOCITY_LOW_THREADHOLD = float(self.sensitivity['ANGULAR_VELOCITY_LOW_THREADHOLD'])
if 'ANGULAR_VELOCITY_UP_THREADHOLD' in self.sensitivity:
ANGULAR_VELOCITY_UP_THREADHOLD = float(self.sensitivity['ANGULAR_VELOCITY_UP_THREADHOLD'])
# calculating accelerationChangelitute vector for 3 axis
Raw_accelerationChange = pow(pow(ax, 2)+pow(ay, 2)+pow(az, 2), 0.5)
# Multiplied by 10 to values are between 0 to 1
accelerationChange = Raw_accelerationChange * 10
# Trigger1 function
# if accelerationChange breaks lower threshold
if(accelerationChange <= ACCELERATION_LOW_THREADHOLD and self.trigger2 == False):
self.trigger1 = True
# print("TRIGGER 1 ACTIVATED")
if (self.trigger1 == True):
self.trigger1count = self.trigger1count + 1
# if accelerationChange breaks upper threshold
if (accelerationChange >= ACCELERATION_UP_THREADHOLD):
self.trigger2 = True
# print("TRIGGER 2 ACTIVATED")
self.trigger1 = False
self.trigger1count = 0
if (self.trigger2 == True):
self.trigger2count = self.trigger2count+1
angleChange = pow(pow(gx, 2)+pow(gy, 2)+pow(gz, 2), 0.5)
# Trigger2 function
# //if orientation changes by between 1-40 degrees
if (angleChange >= ANGULAR_VELOCITY_LOW_THREADHOLD and angleChange <= ANGULAR_VELOCITY_UP_THREADHOLD):
self.trigger2 = False
self.trigger2count = 0
fall = True
return fall
if (fall == True): # //in event of a fall detection
fall = False
if (self.trigger2count >= 50): # //allow time for orientation change
self.trigger2 = False
self.trigger2count = 0
# print("TRIGGER 2 DECACTIVATED")
if (self.trigger1count >= 5): # //allow time for accelerationChange to break upper threshold
self.trigger1 = False
self.trigger1count = 0
# print("TRIGGER 1 DECACTIVATED")
return fall
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/motion/detections/fall_detection.py
|
Python
|
apache-2.0
| 4,794
|
import utime # 延时函数在utime
ITER_NUM = 100
class tap_detection:
def __init__(self, tap_detect_count, getData):
self.ax_offset = 0.0
self.ay_offset = 0.0
self.az_offset = 0.0
self.triggercount = 0
self.untriggercount = 0
self.tapcount = 0
self.tap_detect_count = tap_detect_count
if (self.tap_detect_count == 2):
self.accelerator_up_threshold = 30.0
elif (self.tap_detect_count == 1):
self.accelerator_up_threshold = 30.0
self.latency = 150
self.getData = getData
self.calibrate()
def calibrate(self):
ax_sum = 0.0
ay_sum = 0.0
az_sum = 0.0
for num in range(0, ITER_NUM):
data = self.getData() # 读取传感器信息值
ax_sum += data[0][0]
ay_sum += data[0][1]
az_sum += data[0][2]
self.ax_offset = ax_sum/ITER_NUM
self.ay_offset = ay_sum/ITER_NUM
self.az_offset = az_sum/ITER_NUM
self.accelerator_low_threshold = 0.0
for num in range(0, ITER_NUM):
data = self.getData() # 读取传感器信息值
ax = data[0][0]
ay = data[0][1]
az = data[0][2]
ax = (ax-self.ax_offset)
ay = (ay-self.ay_offset)
az = (az-self.az_offset)
Raw_accelerationChange = pow(pow(ax, 2)+pow(ay, 2)+pow(az, 2), 0.5)
# Multiplied by 10 to values are between 0 to 1
self.accelerator_low_threshold += Raw_accelerationChange * 10
self.accelerator_low_threshold = (
self.accelerator_low_threshold / ITER_NUM)*2
print('Now you can start tap detection!')
def detect(self):
fall = False
data = self.getData() # 读取传感器信息值
AcX = data[0][0]
AcY = data[0][1]
AcZ = data[0][2]
ax = (AcX-self.ax_offset)
ay = (AcY-self.ay_offset)
az = (AcZ-self.az_offset)
# calculating accelerationChangelitute vector for 3 axis
Raw_accelerationChange = pow(pow(ax, 2)+pow(ay, 2)+pow(az, 2), 0.5)
# Multiplied by 10 to values are between 0 to 1
accelerationChange = Raw_accelerationChange * 10
if (fall == True):
fall = False
if hasattr(self, 'sensitivity'):
if 'ACCELERATION_UP_THREADHOLD' in self.sensitivity:
self.accelerator_up_threshold = float(
self.sensitivity['ACCELERATION_UP_THREADHOLD'])
# Trigger function
# if accelerationChange breaks lower threshold
if (self.tap_detect_count == 2):
if(accelerationChange >= self.accelerator_low_threshold and accelerationChange <= self.accelerator_up_threshold):
self.triggercount = self.triggercount+1
if (self.triggercount % 3 == 0): # catch one tap
self.tapcount = self.tapcount+1
utime.sleep_ms(100)
if (self.tapcount == self.tap_detect_count): # catched tap_detect_count
self.triggercount = 0
self.tapcount = 0
fall = True
else:
self.untriggercount = self.untriggercount+1
if (self.untriggercount == 150):
self.triggercount = 0
self.tapcount = 0
self.untriggercount = 0
elif (self.tap_detect_count == 1):
if(accelerationChange >= self.accelerator_low_threshold and accelerationChange <= self.accelerator_up_threshold):
self.triggercount = self.triggercount+1
if (self.triggercount % 5 == 0): # catch one tap
self.tapcount = self.tapcount+1
utime.sleep_ms(100)
if (self.tapcount == self.tap_detect_count): # catched tap_detect_count
self.triggercount = 0
self.tapcount = 0
fall = True
else:
self.untriggercount = self.untriggercount+1
if (self.untriggercount == 150):
self.triggercount = 0
self.tapcount = 0
self.untriggercount = 0
return fall
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/motion/detections/tap_detection.py
|
Python
|
apache-2.0
| 4,356
|
import utime # 延时函数在utime
from .detections.fall_detection import fall_detection
from .detections.tap_detection import tap_detection
import _thread # 线程库
class Motion:
def __init__(self, action, getData, onActionDetected):
self.action = action
if (action == "fall"):
self.detectAction = fall_detection(getData)
elif (action == "single_tap"):
self.detectAction = tap_detection(1, getData)
elif (action == "double_tap"):
self.detectAction = tap_detection(2, getData)
self.onActionDetected = onActionDetected
self.enableDetection = False
self.detectionThreadCreated = False
def detect_action(self):
while(self.enableDetection == True):
isDetected = self.detectAction.detect() # 检测Action是否产生
if (isDetected == True): # Action被检测到
print(self.action, "detected!")
if (hasattr(self, 'onActionDetected')):
self.onActionDetected()
utime.sleep_us(10)
self.detectionThreadCreated = False
# 使能action检测，若用户不指定灵敏度，则使用默认灵敏度
def enable(self, sensitivity=''):
if (self.detectionThreadCreated == False):
if (sensitivity != ''):
self.detectAction.sensitivity = sensitivity
try:
# 创建行为检测线程
self.enableDetection = True
self.detectionThreadCreated = True
_thread.start_new_thread(self.detect_action, ())
except Exception as e:
print(e)
print("Error: unable to start detect_action thread")
self.enableDetection = False
self.detectionThreadCreated = False
# 关闭action检测
def disable(self):
self.enableDetection = False
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/motion/motion.py
|
Python
|
apache-2.0
| 1,974
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
HaaS Python driver for motorspeed
Author: HaaS
Date: 2022/05/15
"""
from driver import GPIO
class MOTORSPEED(object):
def __init__(self, gpioObj, func=None):
self.gpioObj = None
if not isinstance(gpioObj, GPIO):
raise ValueError("parameter is not a GPIO object")
self.gpioObj = gpioObj
if func != None:
self.gpioObj.on(func)
def objectDetection(self):
if self.gpioObj is None:
raise ValueError("invalid GPIO object")
value = self.gpioObj.read()
return value
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/motorspeed/motorspeed.py
|
Python
|
apache-2.0
| 637
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
HaaS Python's driver for MPU6050
Author: HaaS Python Team
Date: 2022/02/02
"""
from micropython import const
from driver import I2C
from utime import sleep_ms
import math
MPU_SELF_TESTX_REG = const(0X0D) #自检寄存器X
MPU_SELF_TESTY_REG = const(0X0E) #自检寄存器Y
MPU_SELF_TESTZ_REG = const(0X0F) #自检寄存器Z
MPU_SELF_TESTA_REG = const(0X10) #自检寄存器A
MPU_SAMPLE_RATE_REG = const(0X19) #采样频率分频器
MPU_CFG_REG = const(0X1A) #配置寄存器
MPU_GYRO_CFG_REG = const(0X1B) #陀螺仪配置寄存器
MPU_ACCEL_CFG_REG = const(0X1C) #加速度计配置寄存器
MPU_MOTION_DET_REG = const(0X1F) #运动检测阀值设置寄存器
MPU_FIFO_EN_REG = const(0X23) #FIFO使能寄存器
MPU_I2CMST_CTRL_REG = const(0X24) #IIC主机控制寄存器
MPU_I2CSLV0_ADDR_REG = const(0X25) #IIC从机0器件地址寄存器
MPU_I2CSLV0_REG = const(0X26) #IIC从机0数据地址寄存器
MPU_I2CSLV0_CTRL_REG = const(0X27) #IIC从机0控制寄存器
MPU_I2CSLV1_ADDR_REG = const(0X28) #IIC从机1器件地址寄存器
MPU_I2CSLV1_REG = const(0X29) #IIC从机1数据地址寄存器
MPU_I2CSLV1_CTRL_REG = const(0X2A) #IIC从机1控制寄存器
MPU_I2CSLV2_ADDR_REG = const(0X2B) #IIC从机2器件地址寄存器
MPU_I2CSLV2_REG = const(0X2C) #IIC从机2数据地址寄存器
MPU_I2CSLV2_CTRL_REG = const(0X2D) #IIC从机2控制寄存器
MPU_I2CSLV3_ADDR_REG = const(0X2E) #IIC从机3器件地址寄存器
MPU_I2CSLV3_REG = const(0X2F) #IC从机3数据地址寄存器
MPU_I2CSLV3_CTRL_REG = const(0X30) #IIC从机3控制寄存器
MPU_I2CSLV4_ADDR_REG = const(0X31) #IIC从机4器件地址寄存器
MPU_I2CSLV4_REG = const(0X32) #IIC从机4数据地址寄存器
MPU_I2CSLV4_DO_REG = const(0X33) #IIC从机4写数据寄存器
MPU_I2CSLV4_CTRL_REG = const(0X34) #IIC从机4控制寄存器
MPU_I2CSLV4_DI_REG = const(0X35) #IIC从机4读数据寄存器
MPU_I2CMST_STA_REG = const(0X36) #IIC主机状态寄存器
MPU_INTBP_CFG_REG = const(0X37) #中断/旁路设置寄存器
MPU_INT_EN_REG = const(0X38) #中断使能寄存器
MPU_INT_STA_REG = const(0X3A) #中断状态寄存器
MPU_ACCEL_XOUTH_REG = const(0X3B) #加速度值,X轴高8位寄存器
MPU_ACCEL_XOUTL_REG = const(0X3C) #速度值,X轴低8位寄存器
MPU_ACCEL_YOUTH_REG = const(0X3D) #加速度值,Y轴高8位寄存器
MPU_ACCEL_YOUTL_REG = const(0X3E) #加速度值,Y轴低8位寄存器
MPU_ACCEL_ZOUTH_REG = const(0X3F) #加速度值,Z轴高8位寄存器
MPU_ACCEL_ZOUTL_REG = const(0X40) #加速度值,Z轴低8位寄存器
MPU_TEMP_OUTH_REG = const(0X41) #温度值高八位寄存器
MPU_TEMP_OUTL_REG = const(0X42) #温度值低8位寄存器
MPU_GYRO_XOUTH_REG = const(0X43) #陀螺仪值,X轴高8位寄存器
MPU_GYRO_XOUTL_REG = const(0X44) #陀螺仪值,X轴低8位寄存器
MPU_GYRO_YOUTH_REG = const(0X45) #陀螺仪值,Y轴高8位寄存器
MPU_GYRO_YOUTL_REG = const(0X46) #陀螺仪值,Y轴低8位寄存器
MPU_GYRO_ZOUTH_REG = const(0X47) #陀螺仪值,Z轴高8位寄存器
MPU_GYRO_ZOUTL_REG = const(0X48) #陀螺仪值,Z轴低8位寄存器
MPU_I2CSLV0_DO_REG = const(0X63) #IIC从机0数据寄存器
MPU_I2CSLV1_DO_REG = const(0X64) #IIC从机1数据寄存器
MPU_I2CSLV2_DO_REG = const(0X65) #IIC从机2数据寄存器
MPU_I2CSLV3_DO_REG = const(0X66) #IIC从机3数据寄存器
MPU_I2CMST_DELAY_REG = const(0X67) #IIC主机延时管理寄存器
MPU_SIGPATH_RST_REG = const(0X68) #信号通道复位寄存器
MPU_MDETECT_CTRL_REG = const(0X69) #运动检测控制寄存器
MPU_USER_CTRL_REG = const(0X6A) #用户控制寄存器
MPU_PWR_MGMT1_REG = const(0X6B) #电源管理寄存器1
MPU_PWR_MGMT2_REG = const(0X6C) #电源管理寄存器2
MPU_FIFO_CNTH_REG = const(0X72) #FIFO计数寄存器高八位
MPU_FIFO_CNTL_REG = const(0X73) #FIFO计数寄存器低八位
MPU_FIFO_RW_REG = const(0X74) #FIFO读写寄存器
MPU_DEVICE_ID_REG = const(0X75) #器件ID寄存器
MPU_DEV_ID = const(0x68)
mpu6050_dict = {'temp': 0.0, 'gyroX': 0, 'gyroY': 0, 'gyroZ': 0, 'accX': 0, 'accY': 0, 'accZ': 0}
class MPU6050Error(Exception):
def __init__(self, value=0, msg="mpu6050 common error"):
self.value = value
self.msg = msg
def __str__(self):
return "Error code:%d, Error message: %s" % (self.value, str(self.msg))
__repr__ = __str__
class MPU6050(object):
"""
This class implements mpu6050 chip's defs.
"""
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make MPU6050's internal object points to i2cDev
self._i2cDev = i2cDev
# 初始化MPU6050传感器
r = self.init()
if r != 0:
raise ValueError("MPU6050 init error")
def i2c_write_byte(self, addr, value):
Reg = bytearray([addr, value])
self._i2cDev.write(Reg)
#print("--> write addr " + str(addr) + ", value = " + str(value))
def i2c_read_byte(self, addr):
Reg = bytearray([addr])
self._i2cDev.write(Reg)
tmp = bytearray(1)
self._i2cDev.read(tmp)
#print("<-- read addr " + str(addr) + ", value = " + str(tmp[0]))
return tmp[0]
def i2c_read_len(self, addr, len):
reg = bytearray([addr])
data = bytearray(len)
self._i2cDev.write(reg)
sleep_ms(20)
self._i2cDev.read(data)
# print("--> read " + str(len) + " bytes from addr " + str(addr) + ", " + str(len) + " bytes value = " + str(data))
return data
# 设置MPU6050陀螺仪传感器满量程范围
# fsr:0,±250dps;1,±500dps;2,±1000dps;3,±2000dps
# 返回值:0,设置成功
# 其他,设置失败
def setGyroFsr(self, fsr):
return self.i2c_write_byte(MPU_GYRO_CFG_REG, fsr << 3) # 设置陀螺仪满量程范围
# 设置MPU6050加速度传感器满量程范围
# fsr:0,±2g;1,±4g;2,±8g;3,±16g
# 返回值:0,设置成功
# 其他,设置失败
def setAccelFsr(self, fsr):
return self.i2c_write_byte(MPU_ACCEL_CFG_REG, fsr << 3) # 设置加速度传感器满量程范围
# 设置MPU6050的数字低通滤波器
# lpf:数字低通滤波频率(Hz)
# 返回值:0,设置成功
# 其他,设置失败
def setLPF(self, lpf):
if (lpf >= 188):
data = 1
elif (lpf >= 98):
data = 2
elif (lpf >= 42):
data = 3
elif (lpf >= 20):
data = 4
elif (lpf >= 10):
data = 5
else:
data = 6
return self.i2c_write_byte(MPU_CFG_REG, data) # 设置数字低通滤波器
# 设置MPU6050的采样率(假定Fs=1KHz)
# rate:4~1000(Hz)
# 返回值:0,设置成功
# 其他,设置失败
def setRate(self, rate):
if (rate > 1000):
rate = 1000
if (rate < 4):
rate = 4
data = 1000 // rate - 1
self.i2c_write_byte(MPU_SAMPLE_RATE_REG, data) # 设置数字低通滤波器
return self.setLPF(rate / 2) # 自动设置LPF为采样率的一半
# 得到温度值
# 返回值:温度值
def getTemperature(self):
buf = bytearray(2)
buf = self.i2c_read_len(MPU_TEMP_OUTH_REG, 2)
raw = (buf[0] << 8) | buf[1]
if (raw > (1 << 15)):
raw = raw - (1<<16)
temp = 36.53 + (raw) / 340
return round(temp, 2)
# 得到陀螺仪值(原始值)
# gx,gy,gz:陀螺仪x,y,z轴的原始读数(带符号)
# 返回值:0,成功
# 其他,错误代码
def getGyroscope(self):
buf = bytearray(6)
buf = self.i2c_read_len(MPU_GYRO_XOUTH_REG, 6)
gx = (buf[0] << 8) | buf[1]
gy = (buf[2] << 8) | buf[3]
gz = (buf[4] << 8) | buf[5]
if (gx > (1 << 15)):
gx = gx - (1<<16)
if (gy > (1 << 15)):
gy = gy - (1<<16)
if (gz > (1 << 15)):
gz = gz - (1<<16)
return (gx, gy, gz)
# 得到加速度值(原始值)
# gx,gy,gz:陀螺仪x,y,z轴的原始读数(带符号)
# 返回值:0,成功
# 其他,错误代码
def getAcceleration(self):
buf = bytearray(6)
buf = self.i2c_read_len(MPU_ACCEL_XOUTH_REG, 6)
ax = (buf[0] << 8) | buf[1]
ay = (buf[2] << 8) | buf[3]
az = (buf[4] << 8) | buf[5]
if (ax > (1 << 15)):
ax = ax - (1<<16)
if (ay > (1 << 15)):
ay = ay - (1<<16)
if (az > (1 << 15)) :
az = az - (1<<16)
return (ax, ay, az)
def getData(self):
global mpu6050_dict
mpu6050_dict['temp'] = self.getTemperature()
arr = self.getGyroscope()
mpu6050_dict['gyroX'] = arr[0]
mpu6050_dict['gyroY'] = arr[1]
mpu6050_dict['gyroZ'] = arr[2]
brr = self.getAcceleration()
mpu6050_dict['accX'] = brr[0]
mpu6050_dict['accY'] = brr[1]
mpu6050_dict['accZ'] = brr[2]
return mpu6050_dict
# 初始化MPU6050
# 返回值:0,成功
# 其他,错误代码
def init(self):
device_id = 0
self.i2c_write_byte(MPU_PWR_MGMT1_REG, 0X80) # 复位MPU6050
sleep_ms(200)
self.i2c_write_byte(MPU_PWR_MGMT1_REG, 0X00) # 唤醒MPU6050
self.setGyroFsr(3) # 陀螺仪传感器,±2000dps
self.setAccelFsr(0) # 加速度传感器,±2g
self.setRate(50) # 设置采样率50Hz
self.i2c_write_byte(MPU_INT_EN_REG, 0X00) # 关闭所有中断
self.i2c_write_byte(MPU_USER_CTRL_REG, 0X00) # I2C主模式关闭
self.i2c_write_byte(MPU_FIFO_EN_REG, 0X00) # 关闭FIFO
self.i2c_write_byte(MPU_INTBP_CFG_REG, 0X80) # INT引脚低电平有效
device_id = self.i2c_read_byte(MPU_DEVICE_ID_REG)
if (device_id == MPU_DEV_ID):
# 器件ID正确
self.i2c_write_byte(MPU_PWR_MGMT1_REG, 0X01) # 设置CLKSEL,PLL X轴为参考
self.i2c_write_byte(MPU_PWR_MGMT2_REG, 0X00) # 加速度与陀螺仪都工作
self.setRate(50) # 设置采样率为50Hz
return 0
else:
return 1
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/mpu6050/mpu6050.py
|
Python
|
apache-2.0
| 10,409
|
"""
HaaSPython I2C driver for MPU6886 6-axis motion tracking device
"""
# pylint: disable=import-error
import ustruct
import utime
# from machine import I2C, Pin
from driver import I2C
from micropython import const
# pylint: enable=import-error
_CONFIG = const(0x1a)
_GYRO_CONFIG = const(0x1b)
_ACCEL_CONFIG = const(0x1c)
_ACCEL_CONFIG2 = const(0x1d)
_ACCEL_XOUT_H = const(0x3b)
_ACCEL_XOUT_L = const(0x3c)
_ACCEL_YOUT_H = const(0x3d)
_ACCEL_YOUT_L = const(0x3e)
_ACCEL_ZOUT_H = const(0x3f)
_ACCEL_ZOUT_L = const(0x40)
_TEMP_OUT_H = const(0x41)
_TEMP_OUT_L = const(0x42)
_GYRO_XOUT_H = const(0x43)
_GYRO_XOUT_L = const(0x44)
_GYRO_YOUT_H = const(0x45)
_GYRO_YOUT_L = const(0x46)
_GYRO_ZOUT_H = const(0x47)
_GYRO_ZOUT_L = const(0x48)
_PWR_MGMT_1 = const(0x6b)
_WHO_AM_I = const(0x75)
ACCEL_FS_SEL_2G = const(0b00000000)
ACCEL_FS_SEL_4G = const(0b00001000)
ACCEL_FS_SEL_8G = const(0b00010000)
ACCEL_FS_SEL_16G = const(0b00011000)
_ACCEL_SO_2G = 16384 # 1 / 16384 ie. 0.061 mg / digit
_ACCEL_SO_4G = 8192 # 1 / 8192 ie. 0.122 mg / digit
_ACCEL_SO_8G = 4096 # 1 / 4096 ie. 0.244 mg / digit
_ACCEL_SO_16G = 2048 # 1 / 2048 ie. 0.488 mg / digit
GYRO_FS_SEL_250DPS = const(0b00000000)
GYRO_FS_SEL_500DPS = const(0b00001000)
GYRO_FS_SEL_1000DPS = const(0b00010000)
GYRO_FS_SEL_2000DPS = const(0b00011000)
_GYRO_SO_250DPS = 131
_GYRO_SO_500DPS = 62.5
_GYRO_SO_1000DPS = 32.8
_GYRO_SO_2000DPS = 16.4
_TEMP_SO = 326.8
_TEMP_OFFSET = 25
SF_G = 1
SF_M_S2 = 9.80665 # 1 g = 9.80665 m/s2 ie. standard gravity
SF_DEG_S = 1
SF_RAD_S = 0.017453292519943 # 1 deg/s is 0.017453292519943 rad/s
class MPU6886:
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make AHB21B's internal object points to _i2cDev
self._i2cDev = i2cDev
self.start()
def start(self,address=0x68):
self.address = address
if 0x19 != self.whoami:
raise RuntimeError("MPU6886 not found in I2C bus.")
self._register_char(_PWR_MGMT_1, 0b10000000) # reset
utime.sleep_ms(100)
self._register_char(_PWR_MGMT_1, 0b00000001) # autoselect clock
accel_fs=ACCEL_FS_SEL_2G
gyro_fs=GYRO_FS_SEL_250DPS
accel_sf=SF_M_S2
gyro_sf=SF_RAD_S
gyro_offset=(0, 0, 0)
self._accel_so = self._accel_fs(accel_fs)
self._gyro_so = self._gyro_fs(gyro_fs)
self._accel_sf = accel_sf
self._gyro_sf = gyro_sf
self._gyro_offset = gyro_offset
@property
def acceleration(self):
"""
Acceleration measured by the sensor. By default will return a
3-tuple of X, Y, Z axis acceleration values in m/s^2 as floats. Will
return values in g if constructor was provided `accel_sf=SF_M_S2`
parameter.
"""
so = self._accel_so
sf = self._accel_sf
xyz = self._register_three_shorts(_ACCEL_XOUT_H)
return tuple([value / so * sf for value in xyz])
@property
def gyro(self):
"""
X, Y, Z radians per second as floats.
"""
so = self._gyro_so
sf = self._gyro_sf
ox, oy, oz = self._gyro_offset
xyz = self._register_three_shorts(_GYRO_XOUT_H)
xyz = [value / so * sf for value in xyz]
xyz[0] -= ox
xyz[1] -= oy
xyz[2] -= oz
return tuple(xyz)
@property
def temperature(self):
"""
Die temperature in celcius as a float.
"""
temp = self._register_short(_TEMP_OUT_H)
# return ((temp - _TEMP_OFFSET) / _TEMP_SO) + _TEMP_OFFSET
return (temp / _TEMP_SO) + _TEMP_OFFSET
@property
def whoami(self):
""" Value of the whoami register. """
return self._register_char(_WHO_AM_I)
def calibrate(self, count=256, delay=0):
ox, oy, oz = (0.0, 0.0, 0.0)
self._gyro_offset = (0.0, 0.0, 0.0)
n = float(count)
while count:
utime.sleep_ms(delay)
gx, gy, gz = self.gyro
ox += gx
oy += gy
oz += gz
count -= 1
self._gyro_offset = (ox / n, oy / n, oz / n)
return self._gyro_offset
def _register_short(self, register, value=None, buf=bytearray(2)):
if value is None:
# cmd = bytearray(2)
# cmd[0] = self.address
# cmd[1] = register
# self._i2cDev.write(cmd)
# self._i2cDev.read(buf)
self._i2cDev.memRead(buf,register,8)
print(buf[0])
# self.i2c.readfrom_mem_into(self.address, register, buf)
return ustruct.unpack(">h", buf)[0]
ustruct.pack_into(">h", buf, 0, value)
# cmd = bytearray(2)
# cmd[0] = self.address
# cmd[1] = register
# self._i2cDev.write(cmd)
# self._i2cDev.write(buf)
self._i2cDev.memWrite(buf,register,8)
# return self.i2c.writeto_mem(self.address, register, buf)
def _register_three_shorts(self, register, buf=bytearray(6)):
# cmd = bytearray(2)
# cmd[0] = self.address
# cmd[1] = register
# self._i2cDev.write(cmd)
# self._i2cDev.read(buf)
self._i2cDev.memRead(buf,register,8)
# self.i2c.readfrom_mem_into(self.address, register, buf)
return ustruct.unpack(">hhh", buf)
def _register_char(self, register, value=None, buf=bytearray(1)):
if value is None:
# cmd = bytearray(2)
# cmd[0] = self.address
# cmd[1] = register
# self._i2cDev.write(cmd)
# self._i2cDev.read(buf)
self._i2cDev.memRead(buf,register,8)
print(buf[0])
# self.i2c.readfrom_mem_into(self.address, register, buf)
return buf[0]
ustruct.pack_into("<b", buf, 0, value)
# cmd = bytearray(2)
# cmd[0] = self.address
# cmd[1] = register
# self._i2cDev.write(cmd)
# self._i2cDev.write(buf)
return self._i2cDev.memWrite(buf,register,8)
# return self.i2c.writeto_mem(self.address, register, buf)
def _accel_fs(self, value):
self._register_char(_ACCEL_CONFIG, value)
# Return the sensitivity divider
if ACCEL_FS_SEL_2G == value:
return _ACCEL_SO_2G
elif ACCEL_FS_SEL_4G == value:
return _ACCEL_SO_4G
elif ACCEL_FS_SEL_8G == value:
return _ACCEL_SO_8G
elif ACCEL_FS_SEL_16G == value:
return _ACCEL_SO_16G
def _gyro_fs(self, value):
self._register_char(_GYRO_CONFIG, value)
# Return the sensitivity divider
if GYRO_FS_SEL_250DPS == value:
return _GYRO_SO_250DPS
elif GYRO_FS_SEL_500DPS == value:
return _GYRO_SO_500DPS
elif GYRO_FS_SEL_1000DPS == value:
return _GYRO_SO_1000DPS
elif GYRO_FS_SEL_2000DPS == value:
return _GYRO_SO_2000DPS
def __enter__(self):
return self
def __exit__(self, exception_type, exception_value, traceback):
pass
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/mpu6886/mpu6886.py
|
Python
|
apache-2.0
| 7,145
|
from driver import ADC
class MQ136(object):
def __init__(self, adcObj):
self.adcObj = None
if not isinstance(adcObj, ADC):
raise ValueError("parameter is not an ADC object")
self.adcObj = adcObj
def getVoltage(self):
if self.adcObj is None:
raise ValueError("invalid ADC object")
value = self.adcObj.readVoltage()
return value
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/mq136/mq136.py
|
Python
|
apache-2.0
| 412
|
from driver import ADC
class MQ2(object):
def __init__(self, adcObj):
self.adcObj = None
if not isinstance(adcObj, ADC):
raise ValueError("parameter is not an ADC object")
self.adcObj = adcObj
def getMq2Value(self):
if self.adcObj is None:
raise ValueError("invalid ADC object")
value = self.adcObj.readVoltage()
return value
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/mq2/mq2.py
|
Python
|
apache-2.0
| 411
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for MQ3
Author: HaaS
Date: 2022/03/15
"""
from driver import ADC
from utime import sleep_ms
from micropython import const
import math
class MQ3(object):
"""
This class implements mq3 chip's defs.
"""
def __init__(self, adcObj):
self._adcObj = None
if not isinstance(adcObj, ADC):
raise ValueError("parameter is not an adcObj object")
self._adcObj = adcObj
def getVoltage(self):
if self._adcObj is None:
raise ValueError("invalid ADC object")
value = self._adcObj.readVoltage()
return value
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/mq3/mq3.py
|
Python
|
apache-2.0
| 682
|
import neopixel
import framebuf
class NeoPixelMatrix:
def __init__(self, pin, width, hight, linedir):
self.width = width
self.height = hight
self.linedir = linedir
self.buffer = bytearray(self.width * self.height * 3)
fb = framebuf.FrameBuffer(
self.buffer, self.width, self.height, framebuf.RGB888)
self.framebuf = fb
self.fill = fb.fill
self.fill_rect = fb.fill_rect
self.hline = fb.hline
self.vline = fb.vline
self.line = fb.line
self.rect = fb.rect
self.pixel = fb.pixel
self.scroll = fb.scroll
self.text = fb.text
self.blit = fb.blit
self.brightness = 255
self.np = neopixel.NeoPixel(pin, width*hight, bpp=3, timing=1)
def show(self):
for i in range(0, self.width * self.height):
x = i // self.height
y = (self.height - i % self.height - 1) if (x %
2 == 1) else (i % self.height)
self.np[i] = (
self.buffer[(x + self.width * y) * 3] * self.brightness >> 8,
(self.buffer[(x + self.width * y) * 3 + 1] * self.brightness) >> 8,
(self.buffer[(x + self.width * y) * 3 + 2] * self.brightness) >> 8)
self.np.write()
def setBuffer(self, buffer):
self.buffer = buffer[:]
def setBrightness(self, bright):
# for i in range(self.width * self.height * 3):
# self.buffer[i] = (self.buffer[i] * bright) >> 8
self.brightness = bright
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/neo_pixel_matrix/neoPixelMatrix.py
|
Python
|
apache-2.0
| 1,593
|
'''
Copyright (C) 2015-2022 Alibaba Group Holding Limited
MicroPython's driver for Noise
Author: HaaS
Date: 2022/03/23
'''
import utime # 延时函数在utime库中
from driver import ADC
class Noise(object):
def __init__(self, adcObj, avgSz=100):
self.adcObj = None
if not isinstance(adcObj, ADC):
raise ValueError('parameter is not an ADC object')
self.adcObj = adcObj
self.avgSz = avgSz
self.avgVec = [0] * self.avgSz
self.avgVecIdx = -1
self.init()
# 初始化均值数组，后续通过计算平滑均值曲线值与当前值进行比较
def init(self):
# init avg vector
for idx in range(self.avgSz):
voltage = self.adcObj.readVoltage()
self.avgVec[idx] = voltage
# 获取当前电压值 mV
def getVoltage(self):
return self.adcObj.readVoltage()
# 单次检查当前声音分贝是否超过阈值，changed 为 True 表示有变化，voltage 为当前电压值(mV)
def checkNoise(self, voltage, threshold=400):
self.avgVecIdx = (self.avgVecIdx + 1) % self.avgSz
self.avgVec[self.avgVecIdx] = voltage
avg = sum(self.avgVec) / self.avgSz
changed = abs(voltage - avg) > threshold
return changed
def main():
adcObj = ADC()
ret = adcObj.open('noise_adc')
if ret != 0:
raise Exception('open device failed %s' % ret)
drv = Noise(adcObj)
print('watch, doing...')
while True:
voltage = drv.getVoltage()
changed = drv.checkNoise(voltage, 400)
if changed:
print('got change %s' % voltage)
utime.sleep_ms(30)
return drv
if __name__ == '__main__':
main()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/noise/noise.py
|
Python
|
apache-2.0
| 1,744
|
#-*- coding: utf-8 -*-
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for CHT8305
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Author: HaaS
"""
'''!
@file DFRobot_PAJ7620U2.h
@brief Define the basic structure of the class DFRobot_PAJ7620 gesture sensor
@n The PAC7620 integrates gesture recognition function with general I2C interface into a single chip forming an image analytic sensor
@n system. It can recognize 9 human hand gesticulations such as moving up, down, left, right, forward, backward, circle-clockwise,
@n circle-counter Key Parameters clockwise, and waving. It also offers built-in proximity detection in sensing approaching or
@n departing object from the sensor. The PAC7620 is designed with great flexibility in power-saving mechanism, well suit for low
@n power battery operated HMI devices. The PAJ7620 is packaged into module form in-built with IR LED and optics lens as a complete
@n sensor solution.
@copyright Copyright (c) 2010 DFRobot Co.Ltd (http://www.dfrobot.com)
@license The MIT License (MIT)
@author Alexander(ouki.wang@dfrobot.com)
@maintainer [fary](feng.yang@dfrobot.com)
@version V1.0
@date 2019-07-16
@url https://github.com/DFRobot/DFRobot_PAJ7620U2
'''
import utime
import json
from driver import I2C
## DEVICE ID
PAJ7620_IIC_ADDR = 0x73
PAJ7620_PARTID = 0x7620
## REGISTER BANK SELECT
PAJ7620_REGITER_BANK_SEL = 0xEF
## REGISTER BANK 0
PAJ7620_ADDR_PART_ID_LOW = 0x00
PAJ7620_ADDR_PART_ID_HIGH = 0x01
PAJ7620_ADDR_VERSION_ID = 0x01
PAJ7620_ADDR_SUSPEND_CMD = 0x03
PAJ7620_ADDR_GES_PS_DET_MASK_0 = 0x41
PAJ7620_ADDR_GES_PS_DET_MASK_1 = 0x42
PAJ7620_ADDR_GES_PS_DET_FLAG_0 = 0x43
PAJ7620_ADDR_GES_PS_DET_FLAG_1 = 0x44
PAJ7620_ADDR_STATE_INDICATOR = 0x45
PAJ7620_ADDR_PS_HIGH_THRESHOLD = 0x69
PAJ7620_ADDR_PS_LOW_THRESHOLD = 0x6A
PAJ7620_ADDR_PS_APPROACH_STATE = 0x6B
PAJ7620_ADDR_PS_RAW_DATA = 0x6C
## REGISTER BANK 1
PAJ7620_ADDR_PS_GAIN = 0x44
PAJ7620_ADDR_IDLE_S1_STEP_0 = 0x67
PAJ7620_ADDR_IDLE_S1_STEP_1 = 0x68
PAJ7620_ADDR_IDLE_S2_STEP_0 = 0x69
PAJ7620_ADDR_IDLE_S2_STEP_1 = 0x6A
PAJ7620_ADDR_OP_TO_S1_STEP_0 = 0x6B
PAJ7620_ADDR_OP_TO_S1_STEP_1 = 0x6C
PAJ7620_ADDR_OP_TO_S2_STEP_0 = 0x6D
PAJ7620_ADDR_OP_TO_S2_STEP_1 = 0x6E
PAJ7620_ADDR_OPERATION_ENABLE = 0x72
PAJ7620_BANK0 = 0
PAJ7620_BANK1 = 1
## PAJ7620_ADDR_SUSPEND_CMD
PAJ7620_I2C_WAKEUP = 0x01
PAJ7620_I2C_SUSPEND = 0x00
## PAJ7620_ADDR_OPERATION_ENABLE
PAJ7620_ENABLE = 0x01
PAJ7620_DISABLE = 0x00
## You can adjust the reaction time according to the actual circumstance.
GES_REACTION_TIME = 0.05
## When you want to recognize the Forward/Backward gestures, your gestures' reaction time must less than GES_ENTRY_TIME(0.8s).
GES_ENTRY_TIME = 2
GES_QUIT_TIME = 1
GESTURE = json.loads('{\
"0": "None",\
"1": "Right",\
"2": "Left",\
"4": "Up",\
"8": "Down",\
"16": "Forward",\
"32": "Backward",\
"64":"Clockwise",\
"128": "Anti-Clockwise",\
"256":"Wave",\
"512":"WaveSlowlyDisorder",\
"3": "WaveSlowlyLeftRight",\
"12": "WaveSlowlyUpDown",\
"48": "WaveSlowlyForwardBackward"}')
class PAJ7620:
## OK
ERR_OK = 0
## Error in I2C Bus
ERR_I2C_BUS = -1
## IC version mismatch
ERR_IC_VERSION = -2
## no gestures detected
GESTURE_NONE = 0x00
## move from left to right
GESTURE_RIGHT = 0x01 << 0
## move from right to left
GESTURE_LEFT = 0x01 << 1
## move from down to up
GESTURE_UP = 0x01 << 2
## move form up to down
GESTURE_DOWN = 0x01 << 3
## starts far, move close to sensor
GESTURE_FORWARD = 0x01 << 4
## starts near, move far to sensor
GESTURE_BACKWARD = 0x01 << 5
## clockwise
GESTURE_CLOCKWISE = 0x01 << 6
## anti - clockwise
GESTURE_ANTI_CLOCKWISE = 0x01 << 7
## wave quickly
GESTURE_WAVE = 0x01 << 8
##wave randomly and slowly
GESTURE_WAVE_SLOWLY_DISORDER = 0x01 << 9
## slowly move left and right
GESTURE_WAVE_SLOWLY_LEFT_RIGHT = GESTURE_LEFT + GESTURE_RIGHT
## slowly move up and down
GESTURE_WAVE_SLOWLY_UP_DOWN = GESTURE_UP + GESTURE_DOWN
##slowly move forward and backward
GESTURE_WAVE_SLOWLY_FORWARD_BACKWARD = GESTURE_FORWARD + GESTURE_BACKWARD
## support all gestures, no practical meaning, only suitable for writing abstract program logic.
GESTURE_ALL = 0xff
## some registers are located in Bank0
BANK_0 = 0
## some registers are located in Bank1
BANK_1 = 1
## Gesture Update Rate is 120HZ, Gesture speed is 60°/s - 600°/s
NORMAL_RATE = 0
## Gesture Update Rate is 240HZ,Gesture speed is 60°/s - 1200°/s
GAMING_RATE = 1
_gesture_high_rate = True
_init_register_array = [
[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]]
def __init__(self, i2cObj):
self.i2cobj = None
if not isinstance(i2cObj, I2C):
raise ValueError("parameter is not an I2C object")
self.i2cobj = i2cObj
while self._begin() != 0:
print("initial PAJ7620 error!! Please check if the wire sequence is correct?")
utime.sleep(0.5)
def _setReg(self,reg,value):
buf = bytearray(value)
self.i2cobj.memWrite(buf,reg,8)
def _getReg(self, reg):
buf = bytearray(8)
self.i2cobj.memRead(buf,reg,8)
return buf
def _selBank(self,data):
if data == self.BANK_0 or data == self.BANK_1:
self._setReg(PAJ7620_REGITER_BANK_SEL, [data])
def _begin(self):
self._selBank(self.BANK_0)
partid = self._getReg(PAJ7620_ADDR_PART_ID_LOW)
if partid == None:
return self.ERR_I2C_BUS
utime.sleep(0.1)
if (partid[1]<<8|partid[0]) != PAJ7620_PARTID:
return self.ERR_IC_VERSION
for i in range(0,len(self._init_register_array)):
self._setReg(self._init_register_array[i][0], [self._init_register_array[i][1]])
self._selBank(self.BANK_0)
return self.ERR_OK
def setGestureHighrate(self,status):
self._gesture_highrate = status
def gestureDescription(self,gesture):
ges = str(gesture)
return GESTURE.get(ges, "")
def getGesture(self):
buf = self._getReg(PAJ7620_ADDR_GES_PS_DET_FLAG_1)
gesture = buf[0] << 8
if gesture == self.GESTURE_WAVE:
utime.sleep(GES_QUIT_TIME)
else :
gesture = self.GESTURE_NONE
buf = self._getReg(PAJ7620_ADDR_GES_PS_DET_FLAG_0)
gesture = buf[0] & 0x00ff
if not self._gesture_highrate:
utime.sleep(GES_ENTRY_TIME)
tmp = self._getReg(PAJ7620_ADDR_GES_PS_DET_FLAG_0)
utime.sleep(0.2)
gesture = gesture|tmp[0]
if gesture != self.GESTURE_NONE:
utime.sleep(0.1)
elif gesture == self.GESTURE_FORWARD:
if not self._gesture_highrate:
utime.sleep(GES_QUIT_TIME)
else:
utime.sleep(GES_QUIT_TIME / 5)
elif gesture == self.GESTURE_BACKWARD:
print("Backward Event Detected")
if not self._gesture_high_rate:
utime.sleep(GES_QUIT_TIME)
else:
utime.sleep(GES_QUIT_TIME / 5)
else:
tmp = self._getReg(PAJ7620_ADDR_GES_PS_DET_FLAG_1)
if tmp[0]:
gesture = self.GESTURE_WAVE
print("Wave Event Detected")
return gesture
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/paj7620/paj7620.py
|
Python
|
apache-2.0
| 12,177
|
import time
from ustruct import pack
from math import pi
from driver import I2C
import math
class PCA9685:
def __init__(self, i2cDev):
self._i2c = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
self._i2c = i2cDev
self.freq = 50 #50hz == 20ms
self.ontime = 410
self.setFreq(self.freq)
def setFreq(self,freq = None):
prescale = int(25000000.0 / 4096.0 / freq + 0.5)
self._i2c.memWrite(b'\x10',0x00,8)
self._i2c.memWrite(pack('B',prescale),0xfe,8)
self._i2c.memWrite(b'\x00',0x00,8)
time.sleep_us(5)
self._i2c.memWrite(b'\xa1',0x00,8)
def pwm(self,index, on=None, off=None):
self._i2c.memWrite(pack('<HH',on,off),0x06 + (index*4),8)
def reset(self, index):
self.pwm(index, 0 , 4095)
def setServo(self,index,pos):
if pos > 0:
value = 205*(pos/(pi/2))
self.offtime = self.ontime + 306 + int(value)
elif pos < 0:
value = 205*((-pos)/(pi/2))
self.offtime = self.ontime + 306 - int(value)
else:
self.offtime = self.ontime + 306
self.pwm(index,self.ontime,self.offtime)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/pca9685/pca9685.py
|
Python
|
apache-2.0
| 1,217
|
from driver import ADC
class PHOTORESISTOR(object):
def __init__(self, adcObj):
self.adcObj = None
if not isinstance(adcObj, ADC):
raise ValueError("parameter is not an ADC object")
self.adcObj = adcObj
def getLightness(self):
if self.adcObj is None:
raise ValueError("invalid ADC object")
value = self.adcObj.readVoltage()
return value
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/photoresistor/photoresistor.py
|
Python
|
apache-2.0
| 422
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for QMC5883l
Author: HaaS
Date: 2021/09/09
"""
from driver import I2C
from utime import sleep_ms
import math
x_max = 0
x_min = 0
z_min = 0
y_max = 0
y_min = 0
z_max = 0
addr = 0
mode = 0
rate = 0
g_range = 0
oversampling = 0
INT16_MIN = (-32767-1)
INT16_MAX = 32767
# Register numbers
QMC5883L_X_LSB = 0
QMC5883L_X_MSB = 1
QMC5883L_Y_LSB = 2
QMC5883L_Y_MSB = 3
QMC5883L_Z_LSB = 4
QMC5883L_Z_MSB = 5
QMC5883L_STATUS = 6
QMC5883L_TEMP_LSB = 7
QMC5883L_TEMP_MSB = 8
QMC5883L_CONFIG = 9
QMC5883L_CONFIG2 = 10
QMC5883L_RESET = 11
QMC5883L_RESERVED = 12
QMC5883L_CHIP_ID = 13
QMC5883L_STATUS_DRDY = 1
QMC5883L_STATUS_OVL = 2
QMC5883L_STATUS_DOR = 4
# Oversampling values for the CONFIG register
QMC5883L_CONFIG_OS512 = 0b00000000
QMC5883L_CONFIG_OS256 = 0b01000000
QMC5883L_CONFIG_OS128 = 0b10000000
QMC5883L_CONFIG_OS64 = 0b11000000
# Range values for the CONFIG register
QMC5883L_CONFIG_2GAUSS = 0b00000000
QMC5883L_CONFIG_8GAUSS = 0b00010000
# Rate values for the CONFIG register
QMC5883L_CONFIG_10HZ = 0b00000000
QMC5883L_CONFIG_50HZ = 0b00000100
QMC5883L_CONFIG_100HZ = 0b00001000
QMC5883L_CONFIG_200HZ = 0b00001100
# Mode values for the CONFIG register
QMC5883L_CONFIG_STANDBY = 0b00000000
QMC5883L_CONFIG_CONT = 0b00000001
# Apparently M_PI isn't available in all environments.
M_PI = 3.14159265358979323846264338327950288
class QMC5883(object):
"""
This class implements qmc5883 chip's defs.
"""
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make QMC5883's internal object points to i2cDev
self._i2cDev = i2cDev
# 初始化QMC5883传感器
self._devInit()
def devRegRead1Byte(self, addr):
return self.devRegReadWrite1Byte(0, addr, 0)
def devRegReadWrite1Byte(self, mode, addr, value):
#0 read mode
#1 write mode
if (mode == 0):
Reg = bytearray([addr])
self._i2cDev.write(Reg)
sleep_ms(30)
tmp = bytearray(1)
self._i2cDev.read(tmp)
#print("<-- read addr " + str(addr) + ", value = " + str(tmp[0]))
return tmp[0]
else:
Reg = bytearray([addr, value])
self._i2cDev.write(Reg)
#print("--> write addr " + str(addr) + ", value = " + str(value))
return 0
def devRegWrite1Byte(self, data):
Reg = bytearray([data])
self._i2cDev.write(Reg)
#print("--> write value = " + str(Reg[0]))
def devRegReadNByte(self, addr, len):
reg = bytearray([addr])
data = bytearray(len)
self._i2cDev.write(reg)
sleep_ms(20)
self._i2cDev.read(data)
#print("--> read " + str(len) + " bytes from addr " + str(addr) + ", " + str(len) + " bytes value = " + str(data))
return data
def _WriteRegister(self, addr, reg, data):
#print(">>>> wirte reg: %d, data: %d\n" %(reg, data))
self.devRegReadWrite1Byte(1, reg, data)
def _ReadRegister(self, reg):
return self.devRegRead1Byte(reg)
def _ReadLen(self, reg, len):
return self.devRegReadNByte(reg, len)
def _reconfig(self):
self._WriteRegister(addr, QMC5883L_CONFIG, oversampling | g_range | rate | mode)
sleep_ms(50)
self._WriteRegister(addr, QMC5883L_CONFIG2, 0x1)
def _reset(self):
self._WriteRegister(addr, QMC5883L_RESET, 0x01)
sleep_ms(500)
self._reconfig()
sleep_ms(50)
self._resetCalibration()
def _setOverSampling(self, x):
global oversampling
if (x == 512):
oversampling = QMC5883L_CONFIG_OS512
elif (x == 256):
oversampling = QMC5883L_CONFIG_OS256
elif (x == 128):
oversampling = QMC5883L_CONFIG_OS128
elif (x == 64):
oversampling = QMC5883L_CONFIG_OS64
self._reconfig()
def _setRange(self, x):
global g_range
if (x == 2):
g_range = QMC5883L_CONFIG_2GAUSS
elif (x == 8):
g_range = QMC5883L_CONFIG_8GAUSS
self._reconfig()
def _setSamplingRate(self, x):
global rate
if (x == 10):
rate = QMC5883L_CONFIG_10HZ
elif (x == 50):
rate = QMC5883L_CONFIG_50HZ
elif (x == 100):
rate = QMC5883L_CONFIG_100HZ
elif (x == 200):
rate = QMC5883L_CONFIG_200HZ
self._reconfig()
def _devInit(self):
global addr
global oversampling
global g_range
global rate
global mode
# This assumes the wire library has been initialized.
oversampling = QMC5883L_CONFIG_OS512
g_range = QMC5883L_CONFIG_8GAUSS
rate = QMC5883L_CONFIG_200HZ
mode = QMC5883L_CONFIG_CONT
#print("addr %d,oversampling %d,g_range %d,rate %d, mode %d" %(addr, oversampling, g_range, rate, mode))
self._reset()
def _devReady(self):
sleep_ms(200)
tmp = self._ReadRegister(QMC5883L_STATUS) & QMC5883L_STATUS_DRDY
return tmp
def _ReadRaw(self):
timeout = 10000
arr = [1, 2, 3]
data = bytearray(6)
ready = self._devReady()
while (ready == 0 and timeout):
ready = self._devReady()
timeout -= 1
#print("ready = %d" %(ready))
data = self._ReadLen(QMC5883L_X_LSB, 6)
x = data[0] | (data[1] << 8)
y = data[2] | (data[3] << 8)
z = data[4] | (data[5] << 8)
#print("read_raw[%f,%f,%f],\n" %(x ,y, z))
if (x > (1 << 15)):
x = x - (1<<16)
if (y > (1 << 15)):
y = y - (1<<16)
if (z > (1 << 15)):
z = z - (1<<16)
arr[0] = x
arr[1] = y
arr[2] = z
return arr
def _resetCalibration(self):
global x_max
global x_min
global z_min
global y_max
global y_min
global z_max
x_max = y_max = z_max = INT16_MIN
x_min = y_min = z_min = INT16_MAX
def getHeading(self):
global x_max
global x_min
global z_min
global y_max
global y_min
global z_max
global addr
global mode
global rate
global g_range
global oversampling
tmp = self._ReadRegister(QMC5883L_STATUS) & QMC5883L_STATUS_DRDY
#print("read QMC5883L_STATUS: %d\n" %(tmp))
xyz_org = self._ReadRaw()
x_org = xyz_org[0]
y_org = xyz_org[1]
z_org = xyz_org[2]
#print("org[%f,%f,%f]\n" %(x_org ,y_org, z_org))
# Update the observed boundaries of the measurements
if (x_org < x_min):
x_min = x_org
if (x_org > x_max):
x_max = x_org
if (y_org < y_min):
y_min = y_org
if (y_org > y_max):
y_max = y_org
if (z_org < z_min):
z_min = z_org
if (z_org > z_max):
z_max = z_org
# Bail out if not enough data is available.
if ((x_min == x_max) or (y_min == y_max) or (z_max == z_min)):
#print("x_min %f == x_max %f or y_min %f == y_max %f or z_max%f == z_min%f\n" %(x_min, x_max, y_min, y_max, z_max, z_min))
return 0
# Recenter the measurement by subtracting the average
x_offset = (x_max + x_min) / 2.0
y_offset = (y_max + y_min) / 2.0
z_offset = (z_max + z_min) / 2.0
x_fit = (x_org - x_offset) * 1000.0 / (x_max - x_min)
y_fit = (y_org - y_offset) * 1000.0 / (y_max - y_min)
z_fit = (z_org - z_offset) * 1000.0 / (z_max - z_min)
#print("fix[%f,%f,%f],\n" %(x_fit ,y_fit, z_fit))
heading = 180.0 * math.atan2(x_fit, y_fit) / M_PI
if (heading <= 0):
heading = heading + 360
#print("heading = %f\n", heading)
return heading
if __name__ == "__main__":
'''
The below i2c configuration is needed in your board.json.
"qmc5883": {
"type": "I2C",
"port": 1,
"addrWidth": 7,
"freq": 400000,
"mode": "master",
"devAddr": 13
}
'''
print("Testing qmc5883 ...")
i2cDev = I2C()
i2cDev.open("qmc5883")
qmc5883Dev = QMC5883(i2cDev)
h = qmc5883Dev.getHeading()
print("The heading data is:", h)
i2cDev.close()
del qmc5883Dev
print("Test qmc5883 done!")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/qmc5883/qmc5883.py
|
Python
|
apache-2.0
| 8,659
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for QMC6310 magnetometer
Author: HaaS
Date: 2021/09/09
"""
from driver import I2C
from micropython import const
import utime
import math
# vendor chip id
QMC6308_IIC_ADDR = const(0x2C)
QMC6310U_IIC_ADDR = const(0x1c)
QMC6310N_IIC_ADDR = const(0x3c)
QMC6310_CHIP_ID_REG = const(0x00)
# data output register
QMC6310_DATA_OUT_X_LSB_REG = const(0x01)
QMC6310_DATA_OUT_X_MSB_REG = const(0x02)
QMC6310_DATA_OUT_Y_LSB_REG = const(0x03)
QMC6310_DATA_OUT_Y_MSB_REG = const(0x04)
QMC6310_DATA_OUT_Z_LSB_REG = const(0x05)
QMC6310_DATA_OUT_Z_MSB_REG = const(0x06)
# Status registers
QMC6310_STATUS_REG = const(0x09)
# configuration registers
QMC6310_CTL_REG_ONE = const(0x0A) # Contrl register one * /
QMC6310_CTL_REG_TWO = const(0x0B) # Contrl register two * /
QMC6310_CTL_REG_THREE = const(0x0D) # Contrl register three * /
# Magnetic Sensor Operating Mode MODE[1:0]
QMC6310_SUSPEND_MODE = const(0x00)
QMC6310_NORMAL_MODE = const(0x01)
QMC6310_SINGLE_MODE = const(0x02)
QMC6310_H_PFM_MODE = const(0x03)
# data output rate OSR2[2:0]
OUTPUT_DATA_RATE_800HZ = const(0x00)
OUTPUT_DATA_RATE_400HZ = const(0x01)
OUTPUT_DATA_RATE_200HZ = const(0x02)
OUTPUT_DATA_RATE_100HZ = const(0x03)
# oversample Ratio OSR[1]
OVERSAMPLE_RATE_256 = const(0x01)
OVERSAMPLE_RATE_128 = const(0x00)
SET_RESET_ON = const(0x00)
SET_ONLY_ON = const(0x01)
SET_RESET_OFF = const(0x02)
QMC6310_DEFAULT_DELAY = const(200)
QMC6310_AXIS_X = const(0x00)
QMC6310_AXIS_Y = const(0x01)
QMC6310_AXIS_Z = const(0x02)
QMC6310_AXIS_TOTAL = const(0x03)
INT16_MIN = const(-32768)
INT16_MAX = const(32767)
class QMC6310():
def __init__(self, i2cDev):
self.addr = QMC6310U_IIC_ADDR
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make QMC6310's internal object points to i2cDev
self._i2cDev = i2cDev
self.chipId = self.getChipId()
self.resetCal()
self.setLayout(0)
self.enable()
ctrl_value = self.getReg(QMC6310_CTL_REG_ONE)
#print('ctrl_value one = %d' % ctrl_value)
ctrl_value = self.getReg(QMC6310_CTL_REG_TWO)
#print('ctrl_value two = %d' % ctrl_value)
ctrl_value = self.getReg(QMC6310_CTL_REG_THREE)
#print('ctrl_value three = %d' % ctrl_value)
def int16(self, dat):
if dat > 32767:
return dat - 65536
else:
return dat
# set reg
def setReg(self, reg, dat):
buf = bytearray(2)
buf[0] = reg
buf[1] = dat
self._i2cDev.write(buf)
# get reg
def getReg(self, reg):
buf = bytearray(1)
buf[0] = reg
self._i2cDev.write(buf)
self._i2cDev.read(buf)
return buf[0]
# get mem reg
def getMemReg(self, reg, len):
buf = bytearray(1)
buf[0] = reg
self._i2cDev.write(buf)
data = bytearray(len)
self._i2cDev.read(data)
return data
def getChipId(self):
id = self.getReg(QMC6310_CHIP_ID_REG)
return id
def setLayout(self, layout):
if (layout == 0):
self.sign_x = 1
self.sign_y = 1
self.sign_z = 1
self.map_x = QMC6310_AXIS_X
self.map_y = QMC6310_AXIS_Y
self.map_z = QMC6310_AXIS_Z
elif (layout == 1):
self.sign_x = -1
self.sign_y = 1
self.sign_z = 1
self.map_x = QMC6310_AXIS_Y
self.map_y = QMC6310_AXIS_X
self.map_z = QMC6310_AXIS_Z
elif (layout == 2):
self.sign_x = -1
self.sign_y = -1
self.sign_z = 1
self.map_x = QMC6310_AXIS_X
self.map_y = QMC6310_AXIS_Y
self.map_z = QMC6310_AXIS_Z
elif (layout == 3):
self.sign_x = 1
self.sign_y = -1
self.sign_z = 1
self.map_x = QMC6310_AXIS_Y
self.map_y = QMC6310_AXIS_X
self.map_z = QMC6310_AXIS_Z
elif (layout == 4):
self.sign_x = -1
self.sign_y = 1
self.sign_z = -1
self.map_x = QMC6310_AXIS_X
self.map_y = QMC6310_AXIS_Y
self.map_z = QMC6310_AXIS_Z
elif (layout == 5):
self.sign_x = 1
self.sign_y = 1
self.sign_z = -1
self.map_x = QMC6310_AXIS_Y
self.map_y = QMC6310_AXIS_X
self.map_z = QMC6310_AXIS_Z
elif (layout == 6):
self.sign_x = 1
self.sign_y = -1
self.sign_z = -1
self.map_x = QMC6310_AXIS_X
self.map_y = QMC6310_AXIS_Y
self.map_z = QMC6310_AXIS_Z
elif (layout == 7):
self.sign_x = -1
self.sign_y = -1
self.sign_z = -1
self.map_x = QMC6310_AXIS_Y
self.map_y = QMC6310_AXIS_X
self.map_z = QMC6310_AXIS_Z
else:
self.sign_x = 1
self.sign_y = 1
self.sign_z = 1
self.map_x = QMC6310_AXIS_X
self.map_y = QMC6310_AXIS_Y
self.map_z = QMC6310_AXIS_Z
def enable(self):
self.setReg(0x0d, 0x40)
self.setReg(0x29, 0x06)
self.setReg(0x0a, 0x0F)
self.setReg(0x0b, 0x00)
def resetCal(self):
self.x_max = INT16_MIN
self.y_max = INT16_MIN
self.z_max = INT16_MIN
self.x_min = INT16_MAX
self.y_min = INT16_MAX
self.z_min = INT16_MAX
def getXYZ(self):
# Check status register for data availability
rdy = self.getReg(QMC6310_STATUS_REG)
count = 0
while not (rdy & 0x01) and (count < 5):
rdy = self.getReg(QMC6310_STATUS_REG)
count = count + 1
utime.sleep(0.5)
data = self.getMemReg(QMC6310_DATA_OUT_X_LSB_REG, 6)
t0 = self.int16((data[1] << 8) | data[0])
t1 = self.int16((data[3] << 8) | data[2])
t2 = self.int16((data[5] << 8) | data[4])
hw_d = [t0, t1, t2]
raw_c0 = self.sign_x * hw_d[self.map_x] / 10.0
raw_c1 = self.sign_y * hw_d[self.map_y] / 10.0
raw_c2 = self.sign_z * hw_d[self.map_z] / 10.0
return [raw_c0, raw_c1, raw_c2]
def getHeading(self):
# Check status register for data availability
rdy = self.getReg(QMC6310_STATUS_REG)
count = 0
while not (rdy & 0x01) and (count < 5):
rdy = self.getReg(QMC6310_STATUS_REG)
count = count + 1
utime.sleep(0.5)
data = self.getMemReg(QMC6310_DATA_OUT_X_LSB_REG, 6)
x_org = self.int16((data[1] << 8) | data[0])
y_org = self.int16((data[3] << 8) | data[2])
z_org = self.int16((data[5] << 8) | data[4])
self.x_min = min(x_org, self.x_min)
self.x_max = max(x_org, self.x_max)
self.y_min = min(y_org, self.y_min)
self.y_max = max(y_org, self.y_max)
self.z_min = min(z_org, self.z_min)
self.z_max = max(z_org, self.z_max)
# Bail out if not enough data is available.
if self.x_min == self.x_max or self.y_min == self.y_max or self.z_min == self.z_max:
return 0.0
# Recenter the measurement by subtracting the average * /
x_offset = (self.x_max + self.x_min) / 2.0
y_offset = (self.y_max + self.y_min) / 2.0
z_offset = (self.z_max + self.z_min) / 2.0
x_fit = (x_org - x_offset) * 1000.0 / (self.x_max - self.x_min)
y_fit = (y_org - y_offset) * 1000.0 / (self.y_max - self.y_min)
z_fit = (z_org - z_offset) * 1000.0 / (self.z_max - self.z_min)
heading = 180.0 * math.atan2(x_fit, y_fit) / math.pi
if heading <= 0:
heading = heading + 360.0
return heading
def setMode(self, mode):
value = self.getReg(QMC6310_CTL_REG_ONE)
value = (value & (~0x03)) | mode
self.setReg(QMC6310_CTL_REG_ONE, value)
def setRate(self, rate):
value = self.getReg(QMC6310_CTL_REG_ONE)
value = (value & (~0xE8)) | (rate << 5)
self.setReg(QMC6310_CTL_REG_ONE, value)
if __name__ == "__main__":
'''
The below i2c configuration is needed in your board.json.
"qmc6310": {
"type": "I2C",
"port": 1,
"addrWidth": 7,
"freq": 100000,
"mode": "master",
"devAddr": 28
},
'''
print("Testing qmc6310 ...")
i2cDev = I2C()
i2cDev.open("qmc6310")
qmc6310Dev = QMC6310(i2cDev)
h = qmc6310Dev.getHeading()
print("The heading data is:", h)
i2cDev.close()
del qmc6310Dev
print("Test qmc6310 done!")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/qmc6310/qmc6310.py
|
Python
|
apache-2.0
| 8,796
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for QMI8610
Author: HaaS
Date: 2021/09/14
"""
from micropython import const
from driver import I2C
from utime import sleep_ms
import math
M_PI = (3.14159265358979323846)
ONE_G = (9.80665)
FISIMU_STATUS1_CMD_DONE = const(0x01)
FISIMU_STATUS1_WAKEUP_EVENT = const(0x04)
FISIMU_CTRL7_DISABLE_ALL = const(0x0)
FISIMU_CTRL7_ACC_ENABLE = const(0x1)
FISIMU_CTRL7_GYR_ENABLE = const(0x2)
FISIMU_CTRL7_MAG_ENABLE = const(0x4)
FISIMU_CTRL7_AE_ENABLE = const(0x8)
FISIMU_CTRL7_ENABLE_MASK = const(0xF)
FISIMU_CONFIG_ACC_ENABLE = FISIMU_CTRL7_ACC_ENABLE
FISIMU_CONFIG_GYR_ENABLE = FISIMU_CTRL7_GYR_ENABLE
FISIMU_CONFIG_MAG_ENABLE = FISIMU_CTRL7_MAG_ENABLE
FISIMU_CONFIG_AE_ENABLE = FISIMU_CTRL7_AE_ENABLE
FISIMU_CONFIG_ACCGYR_ENABLE = (FISIMU_CONFIG_ACC_ENABLE | FISIMU_CONFIG_GYR_ENABLE)
FISIMU_CONFIG_ACCGYRMAG_ENABLE = (FISIMU_CONFIG_ACC_ENABLE | FISIMU_CONFIG_GYR_ENABLE | FISIMU_CONFIG_MAG_ENABLE)
FISIMU_CONFIG_AEMAG_ENABLE = (FISIMU_CONFIG_AE_ENABLE | FISIMU_CONFIG_MAG_ENABLE)
FisRegister_WhoAmI = const(0) # FIS device identifier register.
FisRegister_Revision = const(1) # FIS hardware revision register.
FisRegister_Ctrl1 = const(2) # General and power management modes.
FisRegister_Ctrl2 = const(3) # Accelerometer control. *
FisRegister_Ctrl3 = const(4) # Gyroscope control.
FisRegister_Ctrl4 = const(5) # Magnetometer control.
FisRegister_Ctrl5 = const(6) # Data processing settings.
FisRegister_Ctrl6 = const(7) # AttitudeEngine control.
FisRegister_Ctrl7 = const(8) # Sensor enabled status.
FisRegister_Ctrl8 = const(9) # Reserved - do not write.
FisRegister_Ctrl9 = const(10) # Host command register.
FisRegister_Cal1_L = const(11) # Calibration register 1 least significant byte.
FisRegister_Cal1_H = const(12) # Calibration register 1 most significant byte.
FisRegister_Cal2_L = const(13) # Calibration register 2 least significant byte.
FisRegister_Cal2_H = const(14) # Calibration register 2 most significant byte.
FisRegister_Cal3_L = const(15) # Calibration register 3 least significant byte.
FisRegister_Cal3_H = const(16) # Calibration register 3 most significant byte.
FisRegister_Cal4_L = const(17) # Calibration register 4 least significant byte.
FisRegister_Cal4_H = const(18) # Calibration register 4 most significant byte.
FisRegister_FifoCtrl = const(19) # FIFO control register.
FisRegister_FifoData = const(20) # FIFO data register.
FisRegister_FifoStatus = const(21) # FIFO status register.
FisRegister_Status0 = const(22) # Output data overrun and availability.
FisRegister_Status1 = const(23) # Miscellaneous status register.
FisRegister_CountOut = const(24) # Sample counter.
FisRegister_Ax_L = const(25) # Accelerometer X axis least significant byte.
FisRegister_Ax_H = const(26) # Accelerometer X axis most significant byte.
FisRegister_Ay_L = const(27) # Accelerometer Y axis least significant byte.
FisRegister_Ay_H = const(28) # Accelerometer Y axis most significant byte.
FisRegister_Az_L = const(29) # Accelerometer Z axis least significant byte.
FisRegister_Az_H = const(30) # Accelerometer Z axis most significant byte.
FisRegister_Gx_L = const(31) # Gyroscope X axis least significant byte.
FisRegister_Gx_H = const(32) # Gyroscope X axis most significant byte.
FisRegister_Gy_L = const(33) # Gyroscope Y axis least significant byte.
FisRegister_Gy_H = const(34) # Gyroscope Y axis most significant byte.
FisRegister_Gz_L = const(35) # Gyroscope Z axis least significant byte.
FisRegister_Gz_H = const(36) # Gyroscope Z axis most significant byte.
FisRegister_Mx_L = const(37) # Magnetometer X axis least significant byte.
FisRegister_Mx_H = const(38) # Magnetometer X axis most significant byte.
FisRegister_My_L = const(39) # Magnetometer Y axis least significant byte.
FisRegister_My_H = const(40) # Magnetometer Y axis most significant byte.
FisRegister_Mz_L = const(41) # Magnetometer Z axis least significant byte.
FisRegister_Mz_H = const(42) # Magnetometer Z axis most significant byte.
FisRegister_Q1_L = const(43) # Quaternion increment W least significant byte.
FisRegister_Q1_H = const(44) # Quaternion increment W most significant byte.
FisRegister_Q2_L = const(45) # Quaternion increment X least significant byte.
FisRegister_Q2_H = const(46) # Quaternion increment X most significant byte.
FisRegister_Q3_L = const(47) # Quaternion increment Y least significant byte.
FisRegister_Q3_H = const(48) # Quaternion increment Y most significant byte.
FisRegister_Q4_L = const(49) # Quaternion increment Z least significant byte.
FisRegister_Q4_H = const(50) # Quaternion increment Z most significant byte.
FisRegister_Dvx_L = const(51) # Velocity increment X least significant byte.
FisRegister_Dvx_H = const(52) # Velocity increment X most significant byte.
FisRegister_Dvy_L = const(53) # Velocity increment Y least significant byte.
FisRegister_Dvy_H = const(54) # Velocity increment Y most significant byte.
FisRegister_Dvz_L = const(55) # Velocity increment Z least significant byte.
FisRegister_Dvz_H = const(56) # Velocity increment Z most significant byte.
FisRegister_Temperature = const(57) # Temperature output.
FisRegister_AeClipping = const(58) # AttitudeEngine clipping flags.
FisRegister_AeOverflow = const(59) # AttitudeEngine overflow flags.
Ctrl9_Nop = const(0) # No operation.
Ctrl9_ResetFifo = const(0x2) # Reset FIFO.
Ctrl9_SetMagXCalibration = const(0x6) # Set magnetometer X calibration values.
Ctrl9_SetMagYCalibration = const(0x7) # Set magnetometer Y calibration values.
Ctrl9_SetMagZCalibration = const(0x8) # Set magnetometer Z calibration values.
Ctrl9_SetAccelOffset = const(0x12) # Set accelerometer offset correction value.
Ctrl9_SetGyroOffset = const(0x13) # Set gyroscope offset correction value.
Ctrl9_SetAccelSensitivity = const(0x14) # Set accelerometer sensitivity.
Ctrl9_SetGyroSensitivity = const(0x15) # Set gyroscope sensitivity.
Ctrl9_UpdateMagBias = const(0xB) # Update magnemoter bias compensation.
Ctrl9_TriggerMotionOnDemand = const(0x0c) # Trigger motion on demand sample.
Ctrl9_UpdateAttitudeEngineGyroBias = const(0xE) # Update gyroscope bias compensation.
Ctrl9_ReadTrimmedFrequencyValue = const(0x18) # Read frequency correction value.
Ctrl9_ReadFifo = const(0x0D) # Prepare for FIFO read sequence.
Ctrl9_ConfigureWakeOnMotion = const(0x19) # Set wake on motion parameters.
Lpf_Disable = const(0) # Disable low pass filter.
Lpf_Enable = const(1) # Enable low pass filter.
Hpf_Disable = const(0) # Disable high pass filter.
Hpf_Enable = const(1) # Enable high pass filter.
AccRange_2g = const(0 << 3) # +/- 2g range
AccRange_4g = const(1 << 3) # +/- 4g range
AccRange_8g = const(2 << 3) # +/- 8g range
AccRange_16g = const(3 << 3) # +/- 16g range
AccOdr_1024Hz = const(0) # High resolution 1024Hz output rate.
AccOdr_256Hz = const(1) # High resolution 256Hz output rate.
AccOdr_128Hz = const(2) # High resolution 128Hz output rate.
AccOdr_32Hz = const(3) # High resolution 32Hz output rate.
AccOdr_LowPower_128Hz = const(4) # Low power 128Hz output rate.
AccOdr_LowPower_64Hz = const(5) # Low power 64Hz output rate.
AccOdr_LowPower_25Hz = const(6) # Low power 25Hz output rate.
AccOdr_LowPower_3Hz = const(7) # Low power 3Hz output rate.
GyrRange_32dps = const(0 << 3) # +-32 degrees per second.
GyrRange_64dps = const(1 << 3) # +-64 degrees per second.
GyrRange_128dps = const(2 << 3) # +-128 degrees per second.
GyrRange_256dps = const(3 << 3) # +-256 degrees per second.
GyrRange_512dps = const(4 << 3) # +-512 degrees per second.
GyrRange_1024dps = const(5 << 3) # +-1024 degrees per second.
GyrRange_2048dps = const(6 << 3) # +-2048 degrees per second.
GyrRange_2560dps = const(7 << 3) # +-2560 degrees per second.
"""
Gyroscope output rate configuration.
"""
GyrOdr_1024Hz = const(0) # High resolution 1024Hz output rate.
GyrOdr_256Hz = const(1) # High resolution 256Hz output rate.
GyrOdr_128Hz = const(2) # High resolution 128Hz output rate.
GyrOdr_32Hz = const(3) # High resolution 32Hz output rate.
GyrOdr_OIS_8192Hz = const(6) # OIS Mode 8192Hz output rate.
GyrOdr_OIS_LL_8192Hz = const(7) # OIS LL Mode 8192Hz output rate.
AeOdr_1Hz = const(0) # 1Hz output rate.
AeOdr_2Hz = const(1) # 2Hz output rate.
AeOdr_4Hz = const(2) # 4Hz output rate.
AeOdr_8Hz = const(3) # 8Hz output rate.
AeOdr_16Hz = const(4) # 16Hz output rate.
AeOdr_32Hz = const(5) # 32Hz output rate.
AeOdr_64Hz = const(6) # 64Hz output rate.
"""
* Motion on demand mode.
*
* In motion on demand mode the application can trigger AttitudeEngine
* output samples as necessary. This allows the AttitudeEngine to be
* synchronized with external data sources.
*
* When in Motion on Demand mode the application should request new data
* by calling the FisImu_requestAttitudeEngineData() function. The
* AttitudeEngine will respond with a data ready event (INT2) when the
* data is available to be read.
"""
AeOdr_motionOnDemand = const(128) # 128Hz output rate.
MagOdr_32Hz = const(2) # 32Hz output rate.
MagDev_AK8975 = const(0 << 4) # AKM AK8975.
MagDev_AK8963 = const(1 << 4) # AKM AK8963.
AccUnit_g = const(0) # Accelerometer output in terms of g (9.81m/s^2).
AccUnit_ms2 = const(1) # Accelerometer output in terms of m/s^2.
GyrUnit_dps = const(0) # Gyroscope output in degrees/s.
GyrUnit_rads = const(1) # Gyroscope output in rad/s.
AXIS_X = const(0)
AXIS_Y = const(1)
AXIS_Z = const(2)
AXIS_TOTAL = const(4)
# FIS INT1 line.
Fis_Int1 = const(0 << 6)
# FIS INT2 line.
Fis_Int2 = const(1 << 6)
InterruptInitialState_high = const(1 << 7) # Interrupt high.
InterruptInitialState_low = const(0 << 7) # Interrupt low.
WomThreshold_high = const(128) # High threshold - large motion needed to wake.
WomThreshold_low = const(32) # Low threshold - small motion needed to wake.
acc_lsb_div = 0
gyro_lsb_div = 0
qmi8610_dict = {'temp': 0.0, 'gyroX': 0.0, 'gyroY': 0.0, 'gyroZ': 0.0, 'accX': 0.0, 'accY': 0.0, 'accZ': 0.0}
class QMI8610(object):
"""
This class implements QMI8610 chip's defs.
"""
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make QMI8610's internal object points to i2cDev
self._i2cDev = i2cDev
# 初始化QMI8610传感器
r = self.init()
if r == 0:
raise ValueError("QMI8610 init error")
def int16(self, dat):
if dat > (1 << 15):
return dat - (1 << 16)
else:
return dat
def int32(self, dat):
if dat > (1 << 31):
return dat - (1 << 32)
else:
return dat
#写寄存器
def writeReg(self, addr, value):
Reg = bytearray([addr, value])
self._i2cDev.write(Reg)
#print("--> write addr " + str(addr) + ", value = " + str(value))
#写多个寄存器
def writeRegs(self, addr, value, len):
Regs = bytearray(value)
if (len != Regs.count):
return "Error code:%d, Error message: %s" % (self, str(self.msg))
self.writeReg(addr,Regs)
#print("--> write addr " + str(addr) + ", value = " + str(Regs))
#读寄存器
def readReg(self, addr, len):
reg = bytearray([addr])
data = bytearray(len)
self._i2cDev.memRead(data, addr, 8)
#print("--> read " + str(len) + " bytes from addr " + str(addr) + ", " + str(len) + " bytes value = " + str(data))
return data
# 设置layout
def setLayout(self, layout):
sign = [1,2,3]
map = [1,2,3]
if (layout == 0):
sign[AXIS_X] = 1
sign[AXIS_Y] = 1
sign[AXIS_Z] = 1
map[AXIS_X] = AXIS_X
map[AXIS_Y] = AXIS_Y
map[AXIS_Z] = AXIS_Z
elif (layout == 1):
sign[AXIS_X] = -1
sign[AXIS_Y] = 1
sign[AXIS_Z] = 1
map[AXIS_X] = AXIS_Y
map[AXIS_Y] = AXIS_X
map[AXIS_Z] = AXIS_Z
elif (layout == 2):
sign[AXIS_X] = -1
sign[AXIS_Y] = -1
sign[AXIS_Z] = 1
map[AXIS_X] = AXIS_X
map[AXIS_Y] = AXIS_Y
map[AXIS_Z] = AXIS_Z
elif (layout == 3):
sign[AXIS_X] = 1
sign[AXIS_Y] = -1
sign[AXIS_Z] = 1
map[AXIS_X] = AXIS_Y
map[AXIS_Y] = AXIS_X
map[AXIS_Z] = AXIS_Z
elif (layout == 4):
sign[AXIS_X] = -1
sign[AXIS_Y] = 1
sign[AXIS_Z] = -1
map[AXIS_X] = AXIS_X
map[AXIS_Y] = AXIS_Y
map[AXIS_Z] = AXIS_Z
elif (layout == 5):
sign[AXIS_X] = 1
sign[AXIS_Y] = 1
sign[AXIS_Z] = -1
map[AXIS_X] = AXIS_Y
map[AXIS_Y] = AXIS_X
map[AXIS_Z] = AXIS_Z
elif (layout == 6):
sign[AXIS_X] = 1
sign[AXIS_Y] = -1
sign[AXIS_Z] = -1
map[AXIS_X] = AXIS_X
map[AXIS_Y] = AXIS_Y
map[AXIS_Z] = AXIS_Z
elif (layout == 7):
sign[AXIS_X] = 1
sign[AXIS_Y] = 1
sign[AXIS_Z] = 1
map[AXIS_X] = AXIS_X
map[AXIS_Y] = AXIS_Y
map[AXIS_Z] = AXIS_Z
def configACC(self, range, odr, lpfEnable, hpfEnable):
ctl_dada = 0
range_set = 0
global acc_lsb_div
if (range == AccRange_2g):
range_set = 0 << 3
acc_lsb_div = (1 << 14)
elif (range == AccRange_4g):
range_set = 1 << 3
acc_lsb_div = (1 << 13)
elif (range == AccRange_8g):
range_set = 2 << 3
acc_lsb_div = (1 << 12)
else:
range_set = 2 << 3
acc_lsb_div = (1 << 12)
ctl_dada = range_set | odr
self.writeReg(FisRegister_Ctrl2, ctl_dada)
# set LPF & HPF
ctl_dada = self.readReg(FisRegister_Ctrl5, 1)[0]
ctl_dada &= 0xfc
if (lpfEnable == Lpf_Enable):
ctl_dada |= 0x02
if (hpfEnable == Hpf_Enable):
ctl_dada |= 0x01
self.writeReg(FisRegister_Ctrl5, ctl_dada)
def configGyro(self, range, odr, lpfEnable, hpfEnable):
# Set the CTRL3 register to configure dynamic range and ODR
global gyro_lsb_div
ctl_dada = range | odr
self.writeReg(FisRegister_Ctrl3, ctl_dada)
# Store the scale factor for use when processing raw data
if (range == GyrRange_32dps):
gyro_lsb_div = 1024
elif (range == GyrRange_64dps):
gyro_lsb_div = 512
elif (range == GyrRange_128dps):
gyro_lsb_div = 256
elif (range == GyrRange_256dps):
gyro_lsb_div = 128
elif (range == GyrRange_512dps):
gyro_lsb_div = 64
elif (range == GyrRange_1024dps):
gyro_lsb_div = 32
elif (range == GyrRange_2048dps):
gyro_lsb_div = 16
elif (range == GyrRange_2560dps):
#gyro_lsb_div = 8
pass
else:
gyro_lsb_div = 32
# Conversion from degrees/s to rad/s if necessary
# set LPF & HPF
ctl_dada = self.readReg(FisRegister_Ctrl5, 1)[0]
ctl_dada &= 0xf3
if (lpfEnable == Lpf_Enable):
ctl_dada |= 0x08
if (hpfEnable == Hpf_Enable):
ctl_dada |= 0x04
self.writeReg(FisRegister_Ctrl5, ctl_dada)
def configAe(self, odr):
# Configure Accelerometer and Gyroscope settings
self.configACC(AccRange_8g, AccOdr_1024Hz, Lpf_Enable, Hpf_Disable)
self.configGyro(GyrRange_2048dps, GyrOdr_1024Hz, Lpf_Enable, Hpf_Disable)
self.writeReg(FisRegister_Ctrl5, odr)
def readStatus0(self):
status = self.readReg(FisRegister_Status0, 1)[0]
return status
def readStatus1(self):
status = self.readReg(FisRegister_Status1, 1)[0]
return status
# 读取xyz的值
def readXyz(self):
buf_reg = bytearray(12)
raw_acc_xyz = [1, 2, 3]
raw_gyro_xyz = [1, 2, 3]
xyz_t = [1, 2, 3, 4, 5, 6]
buf_reg = self.readReg(FisRegister_Ax_L | 0x80, 12)
raw_acc_xyz[0] = self.int16((buf_reg[1] << 8) | (buf_reg[0]))
raw_acc_xyz[1] = self.int16((buf_reg[3] << 8) | (buf_reg[2]))
raw_acc_xyz[2] = self.int16((buf_reg[5] << 8) | (buf_reg[4]))
raw_gyro_xyz[0] = self.int16((buf_reg[7] << 8) | (buf_reg[6]))
raw_gyro_xyz[1] = self.int16((buf_reg[9] << 8) | (buf_reg[8]))
raw_gyro_xyz[2] = self.int16((buf_reg[11] << 8) | (buf_reg[10]))
# m/s2
xyz_t[0] = (raw_acc_xyz[0] * ONE_G) / acc_lsb_div
xyz_t[1] = (raw_acc_xyz[1] * ONE_G) / acc_lsb_div
xyz_t[2] = (raw_acc_xyz[2] * ONE_G) / acc_lsb_div
xyz_t[0] = -xyz_t[0]
xyz_t[1] = -xyz_t[1]
xyz_t[2] = -xyz_t[2]
# rad/s
xyz_t[3] = (raw_gyro_xyz[0] * M_PI / 180) / gyro_lsb_div
xyz_t[4] = (raw_gyro_xyz[1] * M_PI / 180) / gyro_lsb_div
xyz_t[5] = (raw_gyro_xyz[2] * M_PI / 180) / gyro_lsb_div
xyz_t[3] = xyz_t[3]
xyz_t[4] = xyz_t[4]
xyz_t[5] = -xyz_t[5]
return xyz_t
def applyScaleFactor(self, scaleFactor, nElements, rawData, calibratedData):
for i in range(nElements):
calibratedData[i] = (scaleFactor * rawData[2 * i]) | (rawData[2 * i + 1] << 8)
def processAccelerometerData(self, rawData, calibratedData):
self.applyScaleFactor(ONE_G/acc_lsb_div, 3, rawData, calibratedData)
def processGyroscopeData(self, rawData, calibratedData):
self.applyScaleFactor(M_PI / (gyro_lsb_div * 180), 3, rawData, calibratedData)
def readRawsample(self, rawData, calibratedData):
self.applyScaleFactor(M_PI / (gyro_lsb_div * 180), 3, rawData, calibratedData)
def writeCalibrationVectorBuffer(self, calVector, conversionFactor, fractionalBits):
o = 0
calCmd = bytearray(6)
for i in range(3):
o = round(calVector[i] * conversionFactor * (1 << fractionalBits))
calCmd[(2 * i)] = o & 0xFF
calCmd[(2 * i) + 1] = o >> 8
self.writeRegs(FisRegister_Cal1_L, calCmd, 6)
def doCtrl9Command(self, cmd):
gyroConfig = 0
oisModeBits = const(0x06)
oisEnabled = 0
status = 0
count = 0
gyroConfig = self.readReg(FisRegister_Ctrl3, 1)[0]
oisEnabled = ((gyroConfig & oisModeBits) == oisModeBits)
if (oisEnabled):
self.writeReg(FisRegister_Ctrl3, (gyroConfig & ~oisModeBits))
self.writeReg(FisRegister_Ctrl9, cmd)
# Check that command has been executed
while (((status & FISIMU_STATUS1_CMD_DONE) == 0) and (count < 10000)):
status = self.readReg(FisRegister_Status1, 1)[0]
count += 1
if (oisEnabled):
# Re-enable OIS mode configuration if necessary
self.writeReg(FisRegister_Ctrl3, gyroConfig)
def applyAccelerometerOffset(self, offset, unit):
if (unit == AccUnit_ms2):
conversionFactor = 1 / ONE_G
else:
conversionFactor = 1
self.writeCalibrationVectorBuffer(offset, conversionFactor, 11)
self.doCtrl9Command(Ctrl9_SetAccelOffset)
def applyGyroscopeOffset(self, offset, unit):
if (unit == GyrUnit_rads):
conversionFactor = 180 / M_PI
else:
conversionFactor = 1
self.writeCalibrationVectorBuffer(offset, conversionFactor, 6)
self.doCtrl9Command(Ctrl9_SetGyroOffset)
def applyOffsetCalibration(self, accUnit, accOffset, gyrUnit, gyrOffset):
self.applyAccelerometerOffset(accOffset, accUnit)
self.applyGyroscopeOffset(gyrOffset, gyrUnit)
# for XKF3
def enableWakeOnMotion(self):
womCmd = bytearray[3]
interrupt = Fis_Int1
initialState = InterruptInitialState_low
threshold = WomThreshold_low
blankingTime = 0x00
blankingTimeMask = 0x3F
self.enableSensors(FISIMU_CTRL7_DISABLE_ALL)
self.configACC(AccRange_2g, AccOdr_LowPower_25Hz, Lpf_Disable, Hpf_Disable)
womCmd[0] = FisRegister_Cal1_L # WoM Threshold: absolute value in mg (with 1mg/LSB resolution)
womCmd[1] = threshold
womCmd[2] = interrupt | initialState | (blankingTime & blankingTimeMask)
self.writeReg(FisRegister_Cal1_L, womCmd[1])
self.writeReg(FisRegister_Cal1_H, womCmd[2])
self.doCtrl9Command(Ctrl9_ConfigureWakeOnMotion)
self.enableSensors(FISIMU_CTRL7_ACC_ENABLE)
def disableWakeOnMotion(self):
self.enableSensors(FISIMU_CTRL7_DISABLE_ALL)
self.writeReg(FisRegister_Cal1_L, 0)
self.doCtrl9Command(Ctrl9_ConfigureWakeOnMotion)
def enableSensors(self, enableFlags):
if (enableFlags & FISIMU_CONFIG_AE_ENABLE):
enableFlags |= FISIMU_CTRL7_ACC_ENABLE | FISIMU_CTRL7_GYR_ENABLE
self.writeReg(FisRegister_Ctrl7, enableFlags & FISIMU_CTRL7_ENABLE_MASK)
def configMAG(self, device, odr):
pass
def configApply(self, inputSelection, accRange, accOdr, gyrRange, gyrOdr, aeOdr, magOdr, magDev):
fisSensors = inputSelection
if (fisSensors & FISIMU_CONFIG_AE_ENABLE):
self.configAe(aeOdr)
else:
if (inputSelection & FISIMU_CONFIG_ACC_ENABLE):
self.configACC(accRange, accOdr, Lpf_Enable, Hpf_Disable)
if (inputSelection & FISIMU_CONFIG_GYR_ENABLE):
self.configGyro(gyrRange, gyrOdr, Lpf_Enable, Hpf_Disable)
if (inputSelection & FISIMU_CONFIG_MAG_ENABLE):
self.configMAG(magDev, magOdr)
self.enableSensors(fisSensors)
# 得到温度值
# 返回值:温度值
def getTemperature(self):
temp = self.readReg(FisRegister_Temperature, 1)[0]
return round(temp, 2)
# 得到加速度值(原始值)
# (gx,gy,gz):陀螺仪x,y,z轴的重力加速度，单位：m/s²
# 返回值:0,成功
# 其他,错误代码
def getAcceleration(self):
global acc_lsb_div
buf_reg = bytearray(6)
raw_acc_xyz = [1, 2, 3]
acc_xyz = [1, 2, 3]
buf_reg[0] = self.readReg(FisRegister_Ax_L, 1)[0]
buf_reg[1] = self.readReg(FisRegister_Ax_H, 1)[0]
buf_reg[2] = self.readReg(FisRegister_Ay_L, 1)[0]
buf_reg[3] = self.readReg(FisRegister_Ay_H, 1)[0]
buf_reg[4] = self.readReg(FisRegister_Az_L, 1)[0]
buf_reg[5] = self.readReg(FisRegister_Az_H, 1)[0]
raw_acc_xyz[0] = self.int16((buf_reg[1] << 8) | (buf_reg[0]))
raw_acc_xyz[1] = self.int16((buf_reg[3] << 8) | (buf_reg[2]))
raw_acc_xyz[2] = self.int16((buf_reg[5] << 8) | (buf_reg[4]))
print("raw acc is acc0[%d] acc1[%d] acc2[%d]" %(raw_acc_xyz[0], raw_acc_xyz[1], raw_acc_xyz[2]))
acc_xyz[0] = (raw_acc_xyz[0] * ONE_G) / acc_lsb_div
acc_xyz[1] = (raw_acc_xyz[1] * ONE_G) / acc_lsb_div
acc_xyz[2] = (raw_acc_xyz[2] * ONE_G) / acc_lsb_div
print("fis210x acc is", acc_xyz[0], acc_xyz[1], acc_xyz[2])
return acc_xyz
# 得到陀螺仪值(原始值)
# gx,gy,gz:陀螺仪x,y,z轴的原始读数(带符号)
# 返回值:0,成功
# 其他,错误代码
def getGyro(self):
global gyro_lsb_div
buf_reg = bytearray(6)
raw_gyro_xyz = [1, 2, 3]
gyro_xyz = [1, 2, 3]
#buf_reg = self.readReg(FisRegister_Gx_L, 6)
buf_reg[0] = self.readReg(FisRegister_Gx_L, 1)[0]
buf_reg[1] = self.readReg(FisRegister_Gx_H, 1)[0]
buf_reg[2] = self.readReg(FisRegister_Gy_L, 1)[0]
buf_reg[3] = self.readReg(FisRegister_Gy_H, 1)[0]
buf_reg[4] = self.readReg(FisRegister_Gz_L, 1)[0]
buf_reg[5] = self.readReg(FisRegister_Gz_H, 1)[0]
raw_gyro_xyz[0] = self.int16((buf_reg[1] << 8) | (buf_reg[0]))
raw_gyro_xyz[1] = self.int16((buf_reg[3] << 8) | (buf_reg[2]))
raw_gyro_xyz[2] = self.int16((buf_reg[5] << 8) | (buf_reg[4]))
#print("raw gyro is g0[%d] g1[%d g2[%d]" %(raw_gyro_xyz[0], raw_gyro_xyz[1], raw_gyro_xyz[2]))
gyro_xyz[0] = (raw_gyro_xyz[0] * 1.0) / gyro_lsb_div
gyro_xyz[1] = (raw_gyro_xyz[1] * 1.0) / gyro_lsb_div
gyro_xyz[2] = (raw_gyro_xyz[2] * 1.0) / gyro_lsb_div
#print("fis210x gyro is", gyro_xyz[0], gyro_xyz[1], gyro_xyz[2])
return gyro_xyz
def getData(self):
global qmi8610_dict
qmi8610_dict['temp'] = self.getTemperature()
arr = self.getGyro()
qmi8610_dict['gyroX'] = arr[0]
qmi8610_dict['gyroY'] = arr[1]
qmi8610_dict['gyroZ'] = arr[2]
brr = self.getAcceleration()
qmi8610_dict['accX'] = brr[0]
qmi8610_dict['accY'] = brr[1]
qmi8610_dict['accZ'] = brr[2]
return qmi8610_dict
def init(self):
chip_id = 0x00
chip_id = self.readReg(FisRegister_WhoAmI, 1)[0]
sleep_ms(100)
if (chip_id == 0xfc):
inputSelection = FISIMU_CONFIG_ACCGYR_ENABLE
accRange = AccRange_4g
accOdr = AccOdr_128Hz
gyrRange = GyrRange_1024dps # GyrRange_1024dps;
gyrOdr = GyrOdr_256Hz # GyrOdr_1024Hz
magOdr = MagOdr_32Hz
magDev = MagDev_AK8963
aeOdr = AeOdr_32Hz
sleep_ms(100)
self.configApply(inputSelection, accRange, accOdr, gyrRange, gyrOdr, aeOdr, magOdr, magDev)
sleep_ms(100)
self.setLayout(2)
else:
chip_id = 0
return chip_id
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/qmi8610/qmi8610.py
|
Python
|
apache-2.0
| 25,897
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for QMP6988
Author: HaaS
Date: 2021/09/14
"""
from driver import I2C
from utime import sleep_ms
from micropython import const
import math
QMP6988_CALC_INT = 1
QMP6988_CHIP_ID = const(0x5C)
QMP6988_CHIP_ID_REG = const(0xD1)
QMP6988_RESET_REG = const(0xE0) # Device reset register
QMP6988_DEVICE_STAT_REG = const(0xF3) # Device state register
QMP6988_CTRLMEAS_REG = const(0xF4) # Measurement Condition Control Register
# data
QMP6988_PRESSURE_MSB_REG = const(0xF7) # Pressure MSB Register
QMP6988_TEMPERATURE_MSB_REG = const(0xFA) # Temperature MSB Reg
# compensation calculation
QMP6988_CALIBRATION_DATA_START = const(0xA0) # QMP6988 compensation coefficients
QMP6988_CALIBRATION_DATA_LENGTH = const(25)
SHIFT_RIGHT_4_POSITION = const(4)
SHIFT_LEFT_2_POSITION = const(2)
SHIFT_LEFT_4_POSITION = const(4)
SHIFT_LEFT_5_POSITION = const(5)
SHIFT_LEFT_8_POSITION = const(8)
SHIFT_LEFT_12_POSITION = const(12)
SHIFT_LEFT_16_POSITION = const(16)
# power mode
QMP6988_SLEEP_MODE = const(0x00)
QMP6988_FORCED_MODE = const(0x01)
QMP6988_NORMAL_MODE = const(0x03)
QMP6988_CTRLMEAS_REG_MODE__POS = const(0)
QMP6988_CTRLMEAS_REG_MODE__MSK = const(0x03)
QMP6988_CTRLMEAS_REG_MODE__LEN = const(2)
# oversampling
QMP6988_OVERSAMPLING_SKIPPED = const(0x00)
QMP6988_OVERSAMPLING_1X = const(0x01)
QMP6988_OVERSAMPLING_2X = const(0x02)
QMP6988_OVERSAMPLING_4X = const(0x03)
QMP6988_OVERSAMPLING_8X = const(0x04)
QMP6988_OVERSAMPLING_16X = const(0x05)
QMP6988_OVERSAMPLING_32X = const(0x06)
QMP6988_OVERSAMPLING_64X = const(0x07)
QMP6988_CTRLMEAS_REG_OSRST__POS = const(5)
QMP6988_CTRLMEAS_REG_OSRST__MSK = const(0xE0)
QMP6988_CTRLMEAS_REG_OSRST__LEN = const(3)
QMP6988_CTRLMEAS_REG_OSRSP__POS = const(2)
QMP6988_CTRLMEAS_REG_OSRSP__MSK = const(0x1C)
QMP6988_CTRLMEAS_REG_OSRSP__LEN = const(3)
# filter
QMP6988_FILTERCOEFF_OFF = const(0x00)
QMP6988_FILTERCOEFF_2 = const(0x01)
QMP6988_FILTERCOEFF_4 = const(0x02)
QMP6988_FILTERCOEFF_8 = const(0x03)
QMP6988_FILTERCOEFF_16 = const(0x04)
QMP6988_FILTERCOEFF_32 = const(0x05)
QMP6988_CONFIG_REG = const(0xF1) #IIR filter co-efficient setting Register
QMP6988_CONFIG_REG_FILTER__POS = const(0)
QMP6988_CONFIG_REG_FILTER__MSK = const(0x07)
QMP6988_CONFIG_REG_FILTER__LEN = const(3)
SUBTRACTOR = const(8388608)
qmp6988_dict = {'Ctemp': 0.0, 'Ftemp': 0.0,'pressure': 0.0, 'altitude': 0.0}
class qmp6988Error(Exception):
def __init__(self, value=0, msg="qmp6988 common error"):
self.value = value
self.msg = msg
def __str__(self):
return "Error code:%d, Error message: %s" % (self.value, str(self.msg))
__repr__ = __str__
class QMP6988(object):
"""
This class implements qmp6988 chip's defs.
"""
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make QMP6988's internal object points to i2cDev
self._i2cDev = i2cDev
self.init()
self.ik_a0 = 0
self.ik_b00 = 0
self.ik_a1 = 0
self.ik_a2 = 0
self.ik_bt1 = 0
self.ik_bt2 = 0
self.ik_bp1 = 0
self.ik_b11 = 0
self.ik_bp2 = 0
self.ik_b12 = 0
self.ik_b21 = 0
self.ik_bp3 = 0
self.fk_a0 = 0.0
self.fk_b00 = 0.0
self.fk_a1 = 0.0
self.fk_a2 = 0.0
self.fk_bt1 = 0.0
self.fk_bt2 = 0.0
self.fk_bp1 = 0.0
self.fk_b11 = 0.0
self.fk_bp2 = 0.0
self.fk_b12 = 0.0
self.fk_b21 = 0.0
self.fk_bp3 = 0.0
self.power_mode = 0
self.temperature = 0
self.init()
def int16(self, dat):
#return int(dat)
if dat > 32767:
return dat - 65536
else:
return dat
def int32(self, dat):
#return int(dat)
if dat > (1 << 31):
return dat - (1 << 32)
else:
return dat
def int64(self, dat):
#return int(dat)
if dat > (1 << 63):
return dat - (1 << 64)
else:
return dat
#写寄存器
def writeReg(self, addr, value):
Reg = bytearray([addr, value])
self._i2cDev.write(Reg)
#print("--> write addr " + hex(addr) + ", value = " + hex(value))
return 0
#读寄存器
def readReg(self, addr, len):
Reg = bytearray([addr])
self._i2cDev.write(Reg)
sleep_ms(2)
tmp = bytearray(len)
self._i2cDev.read(tmp)
#print("<-- read addr " + hex(addr) + ", value = " + hex(tmp[0]))
return tmp
def deviceCheck(self):
ret = self.readReg(QMP6988_CHIP_ID_REG, 1)[0]
#print("qmp6988 read chip id = " + hex(ret))
if (ret == QMP6988_CHIP_ID):
return 0
else:
return 1
def getCalibrationData(self):
if (QMP6988_CALC_INT):
pass
else:
Conv_A_S = [[-6.30E-03, 4.30E-04],
[-1.90E-11, 1.20E-10],
[1.00E-01, 9.10E-02],
[1.20E-08, 1.20E-06],
[3.30E-02, 1.90E-02],
[2.10E-07, 1.40E-07],
[-6.30E-10, 3.50E-10],
[2.90E-13, 7.60E-13],
[2.10E-15, 1.20E-14],
[1.30E-16, 7.90E-17]]
a_data_u8r = bytearray(QMP6988_CALIBRATION_DATA_LENGTH)
for len in range(QMP6988_CALIBRATION_DATA_LENGTH):
a_data_u8r[len] = self.readReg(QMP6988_CALIBRATION_DATA_START + len, 1)[0]
COE_a0 = self.int32(((a_data_u8r[18] << SHIFT_LEFT_12_POSITION) | (a_data_u8r[19] << SHIFT_LEFT_4_POSITION) | (a_data_u8r[24] & 0x0f)) << 12)
COE_a0 = self.int32(COE_a0 >> SHIFT_LEFT_12_POSITION)
COE_a1 = self.int16((a_data_u8r[20] << SHIFT_LEFT_8_POSITION) | a_data_u8r[21])
COE_a2 = self.int16((a_data_u8r[22] << SHIFT_LEFT_8_POSITION) | a_data_u8r[23])
COE_b00 = self.int32((a_data_u8r[0] << SHIFT_LEFT_12_POSITION) | (a_data_u8r[1] << SHIFT_LEFT_4_POSITION) | ((a_data_u8r[24] & 0xf0) >> SHIFT_RIGHT_4_POSITION)) << 12
COE_b00 = self.int32(COE_b00 >> SHIFT_LEFT_12_POSITION)
COE_bt1 = self.int16((a_data_u8r[2] << SHIFT_LEFT_8_POSITION) | a_data_u8r[3])
COE_bt2 = self.int16((a_data_u8r[4] << SHIFT_LEFT_8_POSITION) | a_data_u8r[5])
COE_bp1 = self.int16((a_data_u8r[6] << SHIFT_LEFT_8_POSITION) | a_data_u8r[7])
COE_b11 = self.int16((a_data_u8r[8] << SHIFT_LEFT_8_POSITION) | a_data_u8r[9])
COE_bp2 = self.int16((a_data_u8r[10] << SHIFT_LEFT_8_POSITION) | a_data_u8r[11])
COE_b12 = self.int16((a_data_u8r[12] << SHIFT_LEFT_8_POSITION) | a_data_u8r[13])
COE_b21 = self.int16((a_data_u8r[14] << SHIFT_LEFT_8_POSITION) | a_data_u8r[15])
COE_bp3 = self.int16((a_data_u8r[16] << SHIFT_LEFT_8_POSITION) | a_data_u8r[17])
""""
print("<-----------calibration data-------------->")
print("COE_a0[%d] COE_a1[%d] COE_a2[%d] COE_b00[%d]" %(COE_a0, COE_a1, COE_a2, COE_b00))
print("COE_bt1[%d] COE_bt2[%d] COE_bp1[%d] COE_b11[%d]" %(COE_bt1, COE_bt2, COE_bp1, COE_b11))
print("COE_bp2[%d] COE_b12[%d] COE_b21[%d] COE_bp3[%d]" %(COE_bp2, COE_b12, COE_b21, COE_bp3))
print("<-----------calibration data-------------->")
"""
if (QMP6988_CALC_INT):
self.ik_a0 = COE_a0 # 20Q4
self.ik_b00 = COE_b00 # 20Q4
self.ik_a1 = self.int32(3608 * (COE_a1) - 1731677965) # 31Q23
self.ik_a2 = self.int32(16889 * (COE_a2) - 87619360) # 30Q47
self.ik_bt1 = self.int64(2982 * (COE_bt1) + 107370906) # 28Q15
self.ik_bt2 = self.int64(329854 * (COE_bt2) + 108083093) # 34Q38
self.ik_bp1 = self.int64(19923 * (COE_bp1) + 1133836764) # 31Q20
self.ik_b11 = self.int64(2406 * (COE_b11) + 118215883) # 28Q34
self.ik_bp2 = self.int64(3079 * (COE_bp2) - 181579595) # 29Q43
self.ik_b12 = self.int64(6846 * (COE_b12) + 85590281) # 29Q53
self.ik_b21 = self.int64(13836 * (COE_b21) + 79333336) # 29Q60
self.ik_bp3 = self.int64(2915 * (COE_bp3) + 157155561) # 28Q65
"""
print("<----------- int calibration data -------------->")
print("a0[%d] a1[%d] a2[%d] b00[%d]" %(self.ik_a0, self.ik_a1, self.ik_a2, self.ik_b00))
print("bt1[%d] bt2[%d] bp1[%d] b11[%d]" %(self.ik_bt1, self.ik_bt2, self.ik_bp1, self.ik_b11))
print("bp2[%d] b12[%d] b21[%d] bp3[%d]" %(self.ik_bp2, self.ik_b12, self.ik_b21, self.ik_bp3))
print("<----------- int calibration data -------------->")
"""
else:
self.fk_a0 = COE_a0 / 16.0
self.fk_b00 = COE_b00 / 16.0
self.fk_a1 = Conv_A_S[0][0] + Conv_A_S[0][1] * COE_a1 / 32767.0
self.fk_a2 = Conv_A_S[1][0] + Conv_A_S[1][1] * COE_a2 / 32767.0
self.fk_bt1 = Conv_A_S[2][0] + Conv_A_S[2][1] * COE_bt1 / 32767.0
self.fk_bt2 = Conv_A_S[3][0] + Conv_A_S[3][1] * COE_bt2 / 32767.0
self.fk_bp1 = Conv_A_S[4][0] + Conv_A_S[4][1] * COE_bp1 / 32767.0
self.fk_b11 = Conv_A_S[5][0] + Conv_A_S[5][1] * COE_b11 / 32767.0
self.fk_bp2 = Conv_A_S[6][0] + Conv_A_S[6][1] * COE_bp2 / 32767.0
self.fk_b12 = Conv_A_S[7][0] + Conv_A_S[7][1] * COE_b12 / 32767.0
self.fk_b21 = Conv_A_S[8][0] + Conv_A_S[8][1] * COE_b21 / 32767.0
self.fk_bp3 = Conv_A_S[9][0] + Conv_A_S[9][1] * COE_bp3 / 32767.0
def convTx02e(self, dt):
if (QMP6988_CALC_INT):
wk1 = self.int64((self.ik_a1) * (dt)) # 31Q23+24-1=54 (54Q23)
wk2 = self.int64(((self.ik_a2) * (dt)) >> 14) # 30Q47+24-1=53 (39Q33)
wk2 = self.int64((wk2 * (dt)) >> 10) # 39Q33+24-1=62 (52Q23)
wk2 = self.int64(((wk1 + wk2) // 32767) >> 19) # 54,52->55Q23 (20Q04)
ret = self.int16((self.ik_a0 + wk2) >> 4) # 21Q4 -> 17Q0
return ret
else:
pass
def getPressure02e(self, dp, tx):
if (QMP6988_CALC_INT):
wk1 = ((self.ik_bt1) * (tx)) # 28Q15+16-1=43 (43Q15)
wk2 = self.int64((self.ik_bp1 * (dp)) >> 5) # 31Q20+24-1=54 (49Q15)
wk1 += wk2 # 43,49->50Q15
wk2 = self.int64(((self.ik_bt2) * (tx)) >> 1) # 34Q38+16-1=49 (48Q37)
wk2 = self.int64((wk2 * self.int64(tx)) >> 8) # 48Q37+16-1=63 (55Q29)
wk3 = wk2 # 55Q29
wk2 = self.int64(((self.ik_b11) * (tx)) >> 4) # 28Q34+16-1=43 (39Q30)
wk2 = self.int64((wk2 * (dp)) >> 1) # 39Q30+24-1=62 (61Q29)
wk3 += wk2 # 55,61->62Q29
wk2 = self.int64(((self.ik_bp2) * (dp)) >> 13) # 29Q43+24-1=52 (39Q30)
wk2 = self.int64((wk2 * (dp)) >> 1) # 39Q30+24-1=62 (61Q29)
wk3 += wk2 # 62,61->63Q29
wk1 += self.int64(wk3 >> 14) # Q29 >> 14 -> Q15
wk2 = ((self.ik_b12) * (tx)) # 29Q53+16-1=45 (45Q53)
wk2 = (wk2 * (tx)) >> 22 # 45Q53+16-1=61 (39Q31)
wk2 = (wk2 * (dp)) > 1 # 39Q31+24-1=62 (61Q30)
wk3 = wk2 # 61Q30
wk2 = (self.int64(self.ik_b21) * (tx)) >> 6 # 29Q60+16-1=45 (39Q54)
wk2 = self.int64((wk2 * (dp)) >> 23) # 39Q54+24-1=62 (39Q31)
wk2 = self.int64((wk2 * self.int64(dp)) >> 1) # 39Q31+24-1=62 (61Q20)
wk3 += wk2 # 61,61->62Q30
wk2 = self.int64(((self.ik_bp3) * (dp)) >> 12) # 28Q65+24-1=51 (39Q53)
wk2 = self.int64((wk2 * (dp)) >> 23) # 39Q53+24-1=62 (39Q30)
wk2 = (wk2 * (dp)) # 39Q30+24-1=62 (62Q30)
wk3 += wk2 # 62,62->63Q30
wk1 += self.int64(wk3 >> 15) # Q30 >> 15 = Q15
wk1 = self.int64(wk1 // 32767)
wk1 = self.int64(wk1 >> 11) # Q15 >> 7 = Q4
wk1 += self.ik_b00 # Q4 + 20Q4
# wk1 >>= 4 # 28Q4 -> 24Q0
ret = self.int32(wk1)
# print("wk1[%d] wk2[%d] ret[%d]" %(wk1, wk2, ret))
return ret
else:
pass
def softwareReset(self):
pass
def setPowermode(self, power_mode):
# print("qmp_set_powermode ")
self.power_mode = power_mode
data = self.readReg(QMP6988_CTRLMEAS_REG,1)[0]
data = data & 0xfc
if (power_mode == QMP6988_SLEEP_MODE):
data |= 0x00
elif (power_mode == QMP6988_FORCED_MODE):
data |= 0x01
elif (power_mode == QMP6988_NORMAL_MODE):
data |= 0x03
self.writeReg(QMP6988_CTRLMEAS_REG, data)
# print("qmp_set_powermode 0xf4=0x", data)
sleep_ms(20)
def setFilter(self, filter):
data = (filter & 0x03)
self.writeReg(QMP6988_CONFIG_REG, data)
sleep_ms(20)
def setOversamplingP(self, oversampling_p):
data = self.readReg(QMP6988_CTRLMEAS_REG, 1)[0]
data &= 0xe3
data |= self.int16(oversampling_p << 2)
self.writeReg(QMP6988_CTRLMEAS_REG, data)
sleep_ms(20)
def setOversamplingT(self, oversampling_t):
data = self.readReg(QMP6988_CTRLMEAS_REG, 1)[0]
data &= 0x1f
data |= self.int16(oversampling_t << 5)
self.writeReg(QMP6988_CTRLMEAS_REG, data)
sleep_ms(20)
def calcAltitude(self, pressure, temp):
altitude = (pow((101325 / pressure), 1 / 5.257) - 1) * (temp + 273.15) / 0.0065
return altitude
def getData(self):
global qmp6988_dict
a_data_u8r = bytearray(6)
# press
a_data_u8r = self.readReg(QMP6988_PRESSURE_MSB_REG, 6)
P_read = (a_data_u8r[0] << SHIFT_LEFT_16_POSITION) | (a_data_u8r[1] << SHIFT_LEFT_8_POSITION) | (a_data_u8r[2])
P_raw = self.int32(P_read - SUBTRACTOR)
T_read = (a_data_u8r[3] << SHIFT_LEFT_16_POSITION) | (a_data_u8r[4] << SHIFT_LEFT_8_POSITION) | (a_data_u8r[5])
T_raw = self.int32(T_read - SUBTRACTOR)
if (QMP6988_CALC_INT):
T_int = self.convTx02e(T_raw)
P_int = self.getPressure02e(P_raw, T_int)
#self.temperature = float(T_int) / 256.0
Ctemp = float(T_int) / 256.0
Ftemp = (Ctemp * 9 / 5) + 32
Ftemp = round(Ftemp,2)
#self.pressure = float(P_int) / 16.0
qmp6988_dict['Ctemp'] = Ctemp
qmp6988_dict['Ftemp'] = Ftemp
qmp6988_dict['pressure'] = float(P_int) / 16.0
#print("int temp = %f Pressure = %f " %(self.temperature, self.pressure))
else:
Tr = self.fk_a0 + (self.fk_a1 * T_raw) + (self.fk_a2 * T_raw) *T_raw
# Unit centigrade
#self.temperature = float(Tr) / 256.0
qmp6988_dict['Ctemp'] = float(Tr) / 256.0
# compensation pressure, Unit Pa
qmp6988_dict['pressure'] = self.fk_b00 + (self.fk_bt1 * Tr) + (self.fk_bp1 * P_raw) + (self.fk_b11 * Tr) *P_raw + (self.fk_bt2 * Tr) *Tr + (self.fk_bp2 * P_raw) *P_raw + (self.fk_b12 * P_raw) *(Tr *Tr) + (self.fk_b21 * P_raw) *(P_raw *Tr) + (self.fk_bp3 * P_raw) *(P_raw *P_raw)
#print("float temp = %f Pressure = %f" %(self.temperature, self.pressure))
qmp6988_dict['altitude'] = self.calcAltitude(qmp6988_dict['pressure'], qmp6988_dict['Ctemp'])
#print("altitude = ",self.altitude)
return qmp6988_dict
def getTemperature(self):
return self.getData()['Ctemp']
def getTemperatureF(self):
return self.getData()['Ftemp']
def getPressure(self):
return self.getData()['pressure']
def getAltitude(self):
return self.getData()['altitude']
def init(self):
ret = self.deviceCheck()
if (ret != 0):
return 0
else:
pass
self.softwareReset()
self.getCalibrationData()
self.setPowermode(QMP6988_NORMAL_MODE)
self.setFilter(QMP6988_FILTERCOEFF_OFF)
self.setOversamplingP(QMP6988_OVERSAMPLING_2X)
self.setOversamplingT(QMP6988_OVERSAMPLING_1X)
if __name__ == "__main__":
'''
The below i2c configuration is needed in your board.json.
"qmp6988": {
"type": "I2C",
"port": 1,
"addrWidth": 7,
"freq": 100000,
"mode": "master",
"devAddr": 86
}
'''
print("Testing qmp6988 ...")
i2cDev = I2C()
i2cDev.open("qmp6988")
baroDev = QMC6988(i2cDev)
pressure = baroDev.getPressure()
print("pressure:%f" % (pressure))
i2cDev.close()
del baroDev
i2cDev.close()
print("Test qmp6988 done!")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/qmp6988/qmp6988.py
|
Python
|
apache-2.0
| 16,991
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's drive for Raindrops
Author: HaaS
Date: 2022/03/29
"""
from driver import GPIO
from driver import ADC
class Raindrops(object):
def __init__(self, DO, AO=None):
self.DO = None
self.AO = None
if not isinstance(DO, GPIO):
raise ValueError('parameter DO is not an GPIO object')
if AO is not None and not isinstance(AO, ADC):
raise ValueError('parameter AO should be ADC object or None')
self.DO = DO
self.AO = AO
# 读取数字信号
def raindropDetect(self):
return self.DO.read()
# 读取模拟信号，电压
def getVoltage(self):
if not self.AO:
raise RuntimeError('Can not get voltage, AO is not inited')
return self.AO.readVoltage()
def main():
DO = GPIO()
DO.open('LM393_DO')
AO = ADC()
AO.open('LM393_AO')
drv = Raindrops(DO, AO)
return drv
if __name__ == '__main__':
drv = main()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/raindrops/raindrops.py
|
Python
|
apache-2.0
| 1,034
|
from driver import GPIO
class Relay():
def __init__(self, gpioObj, trigger):
self.gpioObj = None
if not isinstance(gpioObj, GPIO):
raise ValueError("parameter gpioObj is not a GPIO object")
if (trigger != 0) and (trigger != 1):
raise ValueError("parameter trigger should be 0 or 1")
self.gpioObj = gpioObj
self.trigger = trigger
def trigger(self):
if self.gpioObj is None:
raise ValueError("invalid GPIO object")
value = self.gpioObj.write(self.trigger)
return value
def untrigger(self):
if self.gpioObj is None:
raise ValueError("invalid GPIO object")
value = self.gpioObj.write(1 - self.trigger)
return value
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/relay/relay.py
|
Python
|
apache-2.0
| 765
|
from driver import PWM
class RgbLed():
def __init__(self, pwmRObj, pwmGObj, pwmBObj):
if not isinstance(pwmRObj, PWM):
raise ValueError("parameter pwmRObj is not an PWM object")
if not isinstance(pwmGObj, PWM):
raise ValueError("parameter pwmGObj is not an PWM object")
if not isinstance(pwmBObj, PWM):
raise ValueError("parameter pwmBObj is not an PWM object")
self.pwmR = pwmRObj
self.pwmG = pwmGObj
self.pwmB = pwmBObj
self.pwmR.setOption({'freq': 255, 'duty': 0})
self.pwmG.setOption({'freq': 255, 'duty': 0})
self.pwmB.setOption({'freq': 255, 'duty': 0})
def setColor(self, color):
if isinstance(color, tuple) and len(color) is 3:
red = color[0]
green = color[1]
blue = color[2]
self.pwmR.setOption({'freq': 255, 'duty': 255 // red})
self.pwmG.setOption({'freq': 255, 'duty': 255 // green})
self.pwmB.setOption({'freq': 255, 'duty': 255 // blue})
elif isinstance(color, int) and color >= 0 and color <= 0xffffff:
red = color >> 12
green = (color >> 8) & 0x00ff
blue = color & 0x0000ff
self.pwmR.setOption({'freq': 255, 'duty': 255 // red})
self.pwmG.setOption({'freq': 255, 'duty': 255 // green})
self.pwmB.setOption({'freq': 255, 'duty': 255 // blue})
else:
raise ValueError("color type error! color should be like (255, 255, 255) or 0xffffff")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/rgb_led/rgbLed.py
|
Python
|
apache-2.0
| 1,554
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
`HaaS Python ads1x15`
====================================================
A driver for ads1x15
* Author(s): HaaS Group
Implementation Notes
--------------------
**Hardware:**
* HaaS Python ads1x15
https://haas.iot.aliyun.com/solution/detail/hardware
**Software and Dependencies:**
* HaaS Python API documents:
https://haas.iot.aliyun.com/haasapi/index.html#/
* HaaS Python Driver Libraries:
https://github.com/alibaba/AliOS-Things/tree/master/haas_lib_bundles/python/libraries
"""
# coding=utf-8
import utime as time
from driver import I2C
'''
# Choose a gain of 1 for reading voltages from 0 to 4.09V.
# Or pick a different gain to change the range of voltages that are read:
# - 2/3 = +/-6.144V
# - 1 = +/-4.096V
# - 2 = +/-2.048V
# - 4 = +/-1.024V
# - 8 = +/-0.512V
# - 16 = +/-0.256V
'''
# Register and other configuration values:
ADS1x15_DEFAULT_ADDRESS = 0x48
ADS1x15_POINTER_CONVERSION = 0x00
ADS1x15_POINTER_CONFIG = 0x01
ADS1x15_POINTER_LOW_THRESHOLD = 0x02
ADS1x15_POINTER_HIGH_THRESHOLD = 0x03
ADS1x15_CONFIG_OS_SINGLE = 0x8000
ADS1x15_CONFIG_MUX_OFFSET = 12
# Maping of gain values to config register values.
ADS1x15_CONFIG_GAIN = {
2/3: 0x0000,
1: 0x0200,
2: 0x0400,
4: 0x0600,
8: 0x0800,
16: 0x0A00
}
ADS1x15_GAIN_RESOLUTION = {
2/3: 6.144/32767,
1: 4.096/32767,
2: 2.048/32767,
4: 1.024/32767,
8: 0.512/32767,
16: 0.256/32767
}
ADS1x15_CONFIG_MODE_CONTINUOUS = 0x0000
ADS1x15_CONFIG_MODE_SINGLE = 0x0100
# Mapping of data/sample rate to config register values for ADS1015 (faster).
ADS1015_CONFIG_DR = {
128: 0x0000,
250: 0x0020,
490: 0x0040,
920: 0x0060,
1600: 0x0080,
2400: 0x00A0,
3300: 0x00C0
}
# Mapping of data/sample rate to config register values for ADS1115 (slower).
ADS1115_CONFIG_DR = {
8: 0x0000,
16: 0x0020,
32: 0x0040,
64: 0x0060,
128: 0x0080,
250: 0x00A0,
475: 0x00C0,
860: 0x00E0
}
ADS1x15_CONFIG_COMP_WINDOW = 0x0010
ADS1x15_CONFIG_COMP_ACTIVE_HIGH = 0x0008
ADS1x15_CONFIG_COMP_LATCHING = 0x0004
ADS1x15_CONFIG_COMP_QUE = {
1: 0x0000,
2: 0x0001,
4: 0x0002
}
ADS1x15_CONFIG_COMP_QUE_DISABLE = 0x0003
class ADS1x15(object):
def __init__(self, *args,**Kwargs):
self._i2cDev = None
if not isinstance(args[0], I2C):
raise ValueError("parameter is not an I2C object")
#实例化
self.i2cDev=args[0]
self._gain = 1 # voltage range:+/-4.096V
def _data_rate_default(self):
#子类需要实现 父类的方法，否则报错
raise NotImplementedError("subclass must implemet _data_rate_default!")
def _data_rate_config(self,data_rate):
#子类需要实现 父类的方法，否则报错
raise NotImplementedError("subclass must implemet _data_rate_default!")
def _conversion_value(self, low, high):
#子类需要实现 父类的方法，否则报错
raise NotImplementedError('Subclass must implement _conversion_value function!')
#mux, gain, data_rate, and mode 要在规定的范围内
def _read(self, mux, gain, data_rate, mode):
# Go out of power-down mode for conversion.
config = ADS1x15_CONFIG_OS_SINGLE
# Specify mux value.
config |= (mux & 0x07) << ADS1x15_CONFIG_MUX_OFFSET
#设置增益
if gain not in ADS1x15_CONFIG_GAIN:
raise ValueError('Gain must be one of: 2/3, 1, 2, 4, 8, 16')
config |= ADS1x15_CONFIG_GAIN[gain]
#设置模式(continuous or single shot)
config |= mode
#测量速率，默认128bps
if data_rate is None:
data_rate = self._data_rate_default()
#设置速率
config |= self._data_rate_config(data_rate)
#disable 比较器模式
config |= ADS1x15_CONFIG_COMP_QUE_DISABLE
#I2C的写函数
writeData=bytearray(3)
writeData[0]=ADS1x15_POINTER_CONFIG
writeData[1]=(config >> 8) & 0xFF
writeData[2]=config & 0xFF
self.i2cDev.write(writeData)
#等待ADC采样（根据采样率加上一个很小的偏置，如0.1ms)
time.sleep(1.0/data_rate+0.0001)
#读取ADC采样结果
readData=bytearray([0x0,0x00])
self.i2cDev.memRead(readData, ADS1x15_POINTER_CONVERSION, 8)
#return 读取到的数据，包含高八位和低八位
return self._conversion_value(readData[1], readData[0])
def read_adc(self, channel, gain=1, data_rate=None):
#读单个ADC通道，通道值取值范围为[0,3]
assert 0 <= channel <= 3, 'Channel must be a value within 0-3!'
# Perform a single shot read and set the mux value to the channel plus
# the highest bit (bit 3) set.
return self._read(channel + 0x04, gain, data_rate, ADS1x15_CONFIG_MODE_SINGLE)
def readVoltage(self, channel):
#读取ADC量测结果
data = self.read_adc(channel, self._gain)
#电压值：ADC量测结果*分辨率，单位：mV
return round(data * ADS1x15_GAIN_RESOLUTION[self._gain] * 1000, 0)
def setMaxVoltage(self, maxVoltage):
#设置要量测的最大电压，单位：mV
if (maxVoltage > 6144):
raise ValueError('voltage should between (-6144, 6144), unit:mV')
if (maxVoltage >= 4096):
self._gain = 1
elif (maxVoltage >= 2048):
self._gain = 2
elif (maxVoltage >= 1024):
self._gain = 4
elif (maxVoltage >= 512):
self._gain = 8
elif (maxVoltage >= 256):
self._gain = 8
else:
self._gain = 16
return 0
#继承父类
class ADS1115(ADS1x15):
"""ADS1115 16-bit analog to digital converter instance."""
def __init__(self, *args, **kwargs):
super(ADS1115, self).__init__(*args, **kwargs)
def _data_rate_default(self):
#默认速率为128bps
return 128
def _data_rate_config(self, data_rate):
if data_rate not in ADS1115_CONFIG_DR:
raise ValueError('Data rate must be one of: 8, 16, 32, 64, 128, 250, 475, 860')
return ADS1115_CONFIG_DR[data_rate]
def _conversion_value(self, low, high):
#转换16位数据
value = ((high & 0xFF) << 8) | (low & 0xFF)
if value & 0x8000 != 0:
value = -(0xffff - value)
return value
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/rockerkey/ads1x15.py
|
Python
|
apache-2.0
| 6,561
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
HaaS Python driver for rockerkey
Author: HaaS
Date: 2022/05/06
"""
import ads1x15 # ADS1X15 ADC传感器驱动库
from driver import I2C,GPIO
class ROCKERKEY(object):
def __init__(self, i2cObj,gpioObj,MaxVoltage=5500,XAxis=0,YAxis=1,ZAxis=2):
self.i2cObj = None
self.zaxisObj = None
if not isinstance(i2cObj, I2C):
raise ValueError("parameter is not an I2C object")
if not isinstance(gpioObj, GPIO):
raise ValueError("parameter is not an GPIO object")
self.zaxisObj = gpioObj
self.i2cObj = i2cObj
self.adcDev = ads1x15.ADS1115(self.i2cObj) # 初始化ADS1115传感器对象
self.adcDev.setMaxVoltage(MaxVoltage)
self.xaxis = XAxis
self.yaxis = YAxis
self.zaxis = ZAxis
self.xvol = 0
self.yvol = 0
self.zvol = 0
def getXYZAxis(self):
if self.i2cObj is None:
raise ValueError("invalid I2C object")
if self.zaxisObj is None:
raise ValueError("invalid GPIO object")
self.xvol = self.adcDev.readVoltage(self.xaxis) # 量测x轴通道的输入电压值
self.yvol = self.adcDev.readVoltage(self.yaxis) # 量测y轴通道的输入电压值
self.zvol = self.zaxisObj.read() # 获取z轴通道的电平值
return self.xvol,self.yvol,self.zvol
def close(self):
if self.i2cObj is None:
raise ValueError("invalid I2C object")
self.i2cObj.close()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/rockerkey/rockerkey.py
|
Python
|
apache-2.0
| 1,617
|
"""
HaaSPython PWM driver for servo
"""
from driver import PWM
class SERVO(object):
def __init__(self, pwmObj):
self.pwmObj = None
if not isinstance(pwmObj, PWM):
raise ValueError("parameter is not an PWM object")
self.pwmObj = pwmObj
def setOptionSero(self,data):
if self.pwmObj is None:
raise ValueError("invalid PWM object")
data_r = {'freq':50, 'duty': int(((data+90)*2/180+0.5)/20*100)}
self.pwmObj.setOption(data_r)
def close(self):
if self.pwmObj is None:
raise ValueError("invalid PWM object")
self.pwmObj.close()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/servo/servo.py
|
Python
|
apache-2.0
| 642
|
from micropython import const
import utime
import framebuf
from driver import SPI
from driver import GPIO
# register definitions
SET_SCAN_DIR = const(0xc0)
LOW_COLUMN_ADDRESS = const(0x00)
HIGH_COLUMN_ADDRESS = const(0x10)
SET_PAGE_ADDRESS = const(0xB0)
SET_CONTRAST = const(0x81)
SET_ENTIRE_ON = const(0xa4)
SET_NORM_INV = const(0xa6)
SET_DISP = const(0xae)
SET_MEM_ADDR = const(0x20)
SET_COL_ADDR = const(0x21)
SET_PAGE_ADDR = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP = const(0xa0)
SET_MUX_RATIO = const(0xa8)
SET_COM_OUT_DIR = const(0xc0)
SET_DISP_OFFSET = const(0xd3)
SET_COM_PIN_CFG = const(0xda)
SET_DISP_CLK_DIV = const(0xd5)
SET_PRECHARGE = const(0xd9)
SET_VCOM_DESEL = const(0xdb)
SET_CHARGE_PUMP = const(0x8d)
class SH1106:
def __init__(self, width, height):
self.width = width
self.height = height
self.pages = self.height // 8
self.buffer = bytearray(self.pages * self.width)
fb = framebuf.FrameBuffer(
self.buffer, self.width, self.height, framebuf.MVLSB)
self.framebuf = fb
# set shortcuts for the methods of framebuf
self.fill = fb.fill
self.fillRect = fb.fill_rect
self.hline = fb.hline
self.vline = fb.vline
self.line = fb.line
self.rect = fb.rect
self.pixel = fb.pixel
self.scroll = fb.scroll
self.text = fb.text
self.blit = fb.blit
# print("init done")
self.initDisplay()
def initDisplay(self):
self.reset()
for cmd in (
SET_DISP | 0x00, # 关闭显示
SET_DISP_CLK_DIV, 0x80, # 设置时钟分频因子
SET_MUX_RATIO, self.height - 1, # 设置驱动路数 路数默认0x3F（1/64）
SET_DISP_OFFSET, 0x00, # 设置显示偏移 偏移默认为0
SET_DISP_START_LINE | 0x00, # 设置显示开始行[5:0]
SET_CHARGE_PUMP, 0x14, # 电荷泵设置 bit2，开启/关闭
# 设置内存地址模式 [1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10;
SET_MEM_ADDR, 0x02,
SET_SEG_REMAP | 0x01, # 段重定义设置,bit0:0,0->0;1,0->127;
# 设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数
SET_COM_OUT_DIR | 0x08,
SET_COM_PIN_CFG, 0x12, # 设置COM硬件引脚配置 [5:4]配置
SET_PRECHARGE, 0xf1, # 设置预充电周期 [3:0],PHASE 1;[7:4],PHASE 2;
# 设置VCOMH 电压倍率 [6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc;
SET_VCOM_DESEL, 0x30,
SET_CONTRAST, 0xff, # 对比度设置 默认0x7F（范围1~255，越大越亮）
SET_ENTIRE_ON, # 全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏)
SET_NORM_INV, # 设置显示方式;bit0:1,反相显示;0,正常显示
SET_DISP | 0x01): # 开启显示
self.write_cmd(cmd)
self.fill(1)
self.show()
def poweroff(self):
self.write_cmd(SET_DISP | 0x00)
def poweron(self):
self.write_cmd(SET_DISP | 0x01)
def rotate(self, flag, update=True):
if flag:
self.write_cmd(SET_SEG_REMAP | 0x01) # mirror display vertically
self.write_cmd(SET_SCAN_DIR | 0x08) # mirror display hor.
else:
self.write_cmd(SET_SEG_REMAP | 0x00)
self.write_cmd(SET_SCAN_DIR | 0x00)
if update:
self.show()
def sleep(self, value):
self.write_cmd(SET_DISP | (not value))
def contrast(self, contrast):
self.write_cmd(SET_CONTRAST)
self.write_cmd(contrast)
def invert(self, invert):
self.write_cmd(SET_NORM_INV | (invert & 1))
def show(self):
for page in range(self.height // 8):
self.write_cmd(SET_PAGE_ADDRESS | page)
self.write_cmd(LOW_COLUMN_ADDRESS)
self.write_cmd(HIGH_COLUMN_ADDRESS)
page_buffer = bytearray(self.width)
for i in range(self.width):
page_buffer[i] = self.buffer[self.width * page + i]
self.write_data(page_buffer)
def setBuffer(self, buffer):
for i in range(len(buffer)):
self.buffer[i] = buffer[i]
def drawXBM(self, x, y, w, h, bitmap):
x_byte = (w//8) + (w % 8 != 0)
for nbyte in range(len(bitmap)):
for bit in range(8):
if(bitmap[nbyte] & (0b10000000 >> bit)):
p_x = (nbyte % x_byte)*8+bit
p_y = nbyte//x_byte
self.pixel(x + p_x, y + p_y, 1)
# 以屏幕GRAM的原始制式去填充Buffer
def drawBuffer(self, x, y, w, h, bitmap):
y_byte = (h//8) + (h % 8 != 0)
for nbyte in range(len(bitmap)):
for bit in range(8):
if(bitmap[nbyte] & (1 << bit)):
p_y = (nbyte % y_byte)*8+bit
p_x = nbyte//y_byte
self.pixel(x + p_x, y + p_y, 1)
def fillRect(self, x, y, w, h, c):
self.fillRect(x, y, w, h, c)
def fillCircle(self, x0, y0, r, c):
x = 0
y = r
deltax = 3
deltay = 2 - r - r
d = 1 - r
#print(x)
#print(y)
#print(deltax)
#print(deltay)
#print(d)
self.pixel(x + x0, y + y0, c)
self.pixel(x + x0, -y + y0, c)
for i in range(-r + x0, r + x0):
self.pixel(i, y0, c)
while x < y:
if d < 0:
d += deltax
deltax += 2
x = x +1
else:
d += (deltax + deltay)
deltax += 2
deltay += 2
x = x +1
y = y -1
for i in range(-x + x0, x + x0):
self.pixel(i, -y + y0, c)
self.pixel(i, y + y0, c)
for i in range(-y + x0, y + x0):
self.pixel(i, -x + y0, c)
self.pixel(i, x + y0, c)
def drawCircle(self, x0, y0, r, w, c):
self.fillCircle(x0, y0, r, c)
self.fillCircle(x0, y0, r -w, 0)
def reset(self, res):
if res is not None:
res.write(1)
utime.sleep_ms(1)
res.write(0)
utime.sleep_ms(20)
res.write(1)
utime.sleep_ms(20)
class SH1106_I2C(SH1106):
def __init__(self, width, height, i2c, res=None, addr=0x3c):
self.i2c = i2c
self.addr = addr
self.res = res
self.temp = bytearray(2)
super().__init__(width, height)
def write_cmd(self, cmd):
self.temp[0] = 0x80 # Co=1, D/C#=0
self.temp[1] = cmd
self.i2c.write(self.temp)
def write_data(self, buf):
send_buf = bytearray(1 + len(buf))
send_buf[0] = 0x40
for i in range(len(buf)):
send_buf[i+1] = buf[i]
print(send_buf)
self.i2c.write(send_buf)
def reset(self):
super().reset(self.res)
class SH1106_SPI(SH1106):
def __init__(self, width, height, spi, dc, res=None, cs=None):
self.spi = spi
self.dc = dc
self.res = res
self.cs = cs
super().__init__(width, height)
def write_cmd(self, cmd):
if self.cs is not None:
self.cs.write(1)
self.dc.write(0)
self.cs.write(0)
self.spi.write(bytearray([cmd]))
self.cs.write(1)
else:
self.dc.write(0)
self.spi.write(bytearray([cmd]))
def write_data(self, buf):
if self.cs is not None:
self.cs.write(1)
self.dc.write(1)
self.cs.write(0)
self.spi.write(buf)
self.cs.write(1)
else:
self.dc.write(1)
self.spi.write(buf)
def reset(self):
super().reset(self.res)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/sh1106/sh1106.py
|
Python
|
apache-2.0
| 7,916
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for CHT8305
Author: HaaS
Date: 2021/09/14
"""
from micropython import const
import utime
from driver import I2C
'''
# sht3x commands definations
# read serial number: CMD_READ_SERIALNBR 0x3780
# read status register: CMD_READ_STATUS 0xF32D
# clear status register: CMD_CLEAR_STATUS 0x3041
# enabled heater: CMD_HEATER_ENABLE 0x306D
# disable heater: CMD_HEATER_DISABLE 0x3066
# soft reset: CMD_SOFT_RESET 0x30A2
# accelerated response time: CMD_ART 0x2B32
# break, stop periodic data acquisition mode: CMD_BREAK 0x3093
# measurement: polling, high repeatability: CMD_MEAS_POLLING_H 0x2400
# measurement: polling, medium repeatability: CMD_MEAS_POLLING_M 0x240B
# measurement: polling, low repeatability: CMD_MEAS_POLLING_L 0x2416
'''
class SHT3X(object):
# i2cDev should be an I2C object and it should be opened before __init__ is called
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make AHB21B's internal object points to _i2cDev
self._i2cDev = i2cDev
self.start()
def start(self):
# make sure AHB21B's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# send clear status register command - 0x3041 - CMD_CLEAR_STATUS
cmd = bytearray(2)
cmd[0] = 0x30
cmd[1] = 0x41
self._i2cDev.write(cmd)
# wait for 20ms
utime.sleep_ms(20)
return 0
def getTempHumidity(self):
if self._i2cDev is None:
raise ValueError("invalid I2C object")
tempHumidity = [-1, 2]
# start measurement: polling, medium repeatability - 0x240B - CMD_MEAS_POLLING_M
# if you want to adjust measure repeatability, you can send the following commands:
# high repeatability: 0x2400 - CMD_MEAS_POLLING_H
# low repeatability: 0x2416 - CMD_MEAS_POLLING_L
cmd = bytearray(2)
cmd[0] = 0x24
cmd[1] = 0x0b
self._i2cDev.write(cmd)
# must wait for a little before the measurement finished
utime.sleep_ms(20)
dataBuffer = bytearray(6)
# read the measurement result
self._i2cDev.read(dataBuffer)
# print(dataBuffer)
# calculate real temperature and humidity according to SHT3X-DIS' data sheet
temp = (dataBuffer[0]<<8) | dataBuffer[1]
humi = (dataBuffer[3]<<8) | dataBuffer[4]
tempHumidity[1] = humi * 0.0015259022
tempHumidity[0] = -45.0 + (temp) * 175.0 / (0xFFFF - 1)
return tempHumidity
def getTemperature(self):
data = self.getTempHumidity()
return data[0]
def getHumidity(self):
data = self.getTempHumidity()
return data[1]
def stop(self):
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# stop periodic data acquisition mode
cmd = bytearray(3)
cmd[0] = 0x30
cmd[1] = 0x93
self._i2cDev.write(cmd)
# wait for a little while
utime.sleep_ms(20)
self._i2cDev = None
return 0
def __del__(self):
print('sht3x __del__')
if __name__ == "__main__":
'''
The below i2c configuration is needed in your board.json.
"sht3x": {
"type": "I2C",
"port": 1,
"addrWidth": 7,
"freq": 400000,
"mode": "master",
"devAddr": 68
},
'''
print("Testing sht3x ...")
i2cDev = I2C()
i2cDev.open("sht3x")
sht3xDev = SHT3X(i2cDev)
'''
# future usage:
i2cDev = I2C("sht3x")
sht3xDev = sht3x.SHT3X(i2cDev)
'''
temperature = sht3xDev.getTemperature()
print("The temperature is: %f" % temperature)
humidity = sht3xDev.getHumidity()
print("The humidity is: %f" % humidity)
print("Test sht3x done!")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/sht3x/sht3x.py
|
Python
|
apache-2.0
| 4,279
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's drive for SI7006
Author: HaaS
Date: 2021/09/09
"""
from driver import I2C
from utime import sleep_ms
# The commands provided by SI7006
Si7006_MEAS_REL_HUMIDITY_MASTER_MODE = 0xE5
Si7006_MEAS_REL_HUMIDITY_NO_MASTER_MODE = 0xF5
Si7006_MEAS_TEMP_MASTER_MODE = 0xE3
Si7006_MEAS_TEMP_NO_MASTER_MODE = 0xF3
Si7006_READ_OLD_TEMP = 0xE0
Si7006_RESET = 0xFE
Si7006_READ_ID_LOW_0 = 0xFA
Si7006_READ_ID_LOW_1 = 0x0F
Si7006_READ_ID_HIGH_0 = 0xFC
Si7006_READ_ID_HIGH_1 = 0xC9
Si7006_READ_Firmware_Revision_0 = 0x84
Si7006_READ_Firmware_Revision_1 = 0xB8
class SI7006Error(Exception):
def __init__(self, value=0, msg="si7006 common error"):
self.value = value
self.msg = msg
def __str__(self):
return "Error code:%d, Error message: %s" % (self.value, str(self.msg))
__repr__ = __str__
class SI7006(object):
"""
This class implements SI7006 chip's functions.
"""
# i2cDev should be an I2C object and it should be opened before __init__ is called
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make SI7006's internal object points to i2cDev
self._i2cDev = i2cDev
def getVer(self):
"""
Get the firmware version of the chip.
"""
# make sure SI7006's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# send read firmware version command to SI7006
reg = bytearray([Si7006_READ_Firmware_Revision_0, Si7006_READ_Firmware_Revision_1])
self._i2cDev.write(reg)
sleep_ms(30)
version = bytearray(1)
# read the version info back
self._i2cDev.read(version)
return version[0]
def getID(self):
"""Get the chip ID."""
# make sure SI7006's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# send read chip id‘s lower part command to SI7006
reg = bytearray([Si7006_READ_ID_LOW_0, Si7006_READ_ID_LOW_1])
self._i2cDev.write(reg)
sleep_ms(30)
id_buf_low = bytearray(4)
# read the id info back
self._i2cDev.read(id_buf_low)
# send read chip id‘s higher part command to SI7006
reg = bytearray([Si7006_READ_ID_HIGH_0, Si7006_READ_ID_HIGH_1])
id_buf_high = bytearray(4)
self._i2cDev.read(id_buf_high)
return id_buf_low + id_buf_high
def getTemperature(self):
"""Get temperature."""
# make sure SI7006's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# send measure temperature command to SI7006
reg = bytearray([Si7006_MEAS_TEMP_NO_MASTER_MODE])
self._i2cDev.write(reg)
# wait for 30ms to wait for the measure finish according to SI7006's datasheet
sleep_ms(30)
readData = bytearray(2)
# read the temperature measure result
self._i2cDev.read(readData)
value = (readData[0] << 8 | readData[1])
# convert to actual temperature
if (value & 0xFFFC):
temperature = (175.72 * value) / 65536.0 - 46.85
return round(temperature, 1)
else:
raise SI7006Error("failed to get temperature.")
def getHumidity(self):
"""Get humidity."""
# make sure SI7006's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# send measure humidity command to SI7006
reg = bytearray([Si7006_MEAS_REL_HUMIDITY_NO_MASTER_MODE])
self._i2cDev.write(reg)
# wait for 30ms to wait for the measure finish according to SI7006's datasheet
sleep_ms(30)
readData = bytearray(2)
self._i2cDev.read(readData)
value = (readData[0] << 8) | readData[1]
# convert to actual humidity
if (value & 0xFFFE):
humidity = (125.0 * value) / 65535.0 - 6.0
return round(humidity)
else:
raise SI7006Error("failed to get humidity.")
def getTempHumidity(self):
"""Get temperature and humidity."""
# make sure SI7006's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# read tempperature and humidity in sequence
temphumidity = [0, 0]
temphumidity[0] = self.getTemperature()
temphumidity[1] = self.getHumidity()
return temphumidity
if __name__ == "__main__":
'''
The below i2c configuration is needed in your board.json.
"si7006": {
"type": "I2C",
"port": 1,
"addrWidth": 7,
"freq": 400000,
"mode": "master",
"devAddr": 64
}
'''
print("Testing si7006 ...")
i2cDev = I2C()
i2cDev.open("si7006")
si7006Dev = SI7006(i2cDev)
version = si7006Dev.getVer()
print("si7006 version is: %d" % version)
chipID = si7006Dev.getID()
print("si7006 chip id is:", chipID)
temperature = si7006Dev.getTemperature()
print("The temperature is: %f" % temperature)
humidity = si7006Dev.getHumidity()
print("The humidity is: %d" % humidity)
i2cDev.close()
print("Test si7006 done!")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/si7006/si7006.py
|
Python
|
apache-2.0
| 5,698
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for SN74HC595
Author: HaaS
Date: 2022/03/15
"""
from driver import GPIO
from utime import sleep_ms
from micropython import const
import math
class SN74HC595(object):
"""
This class implements sn74hc595 chip's defs.
"""
def __init__(self, rclk, sclk, dio):
self._rclk = None
self._sclk = None
self._dio = None
if not isinstance(rclk, GPIO):
raise ValueError("parameter is not an GPIO object")
if not isinstance(sclk, GPIO):
raise ValueError("parameter is not an GPIO object")
if not isinstance(dio, GPIO):
raise ValueError("parameter is not an GPIO object")
# make 74HC595's internal object points to gpio
self._rclk = rclk
self._sclk = sclk
self._dio = dio
self.led_0f = bytearray([
0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90, 0x8c,
0xbf, 0xc6, 0xa1, 0x86, 0xff, 0xbf
])
def write(self, data):
for i in range(8):
if (data & 0x80) != 0:
self._dio.write(1)
else:
self._dio.write(0)
data <<= 1
self._sclk.write(0)
self._sclk.write(1)
def outSegmentdigit(self, position, digit):
digit = 0xf & digit
position = (0x3 & position)
position = 1 << position
digit = self.led_0f[digit]
self.write(digit)
self.write(position)
self._rclk.write(0)
self._rclk.write(1)
def outSegmentHex(self, data):
digit = data & 0xf
self.outSegmentdigit(0, digit)
sleep_ms(2)
data >>= 4
digit = data & 0xf
self.outSegmentdigit(1, digit)
sleep_ms(2)
data >>= 4
digit = data & 0xf
self.outSegmentdigit(2, digit)
sleep_ms(2)
data >>= 4
digit = data & 0xf
self.outSegmentdigit(3, digit)
sleep_ms(2)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/sn74hc595/sn74hc595.py
|
Python
|
apache-2.0
| 2,055
|
from driver import GPIO
from driver import ADC
class SoilMoisture(object):
def __init__(self, DO, AO=None):
self.DO = None
self.AO = None
if not isinstance(DO, GPIO):
raise ValueError('parameter DO is not an GPIO object')
if AO is not None and not isinstance(AO, ADC):
raise ValueError('parameter AO should be ADC object or None')
self.DO = DO
self.AO = AO
# 读取数字信号
def moistureDetect(self):
return self.DO.read()
# 读取模拟信号，电压
def getVoltage(self):
if not self.AO:
raise RuntimeError('Can not get voltage, AO is not inited')
return self.AO.readVoltage()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/soil_moisture/soil_moisture.py
|
Python
|
apache-2.0
| 715
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's drive for SPL06
Author: HaaS
Date: 2021/09/09
"""
from driver import I2C
from utime import sleep_ms
import math
EEPROM_CHIP_ADDRESS = 0x77
spl06_dict = {'Ctemp': 0.0, 'Ftemp': 0.0,'pressure': 0.0, 'altitude': 0.0}
class SPL06(object):
"""
This class implements spl06 chip's defs.
"""
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make SPL06's internal object points to i2cDev
self._i2cDev = i2cDev
self.init()
def i2c_eeprom_read_var(self, chipAddress, addr):
return self.devRegReadWrite1Byte(0, addr, 0)
def devRegRead1Byte(self, addr):
return self.devRegReadWrite1Byte(0, addr, 0)
def devRegReadWrite1Byte(self, mode, addr, value):
#0 read mode
#1 write mode
if (mode == 0):
Reg = bytearray([addr])
self._i2cDev.write(Reg)
sleep_ms(10)
tmp = bytearray(1)
self._i2cDev.read(tmp)
#print("<-- read addr " + str(addr) + ", value = " + str(tmp[0]))
return tmp[0]
else:
Reg = bytearray([addr, value])
self._i2cDev.write(Reg)
#print("--> write addr " + str(addr) + ", value = " + str(value))
return 0
def init(self):
tmp = 0
rRegID = bytearray([0x0D, 0x0])
wRegPressure8xOversampling = bytearray([0x06, 0x03])
wRegTemperature8xOversampling = bytearray([0x07, 0x83])
wRegContinuousTempAndPressureMeasurement = bytearray([0x08, 0B0111])
wRegFIFOPressureMeasurement = bytearray([0x09, 0x00])
tmp = rRegID
self.devRegReadWrite1Byte(0, tmp[0], tmp[1])
tmp = wRegPressure8xOversampling
self.devRegReadWrite1Byte(1, tmp[0], tmp[1])
tmp = wRegTemperature8xOversampling
self.devRegReadWrite1Byte(1, tmp[0], tmp[1])
tmp = wRegContinuousTempAndPressureMeasurement
self.devRegReadWrite1Byte(1, tmp[0], tmp[1])
tmp = wRegFIFOPressureMeasurement
self.devRegReadWrite1Byte(1, tmp[0], tmp[1])
# Get the firmware version of the chip.
def getID(self) :
reg = bytearray([0x0D])
version = bytearray(1)
self._i2cDev.write(reg)
self._i2cDev.read(version)
#print("spl06 ID is " + str(version[0]))
return version[0]
def get_altitude(self, pressure, seaLevelhPa):
if (seaLevelhPa == 0):
return -1
pressure /= 100
altitude = 44330 * (1.0 - math.pow(pressure / seaLevelhPa, 0.1903))
return altitude
def get_temperature_scale_factor(self):
tmp_Byte = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X07) # MSB
tmp_Byte = tmp_Byte & 0B00000111
#print("tmp_Byte: %d\n" %tmp_Byte)
if (tmp_Byte == 0B000):
k = 524288.0
elif (tmp_Byte == 0B001):
k = 1572864.0
elif (tmp_Byte == 0B010):
k = 3670016.0
elif (tmp_Byte == 0B011):
k = 7864320.0
elif (tmp_Byte == 0B100):
k = 253952.0
elif (tmp_Byte == 0B101):
k = 516096.0
elif (tmp_Byte == 0B110):
k = 1040384.0
elif (tmp_Byte == 0B111):
k = 2088960.0
#print("k=%d\n" %k)
return k
def get_pressure_scale_factor(self):
tmp_Byte = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X06) # MSB
# tmp_Byte = tmp_Byte >> 4 #Focus on bits 6-4 - measurement rate
tmp_Byte = tmp_Byte & 0B00000111 # Focus on 2-0 oversampling rate
# tmp_Byte = 0B011
# oversampling rate
if (tmp_Byte == 0B000):
k = 524288.0
elif (tmp_Byte == 0B001):
k = 1572864.0
elif (tmp_Byte == 0B010):
k = 3670016.0
elif (tmp_Byte == 0B011):
k = 7864320.0
elif (tmp_Byte == 0B100):
k = 253952.0
elif (tmp_Byte == 0B101):
k = 516096.0
elif (tmp_Byte == 0B110):
k = 1040384.0
elif (tmp_Byte == 0B111):
k = 2088960.0
#print("k=%d\n" %k)
return k
def get_traw(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X03) # MSB
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X04) # LSB
tmp_XLSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X05) # XLSB
tmp = (tmp_MSB << 8) | tmp_LSB
tmp = (tmp << 8) | tmp_XLSB
if (tmp & (1 << 23)):
tmp = tmp | 0XFF000000 # Set left bits to one for 2's complement
# conversion of negitive number
#print("get_traw: tmp_MSB=%d, tmp_LSB=%d, tmp_XLSB=%d\n" %(tmp_MSB, tmp_LSB, tmp_XLSB))
return tmp
def get_praw(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X00) # MSB
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X01) # LSB
tmp_XLSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X02) # XLSB
tmp = (tmp_MSB << 8) | tmp_LSB
tmp = (tmp << 8) | tmp_XLSB
if (tmp & (1 << 23)):
tmp = -((2 << 23) - tmp)
return tmp
def get_c0(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X10)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X11)
tmp_LSB = tmp_LSB >> 4
tmp = (tmp_MSB << 4) | tmp_LSB
if (tmp & (1 << 11)):
# Check for 2's complement negative number
tmp = tmp | 0XF000 # Set left bits to one for 2's complement
# conversion of negitive number
if (tmp > (1 << 15)):
tmp &= 0xFFFF
tmp = tmp - (1<<16)
#print("get_c0: tmp_MSB=%d, tmp_LSB=%d, tmp=%d\n" %(tmp_MSB, tmp_LSB, tmp))
return tmp
def get_c1(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X11)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X12)
tmp_MSB = tmp_MSB & 0XF
tmp = (tmp_MSB << 8) | tmp_LSB
if (tmp & (1 << 11)):
# Check for 2's complement negative number
tmp = tmp | 0XF000 # Set left bits to one for 2's complement
# conversion of negitive number
if (tmp > (1 << 15)):
tmp = tmp - (1<<16)
#print("get_c1: tmp_MSB=%d, tmp_LSB=%d, tmp=%d\n" %(tmp_MSB, tmp_LSB, tmp))
return tmp
def get_c00(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X13)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X14)
tmp_XLSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X15)
tmp_XLSB = tmp_XLSB >> 4
tmp = (tmp_MSB << 8) | tmp_LSB
tmp = (tmp << 4) | tmp_XLSB
tmp = tmp_MSB << 12 | tmp_LSB << 4 | tmp_XLSB >> 4
if (tmp & (1 << 19)):
tmp = tmp | 0XFFF00000 # Set left bits to one for 2's complement
# conversion of negitive number
return tmp
def get_c10(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X15) # 4 bits
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X16) # 8 bits
tmp_XLSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X17) # 8 bits
tmp_MSB = tmp_MSB & 0b00001111
tmp = (tmp_MSB << 4) | tmp_LSB
tmp = (tmp << 8) | tmp_XLSB
tmp = tmp_MSB << 16 | tmp_LSB << 8 | tmp_XLSB
if (tmp & (1 << 19)):
tmp = tmp | 0XFFF00000 # Set left bits to one for 2's complement
# conversion of negitive number
if (tmp > (1 << 15)):
tmp &= 0xFFFF
tmp = tmp - (1<<16)
return tmp
def get_c01(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X18)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X19)
tmp = (tmp_MSB << 8) | tmp_LSB
if (tmp > (1 << 15)):
tmp = tmp - (1<<16)
return tmp
def get_c11(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X1A)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X1B)
tmp = (tmp_MSB << 8) | tmp_LSB
if (tmp > (1 << 15)):
tmp = tmp - (1<<16)
return tmp
def get_c20(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X1C)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X1D)
tmp = (tmp_MSB << 8) | tmp_LSB
if (tmp > (1 << 15)):
tmp = tmp - (1<<16)
return tmp
def get_c21(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X1E)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X1F)
tmp = (tmp_MSB << 8) | tmp_LSB
if (tmp > (1 << 15)):
tmp = tmp - (1<<16)
return tmp
def get_c30(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X20)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X21)
tmp = (tmp_MSB << 8) | tmp_LSB
if (tmp > (1 << 15)):
tmp = tmp - (1<<16)
return tmp
def getData(self):
global spl06_dict
tmp = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0x0D)
tmp = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0x06)
tmp = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0x07)
tmp = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0x08)
tmp = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0x09)
tmp = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0x0A)
tmp = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0x0B)
c0 = self.get_c0()
c1 = self.get_c1()
c00 = self.get_c00()
c10 = self.get_c10()
c01 = self.get_c01()
c11 = self.get_c11()
c20 = self.get_c20()
c21 = self.get_c21()
c30 = self.get_c30()
traw = self.get_traw()
traw_sc = traw / self.get_temperature_scale_factor()
traw_sc = round(traw_sc,2)
#print("traw_sc: %0.2f\n" %traw_sc)
Ctemp = c0 * 0.5 + c1 * traw_sc
Ctemp = round(Ctemp,2)
#print("Ctemp:" + str(Ctemp) + ". " + "c0:" + str(c0) + " c1" + str(c1) + " traw_sc:" + str(traw_sc))
Ftemp = (Ctemp * 9 / 5) + 32
Ftemp = round(Ftemp,2)
#print("Ftemp: %d" %Ftemp)
praw = self.get_praw()
praw_sc = (praw) / self.get_pressure_scale_factor()
#print("praw: %d" %praw)
#print("praw_sc: %d" %praw_sc)
#print("c00: %d" %c00)
#print("c10: %d" %c10)
#print("c20: %d" %c20)
#print("c30: %d" %c30)
#print("c01: %d" %c01)
#print("c11: %d" %c11)
#print("c21: %d" %c21)
pcomp =\
(c00) + \
praw_sc * ((c10) + \
praw_sc * ((c20) + praw_sc * (c30))) + \
traw_sc * (c01) + \
traw_sc * praw_sc * ((c11) + praw_sc * (c21))
pressure = pcomp
#print("pressure: %d" %pressure)
# local_pressure = 1010.5 # Look up local sea level pressure on
# google
local_pressure = \
1011.1 # Look up local sea level pressure on google # Local pressure
# from airport website 8/22
#print("Local Airport Sea Level Pressure: %0.2f mb\n" %local_pressure)
altitude = self.get_altitude(pcomp, local_pressure)
#print("altitude: %d" %altitude)
spl06_dict['Ctemp'] = round(Ctemp, 2)
spl06_dict['Ftemp'] = round(Ftemp, 2)
spl06_dict['pressure'] = round(pressure, 1)
spl06_dict['altitude'] = round(altitude, 1)
return spl06_dict
def getTemperature(self):
return self.getData()['Ctemp']
def getFTemperature(self):
return self.getData()['Ftemp']
def getPressure(self):
return self.getData()['pressure']
def getAltitude(self):
return self.getData()['altitude']
if __name__ == "__main__":
'''
The below i2c configuration is needed in your board.json.
"spl06": {
"type": "I2C",
"port": 1,
"addrWidth": 7,
"freq": 400000,
"mode": "master",
"devAddr": 119
}
'''
print("Testing spl06 ...")
i2cDev = I2C()
i2cDev.open("spl06")
baroDev = SPL06(i2cDev)
pressure = baroDev.getPressure()
print("pressure:%f" % (pressure))
i2cDev.close()
del baroDev
i2cDev.close()
print("Test spl06 done!")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/spl06/spl06.py
|
Python
|
apache-2.0
| 12,801
|
"""
HaaSPython SSD1306 OLED driver, I2C interfaces
"""
from micropython import const
import framebuf
from driver import I2C
# register definitions
SET_CONTRAST = const(0x81)
SET_ENTIRE_ON = const(0xa4)
SET_NORM_INV = const(0xa6)
SET_DISP = const(0xae)
SET_MEM_ADDR = const(0x20)
SET_COL_ADDR = const(0x21)
SET_PAGE_ADDR = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP = const(0xa0)
SET_MUX_RATIO = const(0xa8)
SET_COM_OUT_DIR = const(0xc0)
SET_DISP_OFFSET = const(0xd3)
SET_COM_PIN_CFG = const(0xda)
SET_DISP_CLK_DIV = const(0xd5)
SET_PRECHARGE = const(0xd9)
SET_VCOM_DESEL = const(0xdb)
SET_CHARGE_PUMP = const(0x8d)
class SSD1306(framebuf.FrameBuffer):
def __init__(self, width, height, external_vcc):
self.width = width
self.height = height
self.external_vcc = external_vcc
self.pages = self.height // 8
self.buffer = bytearray(self.pages * self.width)
super().__init__(self.buffer, self.width, self.height, framebuf.MONO_VLSB)
self.init_display()
def init_display(self):
for cmd in (
SET_DISP | 0x00, # off
# address setting
SET_MEM_ADDR, 0x00, # horizontal
# resolution and layout
SET_DISP_START_LINE | 0x00,
SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0
SET_MUX_RATIO, self.height - 1,
SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0
SET_DISP_OFFSET, 0x00,
SET_COM_PIN_CFG, 0x02 if self.height == 32 else 0x12,
# timing and driving scheme
SET_DISP_CLK_DIV, 0x80,
SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,
SET_VCOM_DESEL, 0x30, # 0.83*Vcc
# display
SET_CONTRAST, 0xff, # maximum
SET_ENTIRE_ON, # output follows RAM contents
SET_NORM_INV, # not inverted
# charge pump
SET_CHARGE_PUMP, 0x10 if self.external_vcc else 0x14,
SET_DISP | 0x01): # on
self.write_cmd(cmd)
self.fill(0)
self.show()
def poweroff(self):
self.write_cmd(SET_DISP | 0x00)
def poweron(self):
self.write_cmd(SET_DISP | 0x01)
def contrast(self, contrast):
self.write_cmd(SET_CONTRAST)
self.write_cmd(contrast)
def invert(self, invert):
self.write_cmd(SET_NORM_INV | (invert & 1))
def show(self):
x0 = 0
x1 = self.width - 1
if self.width == 64:
# displays with width of 64 pixels are shifted by 32
x0 += 32
x1 += 32
self.write_cmd(SET_COL_ADDR)
self.write_cmd(x0)
self.write_cmd(x1)
self.write_cmd(SET_PAGE_ADDR)
self.write_cmd(0)
self.write_cmd(self.pages - 1)
self.write_data(self.buffer)
class SSD1306_I2C(SSD1306):
def __init__(self, width, height, i2cDev, external_vcc=False):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
self._i2cDev = i2cDev
self.temp = bytearray(2)
super().__init__(width, height, external_vcc)
def write_cmd(self, cmd):
self.temp[0] = 0x80 # Co=1, D/C#=0
self.temp[1] = cmd
self._i2cDev.write(self.temp)
def write_data(self, buf):
send_buf = bytearray(1 + len(buf))
send_buf[0] = 0x40
for i in range(len(buf)):
send_buf[i+1] = buf[i]
self._i2cDev.write(send_buf)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/ssd1306/ssd1306.py
|
Python
|
apache-2.0
| 3,618
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
`HaaS Python tcs34725`
====================================================
A driver for tcs34725 Color Sensor
* Author(s): HaaS Group
Implementation Notes
--------------------
**Hardware:**
* HaaS Python tcs34725:
https://haas.iot.aliyun.com/solution/detail/hardware
**Software and Dependencies:**
* HaaS Python API documents:
https://haas.iot.aliyun.com/haasapi/index.html#/
* HaaS Python Driver Libraries:
https://github.com/alibaba/AliOS-Things/tree/master/haas_lib_bundles/python/libraries
"""
# The MIT License (MIT)
#
# Copyright (c) 2016 Adafruit Industries
#
# 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.
import time
from driver import I2C
TCS34725_ADDRESS = 0x29
TCS34725_ID = 0x12 # 0x44 = TCS34721/TCS34725, 0x4D = TCS34723/TCS34727
TCS34725_COMMAND_BIT = 0x80
TCS34725_ENABLE = 0x00
TCS34725_ENABLE_AIEN = 0x10 # RGBC Interrupt Enable
TCS34725_ENABLE_WEN = 0x08 # Wait enable - Writing 1 activates the wait timer
TCS34725_ENABLE_AEN = 0x02 # RGBC Enable - Writing 1 actives the ADC, 0 disables it
TCS34725_ENABLE_PON = 0x01 # Power on - Writing 1 activates the internal oscillator, 0 disables it
TCS34725_ATIME = 0x01 # Integration time
TCS34725_WTIME = 0x03 # Wait time (if TCS34725_ENABLE_WEN is asserted)
TCS34725_WTIME_2_4MS = 0xFF # WLONG0 = 2.4ms WLONG1 = 0.029s
TCS34725_WTIME_204MS = 0xAB # WLONG0 = 204ms WLONG1 = 2.45s
TCS34725_WTIME_614MS = 0x00 # WLONG0 = 614ms WLONG1 = 7.4s
TCS34725_AILTL = 0x04 # Clear channel lower interrupt threshold
TCS34725_AILTH = 0x05
TCS34725_AIHTL = 0x06 # Clear channel upper interrupt threshold
TCS34725_AIHTH = 0x07
TCS34725_PERS = 0x0C # Persistence register - basic SW filtering mechanism for interrupts
TCS34725_PERS_NONE = 0b0000 # Every RGBC cycle generates an interrupt
TCS34725_PERS_1_CYCLE = 0b0001 # 1 clean channel value outside threshold range generates an interrupt
TCS34725_PERS_2_CYCLE = 0b0010 # 2 clean channel values outside threshold range generates an interrupt
TCS34725_PERS_3_CYCLE = 0b0011 # 3 clean channel values outside threshold range generates an interrupt
TCS34725_PERS_5_CYCLE = 0b0100 # 5 clean channel values outside threshold range generates an interrupt
TCS34725_PERS_10_CYCLE = 0b0101 # 10 clean channel values outside threshold range generates an interrupt
TCS34725_PERS_15_CYCLE = 0b0110 # 15 clean channel values outside threshold range generates an interrupt
TCS34725_PERS_20_CYCLE = 0b0111 # 20 clean channel values outside threshold range generates an interrupt
TCS34725_PERS_25_CYCLE = 0b1000 # 25 clean channel values outside threshold range generates an interrupt
TCS34725_PERS_30_CYCLE = 0b1001 # 30 clean channel values outside threshold range generates an interrupt
TCS34725_PERS_35_CYCLE = 0b1010 # 35 clean channel values outside threshold range generates an interrupt
TCS34725_PERS_40_CYCLE = 0b1011 # 40 clean channel values outside threshold range generates an interrupt
TCS34725_PERS_45_CYCLE = 0b1100 # 45 clean channel values outside threshold range generates an interrupt
TCS34725_PERS_50_CYCLE = 0b1101 # 50 clean channel values outside threshold range generates an interrupt
TCS34725_PERS_55_CYCLE = 0b1110 # 55 clean channel values outside threshold range generates an interrupt
TCS34725_PERS_60_CYCLE = 0b1111 # 60 clean channel values outside threshold range generates an interrupt
TCS34725_CONFIG = 0x0D
TCS34725_CONFIG_WLONG = 0x02 # Choose between short and long (12x) wait times via TCS34725_WTIME
TCS34725_CONTROL = 0x0F # Set the gain level for the sensor
TCS34725_ID = 0x12 # 0x44 = TCS34721/TCS34725, 0x4D = TCS34723/TCS34727
TCS34725_STATUS = 0x13
TCS34725_STATUS_AINT = 0x10 # RGBC Clean channel interrupt
TCS34725_STATUS_AVALID = 0x01 # Indicates that the RGBC channels have completed an integration cycle
TCS34725_CDATAL = 0x14 # Clear channel data
TCS34725_CDATAH = 0x15
TCS34725_RDATAL = 0x16 # Red channel data
TCS34725_RDATAH = 0x17
TCS34725_GDATAL = 0x18 # Green channel data
TCS34725_GDATAH = 0x19
TCS34725_BDATAL = 0x1A # Blue channel data
TCS34725_BDATAH = 0x1B
TCS34725_INTEGRATIONTIME_2_4MS = 0xFF # 2.4ms - 1 cycle - Max Count: 1024
TCS34725_INTEGRATIONTIME_24MS = 0xF6 # 24ms - 10 cycles - Max Count: 10240
TCS34725_INTEGRATIONTIME_50MS = 0xEB # 50ms - 20 cycles - Max Count: 20480
TCS34725_INTEGRATIONTIME_101MS = 0xD5 # 101ms - 42 cycles - Max Count: 43008
TCS34725_INTEGRATIONTIME_154MS = 0xC0 # 154ms - 64 cycles - Max Count: 65535
TCS34725_INTEGRATIONTIME_240MS = 0x9C # 240ms - 100 cycles - Max Count: 65535
TCS34725_INTEGRATIONTIME_700MS = 0x00 # 700ms - 256 cycles - Max Count: 65535
TCS34725_GAIN_1X = 0x00 # No gain
TCS34725_GAIN_4X = 0x01 # 2x gain
TCS34725_GAIN_16X = 0x02 # 16x gain
TCS34725_GAIN_60X = 0x03 # 60x gain
# Lookup table for integration time delays.
INTEGRATION_TIME_DELAY = {
0xFF: 0.0024, # 2.4ms - 1 cycle - Max Count: 1024
0xF6: 0.024, # 24ms - 10 cycles - Max Count: 10240
0xEB: 0.050, # 50ms - 20 cycles - Max Count: 20480
0xD5: 0.101, # 101ms - 42 cycles - Max Count: 43008
0xC0: 0.154, # 154ms - 64 cycles - Max Count: 65535
0x00: 0.700 # 700ms - 256 cycles - Max Count: 65535
}
# Utility methods:
def calculate_color_temperature(r, g, b):
"""Converts the raw R/G/B values to color temperature in degrees Kelvin."""
# 1. Map RGB values to their XYZ counterparts.
# Based on 6500K fluorescent, 3000K fluorescent
# and 60W incandescent values for a wide range.
# Note: Y = Illuminance or lux
X = (-0.14282 * r) + (1.54924 * g) + (-0.95641 * b)
Y = (-0.32466 * r) + (1.57837 * g) + (-0.73191 * b)
Z = (-0.68202 * r) + (0.77073 * g) + ( 0.56332 * b)
# Check for divide by 0 (total darkness) and return None.
if (X + Y + Z) == 0:
return None
# 2. Calculate the chromaticity co-ordinates
xc = (X) / (X + Y + Z)
yc = (Y) / (X + Y + Z)
# Check for divide by 0 again and return None.
if (0.1858 - yc) == 0:
return None
# 3. Use McCamy's formula to determine the CCT
n = (xc - 0.3320) / (0.1858 - yc)
# Calculate the final CCT
cct = (449.0 * (n ** 3.0)) + (3525.0 *(n ** 2.0)) + (6823.3 * n) + 5520.33
return int(cct)
def calculate_lux(r, g, b):
"""Converts the raw R/G/B values to luminosity in lux."""
illuminance = (-0.32466 * r) + (1.57837 * g) + (-0.73191 * b)
return int(illuminance)
class TCS34725(object):
"""TCS34725 color sensor."""
def __init__(self, *args, **Kwargs):
"""Initialize the TCS34725 sensor."""
# Setup I2C interface for the device.
self._i2cDev = None
if not isinstance(args[0], I2C):
raise ValueError("parameter is not an I2C object")
self._i2cDev = args[0]
# default parameters
gain=TCS34725_GAIN_60X
integration_time=TCS34725_INTEGRATIONTIME_240MS
# Make sure we're connected to the sensor.
chip_id = self._readU8(TCS34725_ID)
if chip_id != 0x44:
raise RuntimeError('Failed to read TCS34725 chip ID, check your wiring.')
# Set default integration time and gain.
self.set_integration_time(integration_time)
self.set_gain(gain)
# Enable the device (by default, the device is in power down mode on bootup).
self.enable()
def _readU8(self, reg):
"""Read an unsigned 8-bit register."""
v = bytearray(1)
self._i2cDev.memRead(v, TCS34725_COMMAND_BIT | reg, 8)
return v[0]
def _readU16LE(self, reg):
"""Read a 16-bit little endian register."""
v = bytearray(2)
self._i2cDev.memRead(v, TCS34725_COMMAND_BIT | reg, 8)
return (v[0] | (v[1] << 8))
def _write8(self, reg, value):
"""Write a 8-bit value to a register."""
v = bytearray([value])
self._i2cDev.memWrite(v, TCS34725_COMMAND_BIT | reg, 8)
def enable(self):
"""Enable the chip."""
# Flip on the power and enable bits.
self._write8(TCS34725_ENABLE, TCS34725_ENABLE_PON)
time.sleep(0.01)
self._write8(TCS34725_ENABLE, (TCS34725_ENABLE_PON | TCS34725_ENABLE_AEN))
time.sleep(0.01)
def disable(self):
"""Disable the chip (power down)."""
# Flip off the power on and enable bits.
reg = self._readU8(TCS34725_ENABLE)
reg &= ~(TCS34725_ENABLE_PON | TCS34725_ENABLE_AEN)
self._write8(TCS34725_ENABLE, reg)
def set_integration_time(self, integration_time):
"""Sets the integration time for the TC34725. Provide one of these
constants:
- TCS34725_INTEGRATIONTIME_2_4MS = 2.4ms - 1 cycle - Max Count: 1024
- TCS34725_INTEGRATIONTIME_24MS = 24ms - 10 cycles - Max Count: 10240
- TCS34725_INTEGRATIONTIME_50MS = 50ms - 20 cycles - Max Count: 20480
- TCS34725_INTEGRATIONTIME_101MS = 101ms - 42 cycles - Max Count: 43008
- TCS34725_INTEGRATIONTIME_154MS = 154ms - 64 cycles - Max Count: 65535
- TCS34725_INTEGRATIONTIME_700MS = 700ms - 256 cycles - Max Count: 65535
"""
self._integration_time = integration_time
self._write8(TCS34725_ATIME, integration_time)
def get_integration_time(self):
"""Return the current integration time value. This will be one of the
constants specified in the set_integration_time doc string.
"""
return self._readU8(TCS34725_ATIME)
def set_gain(self, gain):
"""Adjusts the gain on the TCS34725 (adjusts the sensitivity to light).
Use one of the following constants:
- TCS34725_GAIN_1X = No gain
- TCS34725_GAIN_4X = 2x gain
- TCS34725_GAIN_16X = 16x gain
- TCS34725_GAIN_60X = 60x gain
"""
self._write8(TCS34725_CONTROL, gain)
def get_gain(self):
"""Return the current gain value. This will be one of the constants
specified in the set_gain doc string.
"""
return self._readU8(TCS34725_CONTROL)
def wait_for_valid(self):
status = self._readU8(TCS34725_STATUS)
while not (status & TCS34725_STATUS_AVALID):
status = self._readU8(TCS34725_STATUS)
pass
print(self._readU8(TCS34725_STATUS))
def get_raw_data(self):
"""Reads the raw red, green, blue and clear channel values. Will return
a 4-tuple with the red, green, blue, clear color values (unsigned 16-bit
numbers).
"""
self.wait_for_valid()
# Read each color register.
r = self._readU16LE(TCS34725_RDATAL)
g = self._readU16LE(TCS34725_GDATAL)
b = self._readU16LE(TCS34725_BDATAL)
c = self._readU16LE(TCS34725_CDATAL)
# Delay for the integration time to allow for next reading immediately.
#time.sleep(INTEGRATION_TIME_DELAY[self._integration_time])
return (r, g, b, c)
def set_interrupt(self, enabled):
"""Enable or disable interrupts by setting enabled to True or False."""
enable_reg = self._readU8(TCS34725_ENABLE)
if enabled:
enable_reg |= TCS34725_ENABLE_AIEN
else:
enable_reg &= ~TCS34725_ENABLE_AIEN
self._write8(TCS34725_ENABLE, enable_reg)
time.sleep(1)
def set_interrupt_limits(self, low, high):
"""Set the interrupt limits to provied unsigned 16-bit threshold values.
"""
self._write8(0x04, low & 0xFF)
self._write8(0x05, low >> 8)
self._write8(0x06, high & 0xFF)
self._write8(0x07, high >> 8)
def setInterrupt(self, enabled):
self.set_interrupt(enabled)
def setInterruptLimits(self, low, high):
self.set_interrupt_limits(low, high)
def getRawData(self):
return self.get_raw_data()
def getRGB(self):
i = 1.0
r, g, b, c = self.get_raw_data()
'''
r /= c
g /= c
b /= c
return (int(r * 256), int(g * 256), int(b * 256))
'''
if (r >= g) and (r >= b):
i = r/255 + 1
elif (g >= r) and (g >= b):
i = g/255 + 1
elif (b >= g) and (b >= r):
i = b/255 + 1
# print (i, r, g, b)
if i != 0:
r /= i
g /= i
b /= i
if (r > 30):
r -= 30
if (g > 30):
g -= 30
if (b > 30):
b -= 30
r = r * 255 / 225
g = g * 255 / 225
b = b * 255 / 225
if (r > 255):
r = 255
if (g > 255):
g = 255
if (b >= 255):
b = 255
return (int(r), int(g), int(b))
def calculateLux(self, r, g, b):
"""Converts the raw R/G/B values to luminosity in lux."""
return calculate_lux(r, g, b)
def calculateCT(self, r, g, b):
return calculate_color_temperature(r, g, b)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/tcs34725/tcs34725.py
|
Python
|
apache-2.0
| 14,385
|
from driver import ADC
class TDS(object):
def __init__(self, adcObj, T = 25):
self._adcObj = None
if not isinstance(adcObj, ADC):
raise ValueError("parameter is not an ADC object")
self._adcObj = adcObj
self.temperature = T
def setTemperature(self, T):
self.temperature = T
def getTDS(self):
if self._adcObj is None:
raise ValueError("invalid ADC object")
min = 400
max = 0
value = 0
total = 0
for i in range(32):
value = self._adcObj.readVoltage()
total += value
# print(value)
if (min >= value):
min = value
if (max <= value):
max = value
averageVoltage = (total - min - max) / 30
averageVoltage /= 1000.0 # unit:V
# temperature compensation formula: fFinalResult(25^C) = fFinalResult(current)/(1.0+0.02*(fTP-25.0));
cC = 1.0 + 0.02 * (self.temperature - 25.0); # cC - compensationCoefficient
cV = averageVoltage / cC # cV - compensationVolatge
# convert voltage to TDS
tds = 66.71 * cV * cV * cV - 127.93 * cV * cV + 428.7 * cV
return int(tds)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/tds/tds.py
|
Python
|
apache-2.0
| 1,234
|
import time
from driver import I2C
class TEA5767:
FREQ_RANGE = (87.5, 108.0)
ADC = (0, 5, 7, 10)
ADC_BIT = (0, 1, 2, 3)
def __init__(self, i2cDev):
self._i2c = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
self._i2c = i2cDev
self.frequency = 0.0
self.standby_mode = False
self.mute_mode = False
self.soft_mute_mode = True
self.search_mode = False
self.search_direction = 1
self.search_adc_level = 7
self.stereo_mode = True
self.stereo_noise_cancelling_mode = True
self.high_cut_mode = True
self.is_ready = False
self.is_stereo = False
self.signal_adc_level = 0
self.update()
def setFrequency(self, freq):
self.frequency = freq
self.update()
def changeFreqency(self, change):
self.frequency += change
self.search_direction = 1 if change >= 0 else 0
self.update()
def search(self, mode, dir=1, adc=7):
self.search_mode = mode
self.search_direction = dir
self.search_adc_level = adc if adc in TEA5767.ADC else 7
self.update()
def mute(self, mode):
self.mute_mode = mode
self.update()
def standby(self, mode):
self.standby_mode = mode
self.update()
def read(self):
buf = bytearray(5)
self._i2c.read(buf)
freqB = int((buf[0] & 0x3f) << 8 | buf[1])
self.frequency = round((freqB * 32768 / 4 - 225000) / 1000000, 1)
self.is_ready = int(buf[0] >> 7) == 1
self.is_stereo = int(buf[2] >> 7) == 1
self.signal_adc_level = int(buf[3] >> 4)
def update(self):
self.frequency = min(max(self.frequency, TEA5767.FREQ_RANGE[0]), TEA5767.FREQ_RANGE[1])
freqB = 4 * (self.frequency * 1000000 + 225000) / 32768
buf = bytearray(5)
buf[0] = int(freqB) >> 8 | self.mute_mode << 7 | self.search_mode << 6
buf[1] = int(freqB) & 0xff
buf[2] = self.search_direction << 7 | 1 << 4 | self.stereo_mode << 3
try:
buf[2] += TEA5767.ADC_BIT[TEA5767.ADC.index(self.search_adc_level)] << 5
except:
pass
buf[3] = self.standby_mode << 6 | 0 << 5 | 1 << 4
buf[3] += self.soft_mute_mode << 3 | self.high_cut_mode << 2 | self.stereo_noise_cancelling_mode << 1
buf[4] = 0
self._i2c.write(buf)
time.sleep_ms(50)
self.read()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/tea5767/tea5767.py
|
Python
|
apache-2.0
| 2,518
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
HaaS Python driver for tracker
Author: HaaS
Date: 2022/05/13
"""
from driver import GPIO
class TRACKER(object):
def __init__(self, gpioObj):
self.gpioObj = None
if not isinstance(gpioObj, GPIO):
raise ValueError("parameter is not an GPIO object")
self.gpioObj = gpioObj
def getTrackerStatus(self):
if self.gpioObj is None:
raise ValueError("invalid GPIO object")
self.value = self.gpioObj.read()
return self.value
def close(self):
if self.gpioObj is None:
raise ValueError("invalid I2C object")
self.gpioObj.close()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/tracker/tracker.py
|
Python
|
apache-2.0
| 710
|
from driver import GPIO
class TTP224:
def __init__(self,gpio1Dev=None,gpio2Dev=None,gpio3Dev=None,gpio4Dev=None):
self._gpio1Obj = None
self._gpio2Obj = None
self._gpio3Obj = None
self._gpio4Obj = None
self._cntObj = 0
if isinstance(gpio1Dev, GPIO):
self._cntObj = self._cntObj + 1
self._gpio1Obj = gpio1Dev
if isinstance(gpio2Dev, GPIO):
self._cntObj = self._cntObj + 1
self._gpio2Obj = gpio2Dev
if isinstance(gpio3Dev, GPIO):
self._cntObj = self._cntObj + 1
self._gpio3Obj = gpio3Dev
if isinstance(gpio4Dev, GPIO):
self._cntObj = self._cntObj + 1
self._gpio4Obj = gpio4Dev
if self._cntObj == 0:
raise ValueError("no GPIO object")
def getStatus(self):
if self._cntObj == 0:
raise ValueError("no GPIO object")
if self._gpio1Obj is None:
value01 = None
else:
value01 = self._gpio1Obj.read()
if self._gpio2Obj is None:
value02 = None
else:
value02 = self._gpio2Obj.read()
if self._gpio3Obj is None:
value03 = None
else:
value03 = self._gpio3Obj.read()
if self._gpio4Obj is None:
value04 = None
else:
value04 = self._gpio4Obj.read()
return self._cntObj,value01,value02,value03,value04
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/ttp224/ttp224.py
|
Python
|
apache-2.0
| 1,477
|
import lvgl as lv
isStarted = False
isAnimationComplete = False
arc = [None, None, None, None]
anim = [None, None, None, None]
timeCount = [1, 3, 5, 10]
currentSelect = 0
minuteLabel = None
secondLabel = None
millionLabel = None
anim_timeline = None
startLabel = None
currentValue = 0
lvglInitialized = False
def setLabelValue(value):
global currentValue
global minuteLabel
global secondLabel
global millionLabel
global startLabel
currentValue = value
currentMillionSecond = value * 20
minute = currentMillionSecond / 1000 / 60
minuteLabel.set_text('%02d'%minute)
second = currentMillionSecond / 1000 % 60
secondLabel.set_text('%02d'%second)
million = value % 60
millionLabel.set_text('%02d'%million)
def set_time_value(obj, v):
setLabelValue(v)
obj.set_value(v)
def reset_button_event_handler(e):
global isStarted
global isAnimationComplete
global currentValue
global timeCount
global arc
global anim
global anim_timeline
global startLabel
if (isStarted):
return
isAnimationComplete = False
currentValue = timeCount[currentSelect] * 60 * 50
arc[currentSelect].set_value(currentValue)
anim[currentSelect] = lv.anim_t()
anim[currentSelect].init()
anim[currentSelect].set_var(arc[currentSelect])
anim[currentSelect].set_time(currentValue * 20)
anim[currentSelect].set_values(currentValue, 0)
anim[currentSelect].set_custom_exec_cb(lambda a1, val: set_time_value(arc[currentSelect], val))
anim_timeline = lv.anim_timeline_create()
lv.anim_timeline_add(anim_timeline, 0, anim[currentSelect])
startLabel.set_text("START")
setLabelValue(currentValue)
def arc_event_handler(e, index):
global isStarted
global currentSelect
global arc
print("index: " + str(index) + " currentSelect: " + str(currentSelect))
print("isStarted: " + str(isStarted))
if (isStarted or currentSelect == index):
return
arc[currentSelect].set_value(0)
arc[currentSelect].set_style_arc_width(2, lv.PART.INDICATOR)
arc[currentSelect].set_style_arc_width(2, lv.PART.MAIN)
currentSelect = index
arc[currentSelect].set_style_arc_width(8, lv.PART.INDICATOR)
arc[currentSelect].set_style_arc_width(8, lv.PART.MAIN)
reset_button_event_handler(e)
def start_button_event_handler(e):
global isStarted
global isAnimationComplete
global anim_timeline
global startLabel
global anim
global currentSelect
global currentValue
if (isAnimationComplete):
return
if (isStarted):
isStarted = False
lv.anim_timeline_stop(anim_timeline)
lv.anim_timeline_del(anim_timeline)
anim_timeline = None
startLabel.set_text("RESUME")
anim[currentSelect] = lv.anim_t()
anim[currentSelect].init()
anim[currentSelect].set_var(arc[currentSelect])
anim[currentSelect].set_time(currentValue * 20)
anim[currentSelect].set_values(currentValue, 0)
anim[currentSelect].set_custom_exec_cb(lambda a1, val: set_time_value(arc[currentSelect],val))
anim_timeline = lv.anim_timeline_create()
lv.anim_timeline_add(anim_timeline, 0, anim[currentSelect])
else:
isStarted = True
lv.anim_timeline_start(anim_timeline)
startLabel.set_text("PAUSE")
class CountDown:
def createPage(self, value1 = 1, value2 = 3, value3 = 5, value4 = 10):
global isStarted
global isAnimationComplete
global arc
global anim
global timeCount
global currentSelect
global minuteLabel
global secondLabel
global millionLabel
global anim_timeline
global startLabel
global currentValue
global lvglInitialized
if lvglInitialized == False:
import display_driver
lvglInitialized = True
print("Enter count down")
timeCount = [value1, value2, value3, value4]
# init scr
scr = lv.obj()
win = lv.obj(scr)
win.set_size(scr.get_width(), scr.get_height())
win.set_style_border_opa(0, 0)
win.set_style_radius(0, 0)
win.set_style_bg_color(lv.color_black(), 0)
win.clear_flag(lv.obj.FLAG.SCROLLABLE)
isStarted = False
currentSelect = 0
# count down
func_col_dsc = [40, 5, 30, 5, 20, lv.GRID_TEMPLATE.LAST]
func_row_dsc = [30, lv.GRID_TEMPLATE.LAST]
timeContainer = lv.obj(win)
timeContainer.set_style_bg_opa(0, 0)
timeContainer.set_style_border_opa(0, 0)
timeContainer.set_layout(lv.LAYOUT_GRID.value)
timeContainer.set_style_grid_column_dsc_array(func_col_dsc, 0)
timeContainer.set_style_grid_row_dsc_array(func_row_dsc, 0)
timeContainer.set_grid_align(lv.GRID_ALIGN.SPACE_BETWEEN, lv.GRID_ALIGN.SPACE_BETWEEN)
timeContainer.set_style_pad_all(0, 0)
timeContainer.set_size(240, 70)
timeContainer.center()
minuteLabel = lv.label(timeContainer)
minuteLabel.set_style_text_font(lv.font_montserrat_48, 0)
minuteLabel.set_style_text_color(lv.color_white(), 0)
minuteLabel.set_grid_cell(lv.GRID_ALIGN.START, 0, 1, lv.GRID_ALIGN.CENTER, 0, 1)
signLabel = lv.label(timeContainer)
signLabel.set_style_text_font(lv.font_montserrat_48, 0)
signLabel.set_style_text_color(lv.color_white(), 0)
signLabel.set_text(":")
signLabel.set_grid_cell(lv.GRID_ALIGN.CENTER, 1, 1, lv.GRID_ALIGN.CENTER, 0, 1)
secondLabel = lv.label(timeContainer)
secondLabel.set_style_text_font(lv.font_montserrat_48, 0)
secondLabel.set_style_text_color(lv.color_white(), 0)
secondLabel.set_grid_cell(lv.GRID_ALIGN.CENTER, 2, 1, lv.GRID_ALIGN.CENTER, 0, 1)
signLabel = lv.label(timeContainer)
signLabel.set_style_text_font(lv.font_montserrat_48, 0)
signLabel.set_style_text_color(lv.color_white(), 0)
signLabel.set_text(":")
signLabel.set_grid_cell(lv.GRID_ALIGN.CENTER, 3, 1, lv.GRID_ALIGN.CENTER, 0, 1)
millionLabel = lv.label(timeContainer)
millionLabel.set_style_text_font(lv.font_montserrat_36, 0)
millionLabel.set_style_text_color(lv.color_white(), 0)
millionLabel.set_grid_cell(lv.GRID_ALIGN.END, 4, 1, lv.GRID_ALIGN.START, 0, 1)
setLabelValue(timeCount[currentSelect] * 60 * 50)
startButton = lv.btn(win)
startButton.align(lv.ALIGN.CENTER, 0, 40)
startButton.set_size(126, 54)
startButton.set_style_radius(45, lv.PART.MAIN)
startButton.set_style_shadow_opa(0, 0)
startButton.set_style_bg_color(lv.color_make(0xFF, 0xA8, 0x48), lv.PART.MAIN)
startButton.align(lv.ALIGN.BOTTOM_LEFT, 12, -12)
startButton.add_event_cb(start_button_event_handler, lv.EVENT.CLICKED, None)
startLabel = lv.label(startButton)
startLabel.set_text("START")
startLabel.set_style_text_color(lv.color_black(), 0)
startLabel.set_style_text_font(lv.font_montserrat_20, 0)
startLabel.center()
resetButton = lv.btn(win)
resetButton.align(lv.ALIGN.CENTER, 0, 40)
resetButton.set_size(126, 54)
resetButton.set_style_radius(45, lv.PART.MAIN)
resetButton.set_style_shadow_opa(0, 0)
resetButton.set_style_bg_color(lv.color_white(), lv.PART.MAIN)
resetButton.align(lv.ALIGN.BOTTOM_RIGHT, -12, -12)
resetButton.add_event_cb(reset_button_event_handler, lv.EVENT.CLICKED, None)
resetLabel = lv.label(resetButton)
resetLabel.set_text("REST")
resetLabel.set_style_text_color(lv.color_black(), 0)
resetLabel.set_style_text_font(lv.font_montserrat_20, 0)
resetLabel.center()
# select time
col_dsc = [75, 75, 75, 75, lv.GRID_TEMPLATE.LAST]
row_dsc = [60, 80, 60, lv.GRID_TEMPLATE.LAST]
funcContainer = lv.obj(win)
funcContainer.set_layout(lv.LAYOUT_GRID.value)
funcContainer.set_style_bg_opa(0, 0)
funcContainer.set_style_border_opa(0, 0)
funcContainer.set_style_grid_column_dsc_array(col_dsc, 0)
funcContainer.set_style_grid_row_dsc_array(row_dsc, 0)
funcContainer.set_grid_align(lv.GRID_ALIGN.SPACE_BETWEEN, lv.GRID_ALIGN.SPACE_BETWEEN)
funcContainer.set_size(300, 90)
funcContainer.set_style_align(lv.ALIGN.TOP_MID, 0)
maxMillionSecond = timeCount[0] * 60 * 50
arc[0] = lv.arc(funcContainer)
arc[0].set_style_arc_color(lv.color_white(), lv.PART.INDICATOR)
arc[0].set_style_arc_color(lv.color_make(0x33, 0x33, 0x33), lv.PART.MAIN)
arc[0].set_range(0, maxMillionSecond)
arc[0].set_size(55, 55)
arc[0].set_rotation(90)
arc[0].set_bg_angles(0, 360)
arc[0].remove_style(None, lv.PART.KNOB)
arc[0].set_value(maxMillionSecond)
arc[0].set_style_arc_width(8, lv.PART.INDICATOR)
arc[0].set_style_arc_width(8, lv.PART.MAIN)
arc[0].set_grid_cell(lv.GRID_ALIGN.CENTER, 0, 1, lv.GRID_ALIGN.CENTER, 0, 1)
arc[0].clear_flag(lv.obj.FLAG.CLICKABLE)
totalTime = lv.label(funcContainer)
totalTime.set_text(str(timeCount[0]))
totalTime.set_style_text_font(lv.font_montserrat_18, 0)
totalTime.set_style_text_color(lv.color_white(), 0)
totalTime.set_grid_cell(lv.GRID_ALIGN.CENTER, 0, 1, lv.GRID_ALIGN.CENTER, 0, 1)
totalTime.add_flag(lv.obj.FLAG.CLICKABLE)
totalTime.add_event_cb(lambda e: arc_event_handler(e, 0), lv.EVENT.CLICKED, None)
totalTime.set_ext_click_area(30)
anim[0] = lv.anim_t()
anim[0].init()
anim[0].set_var(arc[0])
anim[0].set_time(maxMillionSecond * 20)
anim[0].set_values(maxMillionSecond, 0)
anim[0].set_custom_exec_cb(lambda a1, val: set_time_value(arc[0], val))
anim_timeline = lv.anim_timeline_create()
lv.anim_timeline_add(anim_timeline, 0, anim[0])
arc[1] = lv.arc(funcContainer)
arc[1].set_style_arc_color(lv.color_white(), lv.PART.INDICATOR)
arc[1].set_style_arc_color(lv.color_make(0x33, 0x33, 0x33), lv.PART.MAIN)
arc[1].set_range(0, maxMillionSecond)
arc[1].set_size(55, 55)
arc[1].set_rotation(90)
arc[1].set_bg_angles(0, 360)
arc[1].remove_style(None, lv.PART.KNOB)
arc[1].set_value(0)
arc[1].set_style_arc_width(2, lv.PART.INDICATOR)
arc[1].set_style_arc_width(2, lv.PART.MAIN)
arc[1].set_grid_cell(lv.GRID_ALIGN.CENTER, 1, 1, lv.GRID_ALIGN.CENTER, 0, 1)
arc[1].clear_flag(lv.obj.FLAG.CLICKABLE)
totalTime = lv.label(funcContainer)
totalTime.set_text(str(timeCount[1]))
totalTime.set_style_text_font(lv.font_montserrat_18, 0)
totalTime.set_style_text_color(lv.color_white(), 0)
totalTime.set_grid_cell(lv.GRID_ALIGN.CENTER, 1, 1, lv.GRID_ALIGN.CENTER, 0, 1)
totalTime.add_flag(lv.obj.FLAG.CLICKABLE)
totalTime.add_event_cb(lambda e: arc_event_handler(e, 1), lv.EVENT.CLICKED, None)
totalTime.set_ext_click_area(30)
arc[2] = lv.arc(funcContainer)
arc[2].set_style_arc_color(lv.color_white(), lv.PART.INDICATOR)
arc[2].set_style_arc_color(lv.color_make(0x33, 0x33, 0x33), lv.PART.MAIN)
arc[2].set_range(0, maxMillionSecond)
arc[2].set_size(55, 55)
arc[2].set_rotation(90)
arc[2].set_bg_angles(0, 360)
arc[2].remove_style(None, lv.PART.KNOB)
arc[2].set_value(0)
arc[2].set_style_arc_width(2, lv.PART.INDICATOR)
arc[2].set_style_arc_width(2, lv.PART.MAIN)
arc[2].set_grid_cell(lv.GRID_ALIGN.CENTER, 2, 1, lv.GRID_ALIGN.CENTER, 0, 1)
arc[2].clear_flag(lv.obj.FLAG.CLICKABLE)
totalTime = lv.label(funcContainer)
totalTime.set_text(str(timeCount[2]))
totalTime.set_style_text_font(lv.font_montserrat_18, 0)
totalTime.set_style_text_color(lv.color_white(), 0)
totalTime.set_grid_cell(lv.GRID_ALIGN.CENTER, 2, 1, lv.GRID_ALIGN.CENTER, 0, 1)
totalTime.add_flag(lv.obj.FLAG.CLICKABLE)
totalTime.add_event_cb(lambda e: arc_event_handler(e, 2), lv.EVENT.CLICKED, None)
totalTime.set_ext_click_area(30)
arc[3] = lv.arc(funcContainer)
arc[3].set_style_arc_color(lv.color_white(), lv.PART.INDICATOR)
arc[3].set_style_arc_color(lv.color_make(0x33, 0x33, 0x33), lv.PART.MAIN)
arc[3].set_range(0, maxMillionSecond)
arc[3].set_size(55, 55)
arc[3].set_rotation(90)
arc[3].set_bg_angles(0, 360)
arc[3].remove_style(None, lv.PART.KNOB)
arc[3].set_value(0)
arc[3].set_style_arc_width(2, lv.PART.INDICATOR)
arc[3].set_style_arc_width(2, lv.PART.MAIN)
arc[3].set_grid_cell(lv.GRID_ALIGN.CENTER, 3, 1, lv.GRID_ALIGN.CENTER, 0, 1)
arc[3].clear_flag(lv.obj.FLAG.CLICKABLE)
totalTime = lv.label(funcContainer)
totalTime.set_text(str(timeCount[3]))
totalTime.set_style_text_font(lv.font_montserrat_18, 0)
totalTime.set_style_text_color(lv.color_white(), 0)
totalTime.set_grid_cell(lv.GRID_ALIGN.CENTER, 3, 1, lv.GRID_ALIGN.CENTER, 0, 1)
totalTime.add_flag(lv.obj.FLAG.CLICKABLE)
totalTime.add_event_cb(lambda e: arc_event_handler(e, 3), lv.EVENT.CLICKED, None)
totalTime.set_ext_click_area(30)
# load content
lv.scr_load(scr)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/ui_lite/countDown/countDown.py
|
Python
|
apache-2.0
| 13,526
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/"
lvglInitialized = False
class HumiturePanel:
container = None
scr = None
humidityValue = None
humidityLable = None
def __init__(self):
self.createPage()
def createPage(self):
global lvglInitialized
if lvglInitialized == False:
import display_driver
lvglInitialized = True
# init scr
self.scr = lv.obj()
self.scr.set_style_bg_color(lv.color_black(), 0)
self.container = lv.obj(self.scr)
self.container.set_style_bg_opa(0, 0)
self.container.set_style_border_opa(0, 0)
self.container.set_style_radius(0, 0)
self.container.clear_flag(lv.obj.FLAG.SCROLLABLE)
self.container.set_size(lv.SIZE.CONTENT, lv.SIZE.CONTENT)
self.container.set_flex_flow(lv.FLEX_FLOW.COLUMN)
self.container.set_style_align(lv.ALIGN.CENTER, 0)
self.container.set_style_pad_left(0, 0)
# create temperature item
self.createTemperatureItem(self.container, RESOURCES_ROOT + "temperature.png",
RESOURCES_ROOT + "centigrade_l.png", "Temperature")
self.createInterval(self.container, 25)
# create humidity item
self.createHumidityItem(self.container, RESOURCES_ROOT + "humidity.png", "Humidity")
# load content
lv.scr_load(self.scr)
def showHumiture(self, temperature, humidity):
self.showTemperature(temperature)
self.showHumidity(humidity)
def showTemperature(self, temperature):
self.temperatureLable.set_text(str(int(temperature)))
def showHumidity(self, humidity):
self.humidityLable.set_text(str(int(humidity)) + " %")
def createTemperatureItem(self, parent, iconPath, unityPath, tips):
col_dsc = [lv.GRID.CONTENT, 5, lv.GRID.CONTENT, lv.GRID.CONTENT, lv.GRID_TEMPLATE.LAST]
row_dsc = [lv.GRID.CONTENT, lv.GRID.CONTENT, lv.GRID_TEMPLATE.LAST]
cont = lv.obj(parent)
cont.set_style_bg_opa(0, 0)
cont.set_style_border_opa(0, 0)
cont.set_style_pad_all(0, 0)
cont.set_size(lv.SIZE.CONTENT, lv.SIZE.CONTENT)
cont.set_style_grid_column_dsc_array(col_dsc, 0)
cont.set_style_grid_row_dsc_array(row_dsc, 0)
cont.set_layout(lv.LAYOUT_GRID.value)
img = lv.img(cont)
img.set_src(iconPath)
img.set_grid_cell(lv.GRID_ALIGN.START, 0, 1, lv.GRID_ALIGN.CENTER, 0, 2)
self.temperatureLable = lv.label(cont)
self.temperatureLable.set_text("None")
self.temperatureLable.set_style_text_color(lv.color_white(), 0)
self.temperatureLable.set_style_text_font(lv.font_montserrat_48, 0)
self.temperatureLable.set_style_pad_all(0, 0)
self.temperatureLable.set_grid_cell(lv.GRID_ALIGN.START, 2, 1, lv.GRID_ALIGN.CENTER, 0, 1)
iconImg = lv.img(cont)
iconImg.set_src(unityPath)
iconImg.set_zoom(205)
iconImg.set_style_pad_bottom(0, 0)
iconImg.set_grid_cell(lv.GRID_ALIGN.START, 3, 1, lv.GRID_ALIGN.CENTER, 0, 1)
tip = lv.label(cont)
tip.set_text(tips)
tip.set_style_text_color(lv.color_make(0xCC, 0xCC, 0xCC), 0)
tip.set_grid_cell(lv.GRID_ALIGN.START, 2, 2, lv.GRID_ALIGN.START, 1, 1)
def createHumidityItem(self, parent, iconPath, tips):
col_dsc = [lv.GRID.CONTENT, 5, lv.GRID.CONTENT, lv.GRID.CONTENT, lv.GRID_TEMPLATE.LAST]
row_dsc = [lv.GRID.CONTENT, lv.GRID.CONTENT, lv.GRID_TEMPLATE.LAST]
cont = lv.obj(parent)
cont.set_style_bg_opa(0, 0)
cont.set_style_border_opa(0, 0)
cont.set_style_pad_all(0, 0)
cont.set_size(lv.SIZE.CONTENT, lv.SIZE.CONTENT)
cont.set_style_grid_column_dsc_array(col_dsc, 0)
cont.set_style_grid_row_dsc_array(row_dsc, 0)
cont.set_layout(lv.LAYOUT_GRID.value)
img = lv.img(cont)
img.set_src(iconPath)
img.set_grid_cell(lv.GRID_ALIGN.START, 0, 1, lv.GRID_ALIGN.CENTER, 0, 2)
self.humidityLable = lv.label(cont)
self.humidityLable.set_text("None %")
self.humidityLable.set_style_text_color(lv.color_white(), 0)
self.humidityLable.set_style_text_font(lv.font_montserrat_48, 0)
self.humidityLable.set_style_pad_all(0, 0)
self.humidityLable.set_grid_cell(lv.GRID_ALIGN.START, 2, 1, lv.GRID_ALIGN.CENTER, 0, 1)
tip = lv.label(cont)
tip.set_text(tips)
tip.set_style_text_color(lv.color_make(0xCC, 0xCC, 0xCC), 0)
tip.set_grid_cell(lv.GRID_ALIGN.START, 2, 2, lv.GRID_ALIGN.START, 1, 1)
def createInterval(self, parent, size):
interval = lv.obj(parent)
interval.set_style_bg_opa(0, 0)
interval.set_style_border_opa(0, 0)
interval.set_height(int(size))
interval.set_width(0)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/ui_lite/humiturePanel/humiturePanel.py
|
Python
|
apache-2.0
| 4,853
|
import lvgl as lv
from axp192 import *
from audio import Player
RESOURCES_ROOT = "S:/data/pyamp/"
functionImage = [
RESOURCES_ROOT + 'images/' + "prev.png",
RESOURCES_ROOT + 'images/' + "play.png",
RESOURCES_ROOT + 'images/' + "next.png",
RESOURCES_ROOT + 'images/' + "favorite.png"]
musicData = [
{
"title":"Counting Stars",
"album":"OneRepublic",
"album_url": RESOURCES_ROOT + "album_one_republic.jpg",
"url":"file://data/pyamp/long.mp3",
"duration":11,
"favorite": False
},
{
"title":"Aube",
"album":"Darius",
"album_url": RESOURCES_ROOT + "album_darius.jpg",
"url":"file://data/pyamp/spring.mp3",
"duration":155,
"favorite": False
},
]
lvglInitialized = False
currentMusic = 0
start = False
anim = None
playedTime = None
slider = None
anim_timeline = None
player = None
durationTime = 0
currentValue = 0
image = [None, None, None, None]
albumCover = None
songTitle = None
albumTitle = None
totalTime = None
def setLabelValue(label, value):
global slider
global anim
global start
global anim_timeline
global durationTime
minute = value / 60
second = value % 60
# if (slider.is_dragged() == True):
# print("drag: %d" % value)
# start = False
#
# lv.anim_timeline_stop(anim_timeline)
# lv.anim_timeline_del(anim_timeline)
# anim_timeline = None
#
# slider.set_value(value, lv.ANIM.ON)
# anim.set_time((durationTime - currentValue) * 1000)
# anim.set_values(currentValue, durationTime)
# anim_timeline = lv.anim_timeline_create()
# lv.anim_timeline_add(anim_timeline, 0, anim)
label.set_text('%02d:%02d'%(minute, second))
def setSpentTime(slider, value):
global playedTime
global currentValue
global durationTime
global image
global start
global anim_timeline
global player
global albumCover
global songTitle
global albumTitle
global totalTime
global currentMusic
global musicData
if (value >= durationTime):
# currentMusic += 1
# if (len(musicData) == currentMusic):
# currentMusic = 0
start = False
reset_music()
else:
currentValue = value
setLabelValue(playedTime, value)
slider.set_value(value, lv.ANIM.ON)
def cb(data):
print(data)
def reset_music():
global albumCover
global songTitle
global albumTitle
global totalTime
global musicData
global currentMusic
global durationTime
global slider
global anim
global image
global start
global currentValue
global anim_timeline
global playedTime
global player
if (anim_timeline != None):
lv.anim_timeline_stop(anim_timeline)
lv.anim_timeline_del(anim_timeline)
anim_timeline = None
albumCover.set_src(musicData[currentMusic]["album_url"])
songTitle.set_text(musicData[currentMusic]["title"])
albumTitle.set_text(musicData[currentMusic]["album"])
durationTime = musicData[currentMusic]["duration"]
currentValue = 0
slider.set_range(0, durationTime)
slider.set_value(0, lv.ANIM.ON)
anim.set_time(durationTime * 1000)
anim.set_values(0, durationTime)
anim_timeline = lv.anim_timeline_create()
lv.anim_timeline_add(anim_timeline, 0, anim)
setLabelValue(totalTime, durationTime)
setLabelValue(playedTime, 0)
if (player != None):
player.pause()
player.close()
player = None
if (start == False):
image[1].set_src(RESOURCES_ROOT + "images/play.png")
else:
image[1].set_src(RESOURCES_ROOT + "images/pause.png")
lv.anim_timeline_start(anim_timeline)
player = Player()
player.open()
player.play(musicData[currentMusic]["url"], sync=False)
player.on(cb)
if (musicData[currentMusic]["favorite"] == False):
image[3].set_src(RESOURCES_ROOT + "images/favorite.png")
else:
image[3].set_src(RESOURCES_ROOT + "images/favorited.png")
def controller_click_cb(e, func):
global anim
global start
global anim_timeline
global durationTime
global player
global image
global currentValue
global musicData
global currentMusic
print(func, anim_timeline)
if (func == "play"):
if (start == False):
start = True
if (currentValue == durationTime):
currentValue = 0
anim.set_time((durationTime - currentValue) * 1000)
anim.set_values(currentValue, durationTime)
anim_timeline = lv.anim_timeline_create()
lv.anim_timeline_add(anim_timeline, 0, anim)
lv.anim_timeline_start(anim_timeline)
image[1].set_src(RESOURCES_ROOT + "images/pause.png")
print('start to play')
if (player == None):
player = Player()
player.open()
player.play(musicData[currentMusic]["url"], sync=False)
player.on(cb)
else:
player.resume()
# state = player.getState()
# print(state)
# if (state == 2):
# player.resume()
# image[1].set_src(RESOURCES_ROOT + "images/pause.png")
# else:
# player.pause()
# image[1].set_src(RESOURCES_ROOT + "images/play.png")
else:
start = False
image[1].set_src(RESOURCES_ROOT + "images/play.png")
lv.anim_timeline_stop(anim_timeline)
lv.anim_timeline_del(anim_timeline)
anim_timeline = None
anim.set_time((durationTime - currentValue) * 1000)
anim.set_values(currentValue, durationTime)
anim_timeline = lv.anim_timeline_create()
lv.anim_timeline_add(anim_timeline, 0, anim)
player.pause()
print('music puaused')
elif (func == "fav"):
print('favorite pressed')
if (musicData[currentMusic]["favorite"] == False):
image[3].set_src(RESOURCES_ROOT + "images/favorited.png")
musicData[currentMusic]["favorite"] = True
else:
musicData[currentMusic]["favorite"] = False
image[3].set_src(RESOURCES_ROOT + "images/favorite.png")
elif (func == "next"):
print('switch to next song')
currentMusic += 1
if (len(musicData) == currentMusic):
currentMusic = 0
reset_music()
elif (func == "prev"):
print('switch to previous song')
currentMusic -= 1
if (currentMusic < 0):
currentMusic = len(musicData) - 1
reset_music()
class MusicPlayer:
def createPage(self):
global anim
global playedTime
global durationTime
global slider
global player
global image
global currentMusic
global albumCover
global songTitle
global albumTitle
global totalTime
global anim_timeline
global lvglInitialized
if lvglInitialized == False:
axp = Axp192()
axp.setSpkEnable(1)
import display_driver
lvglInitialized = True
print("Enter Music")
# init scr
scr = lv.obj()
win = lv.obj(scr)
win.set_size(scr.get_width(), scr.get_height())
win.set_style_border_opa(0, 0)
win.set_style_radius(0, 0)
win.set_style_bg_color(lv.color_black(), 0)
win.clear_flag(lv.obj.FLAG.SCROLLABLE)
albumCover = lv.img(win)
albumCover.set_style_pad_left(12, 0)
albumCover.set_style_pad_top(10, 0)
songTitle = lv.label(win)
songTitle.set_style_text_font(lv.font_montserrat_20, 0)
songTitle.set_style_text_color(lv.color_white(), 0)
songTitle.align_to(albumCover, lv.ALIGN.TOP_LEFT, 130, 3)
albumTitle = lv.label(win)
albumTitle.set_style_text_font(lv.font_montserrat_16, 0)
albumTitle.set_style_text_color(lv.color_make(0xCC, 0xCC, 0xCC), 0)
albumTitle.align_to(songTitle, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 12)
props = [lv.STYLE.BG_COLOR, 0]
transition_dsc = lv.style_transition_dsc_t()
transition_dsc.init(props, lv.anim_t.path_linear, 300, 0, None)
style_main = lv.style_t()
style_indicator = lv.style_t()
style_pressed_color = lv.style_t()
style_main.init()
style_main.set_bg_opa(lv.OPA.COVER)
style_main.set_bg_color(lv.color_make(0x66, 0x66, 0x66))
style_main.set_radius(lv.RADIUS.CIRCLE)
style_main.set_line_dash_width(1)
style_indicator.init()
style_indicator.set_bg_opa(lv.OPA.COVER)
style_indicator.set_bg_color(lv.color_white())
style_indicator.set_radius(lv.RADIUS.CIRCLE)
style_indicator.set_transition(transition_dsc)
style_pressed_color.init()
style_pressed_color.set_bg_color(lv.color_white())
# Create a slider and add the style
slider = lv.slider(win)
slider.remove_style_all() # Remove the styles coming from the theme
slider.add_style(style_main, lv.PART.MAIN)
slider.add_style(style_indicator, lv.PART.INDICATOR)
slider.add_style(style_pressed_color, lv.PART.INDICATOR | lv.STATE.PRESSED)
slider.align_to(albumTitle, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 25)
slider.set_size(140, 1)
anim = lv.anim_t()
anim.init()
anim.set_var(slider)
playedTime = lv.label(win)
setLabelValue(playedTime, 0)
playedTime.set_style_text_font(lv.font_montserrat_16, 0)
playedTime.set_style_text_color(lv.color_white(), 0)
playedTime.align_to(slider, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 15)
totalTime = lv.label(win)
totalTime.set_style_text_font(lv.font_montserrat_16, 0)
totalTime.set_style_text_color(lv.color_white(), 0)
totalTime.align_to(slider, lv.ALIGN.OUT_BOTTOM_RIGHT, 0, 15)
func_col_dsc = [80, 80, 80, 80, lv.GRID_TEMPLATE.LAST]
func_row_dsc = [40, lv.GRID_TEMPLATE.LAST]
funcContainer = lv.obj(win)
funcContainer.set_style_bg_opa(0x00, 0)
funcContainer.set_style_border_opa(0x00, 0)
funcContainer.set_layout(lv.LAYOUT_GRID.value)
funcContainer.set_grid_dsc_array(func_col_dsc, func_row_dsc)
funcContainer.set_grid_align(lv.GRID_ALIGN.SPACE_BETWEEN, lv.GRID_ALIGN.SPACE_BETWEEN)
funcContainer.set_align(lv.ALIGN.BOTTOM_MID)
funcContainer.set_size(320, 70)
for i in range(4):
image[i] = lv.img(funcContainer)
image[i].set_src(functionImage[i])
image[i].add_flag(lv.obj.FLAG.CLICKABLE)
image[i].set_ext_click_area(20)
image[i].set_grid_cell(lv.GRID_ALIGN.CENTER, i, 1, lv.GRID_ALIGN.CENTER, 0, 1)
if (i == 0):
image[i].add_event_cb(lambda e: controller_click_cb(e, "prev"), lv.EVENT.CLICKED, None)
elif (i == 1):
image[i].add_event_cb(lambda e: controller_click_cb(e, "play"), lv.EVENT.CLICKED, None)
elif (i == 2):
image[i].add_event_cb(lambda e: controller_click_cb(e, "next"), lv.EVENT.CLICKED, None)
elif (i == 3):
image[i].add_event_cb(lambda e: controller_click_cb(e, "fav"), lv.EVENT.CLICKED, None)
anim.set_custom_exec_cb(lambda a1, val: setSpentTime(slider, val))
reset_music()
# load content
lv.scr_load(scr)
def addToList(self, musicItem):
musicData.append(musicItem)
def removeFromList(self, musicItem):
for i in range(0, len(musicData)):
'''ignore favorite item, because it might be modified runtime'''
if musicData[i]['title'] == musicItem['title'] \
and musicData[i]['album'] == musicItem['album'] \
and musicData[i]['album_url'] == musicItem['album_url'] \
and musicData[i]['url'] == musicItem['url'] \
and musicData[i]['duration'] == musicItem['duration']:
musicData.remove(musicData[i])
break
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/ui_lite/music/music.py
|
Python
|
apache-2.0
| 12,399
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for ULN2003
Author: HaaS
Date: 2022/03/15
"""
from driver import GPIO
from utime import sleep_ms
from micropython import const
import math
class ULN2003(object):
"""
This class implements uln2003 chip's defs.
"""
def __init__(self, a, a_, b, b_):
self._a = None
self._a_ = None
self._b = None
self._b_ = None
if not isinstance(a, GPIO):
raise ValueError("parameter is not an GPIO object")
if not isinstance(a_, GPIO):
raise ValueError("parameter is not an GPIO object")
if not isinstance(b, GPIO):
raise ValueError("parameter is not an GPIO object")
if not isinstance(b_, GPIO):
raise ValueError("parameter is not an GPIO object")
# make ULN2003's internal object points to gpio
self._a = a
self._a_ = a_
self._b = b
self._b_ = b_
def motorCw(self, speed=4):
self._a.write(1)
self._a_.write(0)
self._b.write(0)
self._b_.write(0)
sleep_ms(speed)
self._a.write(0)
self._a_.write(1)
self._b.write(0)
self._b_.write(0)
sleep_ms(speed)
self._a.write(0)
self._a_.write(0)
self._b.write(1)
self._b_.write(0)
sleep_ms(speed)
self._a.write(0)
self._a_.write(0)
self._b.write(0)
self._b_.write(1)
sleep_ms(speed)
def motorCcw(self, speed=4):
self._a.write(0)
self._a_.write(0)
self._b.write(0)
self._b_.write(1)
sleep_ms(speed)
self._a.write(0)
self._a_.write(0)
self._b.write(1)
self._b_.write(0)
sleep_ms(speed)
self._a.write(0)
self._a_.write(1)
self._b.write(0)
self._b_.write(0)
sleep_ms(speed)
self._a.write(1)
self._a_.write(0)
self._b.write(0)
self._b_.write(0)
sleep_ms(speed)
def motorStop(self):
self._a.write(0)
self._a_.write(0)
self._b.write(0)
self._b_.write(0)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/uln2003/uln2003.py
|
Python
|
apache-2.0
| 2,207
|
from driver import UART
import utime
class URM37(object):
def __init__(self, uart_obj):
self.uart_obj = None
if not isinstance(uart_obj, UART):
raise ValueError("parameter is not a UART object")
self.uart_obj = uart_obj
def getRange(self):
tx_buf = bytearray([0x22, 0x00, 0x00, 0x22])
rx_buf = bytearray(4)
while True:
if self.uart_obj.read(rx_buf) <= 0:
break
self.uart_obj.write(tx_buf)
utime.sleep_ms(300)
if self.uart_obj.read(rx_buf) != 4:
return 65535
return rx_buf[1] * 256 + rx_buf[2]
def getTemperature(self):
tx_buf = bytearray([0x11, 0x00, 0x00, 0x11])
rx_buf = bytearray(4)
while True:
if self.uart_obj.read(rx_buf) <= 0:
break
self.uart_obj.write(tx_buf)
utime.sleep_ms(300)
if self.uart_obj.read(rx_buf) != 4:
return -4095.0
ret = rx_buf[1] * 256 + rx_buf[2]
if (ret & 4096) == 0:
ret = (ret & 4095) * 0.1
else:
ret = (ret & 4095) * (-0.1)
return ret
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/urm37/urm37.py
|
Python
|
apache-2.0
| 1,157
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
`HaaS Python UV sensor`
====================================================
A driver for uv sensor
* Author(s): HaaS Group
Implementation Notes
--------------------
**Hardware:**
* HaaS Python uv sensor:
https://haas.iot.aliyun.com/solution/detail/hardware
**Software and Dependencies:**
* HaaS Python API documents:
https://haas.iot.aliyun.com/haasapi/index.html#/
* HaaS Python Driver Libraries:
https://github.com/alibaba/AliOS-Things/tree/master/haas_lib_bundles/python/libraries
"""
# coding=utf-8
from driver import ADC
'''
紫外线传感器测量结果和紫外线级别对应关系
紫外线指数-x 测量电压-v（mV）
0 50
1 227
2 318
3 408
4 503
5 606
6 696
7 798
8 881
9 976
10 1079
11 1170
拟合曲线：
{v} = a{x}+b
用1:227和11:1170进行拟合，a = 94.3, b = 132.7
则x = ({v}-b)/a
'''
from driver import ADC
class UV(object):
def __init__(self, adcObj):
self.adcObj = None
if not isinstance(adcObj, ADC):
raise ValueError("parameter is not an ADC object")
self.adcObj = adcObj
# 量测紫外线强度，返回值：UV强度值，范围[0-11]
def measureUVLevel(self):
if self.adcObj is None:
raise ValueError("invalid ADC object")
value = 0
total = 0
i = 0
for i in range(30):
value = self.adcObj.readVoltage()
total += value
# print(value)
V = total / 30
UVLevel=(V - 132.7)/94.3
print(UVLevel)
if UVLevel <= 0:
UVLevel = 0
if UVLevel >= 11:
UVLevel = 11
return round(UVLevel, 0)
if __name__ == "__main__":
import utime
adcObj = ADC()
adcObj.open("uvSensor")
print('Measuring UV level , press Ctrl-C to quit...')
UVDev = UV(adcObj)
while True:
uvLevel = UVDev.measureUVLevel()
print('UVLevel:', uvLevel)
utime.sleep(1)
adcObj.close()
del UVDev
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/uv/uv.py
|
Python
|
apache-2.0
| 2,047
|
from driver import GPIO
class VibrationSensor():
def __init__(self, gpioObj):
self.gpioObj = None
if not isinstance(gpioObj, GPIO):
raise ValueError("parameter is not a GPIO object")
self.gpioObj = gpioObj
def isVibrating(self):
if self.gpioObj is None:
raise ValueError("invalid GPIO object")
value = self.gpioObj.read()
return value
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/vibration_sensor/vibrationSensor.py
|
Python
|
apache-2.0
| 420
|
from driver import ADC
class WATER4LEVEL(object):
def __init__(self, adcObj):
self.adcObj = None
if not isinstance(adcObj, ADC):
raise ValueError("parameter is not an ADC object")
self.adcObj = adcObj
def measureLevel(self):
if self.adcObj is None:
raise ValueError("invalid ADC object")
value = self.adcObj.readVoltage()
if value >= 0 and value < 800:
return 0
elif value >= 800 and value < 1100:
return 1
elif value >= 1100 and value < 1300:
return 2
elif value >= 1300 and value < 1400:
return 3
elif value >= 1400:
return 4
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/waterlevel/water4level.py
|
Python
|
apache-2.0
| 704
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
HaaS Python driver for ws2812
Author: HaaS
Date: 2022/05/10
"""
from driver import GPIO
from machine import Pin
from neopixel import NeoPixel
import utime
br = 1.0
class WS2812(object):
def __init__(self,gpioObj,led_pixel=24):
self.port_num = None
if not isinstance(gpioObj, GPIO):
raise ValueError("parameter is not an GPIO object")
self.port_num = gpioObj.port()
self.led_pixel = led_pixel
self.pin = Pin(self.port_num, Pin.OUT)
self.np = NeoPixel(self.pin, self.led_pixel)
def set(self,r,g,b,index=0):
if index >= self.led_pixel:
raise ValueError("index is too large")
self.np[index] = (r,g,b)
self.np.write()
def dot(self,r,g,b,t):
r=int(br*r)
g=int(br*g)
b=int(br*b)
for i in range(0,self.led_pixel):
self.clear_array()
self.np[i] = (r,g,b)
self.np.write()
utime.sleep_ms(t)
def rainbow(self,t):
r=100
g=0
b=0
for c in range(0,50):
g=g+2
for i in range(0,self.led_pixel):
self.np[i] = (r,g,b)
self.np.write()
utime.sleep_us(t)
for c in range(0,50):
r=r-2
for i in range(0,self.led_pixel):
self.np[i] = (r,g,b)
self.np.write()
utime.sleep_us(t)
for c in range(0,50):
b=b+2
for i in range(0,self.led_pixel):
self.np[i] = (r,g,b)
self.np.write()
utime.sleep_us(t)
for c in range(0,50):
g=g-2
for i in range(0,self.led_pixel):
self.np[i] = (r,g,b)
self.np.write()
utime.sleep_us(t)
for c in range(0,50):
r=r+2
for i in range(0,self.led_pixel):
self.np[i] = (r,g,b)
self.np.write()
utime.sleep_us(t)
for c in range(0,50):
b=b-2
for i in range(0,self.led_pixel):
self.np[i] = (r,g,b)
self.np.write()
utime.sleep_us(t)
def wipe(self,r,g,b,t):
r=int(br*r)
g=int(br*g)
b=int(br*b)
self.clear_array()
for i in range(0,self.led_pixel):
self.np[i] = (r,g,b)
self.np.write()
utime.sleep_ms(t)
def clear_array(self):
for i in range(0,self.led_pixel):
self.np[i] = (0,0,0)
def clear(self,index=None):
if index == None:
for i in range(0,self.led_pixel):
self.np[i] = (0,0,0)
if index >= self.led_pixel:
raise ValueError("index is too large")
else:
self.np[index] = (0,0,0)
self.np.write()
# h-(0,23) m-(0,59)
def timeShowCircle(self,pr,pg,pb,h,m):
r=int(br*pr)
g=int(br*pg)
b=int(br*pb)
ha = 0
ma = 0
if m == 0:
ha = (h%12)*2
ma = 0
else:
ha = (h%12)*2 + 1
ma = int(m/2.5)
self.clear_array()
for i in range(0,self.led_pixel-2):
if i != ha and i != ma:
self.np[i] = (r,g,b)
if (i+1) != ha and (i+1) != ma:
self.np[i+1] = (r,g,b)
if (i+2) != ha and (i+2) != ma:
self.np[i+2] = (r,g,b)
self.np[ha] = (200,0,0)
self.np[ma] = (0,200,0)
self.np.write()
if i != ha and i != ma:
self.np[i] = (0,0,0)
utime.sleep_ms(41)
# h-(0,23) m-(0,59)
def timeShow(self,pr,pg,pb,h,m,s):
r=int(br*pr)
g=int(br*pg)
b=int(br*pb)
ha = 0
ma = 0
if m == 0 or m < 30:
ha = (h%12)*2
if m == 0:
ma = 0
else:
ma = int(m/2.5)
else:
ha = (h%12)*2 + 1
ma = int(m/2.5)+1
self.clear_array()
i = int(s/2.5)
if i != ha and i != ma:
self.np[i] = (r,g,b)
if (i+1) != ha and (i+1) != ma and i<self.led_pixel-1:
self.np[i+1] = (r,g,b)
if (i+2) != ha and (i+2) != ma and i<self.led_pixel-2:
self.np[i+2] = (r,g,b)
if i == 22:
self.np[0] = (r,g,b)
if i == 23:
self.np[0] = (r,g,b)
self.np[1] = (r,g,b)
if ha != ma:
self.np[ha] = (200,0,0)
if ma==24:
self.np[0] = (0,0,200)
else:
self.np[ma] = (0,0,200)
else:
self.np[ma] = (200,0,200)
self.np.write()
if i != ha and i != ma:
self.np[i] = (0,0,0)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/ws2812/ws2812.py
|
Python
|
apache-2.0
| 4,874
|
class ZZIO606(object):
def __init__(self, mbObj, devAddr):
self.mbObj = mbObj
self.devAddr = devAddr
def openChannel(self, chid):
if self.mbObj is None:
raise ValueError("invalid modbus object.")
ret = self.mbObj.writeCoil(self.devAddr, chid, 0xff00, 200)
return ret[0]
def closeChannel(self, chid):
if self.mbObj is None:
raise ValueError("invalid modbus object.")
ret = self.mbObj.writeCoil(self.devAddr, chid, 0, 200)
return ret[0]
def getChannelStatus(self):
if self.mbObj is None:
raise ValueError("invalid modbus object.")
status = bytearray(1)
ret = self.mbObj.readCoils(self.devAddr, 0, 6, status, 200)
if ret[0] < 0:
raise ValueError("modbus readCoils failed, errno:", ret[0])
return status
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/libraries/zzio606/zzio606.py
|
Python
|
apache-2.0
| 880
|
#include <k_config.h>
;******************************************************************************
; EXTERN PARAMETERS
;******************************************************************************
EXTERN g_active_task
EXTERN g_preferred_ready_task
EXTERN krhino_stack_ovf_check
EXTERN krhino_task_sched_stats_get
;******************************************************************************
; EXPORT FUNCTIONS
;******************************************************************************
EXPORT cpu_intrpt_save
EXPORT cpu_intrpt_restore
EXPORT cpu_task_switch
EXPORT cpu_intrpt_switch
EXPORT cpu_first_task_start
EXPORT PendSV_Handler
EXPORT _first_task_restore
;******************************************************************************
; EQUATES
;******************************************************************************
SCB_ICSR EQU 0xE000ED04 ; Interrupt Control and State Register.
SCB_VTOR EQU 0xE000ED08 ; Vector Table Offset Register.
ICSR_PENDSVSET EQU 0x10000000 ; Value to trigger PendSV exception.
SHPR3_PRI_14 EQU 0xE000ED22 ; System Handler Priority Register 3 (PendSV).
PRI_LVL_PENDSV EQU 0xFF ; PendSV priority level (lowest).
SHPR3_PRI_15 EQU 0xE000ED23 ; System Handler Priority Register 3 (SysTick).
PRI_LVL_SYSTICK EQU 0xFF ; SYstick priority level (lowest).
;******************************************************************************
; CODE GENERATION DIRECTIVES
;******************************************************************************
AREA |.text|, CODE, READONLY, ALIGN=2
THUMB
REQUIRE8
PRESERVE8
;******************************************************************************
; Functions:
; size_t cpu_intrpt_save(void);
; void cpu_intrpt_restore(size_t cpsr);
;******************************************************************************
cpu_intrpt_save
MRS R0, PRIMASK
CPSID I
BX LR
cpu_intrpt_restore
MSR PRIMASK, R0
BX LR
;******************************************************************************
; Functions:
; void cpu_intrpt_switch(void);
; void cpu_task_switch(void);
;******************************************************************************
cpu_task_switch
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
BX LR
cpu_intrpt_switch
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
BX LR
;******************************************************************************
; Functions:
; void cpu_first_task_start(void);
;******************************************************************************
cpu_first_task_start
;set PendSV prority to the lowest
LDR R0, =SHPR3_PRI_14
LDR R1, =PRI_LVL_PENDSV
STRB R1, [R0]
;set Systick prority to the lowest
LDR R0, =SHPR3_PRI_15
LDR R1, =PRI_LVL_SYSTICK
STRB R1, [R0]
;indicate PendSV_Handler branch to _pendsv_handler_nosave
MOVS R0, #0
MSR PSP, R0
;make PendSV exception pending
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
;goto PendSV_Handler
CPSIE I
B .
;******************************************************************************
; Functions:
; void krhino_pendsv_handler(void);
;******************************************************************************
PendSV_Handler
CPSID I
MRS R0, PSP
;branch if cpu_first_task_start
CMP R0, #0
BEQ _first_task_restore
;hardware saved R0~R3,R12,LR,PC,xPSR
;save context
SUBS R0, R0, #0x24
STM R0, {R4-R11, LR}
;g_active_task->task_stack = context region
LDR R1, =g_active_task
LDR R1, [R1]
STR R0, [R1]
#if (RHINO_CONFIG_TASK_STACK_OVF_CHECK > 0)
BL krhino_stack_ovf_check
#endif
#if (RHINO_CONFIG_SYS_STATS > 0)
BL krhino_task_sched_stats_get
#endif
_pendsv_handler_nosave
LDR R0, =g_active_task
LDR R1, =g_preferred_ready_task
LDR R2, [R1]
STR R2, [R0]
;R0 = g_active_task->task_stack = context region
LDR R0, [R2]
;restore context
LDM R0, {R4-R11, LR}
ADDS R0, R0, #0x24
;return stack = PSP
MSR PSP, R0
CPSIE I
;hardware restore R0~R3,R12,LR,PC,xPSR
BX LR
_first_task_restore
;set MSP to the base of system stack
LDR R0, =SCB_VTOR
LDR R0, [R0]
LDR R0, [R0]
MSR MSP, R0
B _pendsv_handler_nosave
ALIGN
END
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/armcc/m3/port_s.S
|
Motorola 68K Assembly
|
apache-2.0
| 4,801
|
#include <k_config.h>
;******************************************************************************
; EXTERN PARAMETERS
;******************************************************************************
EXTERN g_active_task
EXTERN g_preferred_ready_task
EXTERN krhino_stack_ovf_check
EXTERN krhino_task_sched_stats_get
;******************************************************************************
; EXPORT FUNCTIONS
;******************************************************************************
EXPORT cpu_intrpt_save
EXPORT cpu_intrpt_restore
EXPORT cpu_task_switch
EXPORT cpu_intrpt_switch
EXPORT cpu_first_task_start
EXPORT PendSV_Handler
EXPORT _first_task_restore
;******************************************************************************
; EQUATES
;******************************************************************************
SCB_ICSR EQU 0xE000ED04 ; Interrupt Control and State Register.
SCB_VTOR EQU 0xE000ED08 ; Vector Table Offset Register.
ICSR_PENDSVSET EQU 0x10000000 ; Value to trigger PendSV exception.
SHPR3_PRI_14 EQU 0xE000ED22 ; System Handler Priority Register 3 (PendSV).
PRI_LVL_PENDSV EQU 0xFF ; PendSV priority level (lowest).
SHPR3_PRI_15 EQU 0xE000ED23 ; System Handler Priority Register 3 (SysTick).
PRI_LVL_SYSTICK EQU 0xFF ; SYstick priority level (lowest).
;******************************************************************************
; CODE GENERATION DIRECTIVES
;******************************************************************************
AREA |.text|, CODE, READONLY, ALIGN=2
THUMB
REQUIRE8
PRESERVE8
;******************************************************************************
; Functions:
; size_t cpu_intrpt_save(void);
; void cpu_intrpt_restore(size_t cpsr);
;******************************************************************************
cpu_intrpt_save
MRS R0, PRIMASK
CPSID I
BX LR
cpu_intrpt_restore
MSR PRIMASK, R0
BX LR
;******************************************************************************
; Functions:
; void cpu_intrpt_switch(void);
; void cpu_task_switch(void);
;******************************************************************************
cpu_task_switch
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
BX LR
cpu_intrpt_switch
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
BX LR
;******************************************************************************
; Functions:
; void cpu_first_task_start(void);
;******************************************************************************
cpu_first_task_start
;set PendSV prority to the lowest
LDR R0, =SHPR3_PRI_14
LDR R1, =PRI_LVL_PENDSV
STRB R1, [R0]
;set Systick prority to the lowest
LDR R0, =SHPR3_PRI_15
LDR R1, =PRI_LVL_SYSTICK
STRB R1, [R0]
;indicate PendSV_Handler branch to _pendsv_handler_nosave
MOVS R0, #0
MSR PSP, R0
;make PendSV exception pending
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
;goto PendSV_Handler
CPSIE I
B .
;******************************************************************************
; Functions:
; void krhino_pendsv_handler(void);
;******************************************************************************
PendSV_Handler
CPSID I
MRS R0, PSP
;branch if cpu_first_task_start
CMP R0, #0
BEQ _first_task_restore
;hardware saved R0~R3,R12,LR,PC,xPSR
;save context
IF {FPU} != "SoftVFP"
;if the switchout task use FPU, save the FPU regs
TST LR, #0x10
IT EQ
VSTMFDEQ R0!, {D8 - D15}
;hardware saved D0~D7, FPSCR
ENDIF
SUBS R0, R0, #0x24
STM R0, {R4-R11, LR}
;g_active_task->task_stack = context region
LDR R1, =g_active_task
LDR R1, [R1]
STR R0, [R1]
#if (RHINO_CONFIG_TASK_STACK_OVF_CHECK > 0)
BL krhino_stack_ovf_check
#endif
#if (RHINO_CONFIG_SYS_STATS > 0)
BL krhino_task_sched_stats_get
#endif
_pendsv_handler_nosave
LDR R0, =g_active_task
LDR R1, =g_preferred_ready_task
LDR R2, [R1]
STR R2, [R0]
;R0 = g_active_task->task_stack = context region
LDR R0, [R2]
;restore context
LDM R0, {R4-R11, LR}
ADDS R0, R0, #0x24
IF {FPU} != "SoftVFP"
;if the switchin task use FPU, save the FPU regs
TST LR, #0x10
IT EQ
VLDMFDEQ R0!, {D8 - D15}
;hardware will restore D0~D7, FPSCR
ENDIF
;return stack = PSP
MSR PSP, R0
CPSIE I
;hardware restore R0~R3,R12,LR,PC,xPSR
BX LR
_first_task_restore
;set MSP to the base of system stack
LDR R0, =SCB_VTOR
LDR R0, [R0]
LDR R0, [R0]
MSR MSP, R0
B _pendsv_handler_nosave
ALIGN
END
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/armcc/m4/port_s.S
|
Motorola 68K Assembly
|
apache-2.0
| 5,196
|
#include <k_config.h>
;******************************************************************************
; EXTERN PARAMETERS
;******************************************************************************
EXTERN g_active_task
EXTERN g_preferred_ready_task
EXTERN krhino_stack_ovf_check
EXTERN krhino_task_sched_stats_get
;******************************************************************************
; EXPORT FUNCTIONS
;******************************************************************************
EXPORT cpu_intrpt_save
EXPORT cpu_intrpt_restore
EXPORT cpu_task_switch
EXPORT cpu_intrpt_switch
EXPORT cpu_first_task_start
EXPORT PendSV_Handler
EXPORT _first_task_restore
;******************************************************************************
; EQUATES
;******************************************************************************
SCB_ICSR EQU 0xE000ED04 ; Interrupt Control and State Register.
SCB_VTOR EQU 0xE000ED08 ; Vector Table Offset Register.
ICSR_PENDSVSET EQU 0x10000000 ; Value to trigger PendSV exception.
SHPR3_PRI_14 EQU 0xE000ED22 ; System Handler Priority Register 3 (PendSV).
PRI_LVL_PENDSV EQU 0xFF ; PendSV priority level (lowest).
SHPR3_PRI_15 EQU 0xE000ED23 ; System Handler Priority Register 3 (SysTick).
PRI_LVL_SYSTICK EQU 0xFF ; SYstick priority level (lowest).
;******************************************************************************
; CODE GENERATION DIRECTIVES
;******************************************************************************
AREA |.text|, CODE, READONLY, ALIGN=2
THUMB
REQUIRE8
PRESERVE8
;******************************************************************************
; Functions:
; size_t cpu_intrpt_save(void);
; void cpu_intrpt_restore(size_t cpsr);
;******************************************************************************
cpu_intrpt_save
MRS R0, PRIMASK
CPSID I
BX LR
cpu_intrpt_restore
MSR PRIMASK, R0
BX LR
;******************************************************************************
; Functions:
; void cpu_intrpt_switch(void);
; void cpu_task_switch(void);
;******************************************************************************
cpu_task_switch
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
BX LR
cpu_intrpt_switch
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
BX LR
;******************************************************************************
; Functions:
; void cpu_first_task_start(void);
;******************************************************************************
cpu_first_task_start
;set PendSV prority to the lowest
LDR R0, =SHPR3_PRI_14
LDR R1, =PRI_LVL_PENDSV
STRB R1, [R0]
;set Systick prority to the lowest
LDR R0, =SHPR3_PRI_15
LDR R1, =PRI_LVL_SYSTICK
STRB R1, [R0]
;indicate PendSV_Handler branch to _pendsv_handler_nosave
MOVS R0, #0
MSR PSP, R0
;make PendSV exception pending
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
;goto PendSV_Handler
CPSIE I
B .
;******************************************************************************
; Functions:
; void krhino_pendsv_handler(void);
;******************************************************************************
PendSV_Handler
CPSID I
MRS R0, PSP
;branch if cpu_first_task_start
CMP R0, #0
BEQ _first_task_restore
;hardware saved R0~R3,R12,LR,PC,xPSR
;save context
IF {FPU} != "SoftVFP"
;if the switchout task use FPU, save the FPU regs
TST LR, #0x10
IT EQ
VSTMFDEQ R0!, {D8 - D15}
;hardware saved D0~D7, FPSCR
ENDIF
SUBS R0, R0, #0x24
STM R0, {R4-R11, LR}
;g_active_task->task_stack = context region
LDR R1, =g_active_task
LDR R1, [R1]
STR R0, [R1]
#if (RHINO_CONFIG_TASK_STACK_OVF_CHECK > 0)
BL krhino_stack_ovf_check
#endif
#if (RHINO_CONFIG_SYS_STATS > 0)
BL krhino_task_sched_stats_get
#endif
_pendsv_handler_nosave
LDR R0, =g_active_task
LDR R1, =g_preferred_ready_task
LDR R2, [R1]
STR R2, [R0]
;R0 = g_active_task->task_stack = context region
LDR R0, [R2]
;restore context
LDM R0, {R4-R11, LR}
ADDS R0, R0, #0x24
IF {FPU} != "SoftVFP"
;if the switchin task use FPU, save the FPU regs
TST LR, #0x10
IT EQ
VLDMFDEQ R0!, {D8 - D15}
;hardware will restore D0~D7, FPSCR
ENDIF
;return stack = PSP
MSR PSP, R0
CPSIE I
;hardware restore R0~R3,R12,LR,PC,xPSR
BX LR
_first_task_restore
;set MSP to the base of system stack
LDR R0, =SCB_VTOR
LDR R0, [R0]
LDR R0, [R0]
MSR MSP, R0
B _pendsv_handler_nosave
ALIGN
END
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/armcc/m7/port_s.S
|
Motorola 68K Assembly
|
apache-2.0
| 5,196
|
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <limits.h>
#include <stdio.h>
#include "k_api.h"
/* part of ktask_t */
typedef struct
{
void *task_stack;
}ktask_t_shadow;
//#define OS_BACKTRACE_DEBUG
extern void krhino_task_deathbed(void);
extern ktask_t_shadow *debug_task_find(char *name);
extern int debug_task_is_running(ktask_t_shadow *task);
extern void *debug_task_stack_bottom(ktask_t_shadow *task);
extern char *k_int2str(int num, char *str);
void backtrace_handle(char *PC, int *SP, char *LR, int (*print_func)(const char *fmt, ...));
#if defined(__CC_ARM)
#ifdef __BIG_ENDIAN
#error "Not support big-endian!"
#endif
#elif defined(__ICCARM__)
#if (__LITTLE_ENDIAN__ == 0)
#error "Not support big-endian!"
#endif
#elif defined(__GNUC__)
#if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
#error "Not support big-endian!"
#endif
#endif
#define BT_FUNC_LIMIT 0x2000
#define BT_LVL_LIMIT 64
#define BT_PC2ADDR(pc) ((char *)(((uintptr_t)(pc)) & 0xfffffffe))
/* alios_debug_pc_check depends on mcu*/
__attribute__((weak)) int alios_debug_pc_check(char *pc)
{
return 0;
}
#if defined(__ICCARM__)
static unsigned int __builtin_popcount(unsigned int u)
{
unsigned int ret = 0;
while (u) {
u = (u & (u - 1));
ret++;
}
return ret;
}
#endif
void getPLSfromCtx(void *context, char **PC, char **LR, int **SP)
{
int *ptr = context;
int exc_return;
/* reference to cpu_task_stack_init */
exc_return = ptr[8];
if ((exc_return & 0x10) == 0x10) {
*PC = (char *)ptr[15];
*LR = (char *)ptr[14];
*SP = ptr + 17;
} else {
*PC = (char *)ptr[31];
*LR = (char *)ptr[30];
*SP = ptr + 51;
}
}
/* get "blx" or "bl" before LR, return offset */
static int backtraceFindLROffset(char *LR,
int (*print_func)(const char *fmt, ...))
{
unsigned short ins16;
char s_panic_call[] = "backtrace : 0x \r\n";
LR = BT_PC2ADDR(LR);
/* callstack bottom */
if (((int)LR & 0xffffffe0) == 0xffffffe0) {
/* EXC_RETURN, so here is callstack bottom of interrupt handler */
if (print_func != NULL) {
print_func("backtrace : ^interrupt^\r\n");
}
return 0;
}
if (LR == BT_PC2ADDR(&krhino_task_deathbed)) {
/* task delete, so here is callstack bottom of task */
if (print_func != NULL) {
print_func("backtrace : ^task entry^\r\n");
}
return 0;
}
if (alios_debug_pc_check(LR) != 0) {
if (print_func) {
print_func("backtrace : invalid pc : 0x%x\r\n", LR);
}
return -1;
}
ins16 = *(unsigned short *)(LR - 4);
if ((ins16 & 0xf000) == 0xf000) {
if (print_func != NULL) {
k_int2str((int)LR - 4, &s_panic_call[14]);
print_func(s_panic_call);
}
return 5;
} else {
if (print_func != NULL) {
k_int2str((int)LR - 2, &s_panic_call[14]);
print_func(s_panic_call);
}
return 3;
}
}
/* find current function caller, update PC and SP
returns: 0 success
1 success and find buttom
-1 fail */
static int backtraceFromStack(int **pSP, char **pPC,
int (*print_func)(const char *fmt, ...))
{
char *CodeAddr = NULL;
int *SP = *pSP;
char *PC = *pPC;
char *LR;
int i;
unsigned short ins16;
unsigned int ins32;
unsigned int framesize = 0;
unsigned int shift = 0;
unsigned int sub = 0;
unsigned int offset = 1;
#ifdef OS_BACKTRACE_DEBUG
printf("[backtraceFromStack in ] SP = %p, PC = %p\n\r", *pSP, *pPC);
#endif
if (SP == debug_task_stack_bottom(NULL)) {
if (print_func != NULL) {
print_func("backtrace : ^task entry^\r\n");
}
return 1;
}
if (alios_debug_pc_check(*pPC) != 0) {
if (print_func) {
print_func("backtrace : invalid pc : 0x%x\r\n", *pPC);
}
return -1;
}
/* func call ways:
1. "stmdb sp!, ..." or "push ..." to open stack frame and save LR
2. "sub sp, ..." or "sub.w sp, ..." to open stack more
3. call
*/
/* 1. scan code, find frame size from "push" or "stmdb sp!" */
for (i = 2; i < BT_FUNC_LIMIT; i += 2) {
/* find nearest "push {..., lr}" */
ins16 = *(unsigned short *)(PC - i);
if ((ins16 & 0xff00) == 0xb500) {
framesize = __builtin_popcount((unsigned char)ins16);
framesize++;
/* find double push */
ins16 = *(unsigned short *)(PC - i - 2);
if ((ins16 & 0xff00) == 0xb400) {
offset += __builtin_popcount((unsigned char)ins16);
framesize += __builtin_popcount((unsigned char)ins16);
}
CodeAddr = PC - i;
break;
}
/* find "stmdb sp!, ..." */
/* The Thumb instruction stream is a sequence of halfword-aligned
* halfwords */
ins32 = *(unsigned short *)(PC - i);
ins32 <<= 16;
ins32 |= *(unsigned short *)(PC - i + 2);
if ((ins32 & 0xFFFFF000) == 0xe92d4000) {
framesize = __builtin_popcount(ins32 & 0xfff);
framesize++;
CodeAddr = PC - i;
break;
}
}
if (CodeAddr == NULL) {
/* error branch */
if (print_func != NULL) {
print_func("Backtrace fail!\r\n");
}
return -1;
}
/* 2. scan code, find frame size from "sub" or "sub.w" */
for (i = 0; i < BT_FUNC_LIMIT;) {
if (CodeAddr + i > PC) {
break;
}
/* find "sub sp, ..." */
ins16 = *(unsigned short *)(CodeAddr + i);
if ((ins16 & 0xff80) == 0xb080) {
framesize += (ins16 & 0x7f);
break;
}
/* find "sub.w sp, sp, ..." */
ins32 = *(unsigned short *)(CodeAddr + i);
ins32 <<= 16;
ins32 |= *(unsigned short *)(CodeAddr + i + 2);
if ((ins32 & 0xFBFF8F00) == 0xF1AD0D00) {
sub = 128 + (ins32 & 0x7f);
shift = (ins32 >> 7) & 0x1;
shift += ((ins32 >> 12) & 0x7) << 1;
shift += ((ins32 >> 26) & 0x1) << 4;
framesize += sub << (30 - shift);
break;
}
if ((ins16 & 0xf800) >= 0xe800) {
i += 4;
} else {
i += 2;
}
}
#ifdef OS_BACKTRACE_DEBUG
printf("[backtraceFromStack out] frsz = %d offset = %d SP=%p\n\r", framesize, offset, SP);
#endif
/* 3. output */
LR = (char *)*(SP + framesize - offset);
offset = backtraceFindLROffset(LR, print_func);
if (offset < 0) {
return -1;
}
*pSP = SP + framesize;
*pPC = LR - offset;
return offset == 0 ? 1 : 0;
}
/* find current function caller, update PC and SP
returns: 0 success
1 success and find buttom
-1 fail */
static int backtraceFromLR(int **pSP, char **pPC, char *LR,
int (*print_func)(const char *fmt, ...))
{
int *SP = *pSP;
char *PC = *pPC;
char *CodeAddr = NULL;
int i;
unsigned short ins16;
unsigned int framesize = 0;
unsigned int offset;
#ifdef OS_BACKTRACE_DEBUG
printf("[backtraceFromLR in ] SP = %p, PC = %p, LR = %p\n\r", *pSP, *pPC, LR);
#endif
if (alios_debug_pc_check(*pPC) != 0) {
offset = backtraceFindLROffset(LR, print_func);
if ( offset < 0 ){
return -1;
}
PC = LR - offset;
*pPC = PC;
return offset == 0 ? 1 : 0;
}
/*find stack framesize:
1. "push ..." to open stack
2. "sub sp, ..." to open stack
3. 1 + 2
4. do not open stack
*/
/* 1. scan code, find frame size from "push" or "sub" */
for (i = 2; i < BT_FUNC_LIMIT; i += 2) {
ins16 = *(unsigned short *)(PC - i);
/* find "push {..., lr}" */
if ((ins16 & 0xff00) == 0xb500) {
/* another function */
break;
}
/* find "push {...}" */
if ((ins16 & 0xff00) == 0xb400) {
framesize = __builtin_popcount((unsigned char)ins16);
CodeAddr = PC - i;
break;
}
/* find "sub sp, ..." */
if ((ins16 & 0xff80) == 0xb080) {
framesize = (ins16 & 0x7f);
CodeAddr = PC - i;
/* find push before sub */
ins16 = *(unsigned short *)(PC - i - 2);
if ((ins16 & 0xff00) == 0xb400) {
framesize += __builtin_popcount((unsigned char)ins16);
CodeAddr = PC - i - 2;
}
break;
}
}
/* 2. check the "push" or "sub sp" belongs to another function */
if (CodeAddr != NULL) {
for (i = 2; i < PC - CodeAddr; i += 2) {
ins16 = *(unsigned short *)(PC - i);
/* find "pop {..., pc}" or "bx lr" */
if ((ins16 & 0xff00) == 0xbd00 || ins16 == 0x4770) {
/* SP no changed */
framesize = 0;
}
}
} /* else: SP no changed */
#ifdef OS_BACKTRACE_DEBUG
printf("[backtraceFromLR out] frsz = %d offset = %d SP=%p\n\r", framesize, offset, SP);
#endif
/* 3. output */
offset = backtraceFindLROffset(LR, print_func);
if ( offset < 0 ){
return -1;
}
*pSP = SP + framesize;
*pPC = LR - offset;
return offset == 0 ? 1 : 0;
}
/* printf call stack
return levels of call stack */
int backtrace_now(int (*print_func)(const char *fmt, ...))
{
char *PC;
int *SP;
int lvl;
int ret;
if (print_func == NULL) {
print_func = printf;
}
/* compiler specific */
#if defined(__CC_ARM)
SP = (int *)__current_sp();
PC = (char *)__current_pc();
#elif defined(__ICCARM__)
asm volatile("mov %0, sp\n" : "=r"(SP));
asm volatile("mov %0, pc\n" : "=r"(PC));
#elif defined(__GNUC__)
__asm__ volatile("mov %0, sp\n" : "=r"(SP));
__asm__ volatile("mov %0, pc\n" : "=r"(PC));
#endif
print_func("========== Call stack ==========\r\n");
for (lvl = 0; lvl < BT_LVL_LIMIT; lvl++) {
ret = backtraceFromStack(&SP, &PC, print_func);
if (ret != 0) {
break;
}
}
print_func("========== End ==========\r\n");
return lvl;
}
/* printf call stack for task
return levels of call stack */
void backtrace_task(void *task, int (*print_func)(const char *fmt, ...))
{
char *PC;
char *LR;
int *SP;
int lvl = 0;
int ret;
char panic_call[] = "backtrace : 0x \r\n";
//ktask_t_shadow *task;
if (print_func == NULL) {
print_func = printf;
}
getPLSfromCtx(((ktask_t *)task)->task_stack, &PC, &LR, &SP);
#ifdef OS_BACKTRACE_DEBUG
printf("[backtrace_task] SP = %p, PC = %p, LR = %p\r\n", SP, PC, LR);
#endif
print_func("========== Call stack ==========\r\n");
k_int2str((int)BT_PC2ADDR(PC), &panic_call[14]);
if (print_func != NULL) {
print_func(panic_call);
}
ret = debug_task_is_running(task);
switch (ret) {
case 0 :
case 1 :
case 2 :
backtrace_handle(PC, SP, LR, print_func);
break;
default:
print_func("Status of task \"%s\" is 'Running', Can not backtrace!\n",
((ktask_t *)task)->task_name ? ((ktask_t *)task)->task_name : "anonym");
break;
}
print_func("========== End ==========\r\n");
}
/* backtrace start with PC and SP, find LR from stack memory
return levels of call stack */
int backtrace_caller(char *PC, int *SP,
int (*print_func)(const char *fmt, ...))
{
int *bt_sp;
char *bt_pc;
int lvl, ret;
char s_panic_call[] = "backtrace : 0x \r\n";
/* caller must save LR in stack, so find LR from stack */
if (SP == NULL) {
return 0;
}
/* try with no LR */
bt_sp = SP;
bt_pc = BT_PC2ADDR(PC);
ret = -1;
for (lvl = 0; lvl < BT_LVL_LIMIT; lvl++) {
ret = backtraceFromStack(&bt_sp, &bt_pc, NULL);
if (ret != 0) {
break;
}
}
if (ret == 1) {
/* try success, output */
k_int2str((int)PC, &s_panic_call[14]);
if (print_func != NULL) {
print_func(s_panic_call);
}
bt_sp = SP;
bt_pc = PC;
ret = -1;
for (lvl = 1; lvl < BT_LVL_LIMIT; lvl++) {
ret = backtraceFromStack(&bt_sp, &bt_pc, print_func);
if (ret != 0) {
break;
}
}
return lvl;
}
return 0;
}
/* backtrace start with PC SP and LR
return levels of call stack */
int backtrace_callee(char *PC, int *SP, char *LR,
int (*print_func)(const char *fmt, ...))
{
int *bt_sp;
char *bt_pc;
char *bt_lr;
int lvl, ret;
char s_panic_call[] = "backtrace : 0x \r\n";
if (SP == NULL) {
return 0;
}
/* Backtrace: assume ReturnAddr is saved in LR when exception */
k_int2str((int)PC, &s_panic_call[14]);
if (print_func != NULL) {
print_func(s_panic_call);
}
lvl = 1;
bt_sp = SP;
bt_pc = PC;
bt_lr = LR;
/* try, with LR */
ret = backtraceFromLR(&bt_sp, &bt_pc, bt_lr, print_func);
if (ret == 0) {
for (; lvl < BT_LVL_LIMIT; lvl++) {
ret = backtraceFromStack(&bt_sp, &bt_pc, print_func);
if (ret != 0) {
break;
}
}
}
return lvl;
}
void *g_back_trace;
/**
Get call stack, return levels of call stack
trace[] output buffer
size buffer size
offset which lvl start
*/
int backtrace_now_get(void *trace[], int size, int offset)
{
char *PC;
int *SP;
int lvl;
int ret;
/* compiler specific */
#if defined(__CC_ARM)
SP = (int *)__current_sp();
PC = (char *)__current_pc();
#elif defined(__ICCARM__)
asm volatile("mov %0, sp\n" : "=r"(SP));
asm volatile("mov %0, pc\n" : "=r"(PC));
#elif defined(__GNUC__)
__asm__ volatile("mov %0, sp\n" : "=r"(SP));
__asm__ volatile("mov %0, pc\n" : "=r"(PC));
#endif
memset(trace, 0, size*sizeof(void *));
g_back_trace = trace;
for (lvl = 0; lvl < BT_LVL_LIMIT; lvl++) {
ret = backtraceFromStack(&SP, &PC, NULL);
if (ret != 0) {
break;
}
if (lvl >= offset && lvl - offset < size) {
trace[lvl - offset] = PC;
}
if (lvl - offset >= size) {
break;
}
}
return lvl - offset < 0 ? 0 : lvl - offset;
}
void backtrace_handle(char *PC, int *SP, char *LR,
int (*print_func)(const char *fmt, ...))
{
if (SP == NULL) {
print_func("SP is NULL, Can't backtrace\r\n");
return;
}
if (backtrace_caller(PC, SP, print_func) > 0) {
/* Backtrace 1st try: assume ReturnAddr is saved in stack when exception */
/* backtrace success, do not try other way */
goto exit;
} else if (backtrace_callee(PC, SP, LR, print_func) > 0) {
/* Backtrace 2nd try: assume ReturnAddr is saved in LR when exception */
/* backtrace success, do not try other way */
goto exit;
} else {
/* Backtrace 3rd try: assume PC is invalalb, backtrace from LR */
backtrace_caller(LR, SP, print_func);
}
exit:
return;
}
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/common/backtrace.c
|
C
|
apache-2.0
| 15,809
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef MPU_H
#define MPU_H
typedef struct {
// MPU type register
unsigned int type;
// MPU control register
unsigned int ctrl;
// MPU range number register
unsigned int rnr;
// MPU region base address register
unsigned int rbar;
// MPU region attribute and size register
unsigned int rasr;
// MPU alias registers
unsigned int rbar_a1;
unsigned int rasr_a1;
unsigned int rbar_a2;
unsigned int rasr_a2;
unsigned int rbar_a3;
unsigned int rasr_a3;
} MPU_t;
/* System Handler Control and State register */
#define SHCSR_M ((unsigned int*)0xE000ED24UL)
/* MPU registers */
#define MPU_BASE (0xE000ED90UL)
#define MPU ((MPU_t*)(MPU_BASE))
#define MPU_TYPE_IREGION_OFFSET (16U)
#define MPU_TYPE_IREGION_MASK (0xFFUL << MPU_TYPE_IREGION_OFFSET)
#define MPU_TYPE_DREGION_OFFSET (8U)
#define MPU_TYPE_DREGION_MASK (0xFFUL << MPU_TYPE_DREGION_OFFSET)
#define MPU_TYPE_SEPARATE_OFFSET (0U)
#define MPU_TYPE_SEPARATE_MASK (1UL)
#define MPU_CTRL_PRIVDEFENA_OFFSET (2U)
#define MPU_CTRL_PRIVDEFENA_MASK (1UL << MPU_CTRL_PRIVDEFENA_OFFSET)
#define MPU_CTRL_HFNMIENA_OFFSET (1U)
#define MPU_CTRL_HFNMIENA_MASK (1UL << MPU_CTRL_HFNMIENA_OFFSET)
#define MPU_CTRL_ENABLE_OFFSET (0U)
#define MPU_CTRL_ENABLE_MASK (1UL)
#define MPU_RNR_REGION_OFFSET (0U)
#define MPU_RNR_REGION_MASK (0xFFUL)
#define MPU_RBAR_ADDR_OFFSET (5U)
#define MPU_RBAR_ADDR_MASK (0x7FFFFFFUL << MPU_RBAR_ADDR_OFFSET)
#define MPU_RBAR_VALID_OFFSET (4U)
#define MPU_RBAR_VALID_MASK (1UL << MPU_RBAR_VALID_OFFSET)
#define MPU_RBAR_REGION_OFFSET (0U)
#define MPU_RBAR_REGION_MASK (0xFUL)
#define MPU_RASR_ATTRS_OFFSET (16U)
#define MPU_RASR_ATTRS_MASK (0xFFFFUL << MPU_RASR_ATTRS_OFFSET)
#define MPU_RASR_XN_OFFSET (28U)
#define MPU_RASR_XN_MASK (1UL << MPU_RASR_XN_OFFSET)
#define MPU_RASR_AP_OFFSET (24U)
#define MPU_RASR_AP_MASK (0x7UL << MPU_RASR_AP_OFFSET)
#define MPU_RASR_TEX_OFFSET (19U)
#define MPU_RASR_TEX_MASK (0x7UL << MPU_RASR_TEX_OFFSET)
#define MPU_RASR_S_OFFSET (18U)
#define MPU_RASR_S_MASK (1UL << MPU_RASR_S_OFFSET)
#define MPU_RASR_C_OFFSET (17U)
#define MPU_RASR_C_MASK (1UL << MPU_RASR_C_OFFSET)
#define MPU_RASR_B_OFFSET (16U)
#define MPU_RASR_B_MASK (1UL << MPU_RASR_B_OFFSET)
#define MPU_RASR_SRD_OFFSET (8U)
#define MPU_RASR_SRD_MASK (0xFFUL << MPU_RASR_SRD_OFFSET)
#define MPU_RASR_SIZE_OFFSET (1U)
#define MPU_RASR_SIZE_MASK (0x1FUL << MPU_RASR_SIZE_OFFSET)
#define MPU_RASR_ENABLE_OFFSET (0U)
#define MPU_RASR_ENABLE_MASK (1UL)
/* MPU regions size */
#define MPU_REGION_SIZE_32B (0x04U)
#define MPU_REGION_SIZE_64B (0x05U)
#define MPU_REGION_SIZE_128B (0x06U)
#define MPU_REGION_SIZE_256B (0x07U)
#define MPU_REGION_SIZE_512B (0x08U)
#define MPU_REGION_SIZE_1KB (0x09U)
#define MPU_REGION_SIZE_2KB (0x0AU)
#define MPU_REGION_SIZE_4KB (0x0BU)
#define MPU_REGION_SIZE_8KB (0x0CU)
#define MPU_REGION_SIZE_16KB (0x0DU)
#define MPU_REGION_SIZE_32KB (0x0EU)
#define MPU_REGION_SIZE_64KB (0x0FU)
#define MPU_REGION_SIZE_128KB (0x10U)
#define MPU_REGION_SIZE_256KB (0x11U)
#define MPU_REGION_SIZE_512KB (0x12U)
#define MPU_REGION_SIZE_1MB (0x13U)
#define MPU_REGION_SIZE_2MB (0x14U)
#define MPU_REGION_SIZE_4MB (0x15U)
#define MPU_REGION_SIZE_8MB (0x16U)
#define MPU_REGION_SIZE_16MB (0x17U)
#define MPU_REGION_SIZE_32MB (0x18U)
#define MPU_REGION_SIZE_64MB (0x19U)
#define MPU_REGION_SIZE_128MB (0x1AU)
#define MPU_REGION_SIZE_256MB (0x1BU)
#define MPU_REGION_SIZE_512MB (0x1CU)
#define MPU_REGION_SIZE_1GB (0x1DU)
#define MPU_REGION_SIZE_2GB (0x1EU)
#define MPU_REGION_SIZE_4GB (0x1FU)
#define MPU_AP_NA_NA (0x00U)
#define MPU_AP_RW_NA (0x01U)
#define MPU_AP_RW_RO (0x02U)
#define MPU_AP_RW_RW (0x03U)
#define MPU_AP_RESV (0x04U)
#define MPU_AP_RO_NA (0x05U)
#define MPU_AP_RO_RO (0x06U)
typedef struct {
unsigned long base_addr;
unsigned char range_no;
unsigned char size;
unsigned char ext_type;
unsigned char access_permission;
unsigned char disable_exec;
unsigned char subregion_disable;
unsigned char shareable;
unsigned char cacheable;
unsigned char bufferable;
unsigned char enable;
} MPU_Region_Init_t;
#if AOS_COMP_DEBUG
/**
* set mpu region for memory unauthorized access check
*
* @param[in] addr_start monitor start addr
* @param[in] addr_size monitor size
* @param[in] mode prohibit access(0) or read only(>0)
*/
void debug_memory_access_err_check(unsigned long addr_start, unsigned long addr_size, unsigned int mode);
void debug_task_stack_ovf_check(char *task_name);
void debug_check_mem_access_disable(void);
#endif
#endif // MPU_H
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/common/include/panic_mpu.h
|
C
|
apache-2.0
| 5,225
|
#include "k_config.h"
;******************************************************************************
; EQUATES
;******************************************************************************
CONTEXT_REGION EQU 88 ;bigger than sizeof(PANIC_CONTEXT)
;******************************************************************************
; CODE GENERATION DIRECTIVES
;******************************************************************************
AREA |.text|, CODE, READONLY, ALIGN=2
THUMB
REQUIRE8
PRESERVE8
#if AOS_COMP_DEBUG
;******************************************************************************
; EXTERN PARAMETERS
;******************************************************************************
EXTERN panicHandler
EXTERN g_crash_steps
EXTERN _first_task_restore
EXTERN panicRestoreCheck
;******************************************************************************
; EXPORT FUNCTIONS
;******************************************************************************
EXPORT HardFault_Handler
EXPORT MemManage_Handler
EXPORT BusFault_Handler
EXPORT UsageFault_Handler
;******************************************************************************
; FAULT FUNCTIONS
;******************************************************************************
HardFault_Handler
MemManage_Handler
BusFault_Handler
UsageFault_Handler
PUSH {R1, LR}
BL panicRestoreCheck
POP {R1, LR}
CBZ R0, unrecoverable_crash
BL _first_task_restore
unrecoverable_crash
;check double crash
LDR R1, =g_crash_steps
LDR R2, [R1]
ADD R3, R2, #1
STR R3, [R1]
CBZ R2, first_panic
;return from exc to handle panic
MRS R1, PSP
AND R2, LR, #4 ;EXC_RETURN:bit2, 0 MSP, 1 PSP
CBNZ R2, double_panic
MRS R1, MSP
double_panic
LDR R0, =double_panic_entry
STR R0, [R1, #24]
LDR R0, [R1, #28]
ORR R0, R0, #0x1000000
STR R0, [R1, #28] ;set thumb mode
BX LR
double_panic_entry
MOV R0, #0 ;double crash, do not save context
BL panicHandler
B .
first_panic
;R0 as PANIC_CONTEXT
SUB R0, SP, #CONTEXT_REGION
;R1 as CONTEXT saved by hardware
MRS R1, PSP
AND R2, LR, #4 ;EXC_RETURN:bit2, 0 MSP, 1 PSP
CBNZ R2, context_save
MRS R1, MSP
context_save
ADD R2, R0, #16
STM R2!,{R4-R11} ;ctx save, R4~R11
LDM R1, {R4-R11}
STM R0, {R4-R7} ;ctx save, R0~R3
STM R2!,{R8-R11} ;ctx save, R12 LR PC xPSR
;xPSR[9] and EXC_RETURN[4] to determine whether
;the previous top-of-stack was at offset 0x20, 0x24, 0x68, or0x6C
ADD R4, R1, #0x20
IF {FPU} != "SoftVFP"
AND R3, LR, #0x10 ;EXC_RETURN:bit4, 0 floating, 1 non-floating
CBNZ R3, check_aligner
ADD R4, R4, #0x48
check_aligner
ENDIF
LDR R3, [R1, #28]
AND R3, R3, #0x200 ;xPSR:bit9, 0 no-aligner, 1 aligner
CBZ R3, sp_save
ADD R4, R4, #0x4
sp_save
STM R2!,{R4} ;ctx save, SP
MOV R4, LR
STM R2!,{R4} ;ctx save, EXC_RETURN
MRS R4, IPSR
STM R2!,{R4} ;ctx save, EXC_NUMBER
MRS R4, PRIMASK
STM R2!,{R4} ;ctx save, PRIMASK
MRS R4, FAULTMASK
STM R2!,{R4} ;ctx save, FAULTMASK
MRS R4, BASEPRI
STM R2!,{R4} ;ctx save, BASEPRI
;return from exc to handle panic
STR R0, [R1, #0]
LDR R0, =panic_entry
STR R0, [R1, #24]
LDR R0, [R1, #28]
ORR R0, R0, #0x1000000
STR R0, [R1, #28] ;set thumb mode
CPSID I
BX LR
panic_entry
#if DEBUG_PANIC_PRT_INT
MRS R1, CONTROL
MOVS R2, #2
BICS R1, R2
MSR CONTROL, R1
ISB
;printf use interrupt, so here enable it
CPSIE I
#endif
MOV SP, R0
BL panicHandler
B .
ALIGN
#endif
END
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/common/panic_armcc.S
|
Motorola 68K Assembly
|
apache-2.0
| 4,224
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include <stdio.h>
//#include "debug_api.h"
#define REG_NAME_WIDTH 7
typedef struct
{
/* saved in assembler */
int R0;
int R1;
int R2;
int R3;
int R4;
int R5;
int R6;
int R7;
int R8;
int R9;
int R10;
int R11;
int R12;
int LR; // Link Register (LR)
int PC; // Program Counter (PC)
int xPSR; // Program Status Registers
int SP; // Stack Pointer
int MSP;
int PSP;
int EXC_RETURN; // Exception Return
int EXC_NUMBER; // Exception Num
int PRIMASK; // Interrupt Mask
int FAULTMASK; // Interrupt Mask
int BASEPRI; // Interrupt Mask
} PANIC_CONTEXT;
typedef struct
{
int CFSR;
int HFSR;
int MMFAR;
int BFAR;
int AFSR;
} FAULT_REGS;
#if DEBUG_PANIC_CONTEXT_IN_STACK > 0
PANIC_CONTEXT g_panic_contex;
#endif
void panicGetCtx(void *context, char **pPC, char **pLR, int **pSP)
{
PANIC_CONTEXT *arm_context = (PANIC_CONTEXT *)context;
*pSP = (int *)arm_context->SP;
*pPC = (char *)arm_context->PC;
*pLR = (char *)arm_context->LR;
}
void panicShowRegs(void *context, int (*print_func)(const char *fmt, ...))
{
int x;
int *regs = (int *)context;
char s_panic_regs[REG_NAME_WIDTH + 14];
FAULT_REGS stFregs;
/* PANIC_CONTEXT */
char s_panic_ctx[] = "R0 "
"R1 "
"R2 "
"R3 "
"R4 "
"R5 "
"R6 "
"R7 "
"R8 "
"R9 "
"R10 "
"R11 "
"R12 "
"LR "
"PC "
"xPSR "
"SP "
"MSP "
"PSP "
"EXC_RET"
"EXC_NUM"
"PRIMASK"
"FLTMASK"
"BASEPRI";
/* FAULT_REGS */
char s_panic_reg[] = "CFSR "
"HFSR "
"MMFAR "
"BFAR "
"AFSR ";
if (regs == NULL) {
return;
}
print_func("========== Regs info ==========\r\n");
/* show PANIC_CONTEXT */
for (x = 0; x < sizeof(s_panic_ctx) / REG_NAME_WIDTH; x++) {
memcpy(&s_panic_regs[0], &s_panic_ctx[x * REG_NAME_WIDTH],
REG_NAME_WIDTH);
memcpy(&s_panic_regs[REG_NAME_WIDTH], " 0x", 3);
k_int2str(regs[x], &s_panic_regs[REG_NAME_WIDTH + 3]);
s_panic_regs[REG_NAME_WIDTH + 11] = '\r';
s_panic_regs[REG_NAME_WIDTH + 12] = '\n';
s_panic_regs[REG_NAME_WIDTH + 13] = 0;
print_func(s_panic_regs);
}
/* show FAULT_REGS */
stFregs.CFSR = (*((volatile int *)(0xE000ED28)));
stFregs.HFSR = (*((volatile int *)(0xE000ED2C)));
stFregs.MMFAR = (*((volatile int *)(0xE000ED34)));
stFregs.BFAR = (*((volatile int *)(0xE000ED38)));
stFregs.AFSR = (*((volatile int *)(0xE000ED3C)));
for (x = 0; x < sizeof(stFregs) / sizeof(int); x++) {
memcpy(&s_panic_regs[0], &s_panic_reg[x * REG_NAME_WIDTH],
REG_NAME_WIDTH);
memcpy(&s_panic_regs[REG_NAME_WIDTH], " 0x", 3);
k_int2str(((int *)(&stFregs))[x], &s_panic_regs[REG_NAME_WIDTH + 3]);
s_panic_regs[REG_NAME_WIDTH + 11] = '\r';
s_panic_regs[REG_NAME_WIDTH + 12] = '\n';
s_panic_regs[REG_NAME_WIDTH + 13] = 0;
print_func(s_panic_regs);
}
}
#if (RHINO_CONFIG_CLI_AS_NMI > 0)
void panicNmiInputFilter(uint8_t ch)
{
static int check_cnt = 0; /* for '$#@!' */
if ( ch == '$' && check_cnt == 0) {
check_cnt++;
}
else if ( ch == '#' && check_cnt == 1) {
check_cnt++;
}
else if ( ch == '@' && check_cnt == 2) {
check_cnt++;
}
else if ( ch == '!' && check_cnt == 3) {
panicNmiFlagSet();
__asm__ __volatile__("udf":::"memory");
}
else {
check_cnt = 0;
}
}
#else
void panicNmiInputFilter(uint8_t ch){}
#endif
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/common/panic_c.c
|
C
|
apache-2.0
| 4,377
|
#include "k_config.h"
;******************************************************************************
; EQUATES
;******************************************************************************
CONTEXT_REGION EQU 88 ;bigger than sizeof(PANIC_CONTEXT)
;******************************************************************************
; CODE GENERATION DIRECTIVES
;******************************************************************************
SECTION .text:CODE(2)
THUMB
REQUIRE8
PRESERVE8
#if AOS_COMP_DEBUG
;******************************************************************************
; EXTERN PARAMETERS
;******************************************************************************
EXTERN panicHandler
EXTERN g_crash_steps
EXTERN _first_task_restore
EXTERN panicRestoreCheck
;******************************************************************************
; EXPORT FUNCTIONS
;******************************************************************************
PUBLIC HardFault_Handler
PUBLIC MemManage_Handler
PUBLIC BusFault_Handler
PUBLIC UsageFault_Handler
;******************************************************************************
; FAULT FUNCTIONS
;******************************************************************************
HardFault_Handler:
MemManage_Handler:
BusFault_Handler:
UsageFault_Handler:
PUSH {R1, LR}
BL panicRestoreCheck
POP {R1, LR}
CBZ R0, unrecoverable_crash
BL _first_task_restore
unrecoverable_crash:
;check double crash
LDR R1, =g_crash_steps
LDR R2, [R1]
ADD R3, R2, #1
STR R3, [R1]
CBZ R2, first_panic
;return from exc to handle panic
MRS R1, PSP
AND R2, LR, #4 ;EXC_RETURN:bit2, 0 MSP, 1 PSP
CBNZ R2, double_panic
MRS R1, MSP
double_panic:
LDR R0, =double_panic_entry
STR R0, [R1, #24]
LDR R0, [R1, #28]
ORR R0, R0, #0x1000000
STR R0, [R1, #28] ;set thumb mode
BX LR
double_panic_entry:
MOV R0, #0 ;double crash, do not save context
BL panicHandler
B .
first_panic:
;R0 as PANIC_CONTEXT
SUB R0, SP, #CONTEXT_REGION
;R1 as CONTEXT saved by hardware
MRS R1, PSP
AND R2, LR, #4 ;EXC_RETURN:bit2, 0 MSP, 1 PSP
CBNZ R2, context_save
MRS R1, MSP
context_save:
ADD R2, R0, #16
STM R2!,{R4-R11} ;ctx save, R4~R11
LDM R1, {R4-R11}
STM R0, {R4-R7} ;ctx save, R0~R3
STM R2!,{R8-R11} ;ctx save, R12 LR PC xPSR
;xPSR[9] and EXC_RETURN[4] to determine whether
;the previous top-of-stack was at offset 0x20, 0x24, 0x68, or0x6C
ADD R4, R1, #0x20
#if defined(__ARMVFP__)
AND R3, LR, #0x10 ;EXC_RETURN:bit4, 0 floating, 1 non-floating
CBNZ R3, check_aligner
ADD R4, R4, #0x48
check_aligner:
#endif
LDR R3, [R1, #28]
AND R3, R3, #0x200 ;xPSR:bit9, 0 no-aligner, 1 aligner
CBZ R3, sp_save
ADD R4, R4, #0x4
sp_save:
STM R2!,{R4} ;ctx save, SP
MOV R4, LR
STM R2!,{R4} ;ctx save, EXC_RETURN
MRS R4, IPSR
STM R2!,{R4} ;ctx save, EXC_NUMBER
MRS R4, PRIMASK
STM R2!,{R4} ;ctx save, PRIMASK
MRS R4, FAULTMASK
STM R2!,{R4} ;ctx save, FAULTMASK
MRS R4, BASEPRI
STM R2!,{R4} ;ctx save, BASEPRI
;return from exc to handle panic
STR R0, [R1, #0]
LDR R0, =panic_entry
STR R0, [R1, #24]
LDR R0, [R1, #28]
ORR R0, R0, #0x1000000
STR R0, [R1, #28] ;set thumb mode
CPSID I
BX LR
panic_entry:
#if DEBUG_PANIC_PRT_INT
MRS R1, CONTROL
MOVS R2, #2
BICS R1, R2
MSR CONTROL, R1
ISB
;printf use interrupt, so here enable it
CPSIE I
#endif
MOV SP, R0
BL panicHandler
B .
#endif
END
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/common/panic_iccarm.S
|
Motorola 68K Assembly
|
apache-2.0
| 4,210
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#if AOS_COMP_DEBUG
#include <stdio.h>
#include "panic_mpu.h"
#include "k_compiler.h"
#include "k_api.h"
typedef struct {
unsigned long start;
unsigned long size;
unsigned long mpusize;
} mem_region_t;
static void mpu_enable(void);
static void mpu_disable(void);
static void mpu_config_region(MPU_Region_Init_t *init);
static unsigned int size_to_mpusize(unsigned int size);
/*
* Func: mpu is valid in mcu
* IN : none
* Out : 0 -- valid; 1 -- invalid
* */
static unsigned int mpu_is_valid(void)
{
return ((MPU->type) & MPU_TYPE_DREGION_MASK == 0) ? 1: 0;
}
static void mpu_enable(void)
{
MPU->ctrl = MPU_CTRL_ENABLE_MASK | MPU_CTRL_PRIVDEFENA_MASK;
/* Enable memory manage fault */
*(SHCSR_M) |= (1<<16);
OS_DSB();
OS_ISB();
OS_DMB();
}
static void mpu_disable(void)
{
MPU->ctrl = 0U;
OS_DSB();
OS_ISB();
OS_DMB();
}
static void enable_region(mem_region_t *region, int rng_no,
int subregion_disable, int ext_type,
int access_permission, int disable_exec,
int shareable, int cacheable, int bufferable)
{
MPU_Region_Init_t init;
init.range_no = rng_no;
init.base_addr = region->start;
init.size = region->mpusize;
init.subregion_disable = subregion_disable;
init.ext_type = ext_type;
init.access_permission = access_permission;
init.disable_exec = disable_exec;
init.shareable = shareable;
init.cacheable = cacheable;
init.bufferable = bufferable;
init.enable = 1;
mpu_config_region(&init);
}
static void mpu_config_region(MPU_Region_Init_t *init)
{
MPU->rnr = init->range_no;
if (init->enable) {
MPU->rbar = init->base_addr;
MPU->rasr = (init->disable_exec << MPU_RASR_XN_OFFSET
| init->access_permission << MPU_RASR_AP_OFFSET
| init->ext_type << MPU_RASR_TEX_OFFSET
| init->shareable << MPU_RASR_S_OFFSET
| init->cacheable << MPU_RASR_C_OFFSET
| init->bufferable << MPU_RASR_B_OFFSET
| init->subregion_disable << MPU_RASR_SRD_OFFSET
| init->size << MPU_RASR_SIZE_OFFSET
| init->enable << MPU_RASR_ENABLE_OFFSET);
} else {
MPU->rbar = 0;
MPU->rasr = 0;
}
OS_DSB();
OS_ISB();
OS_DMB();
}
static unsigned int size_to_mpusize(unsigned int size)
{
switch (size) {
case 0x20: return MPU_REGION_SIZE_32B;
case 0x40: return MPU_REGION_SIZE_64B;
case 0x80: return MPU_REGION_SIZE_128B;
case 0x100: return MPU_REGION_SIZE_256B;
case 0x200: return MPU_REGION_SIZE_512B;
case 0x400: return MPU_REGION_SIZE_1KB;
case 0x800: return MPU_REGION_SIZE_2KB;
case 0x1000: return MPU_REGION_SIZE_4KB;
case 0x2000: return MPU_REGION_SIZE_8KB;
case 0x4000: return MPU_REGION_SIZE_16KB;
case 0x8000: return MPU_REGION_SIZE_32KB;
case 0x10000: return MPU_REGION_SIZE_64KB;
case 0x20000: return MPU_REGION_SIZE_128KB;
case 0x40000: return MPU_REGION_SIZE_256KB;
case 0x80000: return MPU_REGION_SIZE_512KB;
case 0x100000: return MPU_REGION_SIZE_1MB;
case 0x200000: return MPU_REGION_SIZE_2MB;
case 0x400000: return MPU_REGION_SIZE_4MB;
case 0x800000: return MPU_REGION_SIZE_8MB;
case 0x1000000: return MPU_REGION_SIZE_16MB;
case 0x2000000: return MPU_REGION_SIZE_32MB;
case 0x4000000: return MPU_REGION_SIZE_64MB;
case 0x8000000: return MPU_REGION_SIZE_128MB;
case 0x10000000: return MPU_REGION_SIZE_256MB;
case 0x20000000: return MPU_REGION_SIZE_512MB;
case 0x40000000: return MPU_REGION_SIZE_1GB;
case 0x80000000: return MPU_REGION_SIZE_2GB;
default: return 0;
}
}
static void mpu_set(unsigned long addr, unsigned long size, unsigned int mode)
{
mem_region_t region;
region.start = addr;
region.size = size;
region.mpusize = size_to_mpusize(region.size);
mpu_disable();
enable_region(®ion, 0, 0, 0, mode, 0, 0, 1, 1);
mpu_enable();
}
static unsigned int mpu_check(unsigned long addr, unsigned long size)
{
if ((size < 0x20) || (size > 0x80000000)) {
printf("mpu region size error\r\n");
return 1;
}
if (mpu_is_valid() != 0) {
printf("error:no mpu in mcu\r\n");
return 1;
}
return 0;
}
/**
* set mpu region for memory unauthorized access check
*
* @param[in] addr_start monitor start addr
* @param[in] addr_size monitor size
* @param[in] mode prohibit access (0) or read only(>0)
*/
void debug_memory_access_err_check(unsigned long addr_start, unsigned long addr_size, unsigned int mode)
{
unsigned int mpu_region_type;
if (mpu_check(addr_start, addr_size) != 0)
return;
if ((addr_start % addr_size) != 0)
addr_start = (addr_start + (addr_size - 1)) & ~(addr_size - 1);
if (mode > 0) {
mpu_region_type = MPU_AP_RO_NA;
} else
mpu_region_type = MPU_AP_NA_NA;
mpu_set(addr_start, addr_size, mpu_region_type);
printf("mpu addr: 0x%x\n", addr_start);
}
void debug_task_stack_ovf_check(char *task_name)
{
int ret;
ktask_t *task;
cpu_stack_t *task_stack_base;
if (task_name == NULL) {
printf("error: task name invalid\r\n");
return;
}
task = krhino_task_find(task_name);
if (task == NULL) {
printf("error: task do not exist\r\n");
return;
}
task_stack_base = task->task_stack_base;
if (task_stack_base == NULL) {
printf("error: task_stack_base err\r\n");
return;
}
debug_memory_access_err_check((unsigned long)task_stack_base, 0x20, 1);
}
void debug_check_mem_access_disable(void)
{
mpu_disable();
}
#endif
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/common/panic_mpu.c
|
C
|
apache-2.0
| 6,184
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include <k_api.h>
void *cpu_task_stack_init(cpu_stack_t *stack_base, size_t stack_size,
void *arg, task_entry_t entry)
{
cpu_stack_t *stk;
uint32_t temp = (uint32_t)(stack_base + stack_size);
/* stack aligned by 8 byte */
temp &= 0xfffffff8;
stk = (cpu_stack_t *)temp;
/* task context saved & restore by hardware: */
*(--stk) = (cpu_stack_t)0x01000000L; /* xPSR: EPSR.T = 1, thumb mode */
*(--stk) = (cpu_stack_t)entry; /* Entry Point */
*(--stk) = (cpu_stack_t)krhino_task_deathbed; /* R14 (LR) */
*(--stk) = (cpu_stack_t)0x12121212L; /* R12 */
*(--stk) = (cpu_stack_t)0x03030303L; /* R3 */
*(--stk) = (cpu_stack_t)0x02020202L; /* R2 */
*(--stk) = (cpu_stack_t)0x01010101L; /* R1 */
*(--stk) = (cpu_stack_t)arg; /* R0 : argument */
/* task context saved & restore by software: */
/* EXC_RETURN = 0xFFFFFFFDL
Task begin state: Thread mode + non-floating-point state + PSP */
*(--stk) = (cpu_stack_t)0xFFFFFFFDL;
*(--stk) = (cpu_stack_t)0x11111111L; /* R11 */
*(--stk) = (cpu_stack_t)0x10101010L; /* R10 */
*(--stk) = (cpu_stack_t)0x09090909L; /* R9 */
*(--stk) = (cpu_stack_t)0x08080808L; /* R8 */
*(--stk) = (cpu_stack_t)0x07070707L; /* R7 */
*(--stk) = (cpu_stack_t)0x06060606L; /* R6 */
*(--stk) = (cpu_stack_t)0x05050505L; /* R5 */
*(--stk) = (cpu_stack_t)0x04040404L; /* R4 */
return stk;
}
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/common/port_c.c
|
C
|
apache-2.0
| 1,690
|
#include <k_config.h>
;******************************************************************************
; EXTERN PARAMETERS
;******************************************************************************
EXTERN g_active_task
EXTERN g_preferred_ready_task
EXTERN krhino_stack_ovf_check
EXTERN krhino_task_sched_stats_get
;******************************************************************************
; EXPORT FUNCTIONS
;******************************************************************************
PUBLIC cpu_intrpt_save
PUBLIC cpu_intrpt_restore
PUBLIC cpu_task_switch
PUBLIC cpu_intrpt_switch
PUBLIC cpu_first_task_start
PUBLIC _first_task_restore
PUBLIC PendSV_Handler
;******************************************************************************
; EQUATES
;******************************************************************************
SCB_ICSR EQU 0xE000ED04 ; Interrupt Control and State Register.
SCB_VTOR EQU 0xE000ED08 ; Vector Table Offset Register.
ICSR_PENDSVSET EQU 0x10000000 ; Value to trigger PendSV exception.
SHPR3_PRI_14 EQU 0xE000ED22 ; System Handler Priority Register 3 (PendSV).
PRI_LVL_PENDSV EQU 0xFF ; PendSV priority level (lowest).
SHPR3_PRI_15 EQU 0xE000ED23 ; System Handler Priority Register 3 (SysTick).
PRI_LVL_SYSTICK EQU 0xFF ; SYstick priority level (lowest).
;******************************************************************************
; CODE GENERATION DIRECTIVES
;******************************************************************************
SECTION .text:CODE(2)
THUMB
REQUIRE8
PRESERVE8
;******************************************************************************
; Functions:
; size_t cpu_intrpt_save(void);
; void cpu_intrpt_restore(size_t cpsr);
;******************************************************************************
cpu_intrpt_save:
MRS R0, PRIMASK
CPSID I
BX LR
cpu_intrpt_restore:
MSR PRIMASK, R0
BX LR
;******************************************************************************
; Functions:
; void cpu_intrpt_switch(void);
; void cpu_task_switch(void);
;******************************************************************************
cpu_task_switch:
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
BX LR
cpu_intrpt_switch:
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
BX LR
;******************************************************************************
; Functions:
; void cpu_first_task_start(void);
;******************************************************************************
cpu_first_task_start:
;set PendSV prority to the lowest
LDR R0, =SHPR3_PRI_14
LDR R1, =PRI_LVL_PENDSV
STRB R1, [R0]
;set Systick prority to the lowest
LDR R0, =SHPR3_PRI_15
LDR R1, =PRI_LVL_SYSTICK
STRB R1, [R0]
;indicate PendSV_Handler branch to _pendsv_handler_nosave
MOVS R0, #0
MSR PSP, R0
;make PendSV exception pending
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
;goto PendSV_Handler
CPSIE I
B .
;******************************************************************************
; Functions:
; void krhino_pendsv_handler(void);
;******************************************************************************
PendSV_Handler:
CPSID I
MRS R0, PSP
;branch if cpu_first_task_start
CMP R0, #0
BEQ _first_task_restore
;hardware saved R0~R3,R12,LR,PC,xPSR
;save context
SUBS R0, R0, #0x24
STM R0, {R4-R11, LR}
;g_active_task->task_stack = context region
LDR R1, =g_active_task
LDR R1, [R1]
STR R0, [R1]
#if (RHINO_CONFIG_TASK_STACK_OVF_CHECK > 0)
BL krhino_stack_ovf_check
#endif
#if (RHINO_CONFIG_SYS_STATS > 0)
BL krhino_task_sched_stats_get
#endif
_pendsv_handler_nosave:
LDR R0, =g_active_task
LDR R1, =g_preferred_ready_task
LDR R2, [R1]
STR R2, [R0]
;R0 = g_active_task->task_stack = context region
LDR R0, [R2]
;restore context
LDM R0, {R4-R11, LR}
ADDS R0, R0, #0x24
;return stack = PSP
MSR PSP, R0
CPSIE I
;hardware restore R0~R3,R12,LR,PC,xPSR
BX LR
_first_task_restore:
;set MSP to the base of system stack
LDR R0, =SCB_VTOR
LDR R0, [R0]
LDR R0, [R0]
MSR MSP, R0
B _pendsv_handler_nosave
END
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/iccarm/m3/port_s.S
|
Motorola 68K Assembly
|
apache-2.0
| 4,785
|
#include <k_config.h>
;******************************************************************************
; EXTERN PARAMETERS
;******************************************************************************
EXTERN g_active_task
EXTERN g_preferred_ready_task
EXTERN krhino_stack_ovf_check
EXTERN krhino_task_sched_stats_get
;******************************************************************************
; EXPORT FUNCTIONS
;******************************************************************************
PUBLIC cpu_intrpt_save
PUBLIC cpu_intrpt_restore
PUBLIC cpu_task_switch
PUBLIC cpu_intrpt_switch
PUBLIC cpu_first_task_start
PUBLIC _first_task_restore
PUBLIC PendSV_Handler
;******************************************************************************
; EQUATES
;******************************************************************************
SCB_ICSR EQU 0xE000ED04 ; Interrupt Control and State Register.
SCB_VTOR EQU 0xE000ED08 ; Vector Table Offset Register.
ICSR_PENDSVSET EQU 0x10000000 ; Value to trigger PendSV exception.
SHPR3_PRI_14 EQU 0xE000ED22 ; System Handler Priority Register 3 (PendSV).
PRI_LVL_PENDSV EQU 0xFF ; PendSV priority level (lowest).
SHPR3_PRI_15 EQU 0xE000ED23 ; System Handler Priority Register 3 (SysTick).
PRI_LVL_SYSTICK EQU 0xFF ; SYstick priority level (lowest).
;******************************************************************************
; CODE GENERATION DIRECTIVES
;******************************************************************************
SECTION .text:CODE(2)
THUMB
REQUIRE8
PRESERVE8
;******************************************************************************
; Functions:
; size_t cpu_intrpt_save(void);
; void cpu_intrpt_restore(size_t cpsr);
;******************************************************************************
cpu_intrpt_save:
MRS R0, PRIMASK
CPSID I
BX LR
cpu_intrpt_restore:
MSR PRIMASK, R0
BX LR
;******************************************************************************
; Functions:
; void cpu_intrpt_switch(void);
; void cpu_task_switch(void);
;******************************************************************************
cpu_task_switch:
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
BX LR
cpu_intrpt_switch:
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
BX LR
;******************************************************************************
; Functions:
; void cpu_first_task_start(void);
;******************************************************************************
cpu_first_task_start:
;set PendSV prority to the lowest
LDR R0, =SHPR3_PRI_14
LDR R1, =PRI_LVL_PENDSV
STRB R1, [R0]
;set Systick prority to the lowest
LDR R0, =SHPR3_PRI_15
LDR R1, =PRI_LVL_SYSTICK
STRB R1, [R0]
;indicate PendSV_Handler branch to _pendsv_handler_nosave
MOVS R0, #0
MSR PSP, R0
;make PendSV exception pending
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
;goto PendSV_Handler
CPSIE I
B .
;******************************************************************************
; Functions:
; void krhino_pendsv_handler(void);
;******************************************************************************
PendSV_Handler:
CPSID I
MRS R0, PSP
;branch if cpu_first_task_start
CMP R0, #0
BEQ _first_task_restore
;hardware saved R0~R3,R12,LR,PC,xPSR
;save context
#if defined(__ARMVFP__)
;if the switchout task use FPU, save the FPU regs
TST LR, #0x10
IT EQ
VSTMDBEQ R0!, {D8 - D15}
;hardware saved D0~D7, FPSCR
#endif
SUBS R0, R0, #0x24
STM R0, {R4-R11, LR}
;g_active_task->task_stack = context region
LDR R1, =g_active_task
LDR R1, [R1]
STR R0, [R1]
#if (RHINO_CONFIG_TASK_STACK_OVF_CHECK > 0)
BL krhino_stack_ovf_check
#endif
#if (RHINO_CONFIG_SYS_STATS > 0)
BL krhino_task_sched_stats_get
#endif
_pendsv_handler_nosave:
LDR R0, =g_active_task
LDR R1, =g_preferred_ready_task
LDR R2, [R1]
STR R2, [R0]
;R0 = g_active_task->task_stack = context region
LDR R0, [R2]
;restore context
LDM R0, {R4-R11, LR}
ADDS R0, R0, #0x24
#if defined(__ARMVFP__)
;if the switchin task use FPU, save the FPU regs
TST LR, #0x10
IT EQ
VLDMIAEQ R0!, {D8 - D15}
;hardware will restore D0~D7, FPSCR
#endif
;return stack = PSP
MSR PSP, R0
CPSIE I
;hardware restore R0~R3,R12,LR,PC,xPSR
BX LR
_first_task_restore:
;set MSP to the base of system stack
LDR R0, =SCB_VTOR
LDR R0, [R0]
LDR R0, [R0]
MSR MSP, R0
B _pendsv_handler_nosave
END
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/iccarm/m4/port_s.S
|
Motorola 68K Assembly
|
apache-2.0
| 5,178
|
#include <k_config.h>
;******************************************************************************
; EXTERN PARAMETERS
;******************************************************************************
EXTERN g_active_task
EXTERN g_preferred_ready_task
EXTERN krhino_stack_ovf_check
EXTERN krhino_task_sched_stats_get
;******************************************************************************
; EXPORT FUNCTIONS
;******************************************************************************
PUBLIC cpu_intrpt_save
PUBLIC cpu_intrpt_restore
PUBLIC cpu_task_switch
PUBLIC cpu_intrpt_switch
PUBLIC cpu_first_task_start
PUBLIC _first_task_restore
PUBLIC PendSV_Handler
;******************************************************************************
; EQUATES
;******************************************************************************
SCB_ICSR EQU 0xE000ED04 ; Interrupt Control and State Register.
SCB_VTOR EQU 0xE000ED08 ; Vector Table Offset Register.
ICSR_PENDSVSET EQU 0x10000000 ; Value to trigger PendSV exception.
SHPR3_PRI_14 EQU 0xE000ED22 ; System Handler Priority Register 3 (PendSV).
PRI_LVL_PENDSV EQU 0xFF ; PendSV priority level (lowest).
SHPR3_PRI_15 EQU 0xE000ED23 ; System Handler Priority Register 3 (SysTick).
PRI_LVL_SYSTICK EQU 0xFF ; SYstick priority level (lowest).
;******************************************************************************
; CODE GENERATION DIRECTIVES
;******************************************************************************
SECTION .text:CODE(2)
THUMB
REQUIRE8
PRESERVE8
;******************************************************************************
; Functions:
; size_t cpu_intrpt_save(void);
; void cpu_intrpt_restore(size_t cpsr);
;******************************************************************************
cpu_intrpt_save:
MRS R0, PRIMASK
CPSID I
BX LR
cpu_intrpt_restore:
MSR PRIMASK, R0
BX LR
;******************************************************************************
; Functions:
; void cpu_intrpt_switch(void);
; void cpu_task_switch(void);
;******************************************************************************
cpu_task_switch:
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
BX LR
cpu_intrpt_switch:
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
BX LR
;******************************************************************************
; Functions:
; void cpu_first_task_start(void);
;******************************************************************************
cpu_first_task_start:
;set PendSV prority to the lowest
LDR R0, =SHPR3_PRI_14
LDR R1, =PRI_LVL_PENDSV
STRB R1, [R0]
;set Systick prority to the lowest
LDR R0, =SHPR3_PRI_15
LDR R1, =PRI_LVL_SYSTICK
STRB R1, [R0]
;indicate PendSV_Handler branch to _pendsv_handler_nosave
MOVS R0, #0
MSR PSP, R0
;make PendSV exception pending
LDR R0, =SCB_ICSR
LDR R1, =ICSR_PENDSVSET
STR R1, [R0]
;goto PendSV_Handler
CPSIE I
B .
;******************************************************************************
; Functions:
; void krhino_pendsv_handler(void);
;******************************************************************************
PendSV_Handler:
CPSID I
MRS R0, PSP
;branch if cpu_first_task_start
CMP R0, #0
BEQ _first_task_restore
;hardware saved R0~R3,R12,LR,PC,xPSR
;save context
#if defined(__ARMVFP__)
;if the switchout task use FPU, save the FPU regs
TST LR, #0x10
IT EQ
VSTMDBEQ R0!, {D8 - D15}
;hardware saved D0~D7, FPSCR
#endif
SUBS R0, R0, #0x24
STM R0, {R4-R11, LR}
;g_active_task->task_stack = context region
LDR R1, =g_active_task
LDR R1, [R1]
STR R0, [R1]
#if (RHINO_CONFIG_TASK_STACK_OVF_CHECK > 0)
BL krhino_stack_ovf_check
#endif
#if (RHINO_CONFIG_SYS_STATS > 0)
BL krhino_task_sched_stats_get
#endif
_pendsv_handler_nosave:
LDR R0, =g_active_task
LDR R1, =g_preferred_ready_task
LDR R2, [R1]
STR R2, [R0]
;R0 = g_active_task->task_stack = context region
LDR R0, [R2]
;restore context
LDM R0, {R4-R11, LR}
ADDS R0, R0, #0x24
#if defined(__ARMVFP__)
;if the switchin task use FPU, save the FPU regs
TST LR, #0x10
IT EQ
VLDMIAEQ R0!, {D8 - D15}
;hardware will restore D0~D7, FPSCR
#endif
;return stack = PSP
MSR PSP, R0
CPSIE I
;hardware restore R0~R3,R12,LR,PC,xPSR
BX LR
_first_task_restore:
;set MSP to the base of system stack
LDR R0, =SCB_VTOR
LDR R0, [R0]
LDR R0, [R0]
MSR MSP, R0
B _pendsv_handler_nosave
END
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/iccarm/m7/port_s.S
|
Motorola 68K Assembly
|
apache-2.0
| 5,178
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef BACKTRACE_H
#define BACKTRACE_H
/* printf call stack
return levels of call stack */
int backtrace_now(int (*print_func)(const char *fmt, ...));
/* printf call stack for task
return levels of call stack */
int backtrace_task(char *taskname, int (*print_func)(const char *fmt, ...));
/* backtrace start with PC and SP, find LR from stack memory
return levels of call stack */
int backtrace_caller(char *PC, int *SP,
int (*print_func)(const char *fmt, ...));
/* backtrace start with PC SP and LR
return levels of call stack */
int backtrace_callee(char *PC, int *SP, char *LR,
int (*print_func)(const char *fmt, ...));
#endif /* BACKTRACE_H */
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/include/backtrace.h
|
C
|
apache-2.0
| 773
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef K_COMPILER_H
#define K_COMPILER_H
#if defined(__CC_ARM)
#define RHINO_INLINE static __inline
/* get the return address of the current function
unsigned int __return_address(void) */
#define RHINO_GET_RA() (void *)__return_address()
/* get the the value of the stack pointer
unsigned int __current_sp(void) */
#define RHINO_GET_SP() (void *)__current_sp()
/* Returns the number of leading 0-bits in x,
starting at the most signifi cant bit position. */
#define RHINO_BIT_CLZ(x) __builtin_clz(x)
/* Returns the number of trailing 0-bits in x,
starting at the least signifi cant bit position. */
#define RHINO_BIT_CTZ(x) __builtin_ctz(x)
#ifndef RHINO_WEAK
#define RHINO_WEAK __weak
#endif
#ifndef RHINO_ASM
#define RHINO_ASM __asm
#endif
/* Instruction Synchronization Barrier */
#define OS_ISB() __isb(15) /* Full system Any-Any */
/* Data Memory Barrier */
#define OS_DMB() __dmb(15) /* Full system Any-Any */
/* Data Synchronization Barrier */
#define OS_DSB() __dsb(15) /* Full system Any-Any */
#elif defined(__ICCARM__)
#include "intrinsics.h"
#define RHINO_INLINE static inline
/* get the return address of the current function
unsigned int __get_LR(void) */
#define RHINO_GET_RA() (void *)__get_LR()
/* get the the value of the stack pointer
unsigned int __get_SP(void) */
#define RHINO_GET_SP() (void *)__get_SP()
/* Returns the number of leading 0-bits in x,
starting at the most signifi cant bit position. */
#define RHINO_BIT_CLZ(x) __CLZ(x)
//#define RHINO_BIT_CTZ(x)
#ifndef RHINO_WEAK
#define RHINO_WEAK __weak
#endif
#ifndef RHINO_ASM
#define RHINO_ASM asm
#endif
/* Instruction Synchronization Barrier */
#define OS_ISB() __isb(15) /* Full system Any-Any */
/* Data Memory Barrier */
#define OS_DMB() __dmb(15) /* Full system Any-Any */
/* Data Synchronization Barrier */
#define OS_DSB() __dsb(15) /* Full system Any-Any */
#elif defined(__GNUC__)
#define RHINO_INLINE static inline
/* get the return address of the current function
void * __builtin_return_address (unsigned int level) */
#define RHINO_GET_RA() __builtin_return_address(0)
/* get the return address of the current function */
__attribute__((always_inline)) RHINO_INLINE void *RHINO_GET_SP(void)
{
void *sp;
__asm__ volatile("mov %0, SP\n":"=r"(sp));
return sp;
}
/* Returns the number of leading 0-bits in x,
starting at the most signifi cant bit position. */
#define RHINO_BIT_CLZ(x) __builtin_clz(x)
/* Returns the number of trailing 0-bits in x,
starting at the least signifi cant bit position. */
#define RHINO_BIT_CTZ(x) __builtin_ctz(x)
#ifndef RHINO_WEAK
#define RHINO_WEAK __attribute__((weak))
#endif
#ifndef RHINO_ASM
#define RHINO_ASM __asm__
#endif
/* Instruction Synchronization Barrier */
#define OS_ISB() __asm volatile ("isb sy":::"memory")
/* Data Memory Barrier */
#define OS_DMB() __asm volatile ("dmb sy":::"memory")
/* Data Synchronization Barrier */
#define OS_DSB() __asm volatile ("dsb sy":::"memory")
#else
#error "Unsupported compiler"
#endif
#endif /* K_COMPILER_H */
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/include/k_compiler.h
|
C
|
apache-2.0
| 3,590
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef K_TYPES_H
#define K_TYPES_H
#include "k_compiler.h"
#define RHINO_TASK_STACK_OVF_MAGIC 0xdeadbeafu /* stack overflow magic value */
#define RHINO_INTRPT_STACK_OVF_MAGIC 0xdeaddeadu /* stack overflow magic value */
#define RHINO_MM_CORRUPT_DYE 0xFEFEFEFE
#define RHINO_MM_FREE_DYE 0xABABABAB
typedef uint32_t cpu_stack_t;
typedef uint32_t hr_timer_t;
typedef uint32_t lr_timer_t;
typedef uint32_t cpu_cpsr_t;
#endif /* K_TYPES_H */
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/include/k_types.h
|
C
|
apache-2.0
| 538
|
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef PORT_H
#define PORT_H
cpu_cpsr_t cpu_intrpt_save(void);
void cpu_intrpt_restore(cpu_cpsr_t cpsr);
void cpu_intrpt_switch(void);
void cpu_task_switch(void);
void cpu_first_task_start(void);
void *cpu_task_stack_init(cpu_stack_t *base, size_t size, void *arg, task_entry_t entry);
RHINO_INLINE uint8_t cpu_cur_get(void)
{
return 0;
}
#define CPSR_ALLOC() cpu_cpsr_t cpsr
#define RHINO_CPU_INTRPT_DISABLE() do{cpsr = cpu_intrpt_save();}while(0)
#define RHINO_CPU_INTRPT_ENABLE() do{cpu_intrpt_restore(cpsr);}while(0)
#endif /* PORT_H */
|
YifuLiu/AliOS-Things
|
hardware/arch/armv7m/include/port.h
|
C
|
apache-2.0
| 643
|