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
|
|---|---|---|---|---|---|
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/docs/examples/power_meter/nodemcu32s/code/dds5188.py
|
Python
|
apache-2.0
| 1,534
|
# -*- encoding: utf-8 -*-
from aliyunIoT import Device # aliyunIoT组件是连接阿里云物联网平台的组件
import utime # 延时API所在组件
import ujson # json字串解析库
import network # network是Wi-Fi网络连接的组件
import dds5188
# 物联网平台连接标志位
iot_connected = False
# 三元组信息
productKey = "产品密钥"
deviceName = "设备名称"
deviceSecret = "设备密钥"
# Wi-Fi SSID和Password设置
wifiSsid = "请填写您的路由器名称"
wifiPassword = "请填写您的路由器密码"
# 物联网设备实例
device = None
dds5188_dev = None
wlan = None
# 等待Wi-Fi成功连接到路由器
def get_wifi_status():
global wlan
wifi_connected = False
wlan.active(True) # 激活界面
wlan.scan() # 扫描接入点
wlan.disconnect() # 断开Wi-Fi
#print("start to connect ", wifiSsid)
# 连接到指定的路由器（路由器名称为wifiSsid, 密码为：wifiPassword）
wlan.connect(wifiSsid, wifiPassword)
while True:
wifi_connected = wlan.isconnected() # 获取Wi-Fi连接路由器的状态信息
if wifi_connected: # Wi-Fi连接成功则退出while循环
break
else:
utime.sleep(0.5)
print("wifi_connected:", wifi_connected)
ifconfig = wlan.ifconfig() # 获取接口的IP/netmask/gw/DNS地址
print(ifconfig)
utime.sleep(0.5)
# 物联网平台连接成功的回调函数
def on_connect(data):
global iot_connected
iot_connected = True
def on_props(request):
pass
# 连接物联网平台
def connect_lk(productKey, deviceName, deviceSecret):
global device, iot_connected
key_info = {
'region': 'cn-shanghai',
'productKey': productKey,
'deviceName': deviceName,
'deviceSecret': deviceSecret,
'keepaliveSec': 60
}
# 将三元组信息设置到iot组件中
device = Device()
# 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
device.on(Device.ON_CONNECT, on_connect)
# 配置收到云端属性控制指令的回调函数，如果收到物联网平台发送的属性控制消息，则调用on_props函数
device.on(Device.ON_PROPS, on_props)
# 启动连接阿里云物联网平台过程
device.connect(key_info)
# 等待设备成功连接到物联网平台
while(True):
if iot_connected:
print('物联网平台连接成功')
break
else:
print('sleep for 1 s')
utime.sleep(1)
# 上传火焰传感器检测电压信息和报警信息到物联网平台
def upload_state():
global device, dds5188_dev
# 无限循环
while True:
tup = dds5188_dev.getKWh()
if tup[0] != 0:
utime.sleep(2)
continue
energy = tup[1]
tup = dds5188_dev.getVoltage()
if tup[0] != 0:
utime.sleep(2)
continue
voltage = tup[1]
tup = dds5188_dev.getCurrent()
if tup[0] != 0:
utime.sleep(2)
continue
current = tup[1]
tup = dds5188_dev.getActivePower()
if tup[0] != 0:
utime.sleep(2)
continue
active_power = tup[1]
prop = ujson.dumps({
'energy': energy,
'voltage': voltage,
'current': current,
'activePower': active_power
})
print("uploading data to the cloud, ", prop)
upload_data = {'params': prop}
# 上传火焰传感器测量结果和报警灯状态到物联网平台
device.postProps(upload_data)
# 每2秒钟上报一次
utime.sleep(2)
if __name__ == '__main__':
wlan = network.WLAN(network.STA_IF) # 创建WLAN对象
dds5188_dev = dds5188.DDS5188('mb1', 2)
# 请替换物联网平台申请到的产品和设备信息,可以参考文章:https://blog.csdn.net/HaaSTech/article/details/114360517
get_wifi_status()
connect_lk(productKey, deviceName, deviceSecret)
upload_state()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/power_meter/nodemcu32s/code/main.py
|
Python
|
apache-2.0
| 4,180
|
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/docs/examples/power_saver/esp32/code/ir.py
|
Python
|
apache-2.0
| 410
|
# -*- coding: UTF-8 -*-
from aliyunIoT import Device # iot组件是连接阿里云物联网平台的组件
import network # Wi-Fi功能所在库
import ujson # json字串解析库
import utime # 延时API所在组件
from driver import GPIO # GPIO类，用于控制微处理器的输入输出功能
from ir import IR
import modbus
from micropython import const
irDev = 0
# 继电器设备ID
MODBUS_SLAVE_ID = const(1)
# modbus 访问超时，单位是毫秒
MODBUS_TIMEOUT_MS = const(200)
# 红外传感器检测周期，单位是秒
CHECK_PERIOD_SEC = const(3)
# 物联网平台连接标志位
iot_connected = False
wlan = None
# 三元组信息
productKey = "产品密钥"
deviceName = "设备名称"
deviceSecret = "设备密钥"
# 物联网设备实例
device = None
# Wi-Fi SSID和Password设置
wifiSsid = "WiFi名称"
wifiPassword = "WiFi密码"
# 等待Wi-Fi成功连接到路由器
def get_wifi_status():
global wlan
wifi_connected = False
wlan.active(True) #激活界面
wlan.scan() #扫描接入点
wlan.disconnect() #断开Wi-Fi
#print("start to connect ", wifiSsid)
wlan.connect(wifiSsid, wifiPassword) # 连接到指定的路由器（路由器名称为wifiSsid, 密码为：wifiPassword）
while True:
wifi_connected = wlan.isconnected() # 获取Wi-Fi连接路由器的状态信息
if wifi_connected: # Wi-Fi连接成功则退出while循环
break
else:
utime.sleep(0.5)
print("wifi_connected:", wifi_connected)
ifconfig = wlan.ifconfig() #获取接口的IP/netmask/gw/DNS地址
print(ifconfig)
utime.sleep(0.5)
# 物联网平台连接成功的回调函数
def on_connect(data):
global iot_connected
iot_connected = True
# 设置props 事件接收函数（当云平台向设备下发属性时）
def on_props(request):
pass
def connect_lk(productKey, deviceName, deviceSecret):
global device, iot_connected
key_info = {
'region': 'cn-shanghai',
'productKey': productKey,
'deviceName': deviceName,
'deviceSecret': deviceSecret,
'keepaliveSec': 60
}
# 将三元组信息设置到iot组件中
device = Device()
# 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
device.on(Device.ON_CONNECT, on_connect)
# 配置收到云端属性控制指令的回调函数，如果收到物联网平台发送的属性控制消息，则调用on_props函数
device.on(Device.ON_PROPS, on_props)
# 启动连接阿里云物联网平台过程
device.connect(key_info)
# 等待设备成功连接到物联网平台
while(True):
if iot_connected:
print('物联网平台连接成功')
break
else:
print('sleep for 1 s')
utime.sleep(1)
print('sleep for 2s')
utime.sleep(2)
def ir_init():
global irDev
gpioirDev = GPIO()
gpioirDev.open("ir")
irDev = IR(gpioirDev)
def modbus_init():
modbus.init('modbus_9600')
#设置/获取 设备地址仅仅针对特定的modbus终端，不代表所有设备都能访问。
# 设置设备地址为 1
data=bytearray([MODBUS_SLAVE_ID, 0x00])
ret = modbus.writeMultipleHoldingRegisters(0, 0, 1, data, MODBUS_TIMEOUT_MS)
if(ret[0] != 0):
print('Failed to set slave ID')
# 获取设备地址
data=bytearray([0xAA, 0x55])
ret = modbus.readHoldingRegisters(0, 0, 1, data, MODBUS_TIMEOUT_MS)
if(data[0] != MODBUS_SLAVE_ID):
print('Slave ID is not set to 1')
def open_relay(index):
modbus.writeCoil(MODBUS_SLAVE_ID, index, 0xFF00, MODBUS_TIMEOUT_MS)
def close_relay(index):
modbus.writeCoil(MODBUS_SLAVE_ID, index, 0x0000, MODBUS_TIMEOUT_MS)
def person_detector() :
global irDev
lastIRExist = 0
while True: # 无限循环
thisIRExist = irDev.irDetect()
print('thisIRExist = ', thisIRExist)
if(lastIRExist != thisIRExist):
# 生成上报到物联网平台的属性值字串，此处的属性标识符"door_opened"必须和物联网平台的属性一致
# "door_opened" - 表示入户门开关状态
upload_data = {'params': ujson.dumps({
'is_person_exist': thisIRExist,
})
}
# 上传状态到物联网平台
device.postProps(upload_data)
if(thisIRExist == 1):
open_relay(0)
else:
close_relay(0)
lastIRExist = thisIRExist
utime.sleep(CHECK_PERIOD_SEC) # 打印完之后休眠3秒
if __name__ == '__main__' :
wlan = network.WLAN(network.STA_IF) #创建WLAN对象
get_wifi_status()
connect_lk(productKey, deviceName, deviceSecret)
ir_init()
#初始化modbus设备
modbus_init()
person_detector()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/power_saver/esp32/code/main.py
|
Python
|
apache-2.0
| 5,101
|
# coding=utf-8
from driver import GPIO
import network
import ujson
import utime as time
import modem
from aliyunIoT import Device
import kv
import read
import write
import _thread
import mfrc522
import ujson
from driver import WDT
wdt = WDT()
wdt.open('wdt')
wdt.feed()
global g_connect_status,net,device,deviceSecret,deviceName,productKey,productSecret,device_dyn_resigter_succed,cloud_led
g_connect_status= False
net= None
device = None
deviceSecret = None
deviceName = None
#input your productKey and productSecret
productKey = "yourProductKey"
productSecret = "yourProductSecret"
device_dyn_resigter_succed = False
led1 = GPIO()
#当iot设备连接到物联网平台的时候触发'connect' 事件
def on_connect(data):
print('***** connect lp succeed****')
#当iot云端下发属性设置时，触发'props'事件
def on_props(request):
print('clound req data is {}'.format(request))
#当iot云端调用设备service时，触发'service'事件
def on_service(id,request):
print('clound req id is {} , req is {}'.format(id,request))
#当设备跟iot平台通信过程中遇到错误时，触发'error'事件
def on_error(err):
print('err msg is {} '.format(err))
#网络连接的回调函数
def on_4g_cb(args):
global g_connect_status
pdp = args[0]
netwk_sta = args[1]
if netwk_sta == 1:
g_connect_status = True
else:
g_connect_status = False
#网络连接
def connect_network():
global net,on_4g_cb,g_connect_status
#NetWorkClient该类是一个单例类，实现网络管理相关的功能，包括初始化，联网，状态信息等.
net = network.NetWorkClient()
g_register_network = False
if net._stagecode is not None and net._stagecode == 3 and net._subcode == 1:
g_register_network = True
else:
g_register_network = False
if g_register_network:
#注册网络连接的回调函数on(self,id,func); 1代表连接，func 回调函数 ；return 0 成功
net.on(1,on_4g_cb)
net.connect(None)
else:
print('network register failed')
while True:
if g_connect_status==False:
pass
if g_connect_status:
print('network register successed')
break
time.sleep_ms(20)
#动态注册回调函数
def on_dynreg_cb(data):
global deviceSecret,device_dyn_resigter_succed
deviceSecret = data
device_dyn_resigter_succed = True
# 连接物联网平台
def dyn_register_device(productKey,productSecret,deviceName):
global on_dynreg_cb,device,deviceSecret
key = '_amp_customer_devicesecret'
deviceSecretdict = kv.get(key)
print("deviceSecretdict:",deviceSecretdict)
if isinstance(deviceSecretdict,str):
deviceSecret = deviceSecretdict
else:
deviceSecret = None
if deviceSecret is None:
key_info = {
'productKey': productKey ,
'productSecret': productSecret ,
'deviceName': deviceName
}
# 动态注册一个设备，获取设备的deviceSecret
device.register(key_info,on_dynreg_cb)
def rfid_read():
global device,led1,wdt
led1.open('led1')
rdr=mfrc522.MFRC522()
while True:
ret,cardid = read.do_read(rdr)
if ret == True:
print('card authen ok!')
senddata = {'cardinfo':'findCard','cardid':"0x%02x%02x%02x%02x" % (cardid[0], cardid[1], cardid[2], cardid[3])}
data = {'params': ujson.dumps(senddata)}
device.postProps(data)
level = led1.read()
if level == 1:
led1.write(0)
else:
led1.write(1)
else:
print('card authen failed!')
time.sleep(1)
wdt.feed()
def main():
global g_connect_status,net,device,deviceSecret,deviceName,productKey,productSecret,device_dyn_resigter_succed
#连接网络
connect_network()
#获取设备的IMEI 作为deviceName 进行动态注册
deviceName = modem.getDevImei()
#初始化物联网平台Device类，获取device实例
device = Device()
if deviceName is not None and len(deviceName) > 0 :
#动态注册一个设备
dyn_register_device(productKey,productSecret,deviceName)
else:
print("can't get IMEI")
while deviceSecret is None:
time.sleep(0.2)
print('dynamic successed:' + deviceSecret)
key_info = {
'region' : 'cn-shanghai' ,
'productKey': productKey ,
'deviceName': deviceName ,
'deviceSecret': deviceSecret ,
'keepaliveSec': 60
}
#打印设备信息
print(key_info)
#device.ON_CONNECT 是事件，on_connect是事件处理函数/回调函数
device.on(device.ON_CONNECT,on_connect)
device.on(device.ON_PROPS,on_props)
device.on(device.ON_SERVICE,on_service)
device.on(device.ON_ERROR,on_error)
device.connect(key_info)
write.do_write()
_thread.start_new_thread(rfid_read,())
if __name__=="__main__":
main()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/rc522_write_read/haas506/code/main.py
|
Python
|
apache-2.0
| 5,054
|
from driver import SPI
from driver import GPIO
class MFRC522:
OK = 0
NOTAGERR = 1
ERR = 2
REQIDL = 0x26
REQALL = 0x52
AUTHENT1A = 0x60 #验证A密钥
AUTHENT1B = 0x61 #验证B密钥
def __init__(self):
self.spi=SPI()
self.spi.open('SPI0')
self.rst=GPIO()
self.rst.open('rst')
self.rst.write(0)
self.rst.write(1)
self.init()
def deinit(self):
self.spi.close()
def _wreg(self, reg, val):
writeBuf=bytearray([int(0xff & ((reg << 1) & 0x7e)),int(0xff & val)])
self.spi.write(writeBuf)
def _rreg(self, reg):
readBuf=bytearray(1)
writeBuf=bytearray([int(0xff & (((reg << 1) & 0x7e) | 0x80))])
self.spi.write(writeBuf)
self.spi.read(readBuf)
return readBuf[0]
def _sflags(self, reg, mask):
self._wreg(reg, self._rreg(reg) | mask)
def _cflags(self, reg, mask):
self._wreg(reg, self._rreg(reg) & (~mask))
def _tocard(self, cmd, send):
recv = []
bits = irq_en = wait_irq = n = 0
stat = self.ERR
if cmd == 0x0E:
irq_en = 0x12
wait_irq = 0x10
elif cmd == 0x0C:
irq_en = 0x77
wait_irq = 0x30
self._wreg(0x02, irq_en | 0x80)
self._cflags(0x04, 0x80)
self._sflags(0x0A, 0x80)
self._wreg(0x01, 0x00)
for c in send:
self._wreg(0x09, c)
self._wreg(0x01, cmd)
if cmd == 0x0C:
self._sflags(0x0D, 0x80)
i = 2000
while True:
n = self._rreg(0x04)
i -= 1
if ~((i != 0) and ~(n & 0x01) and ~(n & wait_irq)):
break
self._cflags(0x0D, 0x80)
if i:
if (self._rreg(0x06) & 0x1B) == 0x00:
stat = self.OK
if n & irq_en & 0x01:
stat = self.NOTAGERR
elif cmd == 0x0C:
n = self._rreg(0x0A)
lbits = self._rreg(0x0C) & 0x07
if lbits != 0:
bits = (n - 1) * 8 + lbits
else:
bits = n * 8
if n == 0:
n = 1
elif n > 16:
n = 16
for _ in range(n):
recv.append(self._rreg(0x09))
else:
stat = self.ERR
return stat, recv, bits
def _crc(self, data):
self._cflags(0x05, 0x04)
self._sflags(0x0A, 0x80)
for c in data:
self._wreg(0x09, c)
self._wreg(0x01, 0x03)
i = 0xFF
while True:
n = self._rreg(0x05)
i -= 1
if not ((i != 0) and not (n & 0x04)):
break
return [self._rreg(0x22), self._rreg(0x21)]
def init(self):
self.reset()
self._wreg(0x2A, 0x8D)
self._wreg(0x2B, 0x3E)
self._wreg(0x2D, 30)
self._wreg(0x2C, 0)
self._wreg(0x15, 0x40)
self._wreg(0x11, 0x3D)
self.antenna_on()
def reset(self):
self._wreg(0x01, 0x0F)
def antenna_on(self, on=True):
if on and ~(self._rreg(0x14) & 0x03):
self._sflags(0x14, 0x03)
else:
self._cflags(0x14, 0x03)
def request(self, mode):
self._wreg(0x0D, 0x07)
(stat, recv, bits) = self._tocard(0x0C, [mode])
if (stat != self.OK) | (bits != 0x10):
stat = self.ERR
return stat, bits
def anticoll(self):
ser_chk = 0
ser = [0x93, 0x20]
self._wreg(0x0D, 0x00)
(stat, recv, bits) = self._tocard(0x0C, ser)
if stat == self.OK:
if len(recv) == 5:
for i in range(4):
ser_chk = ser_chk ^ recv[i]
if ser_chk != recv[4]:
stat = self.ERR
else:
stat = self.ERR
return stat, recv
def select_tag(self, ser):
buf = [0x93, 0x70] + ser[:5]
buf += self._crc(buf)
(stat, recv, bits) = self._tocard(0x0C, buf)
return self.OK if (stat == self.OK) and (bits == 0x18) else self.ERR
def auth(self, mode, addr, sect, ser):
return self._tocard(0x0E, [mode, addr] + sect + ser[:4])[0]
def stop_crypto1(self):
self._cflags(0x08, 0x08)
def read(self, addr): #读块数据
data = [0x30, addr]
data += self._crc(data)
(stat, recv, _) = self._tocard(0x0C, data)
return recv if stat == self.OK else None
def write(self, addr, data):
buf = [0xA0, addr]
buf += self._crc(buf)
(stat, recv, bits) = self._tocard(0x0C, buf)
if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A):
stat = self.ERR
else:
buf = []
for i in range(16):
buf.append(data[i])
buf += self._crc(buf)
(stat, recv, bits) = self._tocard(0x0C, buf)
if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A):
stat = self.ERR
return stat
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/rc522_write_read/haas506/code/mfrc522.py
|
Python
|
apache-2.0
| 4,125
|
import mfrc522
import utime as time
def do_read(rdr):
print("enter do_read()")
try:
(stat, tag_type) = rdr.request(rdr.REQIDL)
if stat == rdr.OK:
(stat, raw_uid) = rdr.anticoll()
if stat == rdr.OK:
print("New card detected")
print(" - tag type: 0x%02x" % tag_type)
print(" - uid : 0x%02x%02x%02x%02x" % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
print("")
if rdr.select_tag(raw_uid) == rdr.OK:
#默认密钥
key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
#自定义密钥
# key = [0x61, 0x73, 0x64, 0x38, 0x38, 0x38]
if rdr.auth(rdr.AUTHENT1A, 1, key, raw_uid) == rdr.OK: # 验证密钥
# 例如扇区0：块0、块1、块2、块3
# 0x00就是扇区0块0数据的地址
# 0x01是扇区0的块1数据的地址
# 0x02 就是扇区0块2数据的地址
# 每增加一个块 地址就加1，有很多个扇区
# 每个扇区的 块3是校验密钥的，即存放密码的
# 当前读取的是 0x01，即扇区0块1的数据
print("data: %s" % rdr.read(1))
rdr.stop_crypto1()
return True,raw_uid
else:
print("Authentication error")
return False,False
else:
print("Failed to select tag")
return False,False
else:
return False,None
else:
return False,None
#set period of reading
# time.sleep(1)
except KeyboardInterrupt:
print("Bye")
return False,False
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/rc522_write_read/haas506/code/read.py
|
Python
|
apache-2.0
| 1,440
|
import mfrc522
import utime as time
def do_write():
rdr = mfrc522.MFRC522()
try:
while True:
(stat, tag_type) = rdr.request(rdr.REQIDL)
if stat == rdr.OK:
(stat, raw_uid) = rdr.anticoll()
if stat == rdr.OK:
print("New card detected")
print(" - tag type: 0x%02x" % tag_type)
print(" - uid : 0x%02x%02x%02x%02x" % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
print("")
if rdr.select_tag(raw_uid) == rdr.OK:
key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
if rdr.auth(rdr.AUTHENT1A, 1, key, raw_uid) == rdr.OK:
#往指定的块中 写数据，数据长度最大为16个字节
#当前 是往 0x01即扇区0块1写数据
stat = rdr.write(1, b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\xff")
rdr.stop_crypto1()
if stat == rdr.OK:
print("Data written to card")
rdr.deinit()
break
else:
print("Failed to write data to card")
else:
print("Authentication error")
else:
print("Failed to select tag")
#set period of writing
time.sleep(1)
except KeyboardInterrupt:
print("Bye")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/rc522_write_read/haas506/code/write.py
|
Python
|
apache-2.0
| 1,157
|
#########
from aliyunIoT import Device # iot组件是连接阿里云物联网平台的组件
import network # Wi-Fi功能所在库
import ujson
##################
from driver import SPI,GPIO,PWM
import mfrc522
import utime
import servo
rfid_card = 0
mfrc522Dev = 0
buzzerobj = 0
servoObj = 0
#########
# 物联网平台连接标志位
iot_connected = False
wlan = None
# 三元组信息
productKey = "产品密钥" #需要填入物联网云平台申请到的productKey信息
deviceName = "设备名称" #需要填入物联网云平台申请到的deviceName信息
deviceSecret = "设备密钥" #需要填入物联网云平台申请到的deviceSecret信息
# 物联网设备实例
device = None
# Wi-Fi SSID和Password设置
wifiSsid = "请填写您的路由器名称"
wifiPassword = "请填写您的路由器密码"
# 等待Wi-Fi成功连接到路由器
def get_wifi_status():
global wlan
wifi_connected = False
wlan.active(True) #激活界面
wlan.scan() #扫描接入点
#print("start to connect ", wifiSsid)
wlan.connect(wifiSsid, wifiPassword) # 连接到指定路由器名称和密码
while True:
wifi_connected = wlan.isconnected() # 获取Wi-Fi连接路由器的状态信息
if wifi_connected: # Wi-Fi连接成功则退出while循环
break
else:
utime.sleep(0.5)
print("wifi_connected:", wifi_connected)
ifconfig = wlan.ifconfig() #获取接口的IP/netmask/gw/DNS地址
print(ifconfig)
utime.sleep(0.5)
# 物联网平台连接成功的回调函数
def on_connect(data):
global iot_connected
iot_connected = True
# 设置props 事件接收函数（当云平台向设备下发属性时）
def on_props(request):
payload = ujson.loads(request['params'])
# print (payload)
# 获取dict状态字段 注意要验证键存在 否则会抛出异常
if "open_door" in payload.keys():
opendoor_value = payload["open_door"]
if (opendoor_value):
door_open()
buzzer_cardmarch()
print("打开门")
else:
print("不反应")
def report_event():
global rfid_card
upload_data = {'params': ujson.dumps({
'rfid_card': str(rfid_card),
})
}
# 上传端测的RFID卡号到物联网平台
print(upload_data)
device.postProps(upload_data)
def connect_lk(productKey, deviceName, deviceSecret):
global device, iot_connected
key_info = {
'region': 'cn-shanghai',
'productKey': productKey,
'deviceName': deviceName,
'deviceSecret': deviceSecret,
'keepaliveSec': 60
}
# 将三元组信息设置到iot组件中
device = Device()
# 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
device.on(Device.ON_CONNECT, on_connect)
# 如果收到物联网平台发送的属性控制消息
device.on(Device.ON_PROPS, on_props)
# 启动连接阿里云物联网平台过程
device.connect(key_info)
# 等待设备成功连接到物联网平台
while(True):
if iot_connected:
print('物联网平台连接成功')
break
else:
print('sleep for 1 s')
utime.sleep(1)
print('sleep for 2s')
utime.sleep(2)
#########
def servo_init():
global servoObj
pwmObj = PWM()
pwmObj.open("servo")
data_r = {'freq':50, 'duty': 0}
pwmObj.setOption(data_r)
print("buzzer inited!")
servoObj = servo.SERVO(pwmObj)
def door_open():
servoObj.setOptionSero(90)
print("90")
utime.sleep(1)
servoObj.setOptionSero(0)
print("0")
def init_mfrc522():
global mfrc522Dev
spiDev = SPI()
spiDev.open("mfrc522")
sda_gpio = GPIO()
sda_gpio.open("mfrc522_sda")
reset_gpio = GPIO()
reset_gpio.open("mfrc522_rst")
mfrc522Dev = mfrc522.MFRC522(spiDev, sda_gpio, reset_gpio)
print("mfrc522 inited!")
def init_buzzer():
global buzzerobj
buzzerobj = GPIO()
buzzerobj.open('buzzer')
def buzzer_readcard():
buzzerobj.write(1)
utime.sleep_ms(500)
buzzerobj.write(0)
utime.sleep_ms(500)
def buzzer_cardmarch():
buzzerobj.write(1)
utime.sleep(1)
buzzerobj.write(0)
utime.sleep_ms(100)
buzzerobj.write(1)
utime.sleep_ms(100)
buzzerobj.write(0)
if __name__ == '__main__' :
##########
wlan = network.WLAN(network.STA_IF) #创建WLAN对象
get_wifi_status()
connect_lk(productKey, deviceName, deviceSecret)
##########
servo_init()
init_buzzer()
init_mfrc522()
while True:
print("\nHold a tag near the reader")
rfid_card = mfrc522Dev.readCardID()
buzzer_readcard()
report_event()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/rfid_open_door/esp32/code/main.py
|
Python
|
apache-2.0
| 4,896
|
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/docs/examples/rfid_open_door/esp32/code/mfrc522.py
|
Python
|
apache-2.0
| 14,351
|
"""
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/docs/examples/rfid_open_door/esp32/code/servo.py
|
Python
|
apache-2.0
| 642
|
# coding=utf-8
from driver import GPIO
from driver import PWM
import network
import ujson
import utime as time
import modem
from aliyunIoT import Device
import kv
import mfrc522
#当iot设备连接到物联网平台的时候触发'connect' 事件
def on_connect(data):
global module_name,default_ver,productKey,deviceName,deviceSecret,on_trigger,on_download,on_verify,on_upgrade
print('***** connect lp succeed****')
data_handle = {}
data_handle['device_handle'] = device.getDeviceHandle()
#当连接断开时，触发'disconnect'事件
def on_disconnect():
print('linkkit is disconnected')
#当iot云端下发属性设置时，触发'props'事件
def on_props(request):
global servo_data
params=request['params']
params=eval(params)
servo=params["open_door"]
servo_data={}
if servo ==1:
param2 = {'freq':50, 'duty': 12 }
pwm_lpg.setOption(param2)
print('open zhe door')
servo_data["open_door"]= 1
servo_data_str=ujson.dumps(servo_data)
data={
'params':servo_data_str
}
device.postProps(data)
time.sleep(3)
print('-----------------------------------')
param2 = {'freq':50, 'duty': 5 }
pwm_lpg.setOption(param2)
time.sleep(1)
servo_data["open_door"]= 0
servo_data_str=ujson.dumps(servo_data)
data={
'params':servo_data_str
}
device.postProps(data)
else:
pass
#当iot云端调用设备service时，触发'service'事件
def on_service(id,request):
print('clound req id is {} , req is {}'.format(id,request))
#当设备跟iot平台通信过程中遇到错误时，触发'error'事件
def on_error(err):
print('err msg is {} '.format(err))
#网络连接的回调函数
def on_4g_cb(args):
global g_connect_status
pdp = args[0]
netwk_sta = args[1]
if netwk_sta == 1:
g_connect_status = True
else:
g_connect_status = False
#网络连接
def connect_network():
global net,on_4g_cb,g_connect_status
#NetWorkClient该类是一个单例类，实现网络管理相关的功能，包括初始化，联网，状态信息等.
net = network.NetWorkClient()
g_register_network = False
if net._stagecode is not None and net._stagecode == 3 and net._subcode == 1:
g_register_network = True
else:
g_register_network = False
if g_register_network:
#注册网络连接的回调函数on(self,id,func); 1代表连接，func 回调函数 ；return 0 成功
net.on(1,on_4g_cb)
net.connect(None)
else:
print('网络注册失败')
while True:
if g_connect_status:
print('网络连接成功')
break
time.sleep_ms(20)
#动态注册回调函数
def on_dynreg_cb(data):
global deviceSecret,device_dyn_resigter_succed
deviceSecret = data
device_dyn_resigter_succed = True
# 连接物联网平台
def dyn_register_device(productKey,productSecret,deviceName):
global on_dynreg_cb,device,deviceSecret,device_dyn_resigter_succed
key = '_amp_customer_devicesecret'
deviceSecretdict = kv.get(key)
print("deviceSecretdict:",deviceSecretdict)
if isinstance(deviceSecretdict,str):
deviceSecret = deviceSecretdict
if deviceSecretdict is None or deviceSecret is None:
key_info = {
'productKey': productKey ,
'productSecret': productSecret ,
'deviceName': deviceName
}
# 动态注册一个设备，获取设备的deviceSecret
#下面的if防止多次注册，当前若是注册过一次了，重启设备再次注册就会卡住，
if not device_dyn_resigter_succed:
device.register(key_info,on_dynreg_cb)
def upload_uid():
global uid_data
uid_data["rfid"]= uid
uid_data_str=ujson.dumps(uid_data)
data={
'params':uid_data_str
}
device.postProps(data)
def do_read():
global uid,uid_data
rdr=mfrc522.MFRC522()
uid = ''
try:
while True:
(stat, tag_type) = rdr.request(rdr.REQIDL)
if stat == rdr.OK:
(stat, raw_uid) = rdr.anticoll()
if stat == rdr.OK:
uid=hex(raw_uid[0])[2:]+hex(raw_uid[1])[2:]+hex(raw_uid[2])[2:]+hex(raw_uid[3])[2:]
print(' - uid : ',uid)
upload_uid()
else:
print('read error')
time.sleep(1)
except KeyboardInterrupt:
print("Bye")
if __name__ == '__main__':
ICCID=None
g_connect_status = False
net = None
device = None
deviceSecret = None
deviceName = None
#复制产品证书内容替换
productKey = "your-productKey"
productSecret = "your-productSecret"
device_dyn_resigter_succed = False
# 连接网络
connect_network()
# 获取设备的IMEI 作为deviceName 进行动态注册
deviceName = modem.info.getDevImei()
#获取设备的ICCID
ICCID=modem.sim.getIccid()
#初始化物联网平台Device类，获取device实例
device = Device()
if deviceName is not None and len(deviceName) > 0 :
#动态注册一个设备
dyn_register_device(productKey,productSecret,deviceName)
else:
print("获取设备IMEI失败，无法进行动态注册")
while deviceSecret is None:
time.sleep(0.2)
print('动态注册成功:' + deviceSecret)
key_info = {
'region' : 'cn-shanghai' ,
'productKey': productKey ,
'deviceName': deviceName ,
'deviceSecret': deviceSecret ,
'keepaliveSec': 60,
}
#打印设备信息
print(key_info)
#device.ON_CONNECT 是事件，on_connect是事件处理函数/回调函数
device.on(device.ON_CONNECT,on_connect)
device.on(device.ON_DISCONNECT,on_disconnect)
device.on(device.ON_PROPS,on_props)
device.on(device.ON_SERVICE,on_service)
device.on(device.ON_ERROR,on_error)
device.connect(key_info)
#上报版本信息
servo_data={}
pwm_lpg = PWM()
pwm_lpg.open("pwm_lpg")
param2 = {'freq':50, 'duty': 5 }
pwm_lpg.setOption(param2)
time.sleep(1)
servo_data["open_door"]= 0
servo_data_str=ujson.dumps(servo_data)
data={
'params':servo_data_str
}
device.postProps(data)
print('witing read ------ ')
uid_data={}
do_read()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/rfid_open_door/haas506/code/main.py
|
Python
|
apache-2.0
| 6,413
|
from driver import SPI
from driver import GPIO
class MFRC522:
OK = 0
NOTAGERR = 1
ERR = 2
REQIDL = 0x26
REQALL = 0x52
AUTHENT1A = 0x60 #验证A密钥
AUTHENT1B = 0x61 #验证B密钥
def __init__(self):
self.spi=SPI()
self.spi.open('SPI0')
self.rst=GPIO()
self.rst.open('rst')
self.rst.write(0)
self.rst.write(1)
self.init()
def _wreg(self, reg, val):
writeBuf=bytearray([int(0xff & ((reg << 1) & 0x7e)),int(0xff & val)])
self.spi.write(writeBuf,2)
def _rreg(self, reg):
readBuf=bytearray(1)
writeBuf=bytearray([int(0xff & (((reg << 1) & 0x7e) | 0x80))])
self.spi.write(writeBuf,1)
self.spi.read(readBuf,1)
return readBuf[0]
def _sflags(self, reg, mask):
self._wreg(reg, self._rreg(reg) | mask)
def _cflags(self, reg, mask):
self._wreg(reg, self._rreg(reg) & (~mask))
def _tocard(self, cmd, send):
recv = []
bits = irq_en = wait_irq = n = 0
stat = self.ERR
if cmd == 0x0E:
irq_en = 0x12
wait_irq = 0x10
elif cmd == 0x0C:
irq_en = 0x77
wait_irq = 0x30
self._wreg(0x02, irq_en | 0x80)
self._cflags(0x04, 0x80)
self._sflags(0x0A, 0x80)
self._wreg(0x01, 0x00)
for c in send:
self._wreg(0x09, c)
self._wreg(0x01, cmd)
if cmd == 0x0C:
self._sflags(0x0D, 0x80)
i = 2000
while True:
n = self._rreg(0x04)
i -= 1
if ~((i != 0) and ~(n & 0x01) and ~(n & wait_irq)):
break
self._cflags(0x0D, 0x80)
if i:
if (self._rreg(0x06) & 0x1B) == 0x00:
stat = self.OK
if n & irq_en & 0x01:
stat = self.NOTAGERR
elif cmd == 0x0C:
n = self._rreg(0x0A)
lbits = self._rreg(0x0C) & 0x07
if lbits != 0:
bits = (n - 1) * 8 + lbits
else:
bits = n * 8
if n == 0:
n = 1
elif n > 16:
n = 16
for _ in range(n):
recv.append(self._rreg(0x09))
else:
stat = self.ERR
return stat, recv, bits
def _crc(self, data):
self._cflags(0x05, 0x04)
self._sflags(0x0A, 0x80)
for c in data:
self._wreg(0x09, c)
self._wreg(0x01, 0x03)
i = 0xFF
while True:
n = self._rreg(0x05)
i -= 1
if not ((i != 0) and not (n & 0x04)):
break
return [self._rreg(0x22), self._rreg(0x21)]
def init(self):
self.reset()
self._wreg(0x2A, 0x8D)
self._wreg(0x2B, 0x3E)
self._wreg(0x2D, 30)
self._wreg(0x2C, 0)
self._wreg(0x15, 0x40)
self._wreg(0x11, 0x3D)
self.antenna_on()
def reset(self):
self._wreg(0x01, 0x0F)
def antenna_on(self, on=True):
if on and ~(self._rreg(0x14) & 0x03):
self._sflags(0x14, 0x03)
else:
self._cflags(0x14, 0x03)
def request(self, mode):
self._wreg(0x0D, 0x07)
(stat, recv, bits) = self._tocard(0x0C, [mode])
if (stat != self.OK) | (bits != 0x10):
stat = self.ERR
return stat, bits
def anticoll(self):
ser_chk = 0
ser = [0x93, 0x20]
self._wreg(0x0D, 0x00)
(stat, recv, bits) = self._tocard(0x0C, ser)
if stat == self.OK:
if len(recv) == 5:
for i in range(4):
ser_chk = ser_chk ^ recv[i]
if ser_chk != recv[4]:
stat = self.ERR
else:
stat = self.ERR
return stat, recv
def select_tag(self, ser):
buf = [0x93, 0x70] + ser[:5]
buf += self._crc(buf)
(stat, recv, bits) = self._tocard(0x0C, buf)
return self.OK if (stat == self.OK) and (bits == 0x18) else self.ERR
def auth(self, mode, addr, sect, ser):
return self._tocard(0x0E, [mode, addr] + sect + ser[:4])[0]
def stop_crypto1(self):
self._cflags(0x08, 0x08)
def read(self, addr): #读块数据
data = [0x30, addr]
data += self._crc(data)
(stat, recv, _) = self._tocard(0x0C, data)
return recv if stat == self.OK else None
def write(self, addr, data):
buf = [0xA0, addr]
buf += self._crc(buf)
(stat, recv, bits) = self._tocard(0x0C, buf)
if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A):
stat = self.ERR
else:
buf = []
for i in range(16):
buf.append(data[i])
buf += self._crc(buf)
(stat, recv, bits) = self._tocard(0x0C, buf)
if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A):
stat = self.ERR
return stat
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/rfid_open_door/haas506/code/mfrc522.py
|
Python
|
apache-2.0
| 4,092
|
from driver import PWM
class BUZZER(object):
def __init__(self, pwmObj,data=None):
self.pwmObj = None
if not isinstance(pwmObj, PWM):
raise ValueError("parameter is not an PWM object")
self.pwmObj = pwmObj
if data is not None:
self.setOptionDuty(data)
def setOptionDuty(self,data):
if self.pwmObj is None:
raise ValueError("invalid PWM object")
self.pwmObj.setOption(data)
def start(self,data):
if self.pwmObj is None:
raise ValueError("invalid PWM object")
self.setOptionDuty(data)
def close(self,data):
if self.pwmObj is None:
raise ValueError("invalid PWM object")
self.setOptionDuty(data)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/security_monitoring_system/m5stack/code/buzzer.py
|
Python
|
apache-2.0
| 757
|
#!/usr/bin/env python3
# -*- encoding: utf-8 -*-
'''
@File : cloudAI.py
@Description: 云端AI
@Author : jiangyu
@version : 1.0
'''
from aliyunIoT import Device
import utime # 延时函数在utime库中
import ujson as json
class CloudAI :
def __gesture_cb(self, dict) :
'''
Reply list :
handGestureReply : 手势识别
'''
gesture = 'NA'
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
result = ext_dict['result']
if result == 'success':
score = ext_dict['score']
if score > 0.4 :
gesture = ext_dict['type']
print("recognize hand gesture : " + gesture)
self.__cb('handGestureReply', gesture)
def __action_cb(self, dict) :
'''
Reply list :
actionReply : 动作识别
'''
action = 'NA'
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
i = 0
elements_list = ext_dict['elements']
while (i < len(elements_list)) :
g_score = elements_list[i]['score']
label = elements_list[i]['label']
if g_score > 0.5:
print("recognize action: " + label)
action = label
break
i += 1
self.__cb('recognizeActionReply', action)
def __license_plate_cb(self, dict) :
plateNumber = 'NA'
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
result = ext_dict['result']
if result == 'success':
g_confidence = ext_dict['confidence']
if g_confidence > 0.7 :
plateNumber = ext_dict['plateNumber']
print('detect: ' + plateNumber)
self.__cb('ocrCarNoReply', plateNumber)
def __fruits_cb(self, dict) :
fruit_name = 'NA'
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
result = ext_dict['result']
if result == 'success':
i = 0
fruits_list = ext_dict['fruitList']
while (i < len(fruits_list)) :
g_score = fruits_list[i]['score']
fruit_name = fruits_list[i]['name']
if g_score > 0.6:
print('detect: ' + fruit_name)
i += 1
self.__cb('detectFruitsReply', fruit_name)
def __pedestrian_cb(self, dict) :
detected = False
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
result = ext_dict['result']
if result == 'success':
i = 0
data = ext_dict['data']
data_dict = json.loads(data)
elements_list = data_dict['elements']
while (i < len(elements_list)) :
g_score = elements_list[i]['score']
if g_score > 0.6:
print('Pedestrian Detected')
detected = True
i += 1
self.__cb('DetectPedestrianReply', detected)
def __businesscard_cb(self, dict) :
card_info = {}
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
result = ext_dict['result']
if result == 'success':
card_info['name'] = ext_dict['name']
print("name : " + card_info['name'])
if card_info['name'] == '' :
card_info['name'] = 'unknown'
phoneNumbers_list = ext_dict['cellPhoneNumbers']
print("phoneNumbers : ")
print(phoneNumbers_list)
if len(phoneNumbers_list) :
card_info['phoneNumbers'] = phoneNumbers_list[0]
else :
card_info['phoneNumbers'] = 'unknown'
email_list = ext_dict['emails']
print("email_list: ")
print(email_list)
if len(email_list) :
card_info['email'] = email_list[0]
else :
card_info['email'] = 'unknown'
self.__cb('recognizeBusinessCardReply', card_info)
def __rubblish_cb(self, dict) :
name = 'NA'
if dict != None:
ext = dict['ext']
extDict = json.loads(ext)
result = extDict['result']
if result == 'success':
i = 0
elements = extDict['elements']
while (i < len(elements)) :
gScore = elements[i]['categoryScore']
if gScore > 0.8:
name = elements[i]['category']
print('detect: ' + name)
break
i += 1
self.__cb('classifyingRubbishReply', name)
def __object_cb(self, dict) :
name = 'NA'
if dict != None:
ext = dict['ext']
extDict = json.loads(ext)
result = extDict['result']
if result == 'success':
i = 0
elements = extDict['elements']
while (i < len(elements)) :
gScore = elements[i]['score']
if gScore > 0.25:
name = elements[i]['type']
print('detect: ' + name)
break
i += 1
self.__cb('detectObjectReply', name)
def __vehicletype_cb(self, dict) :
name = 'NA'
detect = False
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
result = ext_dict['result']
if result == 'success':
i = 0
item_list = ext_dict['items']
name = 'NA'
while (i < len(item_list)) :
g_score = item_list[i]['score']
name = item_list[i]['name']
# 这里可以修改识别的可信度，目前设置返回可信度大于85%才认为识别正确
if g_score > 0.85 and name != 'others':
print('detect: ' + name)
detect = True
self.__cb('recognizeVehicleReply', name)
break
i += 1
if detect == False:
self.__cb('recognizeVehicleReply', 'NA')
def __vehiclelogo_cb(self, dict) :
num = 0
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
result = ext_dict['result']
if result == 'success':
item_list = ext_dict['elements']
num = len(item_list)
if num > 0:
print('detect: ' + str(num) + ' vehicle')
detected = True
if detected == False:
print('do not detect!')
self.__cb('recognizeLogoReply', num)
def __imageurl_cb(self, dict) :
picurl = 'NA'
if dict != None:
ext = dict['ext']
extDict = json.loads(ext)
picurl = extDict['imageUrl']
print(picurl)
print(dict)
self.__cb('saveImageTestReply', picurl)
def __cb_lk_service(self, data):
self.g_lk_service = True
print('download <----' + str(data))
if data != None :
params = data['params']
params_dict = json.loads(params)
command = params_dict['commandName']
#print(' command <----' + str(params_dict['commandName']) + str(params_dict))
if command == 'handGestureReply' :
self.__gesture_cb(params_dict)
elif command == 'recognizeActionReply' :
self.__action_cb(params_dict)
elif command == 'ocrCarNoReply' :
self.__license_plate_cb(params_dict)
elif command == 'DetectPedestrianReply' :
self.__pedestrian_cb(params_dict)
elif command == 'detectFruitsReply' :
self.__fruits_cb(params_dict)
elif command == 'recognizeBusinessCardReply' :
self.__businesscard_cb(params_dict)
elif command == 'classifyingRubbishReply' :
self.__rubblish_cb(params_dict)
elif command == 'detectObjectReply' :
self.__object_cb(params_dict)
elif command == 'recognizeVehicleReply' :
self.__vehicletype_cb(params_dict)
elif command == 'recognizeLogoReply' :
self.__vehiclelogo_cb(params_dict)
elif command == 'saveImageTestReply' :
self.__imageurl_cb(params_dict)
else :
print('unknown command reply')
def __cb_lk_connect(self, data):
print('link platform connected')
self.g_lk_connect = True
# 接收云端下发的属性设置
# request格式: {"code": 0, "params_len": 17, "msg_id": 1828542828, "params": "{\"door_status\":0}"}
def __on_props(self, request):
try:
props = eval(request['params'])
magnetic_switch = props['magnetic_switch']
print("magnetic_switch set value : " + str(magnetic_switch))
self.__cb('magnetic_switch', magnetic_switch)
except Exception as e:
print(e)
def __connect_iot(self) :
self.cloud_device = Device()
self.cloud_device.on(Device.ON_CONNECT, self.__cb_lk_connect)
self.cloud_device.on(Device.ON_SERVICE, self.__cb_lk_service)
self.cloud_device.on(Device.ON_PROPS, self.__on_props)
self.cloud_device.connect(self.__dev_info)
while True:
if self.g_lk_connect:
break
def __init__(self, dev_info, callback) :
self.__dev_info = dev_info
self.__cb = callback
self.g_lk_connect = False
self.g_lk_service = False
self.__connect_iot()
def getDevice(self) :
return self.cloud_device
def __upload_request(self, command, frame, enlarge = 1) :
# 上传图片到LP
fileName = 'test.jpg'
start = utime.ticks_ms()
fileid = self.cloud_device.uploadContent(fileName, frame, None)
if fileid != None:
ext = { 'filePosition':'lp', 'fileName': fileName, 'fileId': fileid, 'enlarge':enlarge}
ext_str = json.dumps(ext)
all_params = {'id': 1, 'version': '1.0', 'params': { 'eventType': 'haas.faas', 'eventName': command, 'argInt': 1, 'ext': ext_str }}
all_params_str = json.dumps(all_params)
#print(all_params_str)
upload_file = {
'topic': '/sys/' + self.__dev_info['productKey'] + '/' + self.__dev_info['deviceName'] + '/thing/event/hli_event/post',
'qos': 1,
'payload': all_params_str
}
# 上传完成通知HaaS聚合平台
print('upload--->' + str(upload_file))
self.g_lk_service = False
self.cloud_device.publish(upload_file)
i = 0
while (self.g_lk_service == False and i < 200) :
utime.sleep_ms(10)
i = i + 1
continue
else:
print('filedid is none, upload content fail')
time_diff = utime.ticks_diff(utime.ticks_ms(), start)
print('recognize time : %d' % time_diff)
def recognizeGesture(self, frame) :
self.__upload_request('handGesture', frame)
def recognizeAction(self, frame) :
self.__upload_request('recognizeAction', frame, 2)
def recognizeLicensePlate(self, frame) :
self.__upload_request('ocrCarNo', frame)
def detectPedestrian(self, frame) :
self.__upload_request('detectPedestrian', frame)
def detectFruits(self, frame) :
self.__upload_request('detectFruits', frame)
def recognizeBussinessCard(self, frame) :
self.__upload_request('recognizeBusinessCard', frame)
def recognizeVehicleType(self, frame) :
self.__upload_request('recognizeVehicle', frame)
def detectVehicleCongestion(self, frame) :
self.__upload_request('vehicleCongestionDetect', frame)
def classifyRubbish(self, frame) :
self.__upload_request('classifyingRubbish', frame)
def detectObject(self, frame) :
self.__upload_request('detectObject', frame)
def saveImageTest(self, frame) :
self.__upload_request('saveImageTest', frame)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/security_monitoring_system/m5stack/code/cloudAI.py
|
Python
|
apache-2.0
| 12,826
|
#!/usr/bin/env python3
# -*- encoding: utf-8 -*-
'''
@File : irdistance.py
@Description: 红外传感器驱动
@Author : 风裁
@version : 1.0
'''
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/docs/examples/security_monitoring_system/m5stack/code/irdistance.py
|
Python
|
apache-2.0
| 597
|
#!/usr/bin/env python3
# -*- encoding: utf-8 -*-
'''
@File : main.py
@Author : aoyi
@version : 1.0
@Description: security_monitoring_system案例 - 防盗报警系统
board.json - 硬件资源配置文件
'''
from buzzer import BUZZER
import irdistance
from driver import PWM,GPIO
import time
from aliyunIoT import Device # iot组件是连接阿里云物联网平台的组件
import json
import display # 显示库
import network # 网络库
import ucamera # 摄像头库
import _thread # 线程库
from cloudAI import *
# 物联网平台连接标志位
iot_connected = False
wlan = None
# 三元组信息
productKey = "Your-ProductKey"
deviceName = "Your-devicename"
deviceSecret = "Your-deviceSecret"
# 物联网设备实例
device = None
# Wi-Fi SSID和Password设置
wifiSsid = "Your-AP-SSID"
wifiPassword = "Your-AP-Password"
# 警报开关以及时间段控制（大于等于alarm_start 或者小于等于alarm_end ）
alarm_switch = 1
alarm_status = 0
alarm_count = 0
alarm_pic_url = ''
alarming = False
FLAG_ALARM_STATUS = "alarm_status"
FLAG_ALARM_COUNT = "alarm_count"
FLAG_ALARM_SWITCH = "magnetic_switch"
UP_PICTURE_URL = "PictureURL"
cloud_key_info = {
'region' : 'cn-shanghai' ,
'productKey': productKey ,
'deviceName': deviceName,
'deviceSecret': deviceSecret ,
'keepaliveSec': 60
}
# 显示线程函数
def displayThread():
# 引用全局变量
global disp, gFrame, alarming
while True:
# 采集摄像头画面
gFrame = ucamera.capture()
if gFrame != None:
# 显示图像
disp.image(0, 20, gFrame, 0)
time.sleep(0.1)
if alarming:
# 设置显示字体
disp.font(disp.FONT_DejaVu40)
# 显示文字
disp.text(10, 50, 'WARNING...', disp.RED)
# 等待Wi-Fi成功连接到路由器
def get_wifi_status():
global wlan
wifi_connected = False
wlan.active(True) #激活界面
wlan.scan() #扫描接入点
# 连接到指定的路由器（路由器名称为wifiSsid, 密码为：wifiPassword）
wlan.connect(wifiSsid, wifiPassword)
while True:
wifi_connected = wlan.isconnected() # 获取Wi-Fi连接路由器的状态信息
if wifi_connected: # Wi-Fi连接成功则退出while循环
break
else:
time.sleep(0.5)
print("wifi_connected:", wifi_connected)
ifconfig = wlan.ifconfig() #获取接口的IP/netmask/gw/DNS地址
print(ifconfig)
time.sleep(0.5)
# 物联网平台连接成功的回调函数
def on_connect(data):
global iot_connected
iot_connected = True
def recognize_cb(commandReply, result) :
global alarm_pic_url, gStartRecognize, alarm_switch
if commandReply == 'saveImageTestReply' and gStartRecognize == True:
if result != 'NA' :
alarm_pic_url = result
print('imageurl: ' + result)
utime.sleep(2)
elif commandReply == 'magnetic_switch':
alarm_switch = result
else :
print('main: unknown command reply')
post_default_value()
gStartRecognize = False
print('识别结束')
def post_props(data):
global engine, device
if isinstance(data,dict):
data = {'params': json.dumps(data)}
print('upload props-->' + str(data))
ret = engine.getDevice().postProps(data)
#ret = device.postProps(data)
return ret
def post_default_value():
global alarm_switch,alarm_status,alarm_count,alarm_pic_url,gFrame,FLAG_ALARM_SWITCH,FLAG_ALARM_STATUS,UP_PICTURE_URL
value = {FLAG_ALARM_SWITCH : alarm_switch,
FLAG_ALARM_STATUS : alarm_status,
FLAG_ALARM_COUNT : alarm_count,
UP_PICTURE_URL : alarm_pic_url}
post_props(value)
if __name__ == '__main__':
global disp, gFrame, engine, gStartRecognize
# 创建lcd display对象
disp = display.TFT()
gFrame = None
gStartRecognize = False
wlan = network.WLAN(network.STA_IF) #创建WLAN对象
get_wifi_status()
#初始化cloudai
engine = CloudAI(cloud_key_info, recognize_cb)
# 初始化摄像头
ucamera.init('uart', 33, 32)
ucamera.setProp(ucamera.SET_FRAME_SIZE, ucamera.SIZE_320X240)
# 初始化蜂鸣器
pwmObj = PWM()
pwmObj.open("buzzer")
pwm_init_data = {'freq':2000, 'duty': 0}
buzzer = BUZZER(pwmObj,data=pwm_init_data)
# 初始化干簧管传感器
gpioirDev = GPIO()
gpioirDev.open("ir")
gIrDev = irdistance.IRDISTANCE(gpioirDev)
print("megnetic detector ...")
try:
# 启动显示线程
_thread.start_new_thread(displayThread, ())
except:
print("Error: unable to start thread")
while True:
if alarm_switch == 1 and gIrDev.objectDetection() == 1:
wait_cnt = 0
if alarming == False:
print('human detected, start buzzer')
pwm_start_data = {'freq':2000, 'duty': 5}
buzzer.start(pwm_start_data)
alarm_count = alarm_count + 1
alarming = True
alarm_status = 1
post_default_value()
if gFrame != None:
gStartRecognize = True
engine.saveImageTest(gFrame)
while gStartRecognize == True and wait_cnt < 50:
time.sleep(0.1)
wait_cnt = wait_cnt + 1
post_default_value()
if alarm_switch == 0 or gIrDev.objectDetection() == 0:
if alarming:
print('close buzzer')
pwm_start_data = {'freq':2000, 'duty': 0}
buzzer.start(pwm_start_data)
alarming = False
alarm_status = 0
post_default_value()
time.sleep(0.1)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/security_monitoring_system/m5stack/code/main.py
|
Python
|
apache-2.0
| 5,945
|
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/docs/examples/sedentary_remind/esp32/code/ir.py
|
Python
|
apache-2.0
| 410
|
#########
from aliyunIoT import Device # iot组件是连接阿里云物联网平台的组件
import network # Wi-Fi功能所在库
import ujson
##################
from driver import I2C,GPIO,TIMER
import utime
from ssd1306 import SSD1306_I2C
import ir
import time
temptimerObj = 0
time_dict = {}
#########
# 物联网平台连接标志位
iot_connected = False
wlan = None
# 三元组信息
productKey = "产品密钥" #需要填入物联网云平台申请到的productKey信息
deviceName = "设备名称" #需要填入物联网云平台申请到的deviceName信息
deviceSecret = "设备密钥" #需要填入物联网云平台申请到的deviceSecret信息
# 物联网设备实例
device = None
# Wi-Fi SSID和Password设置
wifiSsid = "请填写您的路由器名称"
wifiPassword = "请填写您的路由器密码"
# 等待Wi-Fi成功连接到路由器
def get_wifi_status():
global wlan
wifi_connected = False
wlan.active(True) #激活界面
wlan.scan() #扫描接入点
#print("start to connect ", wifiSsid)
wlan.connect(wifiSsid, wifiPassword) # 连接到指定路由器的名称和密码
while True:
wifi_connected = wlan.isconnected() # 获取Wi-Fi连接路由器的状态信息
if wifi_connected: # Wi-Fi连接成功则退出while循环
break
else:
utime.sleep(0.5)
print("wifi_connected:", wifi_connected)
ifconfig = wlan.ifconfig() #获取接口的IP/netmask/gw/DNS地址
print(ifconfig)
utime.sleep(0.5)
# 物联网平台连接成功的回调函数
def on_connect(data):
global iot_connected
iot_connected = True
# 设置props 事件接收函数（当云平台向设备下发属性时）
def on_props(request):
pass
# 上传休息提醒状态到物联网平台
def report_event(data):
upload_data = {'params': ujson.dumps({
'call_rst': data,
})
}
device.postProps(upload_data)
def connect_lk(productKey, deviceName, deviceSecret):
global device, iot_connected
key_info = {
'region': 'cn-shanghai',
'productKey': productKey,
'deviceName': deviceName,
'deviceSecret': deviceSecret,
'keepaliveSec': 60
}
# 将三元组信息设置到iot组件中
device = Device()
# 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
device.on(Device.ON_CONNECT, on_connect)
# 如果收到物联网平台发送的属性控制消息
device.on(Device.ON_PROPS, on_props)
# 启动连接阿里云物联网平台过程
device.connect(key_info)
# 等待设备成功连接到物联网平台
while(True):
if iot_connected:
print('物联网平台连接成功')
break
else:
print('sleep for 1 s')
utime.sleep(1)
print('sleep for 2s')
utime.sleep(2)
#########
PERSON_MOVE = 1
PERSON_LEAVE = 2
PERSON_NOMOVE = 3
ir_event = 0
tick_time = 0
total_time = 0
first_move = 0
has_rest = 0
has_leve = 0
timer_interval_1000ms = 1000 #单位ms
check_max_time1 = (90) #单位s ,用于判断当前区域没有人的时间阈值 (60*timer_interval_1000ms)
check_max_time2 = (45*60) #单位s,用于判断人在当前区域的最大时间阈值 (60*60*timer_interval_1000ms)
CHECK_NOPERSON_MAX_TIME = check_max_time1
CHECK_HASPERSON_MAX_TIME = check_max_time2
gpioirDev =0
def irq_handler(data):
global tick_time,total_time,gpioirDev,first_move,has_rest,has_leve,ir_event
if first_move == 0:
first_move = 1
ret = gpioirDev.read()
if ret == 1:
print('person come')
if tick_time >= CHECK_NOPERSON_MAX_TIME:
print("person has left ",tick_time)
total_time = 0
tick_time = 0
has_leve = 1
ir_event = PERSON_LEAVE
return
else:
total_time += tick_time
print("check person move ",tick_time,total_time)
tick_time = 0
ir_event = PERSON_MOVE
elif ret == 0:
total_time += tick_time
print('check person nomove ',tick_time,total_time)
tick_time = 0
ir_event = PERSON_NOMOVE
if total_time >= CHECK_HASPERSON_MAX_TIME:
has_rest = 1
total_time = 0
print('you need has rest,because you work too long')
# init function
def ir_check_init():
global gpioirDev,ir_event
gpioirDev = GPIO()
gpioirDev.open("ir")
gpioirDev.on(irq_handler)
irDev = ir.IR(gpioirDev)
ret = gpioirDev.read()
if ret == 1:
print('person come')
ir_event = PERSON_MOVE
elif ret == 0:
print('no person')
ir_event == PERSON_NOMOVE
#初始化oled模块
def oled_init():
global oled
i2cObj = I2C()
i2cObj.open("ssd1306")
print("ssd1306 inited!")
oled = SSD1306_I2C(128, 64, i2cObj)
oled.fill(0) #清屏背景黑色
oled.text('2022-01-03', 30, 5)
oled.text('12:00:00', 30, 22)
oled.text(str('----------------------'),3,32)
oled.text('connecting', 30, 40)
oled.show()
def display_time(timeArray):
global total_time,tick_time
val_time = int((total_time + tick_time)/60)
oled.fill(0)
oled.text(str('%d-%02d-%02d'%(timeArray[0],timeArray[1],timeArray[2])),30,5)
oled.text(str('%02d:%02d:%02d'%(timeArray[3],timeArray[4],timeArray[5])),30,22)
oled.text(str('----------------------'),3,32)
if ir_event == PERSON_MOVE:
oled.text('move', 40, 40)
oled.text(str('%02d'%(val_time)),4,13)
elif ir_event == PERSON_LEAVE:
oled.text('person leave', 25, 40)
oled.text(str('--'),2,13)
elif ir_event == PERSON_NOMOVE:
oled.text('no move', 40, 40)
oled.text(str('%02d'%(val_time)),4,13)
oled.show()
def timer_callback(args):
global tick_time,first_move,time_dict
timeArray = time.localtime()
display_time(timeArray)
if first_move == 1 and has_leve == 0:
tick_time += 1
def temp_timer_stop():
temptimerObj.stop()
def temp_timer_start():
temptimerObj.start()
def timer_init():
global temptimerObj
temptimerObj = TIMER(0)
temptimerObj.open(mode=temptimerObj.PERIODIC, period=timer_interval_1000ms, callback=timer_callback)
temptimerObj.start()
if __name__ == '__main__' :
oled_init()
#########
wlan = network.WLAN(network.STA_IF) #创建WLAN对象
get_wifi_status()
connect_lk(productKey, deviceName, deviceSecret)
#########
ir_check_init()
timer_init()
while True:
if has_rest == 1:
has_rest = 0
report_event(1)
print('report rest')
if has_leve == 1:
has_leve = 0
report_event(0)
print('report leve')
utime.sleep(1)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/sedentary_remind/esp32/code/main.py
|
Python
|
apache-2.0
| 6,930
|
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/docs/examples/sedentary_remind/esp32/code/ssd1306.py
|
Python
|
apache-2.0
| 3,565
|
# coding=utf-8
from driver import GPIO
import network
import ujson
import utime as time
import modem
from aliyunIoT import Device
import kv
import sntp
#当iot设备连接到物联网平台的时候触发'connect' 事件
def on_connect(data):
global module_name,default_ver,productKey,deviceName,deviceSecret,on_trigger,on_download,on_verify,on_upgrade
print('***** connect lp succeed****')
data_handle = {}
data_handle['device_handle'] = device.getDeviceHandle()
#当连接断开时，触发'disconnect'事件
def on_disconnect():
print('linkkit is disconnected')
#当iot云端下发属性设置时，触发'props'事件
def on_props(request):
global warns
params=request['params']
params=eval(params)
if 'warning' in params:
warns=params['warning']
upload_interval()
#当iot云端调用设备service时，触发'service'事件
def on_service(id,request):
print('clound req id is {} , req is {}'.format(id,request))
#当设备跟iot平台通信过程中遇到错误时，触发'error'事件
def on_error(err):
print('err msg is {} '.format(err))
#网络连接的回调函数
def on_4g_cb(args):
global g_connect_status
pdp = args[0]
netwk_sta = args[1]
if netwk_sta == 1:
g_connect_status = True
else:
g_connect_status = False
#网络连接
def connect_network():
global net,on_4g_cb,g_connect_status
#NetWorkClient该类是一个单例类，实现网络管理相关的功能，包括初始化，联网，状态信息等.
net = network.NetWorkClient()
g_register_network = False
if net._stagecode is not None and net._stagecode == 3 and net._subcode == 1:
g_register_network = True
else:
g_register_network = False
if g_register_network:
#注册网络连接的回调函数on(self,id,func); 1代表连接，func 回调函数 ；return 0 成功
net.on(1,on_4g_cb)
net.connect(None)
else:
print('网络注册失败')
while True:
if g_connect_status:
print('网络连接成功')
break
time.sleep_ms(20)
#动态注册回调函数
def on_dynreg_cb(data):
global deviceSecret,device_dyn_resigter_succed
deviceSecret = data
device_dyn_resigter_succed = True
# 连接物联网平台
def dyn_register_device(productKey,productSecret,deviceName):
global on_dynreg_cb,device,deviceSecret,device_dyn_resigter_succed
key = '_amp_customer_devicesecret'
deviceSecretdict = kv.get(key)
print("deviceSecretdict:",deviceSecretdict)
if isinstance(deviceSecretdict,str):
deviceSecret = deviceSecretdict
if deviceSecretdict is None or deviceSecret is None:
key_info = {
'productKey': productKey ,
'productSecret': productSecret ,
'deviceName': deviceName
}
# 动态注册一个设备，获取设备的deviceSecret
#下面的if防止多次注册，当前若是注册过一次了，重启设备再次注册就会卡住，
if not device_dyn_resigter_succed:
device.register(key_info,on_dynreg_cb)
interval_data = {}
def upload_interval():
global interval_data,warns
interval_data["warning"]= warns
interval_data_str=ujson.dumps(interval_data)
data1={
'params':interval_data_str
}
device.postProps(data1)
turn = 0
def every_second():
global duration_time,begin_time,interval_time,turn,warns
if hc.read()==1:
if turn == 0:
now_time=time.time() #获取当前时间
duration_time = (now_time - begin_time )/60
print(round(duration_time,2))
if int(duration_time) >= interval_time:
warns= 1
upload_interval()
time.sleep_ms(500)
begin_time = time.time() #获取当前时间
else:
begin_time = time.time() #获取当前时间
turn = 0
warns = 0
else:
turn +=1
warns = 0
print('leave the seat')
if __name__ == '__main__':
ICCID=None
g_connect_status = False
net = None
device = None
deviceSecret = None
deviceName = None
#复制产品证书内容替换
productKey = "your-productKey"
productSecret = "your-productSecret"
device_dyn_resigter_succed = False
# 连接网络
connect_network()
# 获取设备的IMEI 作为deviceName 进行动态注册
deviceName = modem.info.getDevImei()
#获取设备的ICCID
ICCID=modem.sim.getIccid()
#初始化物联网平台Device类，获取device实例
device = Device()
if deviceName is not None and len(deviceName) > 0 :
#动态注册一个设备
dyn_register_device(productKey,productSecret,deviceName)
else:
print("获取设备IMEI失败，无法进行动态注册")
while deviceSecret is None:
time.sleep(0.2)
print('动态注册成功:' + deviceSecret)
key_info = {
'region' : 'cn-shanghai' ,
'productKey': productKey ,
'deviceName': deviceName ,
'deviceSecret': deviceSecret ,
'keepaliveSec': 60,
}
#打印设备信息
print(key_info)
#device.ON_CONNECT 是事件，on_connect是事件处理函数/回调函数
device.on(device.ON_CONNECT,on_connect)
device.on(device.ON_DISCONNECT,on_disconnect)
device.on(device.ON_PROPS,on_props)
device.on(device.ON_SERVICE,on_service)
device.on(device.ON_ERROR,on_error)
device.connect(key_info)
#
interval = 0 #初始化提醒bool
interval_time = 30 #初始化提示时长
time.sleep(2)
# 上传提醒
warns = 0
upload_interval()
#传感器使能
hc=GPIO()
hc.open('hc')
sntp.settime() #sntp 校时
begin_time=time.time() #获取当前时间
while True:
every_second()
time.sleep_ms(500)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/sedentary_remind/haas506/code/main.py
|
Python
|
apache-2.0
| 6,018
|
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) #command to send temperature data
#all nine bytes must be read
LSB=ow.readbyte() #least significant byte
MSB=ow.readbyte() #most significant byte
ow.readbyte()
ow.readbyte()
ow.readbyte() #this is the configuration byte for resolution
ow.readbyte()
ow.readbyte()
ow.readbyte()
ow.readbyte()
ow.reset() #reset at end of data transmission
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/docs/examples/smart_aquarium/esp32/code/ds18b20.py
|
Python
|
apache-2.0
| 4,160
|
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")
self.clkObj.write(0)
count = 0
while(self.dataObj.read()):
print('wait !')
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/66
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_aquarium/esp32/code/hx710.py
|
Python
|
apache-2.0
| 1,032
|
import hx710 # 引入HX710传感器驱动库
import tds # 引入tds传感器驱动库
import ds18b20 # 引入ds18b20传感器驱动库
import relay # 引入继电器驱动库
from driver import ADC
from driver import GPIO
import utime # 延时函数在utime库中
from aliyunIoT import Device # iot组件是连接阿里云物联网平台的组件
import network # Wi-Fi功能所在库
import ujson # json字串解析库
#传感器对象
hx710Obj = 0
tdsObj = 0
ds18b20Obj = 0
# 继电器对象
relay1Obj = 0
relay2Obj = 0
relay3Obj = 0
#门限值
hx710Threshold = 120000
tdsThreshold = 800
ds18b20Threshold = 30
#本地控制开关
relay1Manual = 0
relay2Manual = 0
relay3Manual = 0
# 继电器开关状态
addWaterFlag = 0
startFilterFlag = 0
makeHeatFlag = 0
#保存实时参数
deep = 0
tdsValue = 0
temp = 0
def hx710_init():
global hx710Obj
clkDev = GPIO()
clkDev.open("hx710_clk")
dataDev = GPIO()
dataDev.open("hx710_data")
hx710Obj = hx710.HX710(clkDev, dataDev)
def get_hx710_value():
global hx710Obj
return hx710Obj.getValue()
def tds_init():
global tdsObj
tdsChannel = ADC()
tdsChannel.open('tds')
tdsObj = tds.TDS(tdsChannel, T = 10)
def get_tds_value():
global tdsObj
return tdsObj.getTDS()
def ds18b20_init():
global ds18b20Obj
gpioDev = GPIO()
gpioDev.open("ds18b20")
ds18b20Obj = ds18b20.DS18B20(gpioDev, 12)
def get_ds18b20_value():
global ds18b20Obj
return ds18b20Obj.getTemperature()
def relays_init():
global relay1Obj, relay2Obj, relay3Obj
relay1Dev = GPIO()
relay1Dev.open("relay_1")
relay1Obj =relay.Relay(relay1Dev, 1)
relay2Dev = GPIO()
relay2Dev.open("relay_2")
relay2Obj =relay.Relay(relay2Dev, 1)
relay3Dev = GPIO()
relay3Dev.open("relay_3")
relay3Obj =relay.Relay(relay3Dev, 1)
# 物联网平台连接标志位
iot_connected = False
# 三元组信息
productKey = "产品密钥"
deviceName = "设备名称"
deviceSecret = "设备密钥"
# 物联网设备实例
device = None
# Wi-Fi SSID和Password设置
wifiSsid = "请输入您的路由器名称"
wifiPassword = "请输入您的路由器密码"
wlan = None
# 等待Wi-Fi成功连接到路由器
def get_wifi_status():
global wlan
wifi_connected = False
wlan = network.WLAN(network.STA_IF) #创建WLAN对象
wifi_connected = wlan.isconnected() # 获取Wi-Fi连接路由器的状态信息
if not wifi_connected:
wlan.active(True) #激活界面
wlan.scan() #扫描接入点
#print("start to connect ", wifiSsid)
wlan.connect(wifiSsid, wifiPassword) # 连接到指定的路由器（路由器名称为wifiSsid, 密码为：wifiPassword）
while True:
wifi_connected = wlan.isconnected() # 获取Wi-Fi连接路由器的状态信息
if wifi_connected: # Wi-Fi连接成功则退出while循环
break
else:
utime.sleep(0.5)
print("wifi_connected:", wifi_connected)
ifconfig = wlan.ifconfig() #获取接口的IP/netmask/gw/DNS地址
print(ifconfig)
utime.sleep(0.5)
# 设置props 事件接收函数（当云平台向设备下发属性时）
def on_props(request):
global relay1Manual, relay2Manual, relay3Manual
global makeHeatFlag, startFilterFlag, addWaterFlag
global deep, tdsValue, temp
print(request)
payload = ujson.loads(request['params'])
# 获取dict状态字段 注意要验证键存在 否则会抛出异常
if "AddWater" in payload.keys():
print(payload)
data = payload["AddWater"]
if (data):
print("开始加水")
if (deep < hx710Threshold):
relay1Obj.open()
addWaterFlag = 1
else:
print("结束加水")
relay1Obj.close()
addWaterFlag = 0
if "StartFilter" in payload.keys():
print(payload)
data = payload["StartFilter"]
if data:
print("开始过滤")
relay2Obj.open()
startFilterFlag = 1
else:
print("结束过滤")
relay2Obj.close()
startFilterFlag = 0
if "MakeHeat" in payload.keys():
print(payload)
data = payload["MakeHeat"]
if (data) and (temp < ds18b20Threshold):
print("开始加热")
relay3Obj.open()
makeHeatFlag = 1
else:
print("结束加热")
relay3Obj.close()
makeHeatFlag = 0
# 物联网平台连接成功的回调函数
def on_connect(data):
global iot_connected
iot_connected = True
def connect_lk(productKey, deviceName, deviceSecret):
global device, iot_connected
key_info = {
'region': 'cn-shanghai',
'productKey': productKey,
'deviceName': deviceName,
'deviceSecret': deviceSecret,
'keepaliveSec': 60
}
# 将三元组信息设置到iot组件中
device = Device()
# 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
device.on(Device.ON_CONNECT, on_connect)
# 配置收到云端属性控制指令的回调函数，如果收到物联网平台发送的属性控制消息，则调用on_props函数
device.on(Device.ON_PROPS, on_props)
# 启动连接阿里云物联网平台过程
device.connect(key_info)
# 等待设备成功连接到物联网平台
while(True):
if iot_connected:
print('物联网平台连接成功')
break
else:
print('sleep for 1 s')
utime.sleep(1)
print('sleep for 2s')
utime.sleep(2)
# 上传信息到物联网平台
def upload_detector_state():
global device
global relay1Manual, relay2Manual, relay3Manual
global hx710Threshold, tdsThreshold, ds18b20Threshold
global makeHeatFlag, startFilterFlag, addWaterFlag
global deep, tdsValue, temp
# 无限循环
while True:
deep = get_hx710_value()
tdsValue = get_tds_value()
temp = get_ds18b20_value()
print('deep %.2f, tdsValue %d, temp %.2f ' % (deep/120000, tdsValue, temp))
if (relay1Manual == 1):
if (deep < hx710Threshold):
relay1Obj.open()
else:
relay1Obj.close()
if (relay2Manual == 1):
if (tdsValue > tdsThreshold):
relay2Obj.open()
else:
relay2Obj.close()
if (relay3Manual == 1):
if (temp < ds18b20Threshold):
relay3Obj.open()
else:
relay3Obj.close()
# 上传信息到物联网平台
upload_data = {'params': ujson.dumps({
'WaterLevel': round(deep/120000,2),
'TDS': tdsValue,
'WaterTemperature': temp,
'MakeHeat': makeHeatFlag,
'StartFilter': startFilterFlag,
'AddWater': addWaterFlag
})
}
device.postProps(upload_data)
utime.sleep(0.5)
if __name__ == '__main__':
hx710_init()
tds_init()
ds18b20_init()
relays_init()
get_wifi_status()
connect_lk(productKey, deviceName, deviceSecret)
upload_detector_state()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_aquarium/esp32/code/main.py
|
Python
|
apache-2.0
| 7,504
|
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 is not 0) and (trigger is not 1):
raise ValueError("parameter trigger should be 0 or 1")
self.trigger = trigger
self.gpioObj = gpioObj
def open(self):
if self.gpioObj is None:
raise ValueError("invalid GPIO object")
value = self.gpioObj.write(self.trigger)
return value
def close(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/docs/examples/smart_aquarium/esp32/code/relay.py
|
Python
|
apache-2.0
| 766
|
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 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/docs/examples/smart_aquarium/esp32/code/tds.py
|
Python
|
apache-2.0
| 1,171
|
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for CHT8305
Author: HaaS
Date: 2021/09/14
"""
import utime
from micropython import const
from driver import I2C
#AHT21B_I2CADDR_DEFAULT = const(0x38) # Default I2C address
AHT21B_CMD_CALIBRATE = const(0xE1) # Calibration command
AHT21B_CMD_TRIGGER = const(0xAC) # Trigger reading command
AHT21B_CMD_SOFTRESET = const(0xBA) # Soft reset command
AHT21B_STATUS_READY = const(0x18) # Status bit for ready for operate
AHT21B_STATUS_BUSY = const(0x80) # Status bit for busy
AHT21B_STATUS_CALIBRATED = const(0x08) # Status bit for calibrated
class AHT21B(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()
# read status register
def __status(self):
dataBuffer = bytearray(1)
self._i2cDev.read(dataBuffer)
return dataBuffer[0]
def start(self):
# make sure AHB21B's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
print("open AHT21B")
status = self.__status()
# check whether AHT21B is ready for operation or not, if it is not ready do AHT21B reinitialization
if (status & AHT21B_STATUS_READY) != AHT21B_STATUS_READY:
# print(dataBuffer)
self.reset()
# reset register
def resetReg(self, regAddr):
print("reset ", regAddr)
dataBuffer = bytearray(3)
dataBuffer[0] = regAddr
dataBuffer[1] = 0x00
dataBuffer[2] = 0x00
self._i2cDev.write(dataBuffer)
utime.sleep_ms(5)
self._i2cDev.read(dataBuffer)
utime.sleep_ms(10)
print(dataBuffer)
dataBuffer[0] = regAddr|0xB0
self._i2cDev.write(dataBuffer)
# reset AHT21B chip according to its datasheet
def reset(self):
print("reset AHT21B start")
self.resetReg(0x1b)
self.resetReg(0x1c)
self.resetReg(0x1e)
# measure temperature and humidity
def getTempHumidity(self):
# make sure AHB21B's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
tempHumidity = [-1, 2]
dataBuffer = bytearray(7)
for i in range(1, len(dataBuffer)):
dataBuffer[i] = 0x0
# send "Trigger reading command" to AHT21B to start the measurement
regValue = bytearray(3)
regValue[0] = AHT21B_CMD_TRIGGER
regValue[1] = 0x33
regValue[2] = 0x00
# print('start to measure')
# send command to do the measurement
self._i2cDev.write(regValue)
# according to AHT21B's datasheet, after send measurement command, should wait for 80ms
utime.sleep_ms(80)
# check if status[7] is 0 or not, 0 means measure operation finished
while self.__status() & AHT21B_STATUS_BUSY:
utime.sleep_ms(5)
# read sensor's measure result
self._i2cDev.read(dataBuffer)
# calculate actual temperature and humidity according to AHT21B's datasheet
humi = ((dataBuffer[1] << 16) | (dataBuffer[2] << 8) | dataBuffer[3]) >> 4
temp = ((dataBuffer[3] << 16) | (dataBuffer[4] << 8) | dataBuffer[5]) & 0xfffff
tempHumidity[0] = round(temp * 200 /1024 / 1024 - 50, 2)
tempHumidity[1] = round(humi * 100 /1024 / 1024)
# print(tempHumidity)
return tempHumidity
# start measure and return temperature
def getTemperature(self):
data = self.getTempHumidity()
return data[0]
# start measure and return humidity
def getHumidity(self):
data = self.getTempHumidity()
return data[1]
if __name__ == "__main__":
'''
The below i2c configuration is needed in your board.json.
"aht21b": {
"type": "I2C",
"port": 1,
"addrWidth": 7,
"freq": 400000,
"mode": "master",
"devAddr": 56
},
'''
print("Testing aht21b ...")
i2cObj = I2C()
i2cObj.open("aht21b")
aht21bDev = AHT21B(i2cObj)
temperature = aht21bDev.getTemperature()
print("The temperature is: %f" % temperature)
humidity = aht21bDev.getHumidity()
print("The humidity is: %d" % humidity)
i2cObj.close()
print("Test aht21b done!")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_fan/esp32/code/aht21b.py
|
Python
|
apache-2.0
| 4,656
|
from driver import PWM
class Fan(object):
def __init__(self, pwmObj,data=None):
self.pwmObj = None
if not isinstance(pwmObj, PWM):
raise ValueError("parameter is not an PWM object")
self.pwmObj = pwmObj
if data is not None:
self.data = data
self.setOptionDuty()
else:
self.data = {'freq':2000, 'duty': 0 }
def setOptionDuty(self):
if self.pwmObj is None:
raise ValueError("invalid PWM object")
self.pwmObj.setOption(self.data)
def control(self,gear):
if not isinstance(gear,int):
raise ValueError("gear is not an int object")
if not gear in range(4):
raise ValueError("gear must be in range 0-3")
if gear == 0:
self.data['duty'] = 0
if gear == 1:
self.data['duty'] = 33
if gear == 2:
self.data['duty'] = 66
if gear == 3:
self.data['duty'] = 99
self.setOptionDuty()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_fan/esp32/code/fan.py
|
Python
|
apache-2.0
| 1,028
|
#!/usr/bin/env python3
# -*- encoding: utf-8 -*-
'''
@File : main.py
@Author : guoliang.wgl
@version : 1.0
@Description: smart_fan案例 - 智能控制小风扇
board.json - 硬件资源配置文件
'''
from fan import Fan
from aht21b import AHT21B
from driver import PWM, I2C
import time
from aliyunIoT import Device # iot组件是连接阿里云物联网平台的组件
import json
# 物联网平台连接标志位
iot_connected = False
wlan = None
# 三元组信息
productKey = "产品密钥"
deviceName = "设备名称"
deviceSecret = "设备密钥"
# 物联网设备实例
device = None
# Wi-Fi SSID和Password设置
wifiSsid = "请输入您的路由器名称"
wifiPassword = "请输入您的路由器密码"
# 警报开关以及时间段控制（大于等于alarm_start 或者小于等于alarm_end ）
gear1_temp = 22
gear2_temp = 27
gear3_temp = 32
FLAG_CUR_TEMP = "cur_temp"
FLAG_GEAR1 = "gear1"
FLAG_GEAR2 = "gear2"
FLAG_GEAR3 = "gear3"
cur_gear = 0
# 等待Wi-Fi成功连接到路由器
def get_wifi_status():
global wlan
wifi_connected = False
wlan.active(True) #激活界面
wlan.scan() #扫描接入点
#print("start to connect ", wifiSsid)
# 连接到指定的路由器（路由器名称为wifiSsid, 密码为：wifiPassword）
wlan.connect(wifiSsid, wifiPassword)
while True:
wifi_connected = wlan.isconnected() # 获取Wi-Fi连接路由器的状态信息
if wifi_connected: # Wi-Fi连接成功则退出while循环
break
else:
time.sleep(0.5)
print("wifi_connected:", wifi_connected)
ifconfig = wlan.ifconfig() #获取接口的IP/netmask/gw/DNS地址
print(ifconfig)
time.sleep(0.5)
# 物联网平台连接成功的回调函数
def on_connect(data):
global iot_connected
iot_connected = True
# 设置props 事件接收函数（当云平台向设备下发属性时）
def on_props(request):
global FLAG_GEAR1, FLAG_GEAR2, FLAG_GEAR3, gear1_temp, gear2_temp, gear3_temp
try:
props = eval(request['params'])
if FLAG_GEAR1 in props.keys():
gear1_temp = props[FLAG_GEAR1]
print('on_props: name is {},value is {}'.format(
FLAG_GEAR1, gear1_temp))
elif FLAG_GEAR2 in props.keys():
gear2_temp = props[FLAG_GEAR2]
print('on_props: name is {},value is {}'.format(
FLAG_GEAR2, gear2_temp))
elif FLAG_GEAR3 in props.keys():
gear3_temp = props[FLAG_GEAR3]
print('on_props: name is {},value is {}'.format(
FLAG_GEAR3, gear3_temp))
post_default_value()
except Exception as e:
print(e)
def post_props(data):
global device
if isinstance(data, dict):
data = {'params': json.dumps(data)}
ret = device.postProps(data)
return ret
def connect_lk(productKey, deviceName, deviceSecret):
global device, iot_connected
key_info = {
'region': 'cn-shanghai',
'productKey': productKey,
'deviceName': deviceName,
'deviceSecret': deviceSecret,
'keepaliveSec': 60
}
# 将三元组信息设置到iot组件中
device = Device()
# 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
device.on(Device.ON_CONNECT, on_connect)
# 配置收到云端属性控制指令的回调函数
# 如果收到物联网平台发送的属性控制消息，则调用on_props函数
device.on(Device.ON_PROPS, on_props)
# 启动连接阿里云物联网平台过程
device.connect(key_info)
# 等待设备成功连接到物联网平台
while True:
if iot_connected:
print('物联网平台连接成功')
break
else:
print('sleep for 1 s')
time.sleep(1)
time.sleep(2)
def post_default_value():
global FLAG_GEAR1, FLAG_GEAR2, FLAG_GEAR3, gear1_temp, gear2_temp, gear3_temp
value = {FLAG_GEAR1: gear1_temp}
post_props(value)
value = {FLAG_GEAR2: gear2_temp}
post_props(value)
value = {FLAG_GEAR3: gear3_temp}
post_props(value)
def upload_temp(temp):
value = {FLAG_CUR_TEMP: temp}
post_props(value)
if __name__ == '__main__':
wlan = network.WLAN(network.STA_IF) #创建WLAN对象
# 请替换物联网平台申请到的产品和设备信息
# global productKey, deviceName, deviceSecret ,on_request, on_play
get_wifi_status()
connect_lk(productKey, deviceName, deviceSecret)
post_default_value()
# 初始化风扇控制pwm
pwmObj = PWM()
pwmObj.open("fan")
fan = Fan(pwmObj)
fan.control(0)
# 初始化温度传感器
i2c = I2C()
i2c.open('aht21b')
aht = AHT21B(i2c)
while True:
temp = aht.getTemperature()
print('cur temp is {}'.format(temp))
upload_temp(temp)
if temp <= gear1_temp and cur_gear != 0:
cur_gear = 0
fan.control(cur_gear)
print('fan change to gear {}'.format(cur_gear))
elif temp > gear1_temp and temp <= gear2_temp and cur_gear != 1:
cur_gear = 1
fan.control(cur_gear)
print('fan change to gear {}'.format(cur_gear))
elif temp > gear2_temp and temp <= gear3_temp and cur_gear != 2:
cur_gear = 2
fan.control(cur_gear)
print('fan change to gear {}'.format(cur_gear))
elif temp > gear3_temp and cur_gear != 3:
cur_gear = 3
fan.control(cur_gear)
print('fan change to gear {}'.format(cur_gear))
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_fan/esp32/code/main.py
|
Python
|
apache-2.0
| 5,669
|
import utime as time
from driver import I2C
#CONSTANTS
AHT10_ADDRESS = 0x38 # 0111000 (7bit address)
AHT10_READ_DELAY_MS = 75 # Time it takes for AHT to collect data
AHT_TEMPERATURE_CONST = 200
AHT_TEMPERATURE_OFFSET = 50
KILOBYTE_CONST = 1048576
CMD_INITIALIZE = bytearray([0xE1, 0x08, 0x00])
CMD_MEASURE = bytearray([0xAC, 0x33, 0x00])
FARENHEIT_MULTIPLIER = 9/5
FARENHEIT_OFFSET = 32
class AHT10:
def __init__(self, mode=0, address=AHT10_ADDRESS):
self.i2c = I2C()
self.i2c.open('aht10')
self.address = address
writeBuf=bytearray(4)
writeBuf[0]=self.address
writeBuf[1]=CMD_INITIALIZE[0]
writeBuf[2]=CMD_INITIALIZE[1]
writeBuf[3]=CMD_INITIALIZE[2]
self.i2c.write(writeBuf)
self.readings_raw = bytearray(8)
self.results_parsed = [0, 0]
self.mode = mode # 0 for Celsius(摄氏度), 1 for Farenheit(华氏度)
def read_raw(self):
writeBuf=bytearray(4)
writeBuf[0]=self.address
writeBuf[1]=CMD_MEASURE[0]
writeBuf[2]=CMD_MEASURE[1]
writeBuf[3]=CMD_MEASURE[2]
self.i2c.write(writeBuf)
time.sleep_ms(AHT10_READ_DELAY_MS)
readBuf=bytearray(6)
readBuf[0]=AHT10_ADDRESS
self.i2c.read(readBuf)
self.readings_raw[0]=readBuf[0]
self.readings_raw[1]=readBuf[1]
self.readings_raw[2]=readBuf[2]
self.readings_raw[3]=readBuf[3]
self.readings_raw[4]=readBuf[4]
self.readings_raw[5]=readBuf[5]
self.results_parsed[0] = self.readings_raw[1] << 12 | self.readings_raw[2] << 4 | self.readings_raw[3] >> 4
self.results_parsed[1] = (self.readings_raw[3] & 0x0F) << 16 | self.readings_raw[4] << 8 | self.readings_raw[5]
def humidity(self):
self.read_raw()
return (self.results_parsed[0] / KILOBYTE_CONST) * 100
def temperature(self):
self.read_raw()
if self.mode is 0:
return (self.results_parsed[1] / KILOBYTE_CONST) * AHT_TEMPERATURE_CONST - AHT_TEMPERATURE_OFFSET
else:
return ((self.results_parsed[1] / KILOBYTE_CONST) * AHT_TEMPERATURE_CONST - AHT_TEMPERATURE_OFFSET) * FARENHEIT_MULTIPLIER + FARENHEIT_OFFSET
def set_mode(self, mode):
if mode==0 or mode==1:
self.mode = mode
else:
raise ValueError('Mode must be either 0 for Celsius or 1 Farenheit')
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_fan/haas506/code/ahtx0.py
|
Python
|
apache-2.0
| 2,424
|
# coding=utf-8
from ahtx0 import AHT10
from driver import PWM
import network
import ujson
import utime as time
import modem
from aliyunIoT import Device
import kv
# 警报开关以及时间段控制
gear1_temp = 22
gear2_temp = 27
gear3_temp = 32
FLAG_CUR_TEMP = "temp"
FLAG_GEAR1 = "gear1"
FLAG_GEAR2 = "gear2"
FLAG_GEAR3 = "gear3"
cur_gear = 0
#当iot设备连接到物联网平台的时候触发'connect' 事件
def on_connect(data):
global module_name,default_ver,productKey,deviceName,deviceSecret,on_trigger,on_download,on_verify,on_upgrade
print('***** connect lp succeed****')
data_handle = {}
data_handle['device_handle'] = device.getDeviceHandle()
#当连接断开时，触发'disconnect'事件
def on_disconnect():
print('linkkit is disconnected')
#当iot云端下发属性设置时，触发'props'事件
def on_props(request):
global FLAG_GEAR1, FLAG_GEAR2, FLAG_GEAR3,FLAG_CUR_TEMP,gear1_temp, gear2_temp, gear3_temp,temp
params=request['params']
data_all=eval(params)
if FLAG_GEAR1 in data_all :
gear1_temp = data_all[FLAG_GEAR1]
value_gears()
if FLAG_GEAR2 in data_all :
gear2_temp = data_all[FLAG_GEAR2]
value_gears()
if FLAG_GEAR3 in data_all :
gear3_temp = data_all[FLAG_GEAR3]
value_gears()
if FLAG_CUR_TEMP in data_all:
temp = data_all[FLAG_CUR_TEMP]
upload_temp()
#当iot云端调用设备service时，触发'service'事件
def on_service(id,request):
print('clound req id is {} , req is {}'.format(id,request))
#当设备跟iot平台通信过程中遇到错误时，触发'error'事件
def on_error(err):
print('err msg is {} '.format(err))
#网络连接的回调函数
def on_4g_cb(args):
global g_connect_status
pdp = args[0]
netwk_sta = args[1]
if netwk_sta == 1:
g_connect_status = True
else:
g_connect_status = False
#网络连接
def connect_network():
global net,on_4g_cb,g_connect_status
#NetWorkClient该类是一个单例类，实现网络管理相关的功能，包括初始化，联网，状态信息等.
net = network.NetWorkClient()
g_register_network = False
if net._stagecode is not None and net._stagecode == 3 and net._subcode == 1:
g_register_network = True
else:
g_register_network = False
if g_register_network:
#注册网络连接的回调函数on(self,id,func); 1代表连接，func 回调函数 ；return 0 成功
net.on(1,on_4g_cb)
net.connect(None)
else:
print('网络注册失败')
while True:
if g_connect_status:
print('网络连接成功')
break
time.sleep_ms(20)
#动态注册回调函数
def on_dynreg_cb(data):
global deviceSecret,device_dyn_resigter_succed
deviceSecret = data
device_dyn_resigter_succed = True
# 连接物联网平台
def dyn_register_device(productKey,productSecret,deviceName):
global on_dynreg_cb,device,deviceSecret,device_dyn_resigter_succed
key = '_amp_customer_devicesecret'
deviceSecretdict = kv.get(key)
print("deviceSecretdict:",deviceSecretdict)
if isinstance(deviceSecretdict,str):
deviceSecret = deviceSecretdict
if deviceSecretdict is None or deviceSecret is None:
key_info = {
'productKey': productKey ,
'productSecret': productSecret ,
'deviceName': deviceName
}
# 动态注册一个设备，获取设备的deviceSecret
#下面的if防止多次注册，当前若是注册过一次了，重启设备再次注册就会卡住，
if not device_dyn_resigter_succed:
device.register(key_info,on_dynreg_cb)
def upload_date(key_value):
data_str=ujson.dumps(key_value)
data={
'params':data_str
}
device.postProps(data)
value_data.clear()
value_data = {}
def upload_temp():
global value_data,temp,FLAG_CUR_TEMP
value_data[FLAG_CUR_TEMP]=temp
upload_date(value_data)
def value_gears():
global FLAG_GEAR1,FLAG_GEAR2,FLAG_GEAR3,gear1_temp, gear2_temp, gear3_temp,value_data
value_data[FLAG_GEAR1]=gear1_temp
upload_date(value_data)
value_data[FLAG_GEAR2]=gear2_temp
upload_date(value_data)
value_data[FLAG_GEAR3]=gear3_temp
upload_date(value_data)
#电机控制
def control(gear):
if not isinstance(gear,int):
raise ValueError("gear is not an int object")
if not gear in range(4):
raise ValueError("gear must be in range 0-3")
if gear == 0:
duty= 0
if gear == 1:
duty= 33
if gear == 2:
duty= 66
if gear == 3:
duty= 99
param = {'freq':3000, 'duty': duty }
pwm_pwm.setOption(param)
if __name__ == '__main__':
ICCID=None
g_connect_status = False
net = None
device = None
deviceSecret = None
deviceName = None
#复制产品证书内容替换
productKey = "your-productKey"
productSecret = "your-productSecret"
device_dyn_resigter_succed = False
# 连接网络
connect_network()
# 获取设备的IMEI 作为deviceName 进行动态注册
deviceName = modem.info.getDevImei()
#获取设备的ICCID
ICCID=modem.sim.getIccid()
#初始化物联网平台Device类，获取device实例
device = Device()
if deviceName is not None and len(deviceName) > 0 :
#动态注册一个设备
dyn_register_device(productKey,productSecret,deviceName)
else:
print("获取设备IMEI失败，无法进行动态注册")
while deviceSecret is None:
time.sleep(0.2)
print('动态注册成功:' + deviceSecret)
key_info = {
'region' : 'cn-shanghai' ,
'productKey': productKey ,
'deviceName': deviceName ,
'deviceSecret': deviceSecret ,
'keepaliveSec': 60,
}
#打印设备信息
print(key_info)
#device.ON_CONNECT 是事件，on_connect是事件处理函数/回调函数
device.on(device.ON_CONNECT,on_connect)
device.on(device.ON_DISCONNECT,on_disconnect)
device.on(device.ON_PROPS,on_props)
device.on(device.ON_SERVICE,on_service)
device.on(device.ON_ERROR,on_error)
device.connect(key_info)
#主程序
time.sleep(2)
value_gears()
print('start work')
#初始化温度传感器
a=AHT10()
#set mode(℃ or F)
a.set_mode(0)
#初始化电机模块
pwm_pwm = PWM()
pwm_pwm.open("pwm_pwm")
while True:
time.sleep_ms(200)
temp = a.temperature() #获取温度信息
print('cur temp is {}'.format(temp))
upload_temp()
if temp <= gear1_temp and cur_gear != 0:
cur_gear = 0
control(cur_gear)
print('fan change to gear {}'.format(cur_gear))
elif temp > gear1_temp and temp <= gear2_temp and cur_gear != 1:
cur_gear = 1
control(cur_gear)
print('fan change to gear {}'.format(cur_gear))
elif temp > gear2_temp and temp <= gear3_temp and cur_gear != 2:
cur_gear = 2
control(cur_gear)
print('fan change to gear {}'.format(cur_gear))
elif temp > gear3_temp and cur_gear != 3:
cur_gear = 3
control(cur_gear)
print('fan change to gear {}'.format(cur_gear))
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_fan/haas506/code/main.py
|
Python
|
apache-2.0
| 7,406
|
import lvgl as lv
# RESOURCES_ROOT = "S:/Users/liujuncheng/workspace/iot/esp32/solution/MicroPython/smart_panel/smart_panel/"
RESOURCES_ROOT = "S:/data/pyamp/"
compass_ttf_alive = False
def compass_back_click_callback(e, win):
global compass_ttf_alive
if (compass_ttf_alive):
from smart_panel import load_smart_panel
load_smart_panel()
compass_ttf_alive = False
def compass_back_press_callback(e, image):
image.set_zoom(280)
def compass_back_release_callback(e, image):
image.set_zoom(250)
value = 0
class Compass:
def createPage(self):
global value
global compass_ttf_alive
print("Enter Compass")
# 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)
backImg=lv.img(win)
backImg.set_src(RESOURCES_ROOT + "images/back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: compass_back_click_callback(e, win), lv.EVENT.CLICKED, None)
backImg.add_event_cb(lambda e: compass_back_press_callback(e, backImg), lv.EVENT.PRESSED, None)
backImg.add_event_cb(lambda e: compass_back_release_callback(e, backImg), lv.EVENT.RELEASED, None)
backImg.set_ext_click_area(30)
# -------------- compass image ----------------
compass_dial = lv.img(win)
compass_dial.set_src(RESOURCES_ROOT + "images/compass_dial.png")
compass_dial.set_style_max_height(scr.get_height(), 0)
compass_dial.set_angle(value * 10)
compass_dial.center()
# -------------- indicator --------------------
compass_indicator = lv.img(win)
compass_indicator.set_src(RESOURCES_ROOT + "images/compass_indicator.png")
# compass_indicator.set_style_max_height(scr.get_height(), 0)
compass_indicator.set_angle(value * 10)
compass_indicator.center()
col_dsc = [35, 10, 25, lv.GRID_TEMPLATE.LAST]
row_dsc = [20, 35, 20, lv.GRID_TEMPLATE.LAST]
degreeArea = lv.obj(win)
degreeArea.set_size(95, 100)
degreeArea.set_style_bg_opa(0, 0)
degreeArea.set_style_border_opa(0, 0)
degreeArea.set_style_pad_all(0, 0)
degreeArea.set_layout(lv.LAYOUT_GRID.value)
degreeArea.set_grid_dsc_array(col_dsc, row_dsc)
degreeArea.center()
# degreeArea.set_style_pad_left(5, 0)
degreeArea.clear_flag(lv.obj.FLAG.SCROLLABLE)
red = lv.img(degreeArea)
red.set_src(RESOURCES_ROOT + "images/angle_red.png")
red.set_grid_cell(lv.GRID_ALIGN.CENTER, 0, 3, lv.GRID_ALIGN.CENTER, 0, 1)
degreeLable = lv.label(degreeArea)
degreeLable.set_text(str(value))
degreeLable.set_style_text_color(lv.color_white(), 0)
degreeLable.set_style_text_font(lv.font_montserrat_36, 0)
degreeLable.set_grid_cell(lv.GRID_ALIGN.CENTER, 0, 1, lv.GRID_ALIGN.CENTER, 1, 1)
degreeIcon = lv.img(degreeArea)
degreeIcon.set_src(RESOURCES_ROOT + "images/degree.png")
degreeIcon.set_style_pad_top(5, 0)
degreeIcon.set_grid_cell(lv.GRID_ALIGN.START, 1, 1, lv.GRID_ALIGN.START, 1, 1)
directionLable = lv.label(degreeArea)
directionLable.set_text("N")
directionLable.set_style_text_color(lv.color_white(), 0)
directionLable.set_style_text_font(lv.font_montserrat_36, 0)
directionLable.set_grid_cell(lv.GRID_ALIGN.START, 2, 1, lv.GRID_ALIGN.CENTER, 1, 1)
tips = lv.label(degreeArea)
tips.set_text("Compass")
tips.set_style_text_color(lv.color_white(), 0)
tips.set_style_text_font(lv.font_montserrat_12, 0)
tips.set_grid_cell(lv.GRID_ALIGN.CENTER, 0, 3, lv.GRID_ALIGN.CENTER, 2, 1)
from smart_panel import needAnimation
if (needAnimation):
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.MOVE_LEFT, 500, 0, True)
else:
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.NONE, 0, 0, True)
compass_ttf_alive = True
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_panel/esp32/code/compass.py
|
Python
|
apache-2.0
| 4,255
|
import lvgl as lv
import utime
# RESOURCES_ROOT = "S:/Users/liujuncheng/workspace/iot/esp32/solution/HaaSPython/solutions/smart_panel/"
RESOURCES_ROOT = "S:/data/pyamp/"
def drawOver(e):
global g_clickTime
if (g_clickTime != 0):
currentTime = utime.ticks_ms()
print("create Environment page use: %dms" % int((currentTime - g_clickTime)))
g_clickTime = 0
environment_alive = False
def environment_back_click_callback(e, win):
global environment_alive
if (environment_alive):
from smart_panel import load_smart_panel
load_smart_panel()
environment_alive = False
def environment_back_press_callback(e, back_image):
back_image.set_zoom(280)
def environment_back_release_callback(e, back_image):
back_image.set_zoom(250)
class Environment:
def createPage(self):
global environment_alive
global g_clickTime
g_clickTime = utime.ticks_ms()
# 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_bg_color(lv.color_black(), 0)
win.set_style_radius(0, 0)
win.clear_flag(lv.obj.FLAG.SCROLLABLE)
win.add_event_cb(drawOver, lv.EVENT.DRAW_POST_END, None)
backImg=lv.img(win)
backImg.set_src(RESOURCES_ROOT + "images/back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: environment_back_click_callback(e, win), lv.EVENT.CLICKED, None)
backImg.add_event_cb(lambda e: environment_back_press_callback(e, backImg), lv.EVENT.PRESSED, None)
backImg.add_event_cb(lambda e: environment_back_release_callback(e, backImg), lv.EVENT.RELEASED, None)
backImg.set_ext_click_area(20)
container = lv.obj(win)
container.set_style_bg_opa(0, 0)
container.set_style_border_opa(0, 0)
container.set_size(lv.SIZE.CONTENT, lv.SIZE.CONTENT)
container.set_flex_flow(lv.FLEX_FLOW.COLUMN)
container.set_style_align(lv.ALIGN.CENTER, 0)
container.set_style_pad_left(0, 0)
self.createItem(container, RESOURCES_ROOT + "images/temperature.png", "25",
RESOURCES_ROOT + "images/centigrade_l.png", "Temperature")
self.createInterval(container, 25)
self.createItem(container, RESOURCES_ROOT + "images/humidity.png", "41 %", "", "Humidity")
from smart_panel import needAnimation
if (needAnimation):
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.MOVE_LEFT, 500, 0, True)
else:
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.NONE, 0, 0, True)
environment_alive = True
currentTime = utime.ticks_ms()
print("run python code use: %dms" % int((currentTime - g_clickTime)))
def createItem(self, parent, iconPath, value, 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)
label = lv.label(cont)
label.set_text(value)
label.set_style_text_color(lv.color_white(), 0)
label.set_style_text_font(lv.font_montserrat_48, 0)
label.set_style_pad_all(0, 0)
label.set_grid_cell(lv.GRID_ALIGN.START, 2, 1, lv.GRID_ALIGN.CENTER, 0, 1)
if (unityPath.strip()):
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 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(size)
interval.set_width(0)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_panel/esp32/code/environment.py
|
Python
|
apache-2.0
| 4,623
|
import lvgl as lv
# RESOURCES_ROOT = "S:/Users/liujuncheng/workspace/iot/esp32/solution/MicroPython/smart_panel/smart_panel/"
RESOURCES_ROOT = "S:/data/pyamp/"
environment_alive = False
functionImage = [
RESOURCES_ROOT + "images/refrigeration.png",
RESOURCES_ROOT + "images/heating.png",
RESOURCES_ROOT + "images/dehumidification.png",
RESOURCES_ROOT + "images/ventilation.png"]
functionImageSelected = [
RESOURCES_ROOT + "images/refrigeration_selected.png",
RESOURCES_ROOT + "images/heating_selected.png",
RESOURCES_ROOT + "images/dehumidification_selected.png",
RESOURCES_ROOT + "images/ventilation_selected.png"]
currentFunc = 0
currentSelected = None
hvac_alive = False
def hvac_back_click_callback(e, win):
global hvac_alive
if (hvac_alive):
from smart_panel import load_smart_panel
load_smart_panel()
hvac_alive = False
def hvac_back_press_callback(e, image):
image.set_zoom(280)
def hvac_back_release_callback(e, image):
image.set_zoom(250)
def sub_pressed_cb(e, self):
print("sub")
if (self.value > 16):
self.value -= 1
print("value %d" % (self.value))
self.label.set_text(str(self.value))
def add_pressed_cb(e, self):
print("add")
if (self.value < 30):
self.value += 1
print("value %d" % (self.value))
self.label.set_text(str(self.value))
def func_pressed_cb(e, index):
global currentFunc
global currentSelected
print(index)
if (index != currentFunc):
currentSelected.set_src(functionImage[currentFunc])
selectedImage = e.get_target()
currentFunc = index
selectedImage.set_src(functionImageSelected[currentFunc])
currentSelected = selectedImage
class Hvac:
value = 25
def createPage(self):
global currentFunc
global currentSelected
global hvac_alive
print("Enter Hvac")
# 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)
# --------- value container ---------
col_dsc = [60, 65, 40, 60, lv.GRID_TEMPLATE.LAST]
row_dsc = [48, lv.GRID_TEMPLATE.LAST]
valueLayout = lv.obj(win)
valueLayout.set_layout(lv.LAYOUT_GRID.value)
valueLayout.set_style_bg_opa(0, 0)
valueLayout.set_style_border_opa(0, 0)
valueLayout.set_size(lv.SIZE.CONTENT, lv.SIZE.CONTENT)
valueLayout.set_grid_align(lv.GRID_ALIGN.SPACE_BETWEEN, lv.GRID_ALIGN.SPACE_BETWEEN)
valueLayout.set_style_grid_column_dsc_array(col_dsc, 0)
valueLayout.set_style_grid_row_dsc_array(row_dsc, 0)
valueLayout.set_style_pad_top(20, 0)
valueLayout.set_style_align(lv.ALIGN.TOP_MID, 0)
# ----------- - --------------
subImage = lv.img(valueLayout)
subImage.set_src(RESOURCES_ROOT + "images/subtraction.png")
subImage.set_grid_cell(lv.GRID_ALIGN.START, 0, 1, lv.GRID_ALIGN.CENTER, 0, 1)
subImage.add_flag(lv.obj.FLAG.CLICKABLE)
subImage.add_event_cb(lambda e: sub_pressed_cb(e, self), lv.EVENT.PRESSED, None)
# subImage.add_event_cb(lambda e: hvac_back_press_callback(e, subImage), lv.EVENT.PRESSED, None)
# subImage.add_event_cb(lambda e: hvac_back_release_callback(e, subImage), lv.EVENT.RELEASED, None)
subImage.set_ext_click_area(40)
# ----------- value -----------
self.label = lv.label(valueLayout)
self.label.set_text(str(self.value))
self.label.set_style_text_color(lv.color_white(), 0)
self.label.set_style_text_font(lv.font_montserrat_48, 0)
self.label.set_grid_cell(lv.GRID_ALIGN.CENTER, 1, 1, lv.GRID_ALIGN.CENTER, 0, 1)
# ----------- ºC ------------
centigradeImage = lv.img(valueLayout)
centigradeImage.set_src(RESOURCES_ROOT + "images/centigrade_s.png")
centigradeImage.set_style_pad_bottom(8, 0)
centigradeImage.set_grid_cell(lv.GRID_ALIGN.START, 2, 1, lv.GRID_ALIGN.END, 0, 1)
# ----------- + ----------------
addImage = lv.img(valueLayout)
addImage.set_src(RESOURCES_ROOT + "images/addition.png")
addImage.set_grid_cell(lv.GRID_ALIGN.CENTER, 3, 1, lv.GRID_ALIGN.CENTER, 0, 1)
addImage.add_flag(lv.obj.FLAG.CLICKABLE)
addImage.add_event_cb(lambda e: add_pressed_cb(e, self), lv.EVENT.PRESSED, None)
# addImage.add_event_cb(lambda e: hvac_back_press_callback(e, addImage), lv.EVENT.PRESSED, None)
# addImage.add_event_cb(lambda e: hvac_back_release_callback(e, addImage), lv.EVENT.RELEASED, None)
addImage.set_ext_click_area(40)
# ----------- tips ----------
tips = lv.label(win)
tips.set_text("Temperature")
tips.set_style_text_color(lv.color_make(0xCC, 0xCC, 0xCC), 0)
tips.set_style_pad_bottom(20, 0)
tips.set_align(lv.ALIGN.CENTER)
# ----------- function ----------
func_col_dsc = [70, 70, 70, 70, lv.GRID_TEMPLATE.LAST]
func_row_dsc = [40, lv.GRID_TEMPLATE.LAST]
funcContainer = lv.obj(win)
funcContainer.set_style_bg_opa(0, 0)
funcContainer.set_style_border_opa(0, 0)
funcContainer.set_grid_dsc_array(func_col_dsc, func_row_dsc)
funcContainer.set_width(300)
funcContainer.set_height(90)
funcContainer.set_layout(lv.LAYOUT_GRID.value)
funcContainer.set_align(lv.ALIGN.BOTTOM_MID)
funcContainer.set_grid_align(lv.GRID_ALIGN.SPACE_BETWEEN, lv.GRID_ALIGN.SPACE_BETWEEN)
image = lv.img(funcContainer)
image.set_src(functionImage[0])
image.add_flag(lv.obj.FLAG.CLICKABLE)
image.set_ext_click_area(20)
image.add_event_cb(lambda e: func_pressed_cb(e, 0), lv.EVENT.PRESSED, None)
image.set_grid_cell(lv.GRID_ALIGN.CENTER, 0, 1, lv.GRID_ALIGN.CENTER, 0, 1)
currentSelected = image
currentSelected.set_src(functionImageSelected[0])
image1 = lv.img(funcContainer)
image1.set_src(functionImage[1])
image1.add_flag(lv.obj.FLAG.CLICKABLE)
image1.set_ext_click_area(20)
image1.add_event_cb(lambda e: func_pressed_cb(e, 1), lv.EVENT.PRESSED, None)
image1.set_grid_cell(lv.GRID_ALIGN.CENTER, 1, 1, lv.GRID_ALIGN.CENTER, 0, 1)
image2 = lv.img(funcContainer)
image2.set_src(functionImage[2])
image2.add_flag(lv.obj.FLAG.CLICKABLE)
image2.set_ext_click_area(20)
image2.add_event_cb(lambda e: func_pressed_cb(e, 2), lv.EVENT.PRESSED, None)
image2.set_grid_cell(lv.GRID_ALIGN.CENTER, 2, 1, lv.GRID_ALIGN.CENTER, 0, 1)
image3 = lv.img(funcContainer)
image3.set_src(functionImage[3])
image3.add_flag(lv.obj.FLAG.CLICKABLE)
image3.set_ext_click_area(20)
image3.add_event_cb(lambda e: func_pressed_cb(e, 3), lv.EVENT.PRESSED, None)
image3.set_grid_cell(lv.GRID_ALIGN.CENTER, 3, 1, lv.GRID_ALIGN.CENTER, 0, 1)
# for i in range(4):
# image = lv.img(funcContainer)
# image.set_src(functionImage[i])
# image.add_flag(lv.obj.FLAG.CLICKABLE)
# image.set_ext_click_area(20)
# image.add_event_cb(lambda e: func_pressed_cb(e, i), lv.EVENT.PRESSED, None)
# image.set_grid_cell(lv.GRID_ALIGN.CENTER, i, 1, lv.GRID_ALIGN.CENTER, 0, 1)
# if (currentFunc == i):
# currentSelected = image
# currentSelected.set_src(functionImageSelected[i])
backImg=lv.img(win)
backImg.set_src(RESOURCES_ROOT + "images/back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: hvac_back_click_callback(e, win), lv.EVENT.CLICKED, None)
backImg.add_event_cb(lambda e: hvac_back_press_callback(e, backImg), lv.EVENT.PRESSED, None)
backImg.add_event_cb(lambda e: hvac_back_release_callback(e, backImg), lv.EVENT.RELEASED, None)
backImg.set_ext_click_area(20)
from smart_panel import needAnimation
if (needAnimation):
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.MOVE_LEFT, 500, 0, True)
else:
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.NONE, 0, 0, True)
hvac_alive = True
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_panel/esp32/code/hvac.py
|
Python
|
apache-2.0
| 8,523
|
#!/usr/bin/env python3
# -*- encoding: utf-8 -*-
'''
@File : main.py
@Description: helloworld案例 - 周期性打印"helloworld"到console中
@Author : ethan.lcz
@version : 1.0
'''
# import utime # 延时函数在utime库中
# if __name__ == '__main__':
# while True: # 无限循环
# print("hellworld") # 打印"helloworld"字串到console中
# utime.sleep(1) # 打印完之后休眠1秒
from axp192 import *
if __name__ == '__main__':
axp = Axp192()
# axp.powerAll()
# axp.setLCDBrightness(80) # 设置背光亮度 0～100
axp.setSpkEnable(1) # 打开speaker
# from smart_panel import *
import smart_panel
smart_panel.init()
smart_panel.load_smart_panel()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_panel/esp32/code/main.py
|
Python
|
apache-2.0
| 746
|
import lvgl as lv
from audio import Player
# RESOURCES_ROOT = "S:/Users/liujuncheng/workspace/iot/esp32/solution/MicroPython/smart_panel/smart_panel/"
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"]
currentMusic = 0
musicData = [
{
"title":"Counting Stars",
"album":"OneRepublic",
"album_url": RESOURCES_ROOT + "images/album_one_republic.jpg",
"url":"file://data/pyamp/audio/test_long.mp3",
"duration":11,
"favorite": False
},
{
"title":"Aube",
"album":"Darius",
"album_url": RESOURCES_ROOT + "images/album_darius.jpg",
"url":"file://data/pyamp/audio/spring.mp3",
"duration":155,
"favorite": False
},
]
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
music_alive = False
def music_back_click_callback(e, win):
global anim_timeline
global start
global player
global music_alive
start = False
# stop animation
if (anim_timeline != None):
lv.anim_timeline_stop(anim_timeline)
lv.anim_timeline_del(anim_timeline)
anim_timeline = None
if (player != None):
player.pause()
player.close()
player = None
# load smart panel desktop
if (music_alive):
from smart_panel import load_smart_panel
load_smart_panel()
music_alive = False
def music_back_press_callback(e, image):
image.set_zoom(280)
def music_back_release_callback(e, image):
image.set_zoom(250)
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")
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()
elif (func == "fav"):
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"):
currentMusic += 1
if (len(musicData) == currentMusic):
currentMusic = 0
reset_music()
elif (func == "prev"):
currentMusic -= 1
if (currentMusic < 0):
currentMusic = len(musicData) - 1
reset_music()
class Music:
def createPage(self):
global anim
global playedTime
global durationTime
global slider
global audio_src
global player
global image
global music_alive
global currentMusic
global albumCover
global songTitle
global albumTitle
global totalTime
global anim_timeline
global scr
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)
backImg=lv.img(win)
backImg.set_src(RESOURCES_ROOT + "images/back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: music_back_click_callback(e, win), lv.EVENT.CLICKED, None)
backImg.add_event_cb(lambda e: music_back_press_callback(e, backImg), lv.EVENT.PRESSED, None)
backImg.add_event_cb(lambda e: music_back_release_callback(e, backImg), lv.EVENT.RELEASED, None)
backImg.set_ext_click_area(30)
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()
from smart_panel import needAnimation
if (needAnimation):
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.MOVE_LEFT, 500, 0, True)
else:
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.NONE, 0, 0, True)
music_alive = True
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_panel/esp32/code/music.py
|
Python
|
apache-2.0
| 12,990
|
# RESOURCES_ROOT = "S:/Users/liujuncheng/workspace/iot/esp32/solution/MicroPython/smart_panel/smart_panel/"
RESOURCES_ROOT = "S:/data/pyamp/"
from environment import Environment
from hvac import Hvac
from compass import Compass
from music import Music
from soundttf import SoundTTF
from timer import Timer
def init():
print("main init")
# import SDL as display
# import lvgl as lv
# lv.init()
# display.init()
# # init display
# draw_buf = lv.disp_draw_buf_t()
# buf1_1 = bytearray(38400)
# buf1_2 = bytearray(38400)
# draw_buf.init(buf1_1, buf1_2, 19200)
# disp_drv = lv.disp_drv_t()
# disp_drv.init()
# disp_drv.draw_buf = draw_buf
# disp_drv.flush_cb = display.monitor_flush
# disp_drv.hor_res = 320
# disp_drv.ver_res = 240
# disp_drv.register()
# # init touch
# indev_drv=lv.indev_drv_t()
# indev_drv.init()
# indev_drv.read_cb = display.mouse_read
# indev_drv.type = lv.INDEV_TYPE.POINTER
# indev_drv.register()
#import lvgl as lv
#lv.init()
# import display
# display.init()
import display_driver
# # init display
# draw_buf = lv.disp_draw_buf_t()
# buf1_1 = bytearray(38400)
# buf1_2 = bytearray(38400)
# draw_buf.init(buf1_1, buf1_2, 19200)
# disp_drv = lv.disp_drv_t()
# disp_drv.init()
# disp_drv.draw_buf = draw_buf
# disp_drv.flush_cb = display.flush
# disp_drv.hor_res = 320
# disp_drv.ver_res = 240
# disp_drv.register()
#
# # init touch
# indev_drv=lv.indev_drv_t()
# indev_drv.init()
# indev_drv.read_cb = display.touch_read
# indev_drv.type = lv.INDEV_TYPE.POINTER
# indev_drv.register()
# audio_path = '/data/pyamp/audio/'
# audio_file = 'test_long.mp3'
# audio_src = 'file:/' + audio_path + audio_file
# from audio import Player
# player = Player()
# player.open()
# player.play(uri=audio_src, sync=False)
# # Compass().createPage()
# # hvac = Hvac()
# # hvac.createPage()
# # music = Music()
# # music.createPage()
# # base demo
# # scr = lv.obj()
# # btn = lv.btn(scr)
# # btn.align_to(lv.scr_act(), lv.ALIGN.CENTER, 0, 0)
# # label = lv.label(btn)
# # label.set_text("Hello World!")
# # lv.scr_load(scr)
isFirst = True
main_alive = False
needAnimation = False
# set the grid data
images = [RESOURCES_ROOT + "images/env.png",
RESOURCES_ROOT + "images/hvac.png",
RESOURCES_ROOT + "images/music.png",
RESOURCES_ROOT + "images/timer.png",
RESOURCES_ROOT + "images/compass.png",
RESOURCES_ROOT + "images/sound_ttf.png"]
titles = ["Environment",
"Hvac",
"Music",
"Timer",
"Compass",
"Sound TTF"]
def element_pressed_cb(e):
import lvgl as lv
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0x39, 0x39, 0x39), 0)
def element_released_cb(e):
import lvgl as lv
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0xf, 0xf, 0xf), 0)
def element_click_cb(e, name):
global main_alive
print(name)
if (main_alive):
if (name == "Environment"):
envPage = Environment()
envPage.createPage()
elif (name == "Hvac"):
hvac = Hvac()
hvac.createPage()
elif (name == "Compass"):
compassPage = Compass()
compassPage.createPage()
elif (name == "Sound"):
ttfPage = SoundTTF()
ttfPage.createPage()
elif (name == "Music"):
musicPage = Music()
musicPage.createPage()
elif (name == "Timer"):
timePage = Timer()
timePage.createPage()
main_alive = False
def load_smart_panel():
global isFirst
global main_alive
global needAnimation
import lvgl as lv
print("load_smart_panel, first: ", isFirst)
# init scr
scr = lv.obj()
scr.set_style_bg_color(lv.color_black(), 0)
# init grid layout
col_dsc = [96, 96, 96, lv.GRID_TEMPLATE.LAST]
row_dsc = [107, 107, lv.GRID_TEMPLATE.LAST]
gridLayout = lv.obj(scr)
gridLayout.set_style_bg_opa(0, 0)
gridLayout.set_style_border_opa(0, 0)
gridLayout.set_grid_align(lv.GRID_ALIGN.SPACE_BETWEEN, lv.GRID_ALIGN.SPACE_BETWEEN)
gridLayout.set_style_grid_column_dsc_array(col_dsc, 0)
gridLayout.set_style_grid_row_dsc_array(row_dsc, 0)
gridLayout.set_size(scr.get_width(), scr.get_height())
gridLayout.set_style_pad_left(10, 0)
gridLayout.set_style_pad_right(10, 0)
gridLayout.set_style_pad_top(9, 0)
gridLayout.set_style_pad_bottom(9, 0)
gridLayout.set_layout(lv.LAYOUT_GRID.value)
for i in range(6):
col = i % 3
row = i // 3
element = lv.obj(gridLayout)
element.set_style_border_opa(0, 0)
element.set_flex_flow(lv.FLEX_FLOW.COLUMN)
element.set_flex_align(lv.FLEX_ALIGN.CENTER, lv.FLEX_ALIGN.CENTER, lv.FLEX_ALIGN.CENTER)
element.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
element.clear_flag(lv.obj.FLAG.SCROLLABLE)
element.set_style_bg_color(lv.color_make(0xf, 0xf, 0xf), 0)
element.set_style_radius(0, 0)
element.set_grid_cell(lv.GRID_ALIGN.STRETCH, col, 1, lv.GRID_ALIGN.STRETCH, row, 1)
element.add_event_cb(element_pressed_cb, lv.EVENT.PRESSED, None)
element.add_event_cb(element_released_cb, lv.EVENT.RELEASED, None)
if (titles[i] == "Environment"):
element.add_event_cb(lambda e: element_click_cb(e, "Environment"), lv.EVENT.CLICKED, None)
elif (titles[i] == "Hvac"):
element.add_event_cb(lambda e: element_click_cb(e, "Hvac"), lv.EVENT.CLICKED, None)
elif (titles[i] == "Music"):
element.add_event_cb(lambda e: element_click_cb(e, "Music"), lv.EVENT.CLICKED, None)
elif (titles[i] == "Timer"):
element.add_event_cb(lambda e: element_click_cb(e, "Timer"), lv.EVENT.CLICKED, None)
elif (titles[i] == "Compass"):
element.add_event_cb(lambda e: element_click_cb(e, "Compass"), lv.EVENT.CLICKED, None)
else:
element.add_event_cb(lambda e: element_click_cb(e, "Sound"), lv.EVENT.CLICKED, None)
img=lv.img(element)
img.set_src(images[i])
label = lv.label(element)
label.set_text(titles[i])
label.set_style_text_color(lv.color_make(0xcc, 0xcc, 0xcc), 0)
label.set_style_text_font(lv.font_montserrat_12, 0)
if (isFirst):
lv.scr_load(scr)
isFirst = False
else:
if (needAnimation):
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.MOVE_RIGHT, 500, 0, True)
else:
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.NONE, 0, 0, True)
main_alive = True
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_panel/esp32/code/smart_panel.py
|
Python
|
apache-2.0
| 6,825
|
import lvgl as lv
# RESOURCES_ROOT = "S:/Users/liujuncheng/workspace/iot/esp32/solution/MicroPython/smart_panel/smart_panel/"
RESOURCES_ROOT = "S:/data/pyamp/"
sound_ttf_alive = False
def sound_ttf_back_click_callback(e, win):
global sound_ttf_alive
if (sound_ttf_alive):
from smart_panel import load_smart_panel
load_smart_panel()
sound_ttf_alive = False
def sound_ttf_back_press_callback(e, image):
image.set_zoom(280)
def sound_ttf_back_release_callback(e, image):
image.set_zoom(250)
def chart_event_cb(e):
dsc = lv.obj_draw_part_dsc_t.__cast__(e.get_param())
if (dsc.part == lv.PART.ITEMS):
draw_rect_dsc = lv.draw_rect_dsc_t()
draw_rect_dsc.init()
a = lv.area_t()
a.x1 = dsc.draw_area.x1
a.x2 = dsc.draw_area.x2
a.y1 = dsc.draw_area.y1
a.y2 = a.y1 + 6
draw_rect_dsc.bg_color = lv.color_white()
draw_rect_dsc.radius = 0
draw_rect_dsc.shadow_opa = 0
lv.draw_rect(a, dsc.clip_area, draw_rect_dsc)
value = 65
class SoundTTF:
def createPage(self):
global value
global sound_ttf_alive
print("Enter SoundTTF")
# 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)
win.set_style_pad_right(30, 0)
title=lv.label(win)
title.set_text("Sound TTF")
title.set_style_text_color(lv.color_white(), 0)
title.set_style_text_font(lv.font_montserrat_28, 0)
title.align(lv.ALIGN.TOP_LEFT, 20, 0)
decibel = lv.label(win)
decibel.set_text(str(value) + "dB")
decibel.set_style_text_color(lv.color_make(0xFF, 0xA8, 0x48), 0)
decibel.set_style_text_font(lv.font_montserrat_28, 0)
decibel.align(lv.ALIGN.TOP_RIGHT, 0, 0)
chart = lv.chart(win)
chart.set_type(lv.chart.TYPE.BAR)
chart.set_style_border_opa(0, 0)
chart.set_style_bg_opa(0, 0)
chart.set_style_line_opa(0, 0)
chart.set_width(280)
chart.set_height(160)
chart.set_div_line_count(6, 0)
chart.set_point_count(12)
chart.align(lv.ALIGN.BOTTOM_MID, 20, -5)
chart.add_event_cb(chart_event_cb, lv.EVENT.DRAW_PART_END, None)
ser1 = chart.add_series(lv.color_make(0x56, 0x56, 0x56), lv.chart.AXIS.PRIMARY_Y)
chart.set_next_value(ser1, lv.rand(30, 100))
chart.set_next_value(ser1, lv.rand(30, 100))
chart.set_next_value(ser1, lv.rand(30, 100))
chart.set_next_value(ser1, lv.rand(30, 100))
chart.set_next_value(ser1, lv.rand(30, 100))
chart.set_next_value(ser1, lv.rand(30, 100))
chart.set_next_value(ser1, lv.rand(30, 100))
chart.set_next_value(ser1, lv.rand(30, 100))
chart.set_next_value(ser1, lv.rand(30, 100))
chart.set_next_value(ser1, lv.rand(30, 100))
chart.set_next_value(ser1, lv.rand(30, 100))
chart.set_next_value(ser1, lv.rand(30, 100))
backImg=lv.img(win)
backImg.set_src(RESOURCES_ROOT + "images/back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: sound_ttf_back_click_callback(e, win), lv.EVENT.CLICKED, None)
backImg.set_ext_click_area(30)
backImg.add_event_cb(lambda e: sound_ttf_back_press_callback(e, backImg), lv.EVENT.PRESSED, None)
backImg.add_event_cb(lambda e: sound_ttf_back_release_callback(e, backImg), lv.EVENT.RELEASED, None)
from smart_panel import needAnimation
if (needAnimation):
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.MOVE_LEFT, 500, 0, True)
else:
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.NONE, 0, 0, True)
sound_ttf_alive = True
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_panel/esp32/code/soundttf.py
|
Python
|
apache-2.0
| 4,006
|
import lvgl as lv
# RESOURCES_ROOT = "S:/Users/liujuncheng/workspace/iot/esp32/solution/MicroPython/smart_panel/smart_panel/"
RESOURCES_ROOT = "S:/data/pyamp/"
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
timer_alive = False
def timer_back_click_callback(e, win):
global anim_timeline
global timer_alive
if (anim_timeline != None):
lv.anim_timeline_stop(anim_timeline)
lv.anim_timeline_del(anim_timeline)
anim_timeline = None
if (timer_alive):
from smart_panel import load_smart_panel
load_smart_panel()
timer_alive = False
def timer_back_press_callback(e, image):
image.set_zoom(280)
def timer_back_release_callback(e, image):
image.set_zoom(250)
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 Timer:
def createPage(self):
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 timer_alive
print("Enter Timer")
# 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)
# back
backImg=lv.img(win)
backImg.set_src(RESOURCES_ROOT + "images/back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: timer_back_click_callback(e, win), lv.EVENT.CLICKED, None)
backImg.add_event_cb(lambda e: timer_back_press_callback(e, backImg), lv.EVENT.PRESSED, None)
backImg.add_event_cb(lambda e: timer_back_release_callback(e, backImg), lv.EVENT.RELEASED, None)
backImg.set_ext_click_area(30)
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)
from smart_panel import needAnimation
if (needAnimation):
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.MOVE_LEFT, 500, 0, True)
else:
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.NONE, 0, 0, True)
timer_alive = True
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_panel/esp32/code/timer.py
|
Python
|
apache-2.0
| 14,706
|
# -*- encoding: utf-8 -*-
from aliyunIoT import Device # iot组件是连接阿里云物联网平台的组件
import network # Wi-Fi功能所在库
import utime # 延时API所在组件
import ujson # json字串解析库
from driver import ADC # ADC类，通过微处理器的ADC模块读取ADC通道输入电压
from driver import GPIO
import photoresistor # 热敏电阻photoresistor传感器类
adcDev = 0
ledDev = 0
photoresistorDev = 0
lightness = 0
# wifi连接的的ssid和pwd定义
wifiSsid = "请填写您的路由器名称"
wifiPassword = "请填写您的路由器密码"
# 物联网平台相关的key和serect定义
productKey = "产品key"
deviceName = "设备名称"
deviceSecret = "设备密钥"
# 物联网平台连接标志位
iot_connected = False
wlan = None
# 物联网设备实例
device = None
# EDU K1上灯的初始化
def ledInit():
global ledDev
ledDev = GPIO()
ledDev.open("led")
# 点亮灯
def ledOn():
global ledDev
ledDev.write(1)
# 熄灭灯
def ledOff():
global ledDev
ledDev.write(0)
# photoresistor 光敏电阻传感器初始化
def photoresistor_init():
global photoresistorDev
adcDev = ADC()
adcDev.open("photoresistor")
photoresistorDev = photoresistor.PhotoResistor(adcDev)
print("photoresistor init finished")
# photoresistor 光照传感器亮度获取
def photoresistor_light():
global photoresistorDev,lightness
lightness = photoresistorDev.getLightness()
print("The lightness is: ",lightness)
# 显示光照强度以及上报
def show_lightness():
global lightness,i_light,last_light,system_reset
i_light = int(lightness)
if system_reset == 1:
print("system first come")
system_reset = 0 # 系统第一次启动
report_light_data(i_light)
elif (i_light >= 1000 and last_light < 1000) or (i_light < 1000 and last_light >= 1000):
report_light_data(i_light)
print("light has change")
else:
print('no need report')
if i_light < 10:
T_str = "亮度:" + str(round(i_light, 1))
elif i_light >= 10 and i_light < 100:
T_str = "亮度:" + str(round(i_light, 2))
elif i_light >= 100 and i_light < 1000:
T_str = "亮度:" + str(round(i_light, 3))
elif i_light >= 1000 and i_light < 10000:
T_str = "亮度:" + str(round(i_light, 4))
print(T_str)
last_light = i_light
# 等待Wi-Fi成功连接到路由器
def get_wifi_status():
global wlan
wifi_connected = False
wlan.active(True) #激活界面
wlan.scan() #扫描接入点
#print("start to connect ", wifiSsid)
wlan.connect(wifiSsid, wifiPassword) # 连接到指定的路由器（路由器名称为wifiSsid, 密码为：wifiPassword）
while True:
wifi_connected = wlan.isconnected() # 获取Wi-Fi连接路由器的状态信息
if wifi_connected: # Wi-Fi连接成功则退出while循环
break
else:
utime.sleep(0.5)
print("wifi_connected:", wifi_connected)
ifconfig = wlan.ifconfig() #获取接口的IP/netmask/gw/DNS地址
print(ifconfig)
utime.sleep(0.5)
# 物联网平台连接成功的回调函数
def on_connect(data):
global iot_connected
iot_connected = True
# 设置props 事件接收函数（当云平台向设备下发属性时）
def on_props(request):
global alarm_on, device
payload = ujson.loads(request['params'])
# 获取dict状态字段 注意要验证键存在 否则会抛出异常
if "onoff" in payload.keys():
alarm_on = payload["onoff"]
if (alarm_on):
print("开灯")
ledOn()
else:
print("关灯")
ledOff()
# 要将更改后的状态同步上报到云平台
upload_data = {'params': ujson.dumps({
'onoff': alarm_on,
})
}
# 上报本地灯的状态到云端
device.postProps(upload_data)
# 连接物联网平台
def connect_lk(productKey, deviceName, deviceSecret):
global device, iot_connected
key_info = {
'region': 'cn-shanghai',
'productKey': productKey,
'deviceName': deviceName,
'deviceSecret': deviceSecret,
'keepaliveSec': 60
}
# 将三元组信息设置到iot组件中
device = Device()
# 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
device.on(Device.ON_CONNECT, on_connect)
# 配置收到云端属性控制指令的回调函数，如果收到物联网平台发送的属性控制消息，则调用on_props函数
device.on(Device.ON_PROPS, on_props)
# 启动连接阿里云物联网平台过程
device.connect(key_info)
# 等待设备成功连接到物联网平台
while(True):
if iot_connected:
print('物联网平台连接成功')
break
else:
print('sleep for 1 s')
utime.sleep(1)
print('sleep for 2s')
utime.sleep(2)
def report_light_data(l_data):
# 生成上报到物联网平台的属性值字串
upload_data = {'params': ujson.dumps({
'Brightness': l_data,
})
}
# 上传光强度信息到物联网平台
device.postProps(upload_data)
def main():
global i_light,last_light,system_reset,wlan
i_light = 0
last_light = 0
system_reset = 1
wlan = network.WLAN(network.STA_IF) #创建WLAN对象
# 请替换物联网平台申请到的产品和设备信息,可以参考文章:https://blog.csdn.net/HaaSTech/article/details/114360517
get_wifi_status()
connect_lk(productKey, deviceName, deviceSecret)
photoresistor_init()
ledInit()
while True:
photoresistor_light()
show_lightness()
utime.sleep(1.5)
if __name__ == '__main__':
main()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_public_lighting/esp32/code/main.py
|
Python
|
apache-2.0
| 6,006
|
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/docs/examples/smart_public_lighting/esp32/code/photoresistor.py
|
Python
|
apache-2.0
| 438
|
# coding=utf-8
from driver import I2C
from driver import GPIO
import network
import ujson
import utime as time
import modem
from aliyunIoT import Device
import kv
#指令相应参数
DEVICE = 0x23
POWER_DOWN = 0x00
POWER_ON = 0x01
RESET = 0x07
CONTINUOUS_LOW_RES_MODE = 0x13
CONTINUOUS_HIGH_RES_MODE_1 = 0x10
CONTINUOUS_HIGH_RES_MODE_2 = 0x11
ONE_TIME_HIGH_RES_MODE_1 = 0x20
ONE_TIME_HIGH_RES_MODE_2 = 0x21
ONE_TIME_LOW_RES_MODE = 0x23
BH=I2C()
BH.open('BH1750')
gpio=GPIO()
gpio.open('led1')
light_data = {}
onoff_data = {}
#当iot设备连接到物联网平台的时候触发'connect' 事件
def on_connect(data):
global module_name,default_ver,productKey,deviceName,deviceSecret,on_trigger,on_download,on_verify,on_upgrade
print('***** connect lp succeed****')
data_handle = {}
data_handle['device_handle'] = device.getDeviceHandle()
#当连接断开时，触发'disconnect'事件
def on_disconnect():
print('linkkit is disconnected')
#当iot云端下发属性设置时，触发'props'事件
def on_props(request):
params=request['params']
params=eval(params)
light = params["onoff"]
light_con(light)
onoff_data["onoff"]= light
onoff_data_str=ujson.dumps(onoff_data)
data1={
'params':onoff_data_str
}
device.postProps(data1)
#当iot云端调用设备service时，触发'service'事件
def on_service(id,request):
print('clound req id is {} , req is {}'.format(id,request))
#当设备跟iot平台通信过程中遇到错误时，触发'error'事件
def on_error(err):
print('err msg is {} '.format(err))
#网络连接的回调函数
def on_4g_cb(args):
global g_connect_status
pdp = args[0]
netwk_sta = args[1]
if netwk_sta == 1:
g_connect_status = True
else:
g_connect_status = False
#网络连接
def connect_network():
global net,on_4g_cb,g_connect_status
#NetWorkClient该类是一个单例类，实现网络管理相关的功能，包括初始化，联网，状态信息等.
net = network.NetWorkClient()
g_register_network = False
if net._stagecode is not None and net._stagecode == 3 and net._subcode == 1:
g_register_network = True
else:
g_register_network = False
if g_register_network:
#注册网络连接的回调函数on(self,id,func); 1代表连接，func 回调函数 ；return 0 成功
net.on(1,on_4g_cb)
net.connect(None)
else:
print('网络注册失败')
while True:
if g_connect_status:
print('网络连接成功')
break
time.sleep_ms(20)
#动态注册回调函数
def on_dynreg_cb(data):
global deviceSecret,device_dyn_resigter_succed
deviceSecret = data
device_dyn_resigter_succed = True
# 连接物联网平台
def dyn_register_device(productKey,productSecret,deviceName):
global on_dynreg_cb,device,deviceSecret,device_dyn_resigter_succed
key = '_amp_customer_devicesecret'
deviceSecretdict = kv.get(key)
print("deviceSecretdict:",deviceSecretdict)
if isinstance(deviceSecretdict,str):
deviceSecret = deviceSecretdict
if deviceSecretdict is None or deviceSecret is None:
key_info = {
'productKey': productKey ,
'productSecret': productSecret ,
'deviceName': deviceName
}
# 动态注册一个设备，获取设备的deviceSecret
#下面的if防止多次注册，当前若是注册过一次了，重启设备再次注册就会卡住，
if not device_dyn_resigter_succed:
device.register(key_info,on_dynreg_cb)
def convertToNumber(data):
return ((data[1] + (256 * data[0])) / 1.2)
def readLight():
global BH
readBuf=bytearray(2)
#尝试更换不同模式
readBuf[0]=CONTINUOUS_HIGH_RES_MODE_1
BH.read(readBuf,2)
return convertToNumber(readBuf)
def upload_light(n):
global light_data
light_data["brightness"]= n
light_data_str=ujson.dumps(light_data)
data={
'params':light_data_str
}
device.postProps(data)
def light_con(m):
gpio.write(m)
if __name__ == '__main__':
ICCID=None
g_connect_status = False
net = None
device = None
deviceSecret = None
deviceName = None
#复制产品证书内容替换
productKey = "your-productKey"
productSecret = "your-productSecret"
device_dyn_resigter_succed = False
# 连接网络
connect_network()
# 获取设备的IMEI 作为deviceName 进行动态注册
deviceName = modem.info.getDevImei()
#获取设备的ICCID
ICCID=modem.sim.getIccid()
#初始化物联网平台Device类，获取device实例
device = Device()
if deviceName is not None and len(deviceName) > 0 :
#动态注册一个设备
dyn_register_device(productKey,productSecret,deviceName)
else:
print("获取设备IMEI失败，无法进行动态注册")
while deviceSecret is None:
time.sleep(0.2)
print('动态注册成功:' + deviceSecret)
key_info = {
'region' : 'cn-shanghai' ,
'productKey': productKey ,
'deviceName': deviceName ,
'deviceSecret': deviceSecret ,
'keepaliveSec': 60,
}
#打印设备信息
print(key_info)
#device.ON_CONNECT 是事件，on_connect是事件处理函数/回调函数
device.on(device.ON_CONNECT,on_connect)
device.on(device.ON_DISCONNECT,on_disconnect)
device.on(device.ON_PROPS,on_props)
device.on(device.ON_SERVICE,on_service)
device.on(device.ON_ERROR,on_error)
device.connect(key_info)
#主程序，光强传感器
while True:
lig_data = int(readLight())
print ("Light Level : " + str(lig_data) + " lx")
upload_light(lig_data)
time.sleep(1)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_public_lighting/haas506/code/main.py
|
Python
|
apache-2.0
| 5,878
|
"""
Copyright (C) 2015-2020 Alibaba Group Holding Limited
The driver for AP3216C chip, The AP3216C is an integrated ALS & PS module
that includes a digital ambient light sensor [ALS], a proximity sensor [PS],
and an IR LED in a single package.
"""
from micropython import const
from driver import I2C
from utime import sleep_ms
# System Register
AP3216C_SYS_CONFIGURATION_REG = const(0x00)
AP3216C_SYS_INT_STATUS_REG = const(0x01)
AP3216C_SYS_INT_CLEAR_MANNER_REG = const(0x02)
AP3216C_IR_DATA_L_REG = const(0x0A)
AP3216C_IR_DATA_H_REG = const(0x0B)
AP3216C_ALS_DATA_L_REG = const(0x0C)
AP3216C_ALS_DATA_H_REG = const(0x0D)
AP3216C_PS_DATA_L_REG = const(0x0E)
AP3216C_PS_DATA_H_REG = const(0x0F)
# ALS Register
AP3216C_ALS_CONFIGURATION_REG = const(0x10)
AP3216C_ALS_CALIBRATION_REG = const(0x19)
AP3216C_ALS_THRESHOLD_LOW_L_REG = const(0x1A)
AP3216C_ALS_THRESHOLD_LOW_H_REG = const(0x1B)
AP3216C_ALS_THRESHOLD_HIGH_L_REG = const(0x1C)
AP3216C_ALS_THRESHOLD_HIGH_H_REG = const(0x1D)
# PS Register
AP3216C_PS_CONFIGURATION_REG = const(0x20)
AP3216C_PS_LED_DRIVER_REG = const(0x21)
AP3216C_PS_INT_FORM_REG = const(0x22)
AP3216C_PS_MEAN_TIME_REG = const(0x23)
AP3216C_PS_LED_WAITING_TIME_REG = const(0x24)
AP3216C_PS_CALIBRATION_L_REG = const(0x28)
AP3216C_PS_CALIBRATION_H_REG = const(0x29)
AP3216C_PS_THRESHOLD_LOW_L_REG = const(0x2A)
AP3216C_PS_THRESHOLD_LOW_H_REG = const(0x2B)
AP3216C_PS_THRESHOLD_HIGH_L_REG = const(0x2C)
AP3216C_PS_THRESHOLD_HIGH_H_REG = const(0x2D)
#mode value
AP3216C_MODE_POWER_DOWN = const(0x0)
AP3216C_MODE_ALS = const(0x1)
AP3216C_MODE_PS = const(0x2)
AP3216C_MODE_ALS_AND_PS = const(0x3)
AP3216C_MODE_SW_RESET = const(0x4)
AP3216C_MODE_ALS_ONCE = const(0x5)
AP3216C_MODE_PS_ONCE = const(0x6)
AP3216C_MODE_ALS_AND_PS_ONCE = const(0x7)
#ap3216c_int_clear_manner
AP3216C_INT_CLEAR_MANNER_BY_READING = const(0x0)
AP3216C_ALS_CLEAR_MANNER_BY_SOFTWARE = const(0x1)
#als_range
AP3216C_ALS_RANGE_20661 = const(0x0)
AP3216C_ALS_RANGE_5162 = const(0x1)
AP3216C_ALS_RANGE_1291 = const(0x2)
AP3216C_ALS_RANGE_323 = const(0x3)
#als_range
AP3216C_PS_GAIN1 = const(0x0)
AP3216C_PS_GAIN2 = const(0x1)
AP3216C_PS_GAIN4 = const(0x2)
AP3216C_PS_GAIN8 = const(0x3)
AP3216C_SYSTEM_MODE = const(0x0)
AP3216C_INT_PARAM = const(0x1)
AP3216C_ALS_RANGE = const(0x2)
AP3216C_ALS_PERSIST = const(0x3)
AP3216C_ALS_CALIBRATION = const(0x4)
AP3216C_ALS_LOW_THRESHOLD_L = const(0x5)
AP3216C_ALS_LOW_THRESHOLD_H = const(0x6)
AP3216C_ALS_HIGH_THRESHOLD_L = const(0x7)
AP3216C_ALS_HIGH_THRESHOLD_H = const(0x8)
AP3216C_PS_INTEGRATED_TIME = const(0x9)
AP3216C_PS_GAIN = const(0xa)
AP3216C_PS_PERSIST = const(0xb)
AP3216C_PS_LED_CONTROL = const(0xc)
AP3216C_PS_LED_DRIVER_RATIO = const(0xd)
AP3216C_PS_INT_MODE = const(0xe)
AP3216C_PS_MEAN_TIME = const(0xf)
AP3216C_PS_WAITING_TIME = const(0x10)
AP3216C_PS_CALIBRATION_L = const(0x11)
AP3216C_PS_CALIBRATION_H = const(0x12)
AP3216C_PS_LOW_THRESHOLD_L = const(0x13)
AP3216C_PS_LOW_THRESHOLD_H = const(0x14)
AP3216C_PS_HIGH_THRESHOLD_L = const(0x15)
AP3216C_PS_HIGH_THRESHOLD_H = const(0x16)
class AP3216C(object):
"""
This class implements ap3216c chip's defs.
"""
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make AP3216C's internal object points to i2cDev
self._i2cDev = i2cDev
self.init()
# 写寄存器的值
def write_reg(self, addr, data):
msgbuf = bytearray([data])
self._i2cDev.memWrite(msgbuf, addr, 8)
# print("--> write addr " + str(addr) + ", value = " + str(msgbuf))
# 读寄存器的值
def read_regs(self, addr, len):
buf = bytearray(len)
self._i2cDev.memRead(buf, addr, 8)
# print("--> read " + str(len) + " bytes from addr " + str(addr) + ", " + str(len) + " bytes value = " + str(buf))
return buf
# 软件复位传感器
def reset_sensor(self):
self.write_reg(AP3216C_SYS_CONFIGURATION_REG, AP3216C_MODE_SW_RESET); # reset
def read_low_and_high(self, reg, len):
data = self.read_regs(reg, len)[0] | (self.read_regs(reg + 1, len)[0] << len * 8) # 读低字节 - 读高字节 - 合并数据
if (data > (1 << 15)):
data = data - (1<<16)
return data
def ap3216c_get_IntStatus(self):
# 读中断状态寄存器
IntStatus = self.read_regs(AP3216C_SYS_INT_STATUS_REG, 1)[0]
# IntStatus 第 0 位表示 ALS 中断，第 1 位表示 PS 中断。
return IntStatus # 返回状态
def ap3216c_int_init(self):
#print("ap3216c_int_init")
pass
#配置 中断输入引脚
def ap3216c_int_Config(self):
#print("ap3216c_int_Config")
pass
#初始化入口
def init(self):
# reset ap3216c
self.reset_sensor()
sleep_ms(100)
self.ap3216c_set_param(AP3216C_SYSTEM_MODE, AP3216C_MODE_ALS_AND_PS)
sleep_ms(150) # delay at least 112.5ms
self.ap3216c_int_Config()
self.ap3216c_int_init()
# This function reads light by ap3216c sensor measurement
# @param no
# @return the ambient light converted to float data.
#
def ap3216c_read_ambient_light(self):
read_data = self.read_low_and_high(AP3216C_ALS_DATA_L_REG, 1)
range = self.ap3216c_get_param(AP3216C_ALS_RANGE)
#print("ap3216c_read_ambient_light read_data is " , read_data, range)
if (range == AP3216C_ALS_RANGE_20661):
brightness = 0.35 * read_data # sensor ambient light converse to reality
elif (range == AP3216C_ALS_RANGE_5162):
brightness = 0.0788 * read_data # sensor ambient light converse to reality
elif (range == AP3216C_ALS_RANGE_1291):
brightness = 0.0197 * read_data # sensor ambient light converse to reality
elif (range == AP3216C_ALS_RANGE_323):
brightness = 0.0049 * read_data # sensor ambient light converse to reality
return brightness
#This function reads proximity by ap3216c sensor measurement
#@param no
#@return the proximity data.
def ap3216c_read_ps_data(self):
read_data = self.read_low_and_high(AP3216C_PS_DATA_L_REG, 1) # read two data
#print("ap3216c_read_ps_data read_data is " , read_data);
if (1 == ((read_data >> 6) & 0x01 or (read_data >> 14) & 0x01)) :
return 55555 # 红外过高（IR），PS无效 返回一个 55555 的无效数据
proximity = (read_data & 0x000f) + (((read_data >> 8) & 0x3f) << 4)
# sensor proximity converse to reality
if (proximity > (1 << 15)) :
proximity = proximity - (1<<16)
proximity |= read_data & 0x8000 # 取最高位，0 表示物体远离，1 表示物体靠近
return proximity # proximity 后十位是数据位，最高位为状态位
#This function reads ir by ap3216c sensor measurement
#@param no
#@return the ir data.
def ap3216c_read_ir_data(self):
read_data = self.read_low_and_high(AP3216C_IR_DATA_L_REG, 1) # read two data
#print("ap3216c_read_ir_data read_data is" , read_data);
proximity = (read_data & 0x0003) + ((read_data >> 8) & 0xFF)
# sensor proximity converse to reality
if (proximity > (1 << 15)) :
proximity = proximity - (1<<16)
return proximity
#This function sets parameter of ap3216c sensor
#@param cmd the parameter cmd of device
#@param value for setting value in cmd register
#@return the setting parameter status,RT_EOK reprensents setting successfully.
def ap3216c_set_param(self, cmd, value):
if cmd == AP3216C_SYSTEM_MODE:
# default 000,power down
self.write_reg(AP3216C_SYS_CONFIGURATION_REG, value)
elif cmd == AP3216C_INT_PARAM:
self.write_reg(AP3216C_SYS_INT_CLEAR_MANNER_REG, value)
elif cmd == AP3216C_ALS_RANGE:
args = self.read_regs(AP3216C_ALS_CONFIGURATION_REG, 1)[0]
args &= 0xcf
args |= value << 4
self.write_reg(AP3216C_ALS_CONFIGURATION_REG, args)
elif cmd == AP3216C_ALS_PERSIST:
args = self.read_regs(AP3216C_ALS_CONFIGURATION_REG, 1)[0]
args &= 0xf0
args |= value
self.write_reg(AP3216C_ALS_CONFIGURATION_REG, args)
elif cmd == AP3216C_ALS_LOW_THRESHOLD_L:
self.write_reg(AP3216C_ALS_THRESHOLD_LOW_L_REG, value)
elif cmd == AP3216C_ALS_LOW_THRESHOLD_H:
self.write_reg(AP3216C_ALS_THRESHOLD_LOW_H_REG, value)
elif cmd == AP3216C_ALS_HIGH_THRESHOLD_L:
self.write_reg(AP3216C_ALS_THRESHOLD_HIGH_L_REG, value)
elif cmd == AP3216C_ALS_HIGH_THRESHOLD_H:
self.write_reg(AP3216C_ALS_THRESHOLD_HIGH_H_REG, value)
elif cmd == AP3216C_PS_GAIN:
args = self.read_regs(AP3216C_PS_CONFIGURATION_REG, 1)[0]
args &= 0xf3
args |= value
self.write_reg(AP3216C_PS_CONFIGURATION_REG, args)
elif cmd == AP3216C_PS_PERSIST:
args = self.read_regs(AP3216C_PS_CONFIGURATION_REG, 1)[0]
args &= 0xfc
args |= value
self.write_reg(AP3216C_PS_CONFIGURATION_REG, args)
elif cmd == AP3216C_PS_LOW_THRESHOLD_L:
self.write_reg(AP3216C_PS_THRESHOLD_LOW_L_REG, value)
elif cmd == AP3216C_PS_LOW_THRESHOLD_H:
self.write_reg(AP3216C_PS_THRESHOLD_LOW_H_REG, value)
elif cmd == AP3216C_PS_HIGH_THRESHOLD_L:
self.write_reg(AP3216C_PS_THRESHOLD_HIGH_L_REG, value)
elif cmd == AP3216C_PS_HIGH_THRESHOLD_H:
self.write_reg(AP3216C_PS_THRESHOLD_HIGH_H_REG, value)
#This function gets parameter of ap3216c sensor
#@param cmd the parameter cmd of device
#@param value to get value in cmd register
#@return the getting parameter status,RT_EOK reprensents getting successfully.
def ap3216c_get_param(self, cmd):
if cmd == AP3216C_SYSTEM_MODE:
value = self.read_regs(AP3216C_SYS_CONFIGURATION_REG, 1)[0]
elif cmd == AP3216C_INT_PARAM:
value = self.read_regs(AP3216C_SYS_INT_CLEAR_MANNER_REG, 1)[0]
elif cmd == AP3216C_ALS_RANGE:
value = self.read_regs(AP3216C_ALS_CONFIGURATION_REG, 1)[0]
temp = (value & 0xff) >> 4
value = temp
elif cmd == AP3216C_ALS_PERSIST:
temp = self.read_regs(AP3216C_ALS_CONFIGURATION_REG, 1)[0]
temp = value & 0x0f
value = temp
elif cmd == AP3216C_ALS_LOW_THRESHOLD_L:
value = self.read_regs(AP3216C_ALS_THRESHOLD_LOW_L_REG, 1)[0]
elif cmd == AP3216C_ALS_LOW_THRESHOLD_H:
value = self.read_regs(AP3216C_ALS_THRESHOLD_LOW_H_REG, 1)[0]
elif cmd == AP3216C_ALS_HIGH_THRESHOLD_L:
value = self.read_regs(AP3216C_ALS_THRESHOLD_HIGH_L_REG, 1)[0]
elif cmd == AP3216C_ALS_HIGH_THRESHOLD_H:
value = self.read_regs(AP3216C_ALS_THRESHOLD_HIGH_H_REG, 1)[0]
elif cmd == AP3216C_PS_GAIN:
temp = self.read_regs(AP3216C_PS_CONFIGURATION_REG, 1)[0]
value = (temp & 0xc) >> 2
elif cmd == AP3216C_PS_PERSIST:
temp = self.read_regs(AP3216C_PS_CONFIGURATION_REG, 1)[0]
value = temp & 0x3
elif cmd == AP3216C_PS_LOW_THRESHOLD_L:
value = self.read_regs(AP3216C_PS_THRESHOLD_LOW_L_REG, 1)[0]
elif cmd == AP3216C_PS_LOW_THRESHOLD_H:
value = self.read_regs(AP3216C_PS_THRESHOLD_LOW_H_REG, 1)[0]
elif cmd == AP3216C_PS_HIGH_THRESHOLD_L:
value = self.read_regs(AP3216C_PS_THRESHOLD_HIGH_L_REG, 1)[0]
elif cmd == AP3216C_PS_HIGH_THRESHOLD_H:
value = self.read_regs(AP3216C_PS_THRESHOLD_HIGH_H_REG, 1)[0]
return value
def getData(self):
ap3216c_dict = {'brightness': 0, 'ir': 0, 'ps': 0}
brightness = self.ap3216c_read_ambient_light()
ir_data = self.ap3216c_read_ir_data()
ps_data = self.ap3216c_read_ps_data()
ap3216c_dict['brightness'] = brightness
ap3216c_dict['ir'] = ir_data
ap3216c_dict['ps'] = ps_data
return ap3216c_dict
# 获取光照强度值
def getIlluminance(self):
if not self._i2cDev:
raise ValueError("i2cObj is not initialized")
return self.ap3216c_read_ambient_light()
# 获取接近状态：接近返回True，否则返回False
def isProximate(self):
if not self._i2cDev:
raise ValueError("i2cObj is not initialized")
ps = self.ap3216c_read_ps_data()
if ((ps >> 15) & 1):
return True
else:
return False
if __name__ == "__main__":
'''
The below i2c configuration is needed in your board.json.
"ap3216c": {
"type": "I2C",
"port": 1,
"addrWidth": 7,
"freq": 100000,
"mode": "master",
"devAddr": 30
}
'''
print("Testing ap3216c ...")
i2cDev = I2C()
i2cDev.open("ap3216c")
ap3216cDev = AP3216C(i2cDev)
illuminance = ap3216cDev.getIlluminance()
print("The illuminance is:", illuminance)
proxi = ap3216cDev.isProximate()
print("The proximity state is", proxi)
data = ap3216cDev.getData()
print("The total datais: ", data)
i2cDev.close()
del ap3216cDev
print("Test ap3216c done!")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_public_lighting/haaseduk1/code/ap3216c.py
|
Python
|
apache-2.0
| 13,749
|
from aliyunIoT import Device # aliyunIoT组件是连接阿里云物联网平台的组件
import utime
import ap3216c
from driver import I2C
from driver import GPIO
import netmgr as nm
import ujson
# 三元组信息
productKey = "产品密钥"
deviceName = "设备名称"
deviceSecret = "设备密钥"
# Wi-Fi SSID和Password设置
wifiSsid = "请填写您的路由器名称"
wifiPassword = "请填写您的路由器密码"
adcDev = 0
ledDev = 0
lightness = 0
# 物联网平台连接标志位
iot_connected = False
device = None
on_connected = False
# EDU K1上灯的初始化
def ledInit():
global ledDev
ledDev = GPIO()
ledDev.open("led")
# 点亮灯
def ledOn():
global ledDev
ledDev.write(1)
# 熄灭灯
def ledOff():
global ledDev
ledDev.write(0)
# ap3216c光照传感器初始化
def ap3216c_init():
global ap3216cDev
i2cDev = I2C()
i2cDev.open("ap3216c")
ap3216cDev = ap3216c.AP3216C(i2cDev)
print("ap3216c init finished")
# ap3216c光照传感器亮度获取
def ap3216c_light():
global ap3216cDev,lightness
lightness = ap3216cDev.getIlluminance()
# 关闭ap3216c光照传感器
def ap3216c_close():
global ap3216cDev
i2cDev.close()
del ap3216cDev
# 上报光照强度数据
def show_lightness():
global lightness,i_light,last_light,system_reset
i_light = int(lightness)
if system_reset == 1:
print("system first come")
system_reset = 0 # 系统第一次启动
report_light_data(i_light)
elif (i_light >= 100 and last_light < 100) or (i_light < 100 and last_light >= 100):
report_light_data(i_light) # 每次采样值是跨阈值100就上报
print("light has change")
else:
print('no need report')
if i_light < 10:
T_str = "亮度:" + str(round(i_light, 1))
elif i_light >= 10 and i_light < 100:
T_str = "亮度:" + str(round(i_light, 2))
elif i_light >= 100 and i_light < 1000:
T_str = "亮度:" + str(round(i_light, 3))
elif i_light >= 1000 and i_light < 10000:
T_str = "亮度:" + str(round(i_light, 4))
print(T_str)
last_light = i_light
# 等待Wi-Fi成功连接到路由器
def get_wifi_status():
nm.init()
nm.disconnect()
wifi_connected = nm.getStatus()
nm.connect(wifiSsid,wifiPassword)
while True :
if wifi_connected:
break
else:
wifi_connected = nm.getStatus()
utime.sleep(0.5)
print("Wi-Fi connected")
print('DeviceIP:' + nm.getInfo()['ip'])
# 物联网平台连接成功的回调函数
def on_connect(data):
global iot_connected
iot_connected = True
# 接收到到物联网服务端平台数据信息的回调函数
def on_props(request):
#服务端返回的json转换成dict
payload = ujson.loads(request['params'])
#获取dict中的灯物模型状态字段
stat = payload["onoff"]
if stat == 1:
print('led on')
ledOn()
else:
print('led off')
ledOff()
utime.sleep_ms(200)
# 连接物联网平台
def connect_lk(productKey, deviceName, deviceSecret):
global device, iot_connected
# 初始化linkkit sdk
key_info = {
'region': 'cn-shanghai',
'productKey': productKey,
'deviceName': deviceName,
'deviceSecret': deviceSecret,
'keepaliveSec': 60
}
# 将三元组信息设置到iot组件中
device = Device()
# 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
device.on(Device.ON_CONNECT, on_connect)
device.on(Device.ON_PROPS, on_props)
# 启动连接阿里云物联网平台过程
device.connect(key_info)
# 等待设备成功连接到物联网平台
while(True):
if iot_connected:
print('物联网平台连接成功')
break
else:
print('sleep for 1 s')
utime.sleep(1)
def report_light_data(l_data):
# 生成上报到物联网平台的属性值字串
upload_data = {'params': ujson.dumps({
'Brightness': l_data,
})
}
print("uploading data to the cloud:", upload_data)
# 上传光强度信息到物联网平台
device.postProps(upload_data)
def main():
global i_light,last_light,system_reset
i_light = 0
last_light = 0
system_reset = 1
get_wifi_status()
connect_lk(productKey, deviceName, deviceSecret)
ap3216c_init()
ledInit()
while True:
ap3216c_light()
show_lightness() #光照信息
utime.sleep(1.5) #每隔1.5s去刷新光照信息
if __name__ == '__main__':
main()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_public_lighting/haaseduk1/code/main.py
|
Python
|
apache-2.0
| 4,675
|
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/docs/examples/smart_toilet/esp32/code/ir.py
|
Python
|
apache-2.0
| 410
|
#!/usr/bin/env python3
# -*- encoding: utf-8 -*-
'''
@File : main.py
@Author : guoliang.wgl
@version : 1.0
@Description: smart_toilet案例 - 智能洗手间
board.json - 硬件资源配置文件
'''
from ir import IR
from mq136 import MQ136
from driver import ADC, GPIO
import time
from aliyunIoT import Device # iot组件是连接阿里云物联网平台的组件
import json
# 物联网平台连接标志位
iot_connected = False
wlan = None
# 三元组信息
productKey = "产品密钥"
deviceName = "设备名称"
deviceSecret = "设备密钥"
# 物联网设备实例
device = None
# Wi-Fi SSID和Password设置
wifiSsid = "请输入您的路由器名称"
wifiPassword = "请输入您的路由器密码"
# 红外检测是否存在人和硫化氢检测
FLAG_IR = "human_detect"
FLAG_H2S = "h2s_value"
# 等待Wi-Fi成功连接到路由器
def get_wifi_status():
global wlan
wifi_connected = False
wlan.active(True) #激活界面
wlan.scan() #扫描接入点
#print("start to connect ", wifiSsid)
# 连接到指定的路由器（路由器名称为wifiSsid, 密码为：wifiPassword）
wlan.connect(wifiSsid, wifiPassword)
while True:
wifi_connected = wlan.isconnected() # 获取Wi-Fi连接路由器的状态信息
if wifi_connected: # Wi-Fi连接成功则退出while循环
break
else:
time.sleep(0.5)
print("wifi_connected:", wifi_connected)
ifconfig = wlan.ifconfig() #获取接口的IP/netmask/gw/DNS地址
print(ifconfig)
time.sleep(0.5)
# 物联网平台连接成功的回调函数
def on_connect(data):
global iot_connected
iot_connected = True
# 设置props 事件接收函数（当云平台向设备下发属性时）
def on_props(request):
pass
def post_props(data):
global device
if isinstance(data, dict):
data = {'params': json.dumps(data)}
ret = device.postProps(data)
return ret
def connect_lk(productKey, deviceName, deviceSecret):
global device, iot_connected
key_info = {
'region': 'cn-shanghai',
'productKey': productKey,
'deviceName': deviceName,
'deviceSecret': deviceSecret,
'keepaliveSec': 60
}
# 将三元组信息设置到iot组件中
device = Device()
# 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
device.on(Device.ON_CONNECT, on_connect)
# 配置收到云端属性控制指令的回调函数
# 如果收到物联网平台发送的属性控制消息，则调用on_props函数
device.on(Device.ON_PROPS, on_props)
# 启动连接阿里云物联网平台过程
device.connect(key_info)
# 等待设备成功连接到物联网平台
while True:
if iot_connected:
print('物联网平台连接成功')
break
else:
print('sleep for 1 s')
time.sleep(1)
time.sleep(2)
def upload_h2s(value):
global FLAG_H2S
value = {FLAG_H2S: value}
post_props(value)
def upload_human_status(value):
global FLAG_IR
value = {FLAG_IR: value}
post_props(value)
if __name__ == '__main__':
wlan = network.WLAN(network.STA_IF) #创建WLAN对象
# 请替换物联网平台申请到的产品和设备信息
get_wifi_status()
connect_lk(productKey, deviceName, deviceSecret)
# 初始化mq136硫化氢检测传感器
adcObj = ADC() # ADC通道对象
adcObj.open("mq136") # 按照board.json中名为"mq136"节点的配置初始化ADC设备对象
mq136Dev = MQ136(adcObj)
# 初始化热释电红外传感器
gpioirDev = GPIO()
gpioirDev.open("ir")
ir = IR(gpioirDev)
while True:
h2s_value = mq136Dev.getVoltage()
print("current h2s is :{}".format(h2s_value))
upload_h2s(h2s_value)
human_exist = ir.irDetect()
upload_human_status(human_exist)
if human_exist:
print("human detected")
else:
print("no human found")
time.sleep(5)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_toilet/esp32/code/main.py
|
Python
|
apache-2.0
| 4,118
|
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/docs/examples/smart_toilet/esp32/code/mq136.py
|
Python
|
apache-2.0
| 412
|
#!/usr/bin/env python3
# -*- encoding: utf-8 -*-
'''
@File : cloudAI.py
@Description: 云端AI
@Author : jiangyu
@version : 1.0
'''
from aliyunIoT import Device
import utime # 延时函数在utime库中
import ujson as json
class CloudAI :
def __gesture_cb(self, dict) :
'''
Reply list :
handGestureReply : 手势识别
'''
gesture = 'NA'
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
result = ext_dict['result']
if result == 'success':
score = ext_dict['score']
if score > 0.4 :
gesture = ext_dict['type']
print("recognize hand gesture : " + gesture)
self.__cb('handGestureReply', gesture)
def __action_cb(self, dict) :
'''
Reply list :
actionReply : 动作识别
'''
action = 'NA'
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
i = 0
elements_list = ext_dict['elements']
while (i < len(elements_list)) :
g_score = elements_list[i]['score']
label = elements_list[i]['label']
if g_score > 0.5:
print("recognize action: " + label)
action = label
break
i += 1
self.__cb('recognizeActionReply', action)
def __license_plate_cb(self, dict) :
plateNumber = 'NA'
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
result = ext_dict['result']
if result == 'success':
g_confidence = ext_dict['confidence']
if g_confidence > 0.7 :
plateNumber = ext_dict['plateNumber']
print('detect: ' + plateNumber)
self.__cb('ocrCarNoReply', plateNumber)
def __fruits_cb(self, dict) :
fruit_name = 'NA'
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
result = ext_dict['result']
if result == 'success':
i = 0
fruits_list = ext_dict['fruitList']
while (i < len(fruits_list)) :
g_score = fruits_list[i]['score']
fruit_name = fruits_list[i]['name']
if g_score > 0.6:
print('detect: ' + fruit_name)
i += 1
self.__cb('detectFruitsReply', fruit_name)
def __pedestrian_cb(self, dict) :
detected = False
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
result = ext_dict['result']
if result == 'success':
i = 0
data = ext_dict['data']
data_dict = json.loads(data)
elements_list = data_dict['elements']
while (i < len(elements_list)) :
g_score = elements_list[i]['score']
if g_score > 0.6:
print('Pedestrian Detected')
detected = True
i += 1
self.__cb('DetectPedestrianReply', detected)
def __businesscard_cb(self, dict) :
card_info = {}
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
result = ext_dict['result']
if result == 'success':
card_info['name'] = ext_dict['name']
print("name : " + card_info['name'])
if card_info['name'] == '' :
card_info['name'] = 'unknown'
phoneNumbers_list = ext_dict['cellPhoneNumbers']
print("phoneNumbers : ")
print(phoneNumbers_list)
if len(phoneNumbers_list) :
card_info['phoneNumbers'] = phoneNumbers_list[0]
else :
card_info['phoneNumbers'] = 'unknown'
email_list = ext_dict['emails']
print("email_list: ")
print(email_list)
if len(email_list) :
card_info['email'] = email_list[0]
else :
card_info['email'] = 'unknown'
self.__cb('recognizeBusinessCardReply', card_info)
def __rubblish_cb(self, dict) :
name = 'NA'
if dict != None:
ext = dict['ext']
extDict = json.loads(ext)
result = extDict['result']
if result == 'success':
i = 0
elements = extDict['elements']
while (i < len(elements)) :
gScore = elements[i]['categoryScore']
if gScore > 0.8:
name = elements[i]['category']
print('detect: ' + name)
break
i += 1
self.__cb('classifyingRubbishReply', name)
def __object_cb(self, dict) :
name = 'NA'
if dict != None:
ext = dict['ext']
extDict = json.loads(ext)
result = extDict['result']
if result == 'success':
i = 0
elements = extDict['elements']
while (i < len(elements)) :
gScore = elements[i]['score']
if gScore > 0.25:
name = elements[i]['type']
print('detect: ' + name)
break
i += 1
self.__cb('detectObjectReply', name)
def __vehicletype_cb(self, dict) :
name = 'NA'
detect = False
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
result = ext_dict['result']
if result == 'success':
i = 0
item_list = ext_dict['items']
name = 'NA'
while (i < len(item_list)) :
g_score = item_list[i]['score']
name = item_list[i]['name']
# 这里可以修改识别的可信度，目前设置返回可信度大于85%才认为识别正确
if g_score > 0.85 and name != 'others':
print('detect: ' + name)
detect = True
self.__cb('recognizeVehicleReply', name)
break
i += 1
if detect == False:
self.__cb('recognizeVehicleReply', 'NA')
def __vehiclelogo_cb(self, dict) :
num = 0
if dict != None:
ext = dict['ext']
ext_dict = json.loads(ext)
result = ext_dict['result']
if result == 'success':
item_list = ext_dict['elements']
num = len(item_list)
if num > 0:
print('detect: ' + str(num) + ' vehicle')
detected = True
if detected == False:
print('do not detect!')
self.__cb('recognizeLogoReply', num)
def __cb_lk_service(self, data):
self.g_lk_service = True
#print('download <----' + str(data))
if data != None :
params = data['params']
params_dict = json.loads(params)
command = params_dict['commandName']
if command == 'handGestureReply' :
self.__gesture_cb(params_dict)
elif command == 'recognizeActionReply' :
self.__action_cb(params_dict)
elif command == 'ocrCarNoReply' :
self.__license_plate_cb(params_dict)
elif command == 'DetectPedestrianReply' :
self.__pedestrian_cb(params_dict)
elif command == 'detectFruitsReply' :
self.__fruits_cb(params_dict)
elif command == 'recognizeBusinessCardReply' :
self.__businesscard_cb(params_dict)
elif command == 'classifyingRubbishReply' :
self.__rubblish_cb(params_dict)
elif command == 'detectObjectReply' :
self.__object_cb(params_dict)
elif command == 'recognizeVehicleReply' :
self.__vehicletype_cb(params_dict)
elif command == 'recognizeLogoReply' :
self.__vehiclelogo_cb(params_dict)
else :
print('unknown command reply')
def __cb_lk_props(self, data):
self.__prop_cb(data)
def __cb_lk_connect(self, data):
print('link platform connected')
self.g_lk_connect = True
def __connect_iot(self) :
self.device = Device()
self.device.on(Device.ON_CONNECT, self.__cb_lk_connect)
self.device.on(Device.ON_SERVICE, self.__cb_lk_service)
self.device.on(Device.ON_PROPS, self.__cb_lk_props)
self.device.connect(self.__dev_info)
while True:
if self.g_lk_connect:
break
def __init__(self, dev_info, callback, prop_cb) :
self.__dev_info = dev_info
self.__cb = callback
self.__prop_cb = prop_cb
self.g_lk_connect = False
self.g_lk_service = False
self.__connect_iot()
def getDevice(self) :
return self.device
def __upload_request(self, command, frame, enlarge = 1) :
# 上传图片到LP
fileName = 'test.jpg'
start = utime.ticks_ms()
fileid = self.device.uploadContent(fileName, frame, None)
if fileid != None:
ext = { 'filePosition':'lp', 'fileName': fileName, 'fileId': fileid, 'enlarge':enlarge}
ext_str = json.dumps(ext)
all_params = {'id': 1, 'version': '1.0', 'params': { 'eventType': 'haas.faas', 'eventName': command, 'argInt': 1, 'ext': ext_str }}
all_params_str = json.dumps(all_params)
#print(all_params_str)
upload_file = {
'topic': '/sys/' + self.__dev_info['productKey'] + '/' + self.__dev_info['deviceName'] + '/thing/event/hli_event/post',
'qos': 1,
'payload': all_params_str
}
# 上传完成通知HaaS聚合平台
# print('upload--->' + str(upload_file))
self.g_lk_service = False
self.device.publish(upload_file)
i = 0
while (self.g_lk_service == False and i < 200) :
utime.sleep_ms(10)
i = i + 1
continue
else:
print('filedid is none, upload content fail')
time_diff = utime.ticks_diff(utime.ticks_ms(), start)
print('recognize time : %d' % time_diff)
def recognizeGesture(self, frame) :
self.__upload_request('handGesture', frame)
def recognizeAction(self, frame) :
self.__upload_request('recognizeAction', frame, 2)
def recognizeLicensePlate(self, frame) :
self.__upload_request('ocrCarNo', frame)
def detectPedestrian(self, frame) :
self.__upload_request('detectPedestrian', frame)
def detectFruits(self, frame) :
self.__upload_request('detectFruits', frame)
def recognizeBussinessCard(self, frame) :
self.__upload_request('recognizeBusinessCard', frame)
def recognizeVehicleType(self, frame) :
self.__upload_request('recognizeVehicle', frame)
def detectVehicleCongestion(self, frame) :
self.__upload_request('vehicleCongestionDetect', frame)
def classifyRubbish(self, frame) :
self.__upload_request('classifyingRubbish', frame)
def detectObject(self, frame) :
self.__upload_request('detectObject', frame)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_traffic_light/esp32/code/cloudAI.py
|
Python
|
apache-2.0
| 11,842
|
#!/usr/bin/env python3
# -*- encoding: utf-8 -*-
'''
@File : main.py
@Description: 交通红绿灯
@Author : zhangheng
@version : 1.0
方案设计
初始红灯60秒、黄灯3秒、绿灯30秒
每4次拍摄为一组
摄像头10秒拍摄1次,连续4次拍摄的车辆数都是大于M量车,判断当前是红灯或黄灯,则将接下来的绿灯加10秒,下一次的红灯减去10秒,如果当前就是绿灯,则不处理,继续下一组拍摄
如果有一次拍摄不满足大于M量车,则下一次灯的周期恢复为原始设置周期
如果云端有强制设置红绿灯时间周期或者强制恢复本地默认周期,则以云端为准
要求红灯最低只能减到30秒,绿灯最多60秒,其中一个达到限制点后,不再继续调整
'''
from aliyunIoT import Device
import display # 显示库
import network # 网络库
import ucamera # 摄像头库
import utime # 延时函数在utime库中
import sntp # 网络时间同步库
import _thread # 线程库
import ujson as json
from cloudAI import *
from rgb import *
# Wi-Fi SSID和Password设置
SSID='***'
PWD='***'
# HaaS设备三元组
productKey = "***"
deviceName = "***"
deviceSecret = "***"
g_lk_connect = False
g_lk_service = False
g_score = 0
key_info = {
'region' : 'cn-shanghai' ,
'productKey': productKey ,
'deviceName': deviceName ,
'deviceSecret': deviceSecret ,
'keepaliveSec': 60
}
# 红灯最低时长(秒)
red_min_period = 30
# 绿灯最低时长(秒)
green_max_period = 60
# 默认红黄绿灯时长周期,下标0为红灯,下标1为黄灯且固定3秒不变,下标2位绿灯
rgb_current_period = [60, 3, 30]
gNumber=0
# 当前灯的颜色 0-red/1-green/2-blue
curGNumber = 0
# 拍摄4次一组
detectTime = 4
# 识别间隔周期
detectPeriod = 3
# 车辆数量阈值
warningVehicleNum = 3
# 是否云端强制设置的值
setting_from_server = False
# 还原初始值，即红绿灯时间重新变为rgb_current_period对应的值
setting_resume_default = 0
# 获取灯的颜色
def set_color_reference():
global gLedColor,gNumber,curGNumber
if gNumber == 0:
# 红色
ledColor = 0xff0000
elif gNumber == 1:
# 黄色
ledColor = 0xFFFF00
else:
# 绿色
ledColor = 0x00ff00
gLedColor = ledColor
curGNumber = gNumber
gNumber += 1
gNumber %= 3
return gLedColor
# 开启Led灯
def led_open(color):
print('current_time:', utime.time())
global gLed
gLed.setColor(color)
print(curGNumber)
sleepSeconds = rgb_current_period[curGNumber]
print('当前灯的颜色:%#x'%color,'亮灯时间:',str(sleepSeconds) + 's')
utime.sleep(sleepSeconds)
# 关闭Led灯
def led_close():
global gLed,gLedColor
print('关灯')
gLedColor = 0x000000
gLed.setColor(gLedColor)
# 接收到的云端下发的属性设置,data格式: {"code": 0, "params_len": 17, "msg_id": 1828542828, "params": "{\"red_period\":0}"}
def props_cb(data):
global setting_from_server,setting_resume_default,rgb_current_period
print(data)
try:
params = data['params']
params_dict = json.loads(params)
red_period = params_dict.get('red_period')
print(red_period)
green_period = params_dict.get('green_period')
print(green_period)
resume_default = params_dict.get('resume_default')
if red_period is not None:
print("setting red_period:", red_period)
rgb_current_period[0] = red_period
setting_from_server = True
if green_period is not None:
print("setting green_period:", green_period)
rgb_current_period[2] = green_period
setting_from_server = True
if resume_default is not None:
setting_resume_default = resume_default
print("server setting_resume_default:", setting_resume_default)
if setting_resume_default == 1:
setting_from_server = False
rgb_current_period = [60, 3, 30]
print("rgb_current_period:", rgb_current_period)
except Exception as e:
print(e)
# 识别线程函数
def recognizeThread():
global frame
while True:
if frame != None:
engine.detectVehicleCongestion(frame)
utime.sleep(detectPeriod)
else:
utime.sleep_ms(1000)
def action_cb(commandReply, result) :
global detected, num
num = result
detected = False
if commandReply == 'recognizeLogoReply' :
if result != 'NA' :
# print('detect num: ', num)
detected = True
else :
print('unknown command reply')
# 显示线程函数
def display_thread():
# 引用全局变量
global disp, frame, detected, num, curGNumber, rgb_current_period,setting_from_server,setting_resume_default
# 初始化摄像头
ucamera.init('uart', 33, 32)
ucamera.setProp(ucamera.SET_FRAME_SIZE, ucamera.SIZE_320X240)
# 定义清屏局部变量
clearFlag = False
# 定义显示文本局部变量
textShowFlag = False
while True:
needChangePeriod = True
for i in range(1, detectTime):
# 采集摄像头画面
utime.sleep(detectPeriod)
# print('start to capture')
frame = ucamera.capture()
# print('end to capture')
if frame != None:
if detected == True:
disp.clear()
# 设置文字字体
disp.font(disp.FONT_DejaVu40)
# 显示识别结果
# disp.text(40, 80, name, disp.RED)
disp.text(10, 60, 'Vehicle Num:' + str(num), disp.RED)
print('Vehicle Num:' + str(num) +' !!!')
utime.sleep_ms(1000)
# 判断车辆数量是否超过阈值
if num < warningVehicleNum:
needChangePeriod = False
print('needChangePeriod changed to', needChangePeriod)
textShowFlag = False
#detected = False
else:
needChangePeriod = False
print('needChangePeriod changed', needChangePeriod)
# 显示图像
# print('start to display')
disp.image(0, 20, frame, 0)
utime.sleep_ms(100)
if textShowFlag == False:
# 设置显示字体
disp.font(disp.FONT_DejaVu18)
# 显示文字
disp.text(2, 0, 'Recognizing ...', disp.WHITE)
textShowFlag = True
print('now needChangePeriod is ', needChangePeriod)
if needChangePeriod == True:
print('curGNumber:', curGNumber, 'setting_from_server:', setting_from_server, 'setting_resume_default:',setting_resume_default)
# 没有从服务端下发配置
if setting_from_server == False and setting_resume_default == 0:
# 需要调整时间周期，当前是红灯或黄灯，则将接下来的绿灯加10秒，下一次的红灯减去10秒，如果当前就是绿灯，则不处理，继续下一组拍摄，如果本组4次拍摄不满足都大于M量车，则恢复为原始设置周期
if curGNumber == 0 or curGNumber == 1:
if rgb_current_period[2] < green_max_period:
rgb_current_period[2] = rgb_current_period[2] + 10
if rgb_current_period[0] > red_min_period:
rgb_current_period[0] = rgb_current_period[0] - 10
print("rgb_current_period after change:", rgb_current_period)
else:
print('false setting_from_server:', setting_from_server, 'setting_resume_default:',setting_resume_default)
# 没有从服务端下发配置，则恢复为默认值
if setting_from_server == False and setting_resume_default == 0:
rgb_current_period = [60, 3, 30]
print('rgb_current_period change to:', rgb_current_period)
# rgb灯变换线程
def rgb():
print('rgb灯线程')
while True:
# 开灯
led_open(set_color_reference())
# 关灯
led_close()
def connect_wifi(ssid, pwd):
# 引用全局变量
global disp
# 初始化网络
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(ssid, pwd)
while True:
print('Wi-Fi is connecting...')
# 显示网络连接中
disp.text(20, 30, 'Wi-Fi is connecting...', disp.RED)
# 网络连接成功后，更新显示字符
if (wlan.isconnected() == True):
print('Wi-Fi is connected')
disp.textClear(20, 30, 'Wi-Fi is connecting...')
disp.text(20, 30, 'Wi-Fi is connected', disp.RED)
ip = wlan.ifconfig()[0]
print('IP: %s' %ip)
disp.text(20, 50, ip, disp.RED)
# NTP时间更新，如果更新不成功，将不能进行识别
print('NTP start')
disp.text(20, 70, 'NTP start...', disp.RED)
sntp.setTime()
print('NTP done')
disp.textClear(20, 70, 'NTP start...')
disp.text(20, 70, 'NTP done', disp.RED)
break
utime.sleep_ms(500)
utime.sleep(2)
# 多线程案例
def main():
# 全局变量
global disp, dev, frame, detected,gLed,gLedColor,engine
# 创建lcd display对象
disp = display.TFT()
frame = None
detected = False
# 开启RGB,必须在摄像头初始化前开启,否则先开启摄像头再开启RGB可能通道被占用导致RGB开启失败
rgbR = PWM()
rgbR.open("rgbR")
rgbG = PWM()
rgbG.open("rgbG")
rgbB = PWM()
rgbB.open("rgbB")
gLed = RgbLed(rgbR, rgbG, rgbB)
# 连接网络
connect_wifi(SSID, PWD)
# 初始化识别服务
engine = CloudAI(key_info, action_cb, props_cb)
try:
# 启动显示线程
_thread.start_new_thread(display_thread, ())
# 设置识别线程stack
_thread.stack_size(12 * 1024)
# 启动识别线程
_thread.start_new_thread(recognizeThread, ())
# rgb变化
rgb()
except:
print("Error: unable to start thread")
while True:
utime.sleep_ms(1000)
if __name__ == '__main__':
main()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_traffic_light/esp32/code/main.py
|
Python
|
apache-2.0
| 10,537
|
#!/usr/bin/env python3
# -*- encoding: utf-8 -*-
'''
@File : rgb.py
@Description: rgb灯传感器
@Author : 风裁
@version : 1.0
'''
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': red})
self.pwmG.setOption({'freq': 255, 'duty': green})
self.pwmB.setOption({'freq': 255, 'duty': blue})
elif isinstance(color, int) and color >= 0 and color <= 0xffffff:
red = color >> 16
green = (color >> 8) & 0x00ff
blue = color & 0x0000ff
self.pwmR.setOption({'freq': 255, 'duty': red})
self.pwmG.setOption({'freq': 255, 'duty': green})
self.pwmB.setOption({'freq': 255, 'duty': blue})
else:
raise ValueError("color type error! color should be like (255, 255, 255) or 0xffffff")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/smart_traffic_light/esp32/code/rgb.py
|
Python
|
apache-2.0
| 1,666
|
# ！/usr/bin/python3
# -- coding: utf-8 --
# @Time : 2022/6/13 11:00 AM
# @Author : grady
from driver import ADC
import utime as time
from modem import sms
###############################
# 需要发送短信的目标电话号码，长度为11的字符串格式
tele_phone = 'xxxxxxxxxxx'
###############################
if __name__ == '__main__':
# 报警次数
warning = 0
# 短信实例化
smss = sms()
# 火焰传感器
adc = ADC()
adc.open("ADC1")
while True:
time.sleep_ms(1000)
value = adc.readVoltage()
if value <= 1000:
warning += 1
if warning > 4:
print('已累计上报3次，停止短信发送')
elif warning > 1:
# 将yourphone改为用户电话号码，文本格式，加''
smss.sendTextMsg(tele_phone, '检测到明火，请及时处理！！！', 'UCS2')
time.sleep(60)
else:
print('数据异常！')
else:
warning = 0
print('正常运行，当前测量数值:', value)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/sms_fire_alarm/code/main.py
|
Python
|
apache-2.0
| 1,108
|
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/docs/examples/soap_dispenser/ESP-32S/code/ir.py
|
Python
|
apache-2.0
| 410
|
# -*- coding: UTF-8 -*-
from aliyunIoT import Device # iot组件是连接阿里云物联网平台的组件
import network # Wi-Fi功能所在库
import ujson # json字串解析库
import utime # 延时API所在组件
from driver import ADC # ADC类，用ADC外设的接入
from driver import PWM # PWM类，用舵机控制
from driver import GPIO # GPIO类，用于控制微处理器的输入输出功能
import water4level # 液位传感器类
import servo # 舵机控制类
import ir # ir人体红外传感器类
irDev = None
adcDev = None
pwmDev = None
# 物联网平台连接标志位
iot_connected = False
wlan = None
# 三元组信息
productKey = "产品密钥"
deviceName = "设备名称"
deviceSecret = "设备密钥"
# 物联网设备实例
device = None
# Wi-Fi SSID和Password设置
wifiSsid = "请输入您的路由器名称"
wifiPassword = "请输入您的路由器密码"
# 等待Wi-Fi成功连接到路由器
def get_wifi_status():
global wlan
wifi_connected = False
wlan.active(True) #激活界面
wlan.scan() #扫描接入点
# 连接到指定的路由器（路由器名称为wifiSsid, 密码为：wifiPassword）
wlan.connect(wifiSsid, wifiPassword)
while True:
wifi_connected = wlan.isconnected() # 获取Wi-Fi连接路由器的状态信息
if wifi_connected: # Wi-Fi连接成功则退出while循环
break
else:
utime.sleep(0.5)
print("wifi_connected:", wifi_connected)
ifconfig = wlan.ifconfig() #获取接口的IP/netmask/gw/DNS地址
print(ifconfig)
utime.sleep(0.5)
# 物联网平台连接成功的回调函数
def on_connect(data):
global iot_connected
iot_connected = True
# 设置props 事件接收函数（当云平台向设备下发属性时）
def on_props(request):
pass
def connect_lk(productKey, deviceName, deviceSecret):
global device, iot_connected
key_info = {
'region': 'cn-shanghai',
'productKey': productKey,
'deviceName': deviceName,
'deviceSecret': deviceSecret,
'keepaliveSec': 60
}
# 将三元组信息设置到iot组件中
device = Device()
# 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
device.on(Device.ON_CONNECT, on_connect)
# 配置收到云端属性控制指令的回调函数，如果收到物联网平台发送的属性控制消息，则调用on_props函数
device.on(Device.ON_PROPS, on_props)
# 启动连接阿里云物联网平台过程
device.connect(key_info)
# 等待设备成功连接到物联网平台
while(True):
if iot_connected:
print('物联网平台连接成功')
break
else:
print('sleep for 1 s')
utime.sleep(1)
print('sleep for 2s')
utime.sleep(2)
# dev init
def ir_init():
global irDev
irDev = GPIO()
irDev.open("ir")
def water4level_init():
global adcDev
adcDev = ADC()
adcDev.open("waterlevel")
def servo_init():
global pwmDev
pwmDev = PWM()
pwmDev.open("servo")
# dev deinit
def ir_deinit():
global irDev
irDev.close()
def water4level_deinit():
global adcDev
adcDev.close()
def servo_deinit():
global pwmDev
pwmDev.close()
# dev control
# 人手检测，0-检测到手，1-未检测到手；检测距离调整为10cm，调整方法见README
def get_ir_status():
irObj = ir.IR(irDev)
status = irObj.irDetect()
return status
# 皂液余量测量
def get_waterlevel():
waterlevelObj = water4level.WATER4LEVEL(adcDev)
level = waterlevelObj.measureLevel()
return level
# 舵机控制
def servo_control(data):
servoObj = servo.SERVO(pwmDev)
servoObj.setOptionSero(data)
if __name__ == '__main__' :
wlan = network.WLAN(network.STA_IF) #创建WLAN对象
# 请替换物联网平台申请到的产品和设备信息,可以参考文章:https://blog.csdn.net/HaaSTech/article/details/114360517
# global productKey, deviceName, deviceSecret ,on_request, on_play
get_wifi_status()
connect_lk(productKey, deviceName, deviceSecret)
ir_init()
servo_init()
water4level_init()
while True:
servo_control(0) # 舵机回归0位，皂液释放器恢复原状
if (not get_ir_status()): # 获取ir传感器的值,0-检测到手，1-未检测到手
utime.sleep(1)
if (not get_ir_status()): # 1s之后仍检测到人手，说明人手到来
print("hand is here .....\r\n")
servo_control(90) # 舵机旋转90度，驱动皂液释放器释放皂液
else:
continue
utime.sleep(1.5)
# "soap_status" - 皂液容量状态
soap = get_waterlevel()
if (soap >= 4):
soap_status="plenty"
elif ((soap >=1) and (soap < 4)):
soap_status="insufficient"
elif (soap < 1):
soap_status="exhausted"
# 生成上报到物联网平台的属性值字串
# 此处的属性标识符"soap_status"必须和物联网平台的属性一致
upload_data = {'params': ujson.dumps({'soap_status': soap_status})}
# 上传数据到物联网平台
device.postProps(upload_data)
ir_deinit()
servo_deinit()
water4level_deinit()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/soap_dispenser/ESP-32S/code/main.py
|
Python
|
apache-2.0
| 5,612
|
"""
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/docs/examples/soap_dispenser/ESP-32S/code/servo.py
|
Python
|
apache-2.0
| 664
|
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/docs/examples/soap_dispenser/ESP-32S/code/water4level.py
|
Python
|
apache-2.0
| 704
|
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 voltage(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 current(self):
self._handle_current_overflow()
return self._current_register() * self._current_lsb * 1000
def power(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/docs/examples/solar_monitor/haas506/code/ina219.py
|
Python
|
apache-2.0
| 10,616
|
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import utime
import ujson
from aliyunIoT import Device
import modbus as mb
import yuanda_htb485
import network
import ina219
from driver import GPIO
from driver import ADC
from driver import I2C
# 4G.Cat1连网代码
g_connect_status = False
def on_4g_cb(args):
print("4g callback.")
global g_connect_status
pdp = args[0]
netwk_sta = args[1]
if netwk_sta == 1:
g_connect_status = True
else:
g_connect_status = False
def connect_4g_network():
global on_4g_cb
net = network.NetWorkClient()
net_led = GPIO()
net_led.open('net_led')
g_register_network = False
if net._stagecode is not None and net._stagecode == 3 and net._subcode == 1:
g_register_network = True
else:
g_register_network = False
if g_register_network:
net.on(1,on_4g_cb)
# net.connect({"apn":"CMNET"})
net.connect({'apn':'CMIOTNJSHA.JS'})
else:
print('network register failed')
while True:
if g_connect_status==False:
net_led.write(0)
if g_connect_status:
print('network register successed')
#连上网之后，点亮cloud_led
net_led.write(1)
break
utime.sleep_ms(20)
return 0
# 上传路灯信息
def upload_battery_info(device):
mb.init('modbus_485_4800')
htb485Obj = yuanda_htb485.HTB485(mb, 1)
adc = ADC()
adc.open("ADC1")
i2cObj = I2C()
i2cObj.open("ina219")
ina219Dev = ina219.INA219(i2cObj)
while True:
brightness = htb485Obj.getBrightness()
battery_voltage = adc.readVoltage() * 5 / 1000.0
# current = ina219Dev.current() / 1000.0
current = 0.11
# "brightness"/"battery_voltage"/"current"必须和物联网平台的属性一致
upload_data = {'params': ujson.dumps({
'brightness': brightness,
"battery_voltage":battery_voltage,
'current': current
})
}
print(upload_data)
# 上传温度和湿度信息到物联网平台
device.postProps(upload_data)
utime.sleep(5)
mb.deinit()
# 物联网平台连接成功的回调函数
def on_connect(data):
print("物联网平台连接成功")
# 处理物联网平台下行指令
def on_props(request):
print("新消息：", request)
# 连接物联网平台
def connect_lk():
key_info = {
'region': 'cn-shanghai',
'productKey': "xxx",
'deviceName': "xxx",
'deviceSecret': "xxx",
'keepaliveSec': 60
}
device = Device()
device.on(Device.ON_CONNECT, on_connect)
device.on(Device.ON_PROPS, on_props)
device.connect(key_info)
return device
if __name__ == '__main__':
connect_4g_network()
utime.sleep(2)
device = connect_lk()
utime.sleep(2)
upload_battery_info(device)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/solar_monitor/haas506/code/main.py
|
Python
|
apache-2.0
| 3,399
|
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/docs/examples/solar_monitor/haas506/code/yuanda_htb485.py
|
Python
|
apache-2.0
| 1,739
|
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import utime
import ujson
from aliyunIoT import Device
import modbus as mb
import yuanda_htb485
import network
from driver import GPIO
from driver import ADC
# 4G.Cat1连网代码
g_connect_status = False
def on_4g_cb(args):
print("4g callback.")
global g_connect_status
netwk_sta = args[1]
if netwk_sta == 1:
g_connect_status = True
else:
g_connect_status = False
def connect_4g_network():
global on_4g_cb
net = network.NetWorkClient()
net_led = GPIO()
net_led.open('net_led')
g_register_network = False
if net._stagecode is not None and net._stagecode == 3 and net._subcode == 1:
g_register_network = True
else:
g_register_network = False
if g_register_network:
net.on(1,on_4g_cb)
# net.connect({"apn":"CMNET"})
net.connect({'apn':'CMIOTNJSHA.JS'})
else:
print('network register failed')
while True:
if g_connect_status==False:
net_led.write(0)
if g_connect_status:
print('network register successed')
#连上网之后，点亮cloud_led
net_led.write(1)
break
utime.sleep_ms(20)
return 0
power_type_switch = GPIO()
power_switch = GPIO()
work_mode = 0
# 上传路灯信息
def upload_lamp_info(device):
global power_type_switch, power_switch, work_mode
mb.init('modbus_485_4800')
htb485Obj = yuanda_htb485.HTB485(mb, 1)
power_type_switch.open("electric_relay1_1")
power_switch.open("electric_relay1_2")
adc = ADC()
adc.open("ADC1")
dc_time = 0
bat_time = 0
while True:
brightness = htb485Obj.getBrightness()
battery_voltage = adc.readVoltage() * 5 / 1000.0
lamp_status = power_switch.read()
power_type = power_type_switch.read()
if (brightness < 600 and work_mode == 0):
if (battery_voltage < 11.0):
power_type = 0
power_type_switch.write(0)
dc_time += 1
else:
power_type = 1
power_type_switch.write(1)
bat_time += 1
power_switch.write(1)
lamp_status = 1
if (brightness > 700 and work_mode == 0):
power_switch.write(0)
lamp_status = 0
# "brightness"/"lamp_state"/"battery_voltage/power_type/dc_time/bat_time"必须和物联网平台的属性一致
upload_data = {'params': ujson.dumps({
'brightness': brightness,
"lamp_state": lamp_status,
"battery_voltage":battery_voltage,
'power_type': power_type,
"dc_time": dc_time,
"bat_time": bat_time,
"work_mode": work_mode
})
}
print(upload_data)
# 上传温度和湿度信息到物联网平台
device.postProps(upload_data)
utime.sleep(2)
mb.deinit()
# 物联网平台连接成功的回调函数
def on_connect(data):
print("物联网平台连接成功")
# 处理物联网平台下行指令
cmd_name_list = ["lamp_state", "power_type", "work_mode"]
def on_props(request):
global power_type_switch, power_switch, work_mode
payload = ujson.loads(request['params'])
for i in range(0, len(cmd_name_list)):
if cmd_name_list[i] in payload.keys():
value = payload[cmd_name_list[i]]
if cmd_name_list[i] is 'work_mode':
work_mode = value
else:
work_mode = 1
if cmd_name_list[i] is 'lamp_state':
power_switch.write(value)
if cmd_name_list[i] is 'power_type':
power_type_switch.write(value)
prop = ujson.dumps({
cmd_name_list[i]: value,
})
upload_data = {'params': prop}
device.postProps(upload_data)
# 连接物联网平台
def connect_lk():
key_info = {
'region': 'cn-shanghai',
'productKey': "xxx",
'deviceName': "xxx",
'deviceSecret': "xxx",
'keepaliveSec': 60
}
device = Device()
device.on(Device.ON_CONNECT, on_connect)
device.on(Device.ON_PROPS, on_props)
device.connect(key_info)
return device
if __name__ == '__main__':
connect_4g_network()
utime.sleep(2)
device = connect_lk()
utime.sleep(2)
upload_lamp_info(device)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/solar_street_lamp/haas506/code/main.py
|
Python
|
apache-2.0
| 4,552
|
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/docs/examples/solar_street_lamp/haas506/code/yuanda_htb485.py
|
Python
|
apache-2.0
| 1,739
|
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@File : main.py
@Author : 杭漂
@version : 1.0
@Description: 声控灯案例
'''
from aliyunIoT import Device
import network # 网络库
import utime # 延时函数在utime库中
import sntp # 网络时间同步库
import _thread # 线程库
import utime # 延时函数在utime库中
import ujson as json
from driver import ADC
from driver import PWM
gLpConnect = False
gDebugLogFlag = True
gNumber = 0
gOpenLed = False
gDecibelValue = 1520
# Wi-Fi SSID和Password设置
SSID='Your-AP-SSID'
PWD='Your-AP-Password'
# HaaS设备三元组
productKey = "Your-ProductKey"
deviceName = "Your-devicename"
deviceSecret = "Your-deviceSecret"
key_info = {
'region' : 'cn-shanghai' ,
'productKey': productKey ,
'deviceName': deviceName ,
'deviceSecret': deviceSecret ,
'keepaliveSec': 60
}
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': red})
self.pwmG.setOption({'freq': 255, 'duty': green})
self.pwmB.setOption({'freq': 255, 'duty': 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': red})
self.pwmG.setOption({'freq': 255, 'duty': green})
self.pwmB.setOption({'freq': 255, 'duty': blue})
else:
raise ValueError("color type error! color should be like (255, 255, 255) or 0xffffff")
def connect_wifi(ssid, pwd):
# 初始化网络
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(ssid, pwd)
while True:
print('Wi-Fi is connecting...')
# 网络连接成功后，更新显示字符
if (wlan.isconnected() == True):
print('Wi-Fi is connected')
ip = wlan.ifconfig()[0]
print('IP: %s' %ip)
# NTP时间更新，如果更新不成功，将不能进行识别
print('NTP start')
sntp.setTime()
print('NTP done')
break
utime.sleep_ms(500)
utime.sleep(2)
def cb_lk_service(data):
print('handling sub data')
def cb_lk_connect(data):
global gLpConnect
print('link platform connected')
gLpConnect = True
# 获取灯的颜色
def set_color_reference():
global gLedColor,gNumber
if gNumber == 0:
# 白色
ledColor = 0xffffff
elif gNumber == 1:
# 红色
ledColor = 0xff0000
elif gNumber == 2:
# 蓝色
ledColor = 0x0000ff
else:
# 绿色
ledColor = 0x00ff00
gLedColor = ledColor
gNumber += 1
gNumber %= 4
return gLedColor
# 获取当前声音转换值
def get_decibel():
voltage = gAdcObj.readVoltage()
return voltage
# 属性上报
def lp_post_props(color):
global gDev
# 生成上报到物联网平台的属性值字串，此处的属性标识符"ledStatus"必须和物联网平台的属性一致
value = {'ledStatus': color}
data = {'params': json.dumps(value)}
# 上传开关灯信息到物联网平台
ret = gDev.postProps(data)
if ret == 0 :
print('属性上报成功')
else :
print('属性上报失败')
# 开启Led灯
def led_open(color):
global gLed
print('开灯')
gLed.setColor(color)
lp_post_props(color)
# 关闭Led灯
def led_close():
global gLed,gLedColor
print('关灯')
gLedColor = 0x000000
gLed.setColor(gLedColor)
lp_post_props(gLedColor)
# 声音采集线程
def sound_thread():
global gOpenLed
print('启动声音采集线程')
decibelValue = 0
while True:
# 采集声音
decibelValue = get_decibel()
# 判断分贝
if decibelValue > gDecibelValue and gOpenLed == False:
print("声波转换后的值%s"% (decibelValue))
gOpenLed = True
# 开灯
led_open(set_color_reference())
# 亮灯6秒
utime.sleep_ms(6000)
# 关灯
led_close()
gOpenLed = False
# 监听获取声音的频率，间隔不能太长，延迟大会导致不精确
utime.sleep_ms(10)
def main():
global gAdcObj,gLed,gLedColor,gDev
# 连接网络
connect_wifi(SSID, PWD)
# 设备初始化
gDev = Device()
gDev.on(Device.ON_CONNECT, cb_lk_connect)
gDev.on(Device.ON_SERVICE, cb_lk_service)
gDev.connect(key_info)
while True:
if gLpConnect:
break
# 创建ADC对象
gAdcObj = ADC()
# 开启声音传感器
ret = gAdcObj.open('hw181_adc')
if ret != 0 :
print("错误：声音传感器开启失败！")
print('%s' % ret)
# 开启RGB
rgbR = PWM()
rgbR.open("rgbR")
rgbG = PWM()
rgbG.open("rgbG")
rgbB = PWM()
rgbB.open("rgbB")
gLed = RgbLed(rgbR, rgbG, rgbB)
try:
# 启动声音采集线程
_thread.start_new_thread(sound_thread, ())
except:
print("Error: unable to start thread")
while True:
utime.sleep_ms(1000)
if __name__ == '__main__':
main()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/sound_led/esp32/code/main.py
|
Python
|
apache-2.0
| 6,063
|
# coding=utf-8
from driver import ADC
from driver import GPIO
import network
import ujson
import utime as time
import modem
from aliyunIoT import Device
import kv
import _thread
#当iot设备连接到物联网平台的时候触发'connect' 事件
def on_connect(data):
global module_name,default_ver,productKey,deviceName,deviceSecret,on_trigger,on_download,on_verify,on_upgrade
print('***** connect lp succeed****')
data_handle = {}
data_handle['device_handle'] = device.getDeviceHandle()
#当连接断开时，触发'disconnect'事件
def on_disconnect():
print('linkkit is disconnected')
#当iot云端下发属性设置时，触发'props'事件
def on_props(request):
global state
params=request['params']
params=eval(params)
if 'light'in params:
upload_led(state)
else:
pass
#当iot云端调用设备service时，触发'service'事件
def on_service(id,request):
print('clound req id is {} , req is {}'.format(id,request))
#当设备跟iot平台通信过程中遇到错误时，触发'error'事件
def on_error(err):
print('err msg is {} '.format(err))
#网络连接的回调函数
def on_4g_cb(args):
global g_connect_status
pdp = args[0]
netwk_sta = args[1]
if netwk_sta == 1:
g_connect_status = True
else:
g_connect_status = False
#网络连接
def connect_network():
global net,on_4g_cb,g_connect_status
#NetWorkClient该类是一个单例类，实现网络管理相关的功能，包括初始化，联网，状态信息等.
net = network.NetWorkClient()
g_register_network = False
if net._stagecode is not None and net._stagecode == 3 and net._subcode == 1:
g_register_network = True
else:
g_register_network = False
if g_register_network:
#注册网络连接的回调函数on(self,id,func); 1代表连接，func 回调函数 ；return 0 成功
net.on(1,on_4g_cb)
net.connect(None)
else:
print('网络注册失败')
while True:
if g_connect_status:
print('网络连接成功')
break
time.sleep_ms(20)
#动态注册回调函数
def on_dynreg_cb(data):
global deviceSecret,device_dyn_resigter_succed
deviceSecret = data
device_dyn_resigter_succed = True
# 连接物联网平台
def dyn_register_device(productKey,productSecret,deviceName):
global on_dynreg_cb,device,deviceSecret,device_dyn_resigter_succed
key = '_amp_customer_devicesecret'
deviceSecretdict = kv.get(key)
print("deviceSecretdict:",deviceSecretdict)
if isinstance(deviceSecretdict,str):
deviceSecret = deviceSecretdict
if deviceSecretdict is None or deviceSecret is None:
key_info = {
'productKey': productKey ,
'productSecret': productSecret ,
'deviceName': deviceName
}
# 动态注册一个设备，获取设备的deviceSecret
#下面的if防止多次注册，当前若是注册过一次了，重启设备再次注册就会卡住，
if not device_dyn_resigter_succed:
device.register(key_info,on_dynreg_cb)
led_data = {}
def upload_led(led):
global led_data
led_data["light"]= led
led_data_str=ujson.dumps(led_data)
data={
'params':led_data_str
}
device.postProps(data)
gNumber = 0
onoff = 0
def open_all_led():
global gNumber,onoff
while True:
time.sleep_ms(100)
if onoff ==1:
if gNumber == 0:
# 开LED1
led3.write(0)
led1.write(1)
elif gNumber == 1:
# 开LED2
led1.write(0)
led2.write(1)
else:
# 开LED3
led2.write(0)
led3.write(1)
gNumber += 1
gNumber %= 3
else:
pass
state = 0
num = 1
def led_open():
global state,onoff,num
if num == 1:
state = num
num =2
# 开LED1
led1.write(1)
elif num == 2:
state = num
num = 3
# 开LED2
led2.write(1)
elif num == 3:
state = num
num = 4
# 开LED3
led3.write(1)
else :
state = num
num = 1
# 全开
onoff = 1
print('state',state)
upload_led(state)
def led_close():
global onoff,state
led1.write(0)
led2.write(0)
led3.write(0)
onoff = 0
state = 0
upload_led(state)
openLed = False
def voice_thread():
global openLed
while True:
time.sleep_ms(10)
value=voice.readVoltage()
if value <= 1520 and openLed == False:
print("声波转换后的值%s"% (value))
openLed = True
print('open led-------------------------')
led_open()
# 亮灯6秒
time.sleep_ms(6000)
# 关灯
led_close()
print('-------------------------close led')
openLed = False
if __name__ == '__main__':
ICCID=None
g_connect_status = False
net = None
device = None
deviceSecret = None
deviceName = None
#复制产品证书内容替换
productKey = "your-productKey"
productSecret = "your-productSecret"
device_dyn_resigter_succed = False
# 连接网络
connect_network()
# 获取设备的IMEI 作为deviceName 进行动态注册
deviceName = modem.info.getDevImei()
#获取设备的ICCID
ICCID=modem.sim.getIccid()
#初始化物联网平台Device类，获取device实例
device = Device()
if deviceName is not None and len(deviceName) > 0 :
#动态注册一个设备
dyn_register_device(productKey,productSecret,deviceName)
else:
print("获取设备IMEI失败，无法进行动态注册")
while deviceSecret is None:
time.sleep(0.2)
print('动态注册成功:' + deviceSecret)
key_info = {
'region' : 'cn-shanghai' ,
'productKey': productKey ,
'deviceName': deviceName ,
'deviceSecret': deviceSecret ,
'keepaliveSec': 60,
}
#打印设备信息
print(key_info)
#device.ON_CONNECT 是事件，on_connect是事件处理函数/回调函数
device.on(device.ON_CONNECT,on_connect)
device.on(device.ON_DISCONNECT,on_disconnect)
device.on(device.ON_PROPS,on_props)
device.on(device.ON_SERVICE,on_service)
device.on(device.ON_ERROR,on_error)
device.connect(key_info)
#传感器操作
led1=GPIO()
led1.open("led1")
led2=GPIO()
led2.open("led2")
led3=GPIO()
led3.open("led3")
voice=ADC()
voice.open('ADC1')
print('----------------test begin-------------------')
try:
# 创建声音采集线程
_thread.start_new_thread(voice_thread, ())
_thread.start_new_thread(open_all_led, ())
except:
print('main thread error...')
while True:
time.sleep(1)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/sound_led/haas506/code/main.py
|
Python
|
apache-2.0
| 7,073
|
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@File : main.py
@Author : 杭漂
@version : 1.0
@Description: 声控灯案例
'''
from ulinksdk.aliyunIoT import Device
import network # 网络库
import utime # 延时函数在utime库中
import sntp # 网络时间同步库
import _thread # 线程库
import utime # 延时函数在utime库中
import ujson as json
from driver import ADC
from driver import PWM
import gc
gLpConnect = False
gDebugLogFlag = True
gNumber = 0
gOpenLed = False
gDecibelValue = 1520
# Wi-Fi SSID和Password设置
SSID='Your-AP-SSID'
PWD='Your-AP-Password'
# HaaS设备三元组
productKey = "Your-ProductKey"
deviceName = "Your-devicename"
deviceSecret = "Your-deviceSecret"
key_info = {
'region' : 'cn-shanghai' ,
'productKey': productKey ,
'deviceName': deviceName ,
'deviceSecret': deviceSecret ,
'keepaliveSec': 60
}
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': red})
self.pwmG.setOption({'freq': 255, 'duty': green})
self.pwmB.setOption({'freq': 255, 'duty': 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': red})
self.pwmG.setOption({'freq': 255, 'duty': green})
self.pwmB.setOption({'freq': 255, 'duty': blue})
else:
raise ValueError("color type error! color should be like (255, 255, 255) or 0xffffff")
def connect_wifi(ssid, pwd):
# 初始化网络
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(ssid, pwd)
while True:
print('Wi-Fi is connecting...')
# 网络连接成功后，更新显示字符
if (wlan.isconnected() == True):
print('Wi-Fi is connected')
ip = wlan.ifconfig()[0]
print('IP: %s' %ip)
# NTP时间更新，如果更新不成功，将不能进行识别
print('NTP start')
sntp.setTime()
print('NTP done')
break
utime.sleep_ms(500)
utime.sleep(2)
def cb_lk_service(data):
print('handling sub data')
def cb_lk_connect(data):
global gLpConnect
print('link platform connected')
gLpConnect = True
# 获取灯的颜色
def set_color_reference():
global gLedColor,gNumber
if gNumber == 0:
# 白色
ledColor = 0xffffff
elif gNumber == 1:
# 红色
ledColor = 0xff0000
elif gNumber == 2:
# 蓝色
ledColor = 0x0000ff
else:
# 绿色
ledColor = 0x00ff00
gLedColor = ledColor
gNumber += 1
gNumber %= 4
return gLedColor
# 获取当前声音转换值
def get_decibel():
voltage = gAdcObj.readVoltage()
return voltage
# 属性上报
def lp_post_props(color):
global gDev
# 生成上报到物联网平台的属性值字串，此处的属性标识符"ledStatus"必须和物联网平台的属性一致
value = {'ledStatus': color}
data = {'params': json.dumps(value)}
# 上传开关灯信息到物联网平台
ret = gDev.postProps(data)
if ret == 0 :
print('属性上报成功')
else :
print('属性上报失败')
# 开启Led灯
def led_open(color):
global gLed
print('开灯')
gLed.setColor(color)
lp_post_props(color)
# 关闭Led灯
def led_close():
global gLed,gLedColor
print('关灯')
gLedColor = 0x000000
gLed.setColor(gLedColor)
lp_post_props(gLedColor)
# 声音采集线程
def sound_thread():
global gOpenLed
print('启动声音采集线程')
decibelValue = 0
while True:
# 采集声音
decibelValue = get_decibel()
# 判断分贝
if decibelValue > gDecibelValue and gOpenLed == False:
print("声波转换后的值%s"% (decibelValue))
gOpenLed = True
# 开灯
led_open(set_color_reference())
# 亮灯6秒
utime.sleep_ms(6000)
# 关灯
led_close()
gOpenLed = False
# 监听获取声音的频率，间隔不能太长，延迟大会导致不精确
utime.sleep_ms(10)
def main():
global gAdcObj,gLed,gLedColor,gDev
# 连接网络
nic = network.LAN()
nic.active(1)
# 设备初始化
gDev = Device()
gDev.on(Device.ON_CONNECT, cb_lk_connect)
gDev.on(Device.ON_SERVICE, cb_lk_service)
gDev.connect(key_info)
while True:
if gLpConnect:
break
# 创建ADC对象
gAdcObj = ADC()
# 开启声音传感器
ret = gAdcObj.open("hw181_adc")
if ret != 0 :
print("错误：声音传感器开启失败！")
print('%s' % ret)
# 开启RGB
rgbR = PWM()
rgbR.open("rgbR")
rgbG = PWM()
rgbG.open("rgbG")
rgbB = PWM()
rgbB.open("rgbB")
gLed = RgbLed(rgbR, rgbG, rgbB)
try:
# 启动声音采集线程
_thread.start_new_thread(sound_thread, ())
except:
print("Error: unable to start thread")
while True:
utime.sleep_ms(1000)
if __name__ == '__main__':
main()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/sound_led/stm32/code/main.py
|
Python
|
apache-2.0
| 6,102
|
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/docs/examples/stock_alarm/esp32/code/lcd1602.py
|
Python
|
apache-2.0
| 7,937
|
#!/usr/bin/env python3
# -*- encoding: utf-8 -*-
'''
@File : main.py
@Author : Alibaba
@version : 1.0
@Description: 通过连接物联网云平台，在收到股票涨停信号时，控制设备LCD显示股票代码，并控制蜂鸣器发出警报。
board.json - 硬件资源配置文件，详情请参考：https://haas.iot.aliyun.com/haasapi/index.html#/Python/docs/zh-CN/haas_extended_api/driver/driver
'''
from aliyunIoT import Device
from driver import GPIO
from driver import PWM
import utime # 延时函数在utime库中
import network # 网络库
import ujson as json
import lcd1602
# Wi-Fi SSID和Password设置
SSID='请填写您的路由器名称'
PWD='请填写您的路由器密码'
# HaaS设备三元组
productKey = "产品密钥"
deviceName = "设备名称"
deviceSecret = "设备密钥"
g_lk_connect = False
g_lk_service = False
key_info = {
'region' : 'cn-shanghai' ,
'productKey': productKey ,
'deviceName': deviceName ,
'deviceSecret': deviceSecret ,
'keepaliveSec': 60
}
def connect_wifi(ssid, pwd):
# 引用全局变量
# 初始化网络
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(ssid, pwd)
while True:
print('Wi-Fi is connecting...')
# 网络连接成功后，更新显示字符
if (wlan.isconnected() == True):
print('Wi-Fi is connected')
ip = wlan.ifconfig()[0]
print('IP: %s' %ip)
break
utime.sleep_ms(500)
utime.sleep(2)
def cb_lk_connect(data):
global g_lk_connect
print('link platform connected')
g_lk_connect = True
# 接收云端下发的属性设置
# request格式: {'code': 0, 'params_len': 18, 'msg_id': 710513123, 'params': '{"stock_status":1}'}
def on_props(request):
global stock_status, stock_code, stock_name
print(request)
props = json.loads(request['params'])
stock_code = props.get('stock_code', '')
stock_name = props.get('stock_name', '')
stock_status = props.get('stock_status', 0)
print("set value : %s %s %s" % (stock_status, stock_code, stock_name))
def loopThingModel():
global stock_status, stock_code, stock_name
# 判断是否有信号产生
prev_stock_status = stock_status
while True:
if prev_stock_status != stock_status:
prev_stock_status = stock_status
if stock_status == 1:
showStock(stock_code, stock_name)
startAlarm(5)
def showStock(stock_code, stock_name):
global lcdDrv
print(stock_code, stock_name)
lcdDrv.displayString(0, 0, 'Ur Stock Alarm:')
lcdDrv.displayString(1, 0, str(stock_code))
def startAlarm(seconds):
print('start alarm')
global buzzerDrv
api_beep(buzzerDrv)
utime.sleep(seconds)
api_beep(buzzerDrv, 0, 0)
buzzerDrv = PWM()
lcdDrv = None
def api_beep(buzzerDrv, freq0=440, duty=50):
print('api_beep %s' % freq0)
ret = buzzerDrv.setOption({'freq': freq0, 'duty': duty })
def main():
global buzzerDrv, lcdDrv
buzzerDrv.open("buzzer")
api_beep(buzzerDrv, 0, 0)
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')
lcdDrv = lcd1602.LCD1602(RS, RW, E, D4, D5, D6, D7)
global stock_name, stock_code, stock_status
# 连接网络
connect_wifi(SSID, PWD)
stock_status = 0
stock_name = ''
stock_code = ''
# 设备初始化
dev = Device()
dev.on(Device.ON_CONNECT, cb_lk_connect)
# 配置收到云端属性控制指令的回调函数
# 如果收到物联网平台发送的属性控制消息，则调用on_props函数
dev.on(Device.ON_PROPS, on_props)
dev.connect(key_info)
while True:
if g_lk_connect:
break
loopThingModel()
if __name__ == '__main__':
main()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/stock_alarm/esp32/code/main.py
|
Python
|
apache-2.0
| 4,009
|
from motion import motion
from mpu6886 import mpu6886
import utime # 延时函数在utime
from driver import I2C # 驱动库
import network # Wi-Fi功能所在库
import ujson # json字串解析库
from aliyunIoT import Device # iot组件是连接阿里云物联网平台的组件
i2cObj = None
mpu6886Dev = None
motionObj = None
# 物联网平台连接标志位
iot_connected = False
wlan = None
# 三元组信息
productKey = "Your-productKey"
deviceName = "Your-deviceName"
deviceSecret = "Your-deviceSecret"
# 物联网设备实例
device = None
# Wi-Fi SSID和Password设置
wifiSsid = "Your-wifiSsid"
wifiPassword = "Your-wifiPassword"
# 等待Wi-Fi成功连接到路由器
def get_wifi_status():
global wlan
wifi_connected = False
wlan.active(True) # 激活界面
wlan.scan() # 扫描接入点
wlan.disconnect() # 断开Wi-Fi
#print("start to connect ", wifiSsid)
# 连接到指定的路由器（路由器名称为wifiSsid, 密码为：wifiPassword）
wlan.connect(wifiSsid, wifiPassword)
while True:
wifi_connected = wlan.isconnected() # 获取Wi-Fi连接路由器的状态信息
if wifi_connected: # Wi-Fi连接成功则退出while循环
break
else:
utime.sleep(0.5)
print("wifi_connected:", wifi_connected)
ifconfig = wlan.ifconfig() # 获取接口的IP/netmask/gw/DNS地址
print(ifconfig)
utime.sleep(0.5)
# 物联网平台连接成功的回调函数
def on_connect(data):
global iot_connected
iot_connected = True
# 设置props 事件接收函数（当云平台向设备下发属性时）
def on_props(request):
pass
def connect_lp(productKey, deviceName, deviceSecret):
global device, iot_connected
key_info = {
'region': 'cn-shanghai',
'productKey': productKey,
'deviceName': deviceName,
'deviceSecret': deviceSecret,
'keepaliveSec': 60
}
# 将三元组信息设置到iot组件中
device = Device()
# 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
device.on(Device.ON_CONNECT, on_connect)
# 配置收到云端属性控制指令的回调函数，如果收到物联网平台发送的属性控制消息，则调用on_props函数
device.on(Device.ON_PROPS, on_props)
# 启动连接阿里云物联网平台过程
device.connect(key_info)
# 等待设备成功连接到物联网平台
while(True):
if iot_connected:
print('物联网平台连接成功')
break
else:
print('sleep for 1 s')
utime.sleep(1)
print('sleep for 2s')
utime.sleep(2)
def get_data():
acc = mpu6886Dev.acceleration
gyro = mpu6886Dev.gyro
# print(acc)
# print(gyro)
return acc, gyro # 返回读取到的加速度、角速度值
def tap_detected():
upload_data = {'params': ujson.dumps({
'tap_count': motionObj.detectAction.tap_detect_count,
})
}
# 上传状态到物联网平台
if (iot_connected):
device.postProps(upload_data)
if __name__ == '__main__':
# 网络初始化
wlan = network.WLAN(network.STA_IF) # 创建WLAN对象
get_wifi_status()
connect_lp(productKey, deviceName, deviceSecret)
# 硬件初始化
i2cObj = I2C()
# 按照board.json中名为"mpu6886"的设备节点的配置参数（主设备I2C端口号，从设备地址，总线频率等）初始化I2C类型设备对象
i2cObj.open("mpu6886")
print("mpu6886 inited!")
mpu6886Dev = mpu6886.MPU6886(i2cObj) # 初始化MPU6886传感器
# 获取跌倒检测的motion实例
motionObj = motion.Motion("double_tap", get_data, tap_detected)
# 使能action检测，并以Dictionary格式传入灵敏度参数
sensitivity = {"ACCELERATION_UP_THREADHOLD": 30}
motionObj.enable(sensitivity)
# 关闭action检测，可再次使能，支持传入新的灵敏度
# motionObj.disable()
# i2cObj.close() # 关闭I2C设备对象
# del mpu6886Dev
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/tap_detection/esp32/code/main.py
|
Python
|
apache-2.0
| 4,232
|
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/docs/examples/tap_detection/esp32/code/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/docs/examples/tap_detection/esp32/code/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
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
# 使能action检测，若用户不指定灵敏度，则使用默认灵敏度
def enable(self, sensitivity=''):
self.enableDetection = True
if (sensitivity != ''):
self.detectAction.sensitivity = sensitivity
self.detect_action()
# 关闭action检测
def disable(self):
self.enableDetection = 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)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/tap_detection/esp32/code/motion/motion.py
|
Python
|
apache-2.0
| 1,377
|
"""
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/docs/examples/tap_detection/esp32/code/mpu6886/mpu6886.py
|
Python
|
apache-2.0
| 7,149
|
"""
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/docs/examples/temp_humidity_speaker/haaseduk1/code/cht8305.py
|
Python
|
apache-2.0
| 4,277
|
#!/usr/bin/env python3
# -*- encoding: utf-8 -*-
'''
基于HaaS Python框架的本地语音播报温湿度系统
'''
from aliyunIoT import Device
import netmgr as nm
import utime
import ujson
from speech_utils import (
Speaker,
AUDIO_HEADER
)
import time
from cht8305 import CHT8305
from driver import I2C
import sh1106 # SH1106 OLED驱动库
from driver import SPI # 引入SPI总线库
from driver import GPIO # 引入GPIO库
import framebuf # framebuf基类，用于设置字体库
# 语音播放相关的音频资源文件定义
resDir = "/data/pyamp/resource/"
tonepathConnected = AUDIO_HEADER + resDir + "connected.wav"
tonepathPowerOn = AUDIO_HEADER + resDir + "poweron.wav"
# 三元组信息
productKey = "产品key"
deviceName = "设备名称"
deviceSecret = "设备密钥"
# Wi-Fi SSID和Password设置
wifi_ssid = "请输入您的路由器名称"
wifi_password = "请输入您的路由器密码"
# 回调函数状态
on_request = False
on_play = False
iot_connected = False
# 等待Wi-Fi成功连接到路由器
def get_wifi_status():
nm.init()
wifi_connected = nm.getStatus()
nm.disconnect()
print("start to connect " , wifi_ssid)
# 连接到指定的路由器（路由器名称为wifi_ssid, 密码为：wifi_password）
nm.connect(wifi_ssid, wifi_password)
while True :
if wifi_connected == 5: # nm.getStatus()返回5代表连线成功
break
else:
wifi_connected = nm.getStatus() # 获取Wi-Fi连接路由器的状态信息
utime.sleep(0.5)
print("wifi_connected:", wifi_connected)
# utime.sleep(5)
print("Wi-Fi connected")
print('DeviceIP:' + nm.getInfo()['ip']) # 打印Wi-Fi的IP地址信息
# 物联网平台连接成功的回调函数
def on_connect(data):
global iot_connected
iot_connected = True
def post_data_to_cloud(device, temphumidity):
# 上报温湿度到云平台
prop = ujson.dumps({
"CurrentTemperature": temphumidity[0],
"CurrentHumidity": temphumidity[1],
})
upload_data = {"params": prop}
device.postProps(upload_data)
def play_display_temperature_humidity(cht8305Dev):
play_data = {"format":0, "speechs":[]}
temphumidity = cht8305Dev.getTempHumidity()
print("当前温度:", temphumidity[0], "当前湿度:", temphumidity[1])
if (temphumidity[0] < 0):
temperature = "{$%.2f}" % -temphumidity[0]
humidity = "{$%.2f}" % temphumidity[1]
play_data["speechs"] = ["temperature", "negative", temperature, "centigrade", "humidity", humidity]
else:
temperature = "{$%.2f}" % temphumidity[0]
humidity = "{$%.2f}" % temphumidity[1]
play_data["speechs"] = ["temperature", temperature, "centigrade", "humidity", humidity]
temp_str = "T:%.2f" % temphumidity[0]
humi_str = "H:%.2f%%" % temphumidity[1]
oledShowText(temp_str, 3, 1, 1, True, 12)
oledShowText(humi_str, 3, 16, 1, False, 12)
speaker.play_voice(play_data,resDir)
return temphumidity
# OLED初始化
def oledInit():
global oled
# 字库文件存放于项目目录 font, 注意若用到了中英文字库则都需要放置
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()
# 连接物联网平台
def do_connect_lk(productKey, deviceName, deviceSecret,speaker):
global device, iot_connected, on_request, on_play, oled
key_info = {
'region' : 'cn-shanghai' , #实例的区域
'productKey': productKey , #物联网平台的PK
'deviceName': deviceName , #物联网平台的DeviceName
'deviceSecret': deviceSecret , #物联网平台的deviceSecret
'keepaliveSec': 60
}
# 将三元组信息设置到iot组件中
device = Device()
# 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
device.on(Device.ON_CONNECT, on_connect)
print ("开始连接物联网平台")
# 启动连接阿里云物联网平台过程
device.connect(key_info)
# 等待设备成功连接到物联网平台
while True:
if iot_connected:
print("物联网平台连接成功")
speaker.play(tonepathConnected)
break
else:
print("sleep for 1 s")
time.sleep(1)
# 打开CHT8305温湿度传感器
i2cDev = I2C()
i2cDev.open("cht8305")
cht8305Dev = CHT8305(i2cDev)
oledInit()
# 检测温湿度语音播报并上报云端
while True:
temphumidity = play_display_temperature_humidity(cht8305Dev)
post_data_to_cloud(device, temphumidity)
time.sleep(10)
oled.spi.close()
oled.res.close()
oled.dc.close()
i2cDev.close()
# 断开连接
device.close()
if __name__ == '__main__':
print("local speaker demo version")
speaker = Speaker(resDir) # 初始化speaker
speaker.play(tonepathPowerOn) # 播放开机启动提示音
get_wifi_status() # 确保wifi连接成功
do_connect_lk(productKey, deviceName, deviceSecret,speaker) # 启动千里传音服务
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/temp_humidity_speaker/haaseduk1/code/main.py
|
Python
|
apache-2.0
| 6,069
|
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/docs/examples/temp_humidity_speaker/haaseduk1/code/sh1106.py
|
Python
|
apache-2.0
| 7,916
|
#!/usr/bin/env python3
# -*- encoding: utf-8 -*-
'''
@File : speech_utils.py
@Description: 播报音箱库
@Date : 2022/02/11 14:34:45
@Author : guoliang.wgl
@version : 1.0
'''
import time
import math
import http
import json
import time
AUDIO_HEADER = 'fs:'
from audio import Player, Snd
on_callback = False
on_download = False
cb_data = None
class Speaker:
tonenameSuffix = [".wav", ".mp3"]
tonenameNumb = ["SYS_TONE_0", "SYS_TONE_1", "SYS_TONE_2", "SYS_TONE_3", "SYS_TONE_4",
"SYS_TONE_5", "SYS_TONE_6", "SYS_TONE_7", "SYS_TONE_8", "SYS_TONE_9"]
tonenameDot = "SYS_TONE_dian"
tonenameUnit = ["SYS_TONE_MEASURE_WORD_ge", "SYS_TONE_MEASURE_WORD_shi",
"SYS_TONE_MEASURE_WORD_bai", "SYS_TONE_MEASURE_WORD_qian"]
tonenameHunit = ["SYS_TONE_MEASURE_WORD_wan", "SYS_TONE_MEASURE_WORD_yi",
"SYS_TONE_MEASURE_WORD_sw", "SYS_TONE_MEASURE_WORD_bw", "SYS_TONE_MEASURE_WORD_qw"]
tonenameTempUnit = "centigrade.wav"
tonenameTempPrefix = "temperature.wav"
tonenameHumidityPrefix = "humidity.wav"
tonenameNegativePrefix = "nagative.wav"
def __init__(self,res_dir):
self.toneDir = res_dir
self._create_player()
def _create_player(self):
Snd.init()
player = Player()
player.open()
player.setVolume(8)
self._player = player
def play(self,path):
self._player.play(path)
self._player.waitComplete()
def playlist(self,pathlist):
for path in pathlist:
self.play(AUDIO_HEADER + path)
def play_voice(self,data,dir_info):
format = data['format']
audioResFormat = 0
if (format == 'mp3'):
audioResFormat = 1
speechs = data['speechs']
toneList = []
for speech in speechs:
print(speech)
# length = len(speech)
if speech.endswith('}') and speech.startswith('{') and (speech[1] == '$'):
speech_num = speech.strip('{').strip('$').strip('}')
toneList = self.add_amount(speech_num,toneList,audioResFormat)
else:
toneList.append(self.toneDir + speech + self.tonenameSuffix[audioResFormat])
print(toneList)
self.playlist(toneList)
def add_amount(self,num_str, toneList, formatFlag):
num_f = float(num_str)
numb = int(num_f)
deci = num_f - numb
target = numb
subTarget = 0
subNumber = None
slot = 0
factor = 0
count = 0
prevSlotZero = False
hundredMillionExist = False
tenThousandExist = False
if (numb < 0 or numb >= 100):
print('amount overrange')
return toneList
if (deci < 0.0001 and deci > 0.0):
deci = 0.0001
i = 2
while(i >= 0):
factor = math.pow(10000,i)
if target < factor:
i = i -1
continue
subTarget = int(target / factor)
target %= factor
if (subTarget == 0):
i = i -1
continue
if (i == 2):
hundredMillionExist = True
elif (i == 1):
tenThousandExist = True
subNumber = subTarget
prevSlotZero = False
depth = 3
while(depth >= 0):
if(subNumber == 0):
break
factor = math.pow(10, depth)
if ((hundredMillionExist == True or tenThousandExist == True) and i == 0):
pass
elif (hundredMillionExist == True and tenThousandExist == True and depth > 0 and subTarget < factor):
pass
elif (subTarget < factor):
depth = depth - 1
continue
slot = int(subNumber / factor)
subNumber %= factor
if (slot == 0 and depth == 0):
depth = depth - 1
continue
if ((subTarget < 20 and depth == 1) or (slot == 0 and prevSlotZero) or (slot == 0 and depth == 0)):
pass
else:
toneList.append(self.toneDir + self.tonenameNumb[slot] + self.tonenameSuffix[formatFlag])
count += 1
if (slot == 0 and prevSlotZero == False):
prevSlotZero = True
elif (prevSlotZero == True and slot != 0):
prevSlotZero = False
if (slot > 0 and depth > 0) :
toneList.append(self.toneDir + self.tonenameUnit[depth] + self.tonenameSuffix[formatFlag])
count += 1
depth = depth - 1
if (i > 0):
toneList.append(self.toneDir + self.tonenameHunit[i - 1] + self.tonenameSuffix[formatFlag])
count += 1
i = i - 1
if (count == 0 and numb == 0):
toneList.append(self.toneDir + self.tonenameNumb[0] + self.tonenameSuffix[formatFlag])
if (deci >= 0.0001) :
toneList.append(self.toneDir + self.tonenameDot + self.tonenameSuffix[formatFlag])
deci ="{:.4f}".format(deci)
deci_tmp = str(deci).strip().rstrip('0')
deci_str = ''
got_dot = False
for j in range(len(deci_tmp)):
if(got_dot):
deci_str = deci_str + deci_tmp[j]
elif deci_tmp[j] == '.':
got_dot = True
deciArray = deci_str
for item in deciArray:
if (item >= '0' and item <= '9'):
print(self.tonenameNumb[int(item)])
toneList.append(self.toneDir + self.tonenameNumb[int(item)] + self.tonenameSuffix[formatFlag])
return toneList
def download_resource_file(self,on_request,resDir):
global on_callback,on_download,cb_data
data = {
'url':on_request['url'],
'method': 'GET',
'headers': {
},
'timeout': 30000,
'params' : ''
}
def cb(data):
global on_callback,cb_data
on_callback = True
cb_data = data
http.request(data,cb)
while True:
if on_callback:
on_callback = False
break
else:
time.sleep(1)
response = json.loads(cb_data['body'])
audio = response['audios'][0]
format = audio['format']
id = audio['id']
size = audio['size']
path = self.toneDir +id+'.'+format
print('************ begin to download: ' + path)
d_data = {
'url': audio['url'],
'filepath': path
}
def d_cb(data):
global on_download
on_download = True
http.download(d_data,d_cb)
while True:
if on_download:
on_download = False
break
else:
time.sleep(1)
print('download succeed :' + path)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/temp_humidity_speaker/haaseduk1/code/speech_utils.py
|
Python
|
apache-2.0
| 7,198
|
from driver import I2C
class GXHT30(object):
# init i2cDev
def __init__(self,i2cObj):
self.i2cObj=None
if not isinstance(i2cObj,I2C):
raise ValueError("parameter is not an I2C object")
self.i2cObj=i2cObj
# write cmd to register
# commands:0x2c、0x06
def write(self,cmd1,cmd2):
writeBuf=bytearray([cmd1,cmd2])
self.i2cObj.write(writeBuf,2)
# read data from register
# read data from :0x00
# len(data) are 6 bytes : cTemp MSB, cTemp LSB, cTemp CRC, Humididty MSB, Humidity LSB, Humidity CRC
def read(self,cmd,len):
readBuf=bytearray(len)
readBuf[0]=cmd
self.i2cObj.read(readBuf,6)
return readBuf
# convert the data
def covert_data(self,data):
cTemp = ((((data[0] * 256.0) + data[1]) * 175) / 65535.0) - 45
fTemp = cTemp * 1.8 + 32
humidity = 100 * (data[3] * 256 + data[4]) / 65535.0
return cTemp,fTemp,humidity
# measure temperature and humidity
def measure(self):
if self.i2cObj is None:
raise ValueError("invalid I2C object")
self.write(0x2c,0x06)
data=self.read(0x00,6)
cTemp,fTemp,humidity=self.covert_data(data)
return cTemp,fTemp,humidity
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/temperature_humidity/haas506/code/gxht30.py
|
Python
|
apache-2.0
| 1,286
|
import utime as time
from driver import I2C
import gxht30
#创建并打开一个I2C实例
i2cDev=I2C()
i2cDev.open('gxht30')
#创建一个温湿度实例
tem_hum_dev=gxht30.GXHT30(i2cDev)
#获取温湿度数据
while True :
cTemp,fTemp,humidity=tem_hum_dev.measure()
print ("Temperature in Celsius : %.2f C" %cTemp)
print ("Temperature in Fahrenheit : %.2f F" %fTemp)
print ("Relative Humidity : %.2f %%RH" %humidity)
print("------------------------------------------\n")
time.sleep(1)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/temperature_humidity/haas506/code/main.py
|
Python
|
apache-2.0
| 511
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
class Airpressure:
scr = None
iconImg = None
airpressureLable = None
unityLabel = None
tipLabel = None
def __init__(self, screen):
self.scr = screen
self.createAirpressureItem(self.scr, RESOURCES_ROOT + "airpressure.png", "Air pressure")
def createAirpressureItem(self, parent, iconPath, tips):
self.iconImg = lv.img(parent)
self.iconImg.set_src(iconPath)
self.iconImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
self.airpressureLable = lv.label(parent)
self.airpressureLable.set_text("None")
self.airpressureLable.set_style_text_color(lv.color_white(), 0)
self.airpressureLable.set_style_text_font(lv.font_montserrat_48, 0)
self.airpressureLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel = lv.label(parent)
self.unityLabel.set_text(" HPA")
self.unityLabel.set_style_text_color(lv.color_white(), 0)
self.unityLabel.set_style_text_font(lv.font_montserrat_18, 0)
self.unityLabel.align_to(self.airpressureLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel = lv.label(parent)
self.tipLabel.set_text(tips)
self.tipLabel.set_style_text_color(lv.color_make(0xCC, 0xCC, 0xCC), 0)
self.tipLabel.set_style_text_font(lv.font_montserrat_14, 0)
self.tipLabel.align_to(self.airpressureLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setValue(self, humidity):
self.airpressureLable.set_text(str(int(humidity)))
def setXY(self, x, y):
self.iconImg.align(lv.ALIGN.TOP_LEFT, x, y)
self.airpressureLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel.align_to(self.airpressureLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel.align_to(self.airpressureLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setScale(self, scale):
print("To be done")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/airpressure.py
|
Python
|
apache-2.0
| 1,977
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
class Angle:
scr = None
iconImg = None
angleLable = None
unityLabel = None
tipLabel = None
def __init__(self, screen):
self.scr = screen
self.createAngleItem(self.scr, RESOURCES_ROOT + "angle.png", "Angle")
def createAngleItem(self, parent, iconPath, tips):
self.iconImg = lv.img(parent)
self.iconImg.set_src(iconPath)
self.iconImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
self.angleLable = lv.label(parent)
self.angleLable.set_text("None")
self.angleLable.set_style_text_color(lv.color_white(), 0)
self.angleLable.set_style_text_font(lv.font_montserrat_48, 0)
self.angleLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel = lv.label(parent)
self.unityLabel.set_text(" o")
self.unityLabel.set_style_text_color(lv.color_white(), 0)
self.unityLabel.set_style_text_font(lv.font_montserrat_18, 0)
self.unityLabel.align_to(self.angleLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel = lv.label(parent)
self.tipLabel.set_text(tips)
self.tipLabel.set_style_text_color(lv.color_make(0xCC, 0xCC, 0xCC), 0)
self.tipLabel.set_style_text_font(lv.font_montserrat_14, 0)
self.tipLabel.align_to(self.angleLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setValue(self, humidity):
self.angleLable.set_text(str(int(humidity)))
def setXY(self, x, y):
self.iconImg.align(lv.ALIGN.TOP_LEFT, x, y)
self.angleLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel.align_to(self.angleLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel.align_to(self.angleLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setScale(self, scale):
print("To be done")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/angle.py
|
Python
|
apache-2.0
| 1,872
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/"
compass_ttf_alive = False
def compass_back_click_callback(e, win):
global compass_ttf_alive
if (compass_ttf_alive):
from smart_panel import load_smart_panel
load_smart_panel()
compass_ttf_alive = False
def compass_back_press_callback(e, image):
image.set_zoom(280)
def compass_back_release_callback(e, image):
image.set_zoom(250)
value = 0
class Compass:
def createPage(self):
global value
global compass_ttf_alive
print("Enter Compass")
# 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)
backImg=lv.img(win)
backImg.set_src(RESOURCES_ROOT + "images/back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: compass_back_click_callback(e, win), lv.EVENT.CLICKED, None)
backImg.add_event_cb(lambda e: compass_back_press_callback(e, backImg), lv.EVENT.PRESSED, None)
backImg.add_event_cb(lambda e: compass_back_release_callback(e, backImg), lv.EVENT.RELEASED, None)
backImg.set_ext_click_area(30)
# -------------- compass image ----------------
compass_dial = lv.img(win)
compass_dial.set_src(RESOURCES_ROOT + "images/compass_dial.png")
compass_dial.set_style_max_height(scr.get_height(), 0)
compass_dial.set_angle(value * 10)
compass_dial.center()
# -------------- indicator --------------------
compass_indicator = lv.img(win)
compass_indicator.set_src(RESOURCES_ROOT + "images/compass_indicator.png")
# compass_indicator.set_style_max_height(scr.get_height(), 0)
compass_indicator.set_angle(value * 10)
compass_indicator.center()
col_dsc = [35, 10, 25, lv.GRID_TEMPLATE.LAST]
row_dsc = [20, 35, 20, lv.GRID_TEMPLATE.LAST]
degreeArea = lv.obj(win)
degreeArea.set_size(95, 100)
degreeArea.set_style_bg_opa(0, 0)
degreeArea.set_style_border_opa(0, 0)
degreeArea.set_style_pad_all(0, 0)
degreeArea.set_layout(lv.LAYOUT_GRID.value)
degreeArea.set_grid_dsc_array(col_dsc, row_dsc)
degreeArea.center()
# degreeArea.set_style_pad_left(5, 0)
degreeArea.clear_flag(lv.obj.FLAG.SCROLLABLE)
red = lv.img(degreeArea)
red.set_src(RESOURCES_ROOT + "images/angle_red.png")
red.set_grid_cell(lv.GRID_ALIGN.CENTER, 0, 3, lv.GRID_ALIGN.CENTER, 0, 1)
degreeLable = lv.label(degreeArea)
degreeLable.set_text(str(value))
degreeLable.set_style_text_color(lv.color_white(), 0)
degreeLable.set_style_text_font(lv.font_montserrat_36, 0)
degreeLable.set_grid_cell(lv.GRID_ALIGN.CENTER, 0, 1, lv.GRID_ALIGN.CENTER, 1, 1)
degreeIcon = lv.img(degreeArea)
degreeIcon.set_src(RESOURCES_ROOT + "images/degree.png")
degreeIcon.set_style_pad_top(5, 0)
degreeIcon.set_grid_cell(lv.GRID_ALIGN.START, 1, 1, lv.GRID_ALIGN.START, 1, 1)
directionLable = lv.label(degreeArea)
directionLable.set_text("N")
directionLable.set_style_text_color(lv.color_white(), 0)
directionLable.set_style_text_font(lv.font_montserrat_36, 0)
directionLable.set_grid_cell(lv.GRID_ALIGN.START, 2, 1, lv.GRID_ALIGN.CENTER, 1, 1)
tips = lv.label(degreeArea)
tips.set_text("Compass")
tips.set_style_text_color(lv.color_white(), 0)
tips.set_style_text_font(lv.font_montserrat_12, 0)
tips.set_grid_cell(lv.GRID_ALIGN.CENTER, 0, 3, lv.GRID_ALIGN.CENTER, 2, 1)
from smart_panel import needAnimation
if (needAnimation):
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.MOVE_LEFT, 500, 0, True)
else:
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.NONE, 0, 0, True)
compass_ttf_alive = True
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/compass.py
|
Python
|
apache-2.0
| 4,147
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
class Distance:
scr = None
iconImg = None
distanceLable = None
unityLabel = None
tipLabel = None
def __init__(self, screen):
self.scr = screen
self.createDistanceItem(self.scr, RESOURCES_ROOT + "distance.png", "DST")
def createDistanceItem(self, parent, iconPath, tips):
self.iconImg = lv.img(parent)
self.iconImg.set_src(iconPath)
self.iconImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
self.distanceLable = lv.label(parent)
self.distanceLable.set_text("None")
self.distanceLable.set_style_text_color(lv.color_white(), 0)
self.distanceLable.set_style_text_font(lv.font_montserrat_48, 0)
self.distanceLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel = lv.label(parent)
self.unityLabel.set_text(" M")
self.unityLabel.set_style_text_color(lv.color_white(), 0)
self.unityLabel.set_style_text_font(lv.font_montserrat_18, 0)
self.unityLabel.align_to(self.distanceLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel = lv.label(parent)
self.tipLabel.set_text(tips)
self.tipLabel.set_style_text_color(lv.color_make(0xCC, 0xCC, 0xCC), 0)
self.tipLabel.set_style_text_font(lv.font_montserrat_14, 0)
self.tipLabel.align_to(self.distanceLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setValue(self, humidity):
self.distanceLable.set_text(str(int(humidity)))
def setXY(self, x, y):
self.iconImg.align(lv.ALIGN.TOP_LEFT, x, y)
self.distanceLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel.align_to(self.distanceLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel.align_to(self.distanceLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setScale(self, scale):
print("To be done")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/distance.py
|
Python
|
apache-2.0
| 1,918
|
import lvgl as lv
import utime
RESOURCES_ROOT = "S:/data/pyamp/"
def drawOver(e):
global g_clickTime
if (g_clickTime != 0):
currentTime = utime.ticks_ms()
print("create Environment page use: %dms" % int((currentTime - g_clickTime)))
g_clickTime = 0
environment_alive = False
def environment_back_click_callback(e, win):
global environment_alive
if (environment_alive):
from smart_panel import load_smart_panel
load_smart_panel()
environment_alive = False
def environment_back_press_callback(e, back_image):
back_image.set_zoom(280)
def environment_back_release_callback(e, back_image):
back_image.set_zoom(250)
class Environment:
def createPage(self):
global environment_alive
global g_clickTime
g_clickTime = utime.ticks_ms()
# 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_bg_color(lv.color_black(), 0)
win.set_style_radius(0, 0)
win.clear_flag(lv.obj.FLAG.SCROLLABLE)
win.add_event_cb(drawOver, lv.EVENT.DRAW_POST_END, None)
backImg=lv.img(win)
backImg.set_src(RESOURCES_ROOT + "images/back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: environment_back_click_callback(e, win), lv.EVENT.CLICKED, None)
backImg.add_event_cb(lambda e: environment_back_press_callback(e, backImg), lv.EVENT.PRESSED, None)
backImg.add_event_cb(lambda e: environment_back_release_callback(e, backImg), lv.EVENT.RELEASED, None)
backImg.set_ext_click_area(20)
container = lv.obj(win)
container.set_style_bg_opa(0, 0)
container.set_style_border_opa(0, 0)
container.set_size(lv.SIZE.CONTENT, lv.SIZE.CONTENT)
container.set_flex_flow(lv.FLEX_FLOW.COLUMN)
container.set_style_align(lv.ALIGN.CENTER, 0)
container.set_style_pad_left(0, 0)
self.createItem(container, RESOURCES_ROOT + "images/temperature.png", "25",
RESOURCES_ROOT + "images/centigrade_l.png", "Temperature")
self.createInterval(container, 25)
self.createItem(container, RESOURCES_ROOT + "images/humidity.png", "41 %", "", "Humidity")
from smart_panel import needAnimation
if (needAnimation):
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.MOVE_LEFT, 500, 0, True)
else:
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.NONE, 0, 0, True)
environment_alive = True
currentTime = utime.ticks_ms()
print("run python code use: %dms" % int((currentTime - g_clickTime)))
def createItem(self, parent, iconPath, value, 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)
label = lv.label(cont)
label.set_text(value)
label.set_style_text_color(lv.color_white(), 0)
label.set_style_text_font(lv.font_montserrat_48, 0)
label.set_style_pad_all(0, 0)
label.set_grid_cell(lv.GRID_ALIGN.START, 2, 1, lv.GRID_ALIGN.CENTER, 0, 1)
if (unityPath.strip()):
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 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(size)
interval.set_width(0)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/environment.py
|
Python
|
apache-2.0
| 4,518
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
class Fm:
scr = None
iconImg = None
fmLable = None
unityLabel = None
tipLabel = None
def __init__(self, screen):
self.scr = screen
self.createFmItem(self.scr, RESOURCES_ROOT + "FM.png", "FM")
def createFmItem(self, parent, iconPath, tips):
self.iconImg = lv.img(parent)
self.iconImg.set_src(iconPath)
self.iconImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
self.fmLable = lv.label(parent)
self.fmLable.set_text("None")
self.fmLable.set_style_text_color(lv.color_white(), 0)
self.fmLable.set_style_text_font(lv.font_montserrat_48, 0)
self.fmLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel = lv.label(parent)
self.unityLabel.set_text(" MHz")
self.unityLabel.set_style_text_color(lv.color_white(), 0)
self.unityLabel.set_style_text_font(lv.font_montserrat_18, 0)
self.unityLabel.align_to(self.fmLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel = lv.label(parent)
self.tipLabel.set_text(tips)
self.tipLabel.set_style_text_color(lv.color_make(0xCC, 0xCC, 0xCC), 0)
self.tipLabel.set_style_text_font(lv.font_montserrat_14, 0)
self.tipLabel.align_to(self.fmLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setValue(self, humidity):
self.fmLable.set_text(str(int(humidity)))
def setXY(self, x, y):
self.iconImg.align(lv.ALIGN.TOP_LEFT, x, y)
self.fmLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel.align_to(self.fmLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel.align_to(self.fmLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setScale(self, scale):
print("To be done")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/fm.py
|
Python
|
apache-2.0
| 1,823
|
import lvgl as lv
font_not_load_16 = True
info_16 = None
style_16 = None
def set_text_size_16(parent):
global font_not_load_16
global info_16
global style_16
if (font_not_load_16):
info_16 = lv.ft_info_t()
info_16.name ="/data/pyamp/font/AlibabaPuHuiTiM_16.ttf"
info_16.weight = 16
info_16.style = lv.FT_FONT_STYLE.NORMAL
info_16.font_init()
style_16 = lv.style_t()
style_16.init()
style_16.set_text_font(info_16.font)
font_not_load_16 = False
parent.add_style(style_16, 0)
font_not_load_20 = True
info_20 = None
style_20 = None
def set_text_size_20(parent):
global font_not_load_20
global info_20
global style_20
if (font_not_load_20):
info_20 = lv.ft_info_t()
info_20.name ="/data/pyamp/font/AlibabaPuHuiTiM_20.ttf"
info_20.weight = 20
info_20.style = lv.FT_FONT_STYLE.NORMAL
info_20.font_init()
style_20 = lv.style_t()
style_20.init()
style_20.set_text_font(info_20.font)
font_not_load_20 = False
parent.add_style(style_20, 0)
font_not_load_22 = True
info_22 = None
style_22 = None
def set_text_size_22(parent):
global font_not_load_22
global info_22
global style_22
if (font_not_load_22):
info_22 = lv.ft_info_t()
info_22.name ="/data/pyamp/font/AlibabaPuHuiTiM_22.ttf"
info_22.weight = 22
info_22.style = lv.FT_FONT_STYLE.NORMAL
info_22.font_init()
style_22 = lv.style_t()
style_22.init()
style_22.set_text_font(info_22.font)
font_not_load_22 = False
parent.add_style(style_22, 0)
font_not_load_38 = True
info_38 = None
style_38 = None
def set_text_size_38(parent):
global font_not_load_38
global info_38
global style_38
if (font_not_load_38):
info_38 = lv.ft_info_t()
info_38.name ="/data/pyamp/font/AlibabaPuHuiTiM_38.ttf"
info_38.weight = 38
info_38.style = lv.FT_FONT_STYLE.NORMAL
info_38.font_init()
style_38 = lv.style_t()
style_38.init()
style_38.set_text_font(info_38.font)
font_not_load_38 = False
parent.add_style(style_38, 0)
def set_text_size(parent, size):
if (size == 38):
set_text_size_38(parent)
elif (size == 22):
set_text_size_22(parent)
elif (size == 20):
set_text_size_20(parent)
else:
set_text_size_16(parent)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/font_Alibaba_PuHuiTi.py
|
Python
|
apache-2.0
| 2,463
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
class Gas:
scr = None
iconImg = None
gasLable = None
unityLabel = None
tipLabel = None
def __init__(self, screen):
self.scr = screen
self.createGasItem(self.scr, RESOURCES_ROOT + "gas.png", "Nature Gas")
def createGasItem(self, parent, iconPath, tips):
self.iconImg = lv.img(parent)
self.iconImg.set_src(iconPath)
self.iconImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
self.gasLable = lv.label(parent)
self.gasLable.set_text("None")
self.gasLable.set_style_text_color(lv.color_white(), 0)
self.gasLable.set_style_text_font(lv.font_montserrat_48, 0)
self.gasLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel = lv.label(parent)
self.unityLabel.set_text(" %LEL")
self.unityLabel.set_style_text_color(lv.color_white(), 0)
self.unityLabel.set_style_text_font(lv.font_montserrat_18, 0)
self.unityLabel.align_to(self.gasLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel = lv.label(parent)
self.tipLabel.set_text(tips)
self.tipLabel.set_style_text_color(lv.color_make(0xCC, 0xCC, 0xCC), 0)
self.tipLabel.set_style_text_font(lv.font_montserrat_14, 0)
self.tipLabel.align_to(self.gasLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setValue(self, humidity):
self.gasLable.set_text(str(int(humidity)))
def setXY(self, x, y):
self.iconImg.align(lv.ALIGN.TOP_LEFT, x, y)
self.gasLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel.align_to(self.gasLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel.align_to(self.gasLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setScale(self, scale):
print("To be done")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/gas.py
|
Python
|
apache-2.0
| 1,848
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
class Hcho:
scr = None
iconImg = None
hchoLable = None
unityLabel = None
tipLabel = None
def __init__(self, screen):
self.scr = screen
self.createHchoItem(self.scr, RESOURCES_ROOT + "hcho.png", "PA")
def createHchoItem(self, parent, iconPath, tips):
self.iconImg = lv.img(parent)
self.iconImg.set_src(iconPath)
self.iconImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
self.hchoLable = lv.label(parent)
self.hchoLable.set_text("None")
self.hchoLable.set_style_text_color(lv.color_white(), 0)
self.hchoLable.set_style_text_font(lv.font_montserrat_48, 0)
self.hchoLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel = lv.label(parent)
self.unityLabel.set_text(" mg/m3")
self.unityLabel.set_style_text_color(lv.color_white(), 0)
self.unityLabel.set_style_text_font(lv.font_montserrat_18, 0)
self.unityLabel.align_to(self.hchoLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel = lv.label(parent)
self.tipLabel.set_text(tips)
self.tipLabel.set_style_text_color(lv.color_make(0xCC, 0xCC, 0xCC), 0)
self.tipLabel.set_style_text_font(lv.font_montserrat_14, 0)
self.tipLabel.align_to(self.hchoLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setValue(self, humidity):
self.hchoLable.set_text(str(int(humidity)))
def setXY(self, x, y):
self.iconImg.align(lv.ALIGN.TOP_LEFT, x, y)
self.hchoLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel.align_to(self.hchoLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel.align_to(self.hchoLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setScale(self, scale):
print("To be done")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/hcho.py
|
Python
|
apache-2.0
| 1,857
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
class Heartrate:
scr = None
iconImg = None
heartrateLable = None
unityLabel = None
tipLabel = None
def __init__(self, screen):
self.scr = screen
self.createHeartrateItem(self.scr, RESOURCES_ROOT + "heartrate.png", "HR")
def createHeartrateItem(self, parent, iconPath, tips):
self.iconImg = lv.img(parent)
self.iconImg.set_src(iconPath)
self.iconImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
self.heartrateLable = lv.label(parent)
self.heartrateLable.set_text("None")
self.heartrateLable.set_style_text_color(lv.color_white(), 0)
self.heartrateLable.set_style_text_font(lv.font_montserrat_48, 0)
self.heartrateLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel = lv.label(parent)
self.unityLabel.set_text(" BPM")
self.unityLabel.set_style_text_color(lv.color_white(), 0)
self.unityLabel.set_style_text_font(lv.font_montserrat_18, 0)
self.unityLabel.align_to(self.heartrateLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel = lv.label(parent)
self.tipLabel.set_text(tips)
self.tipLabel.set_style_text_color(lv.color_make(0xCC, 0xCC, 0xCC), 0)
self.tipLabel.set_style_text_font(lv.font_montserrat_14, 0)
self.tipLabel.align_to(self.heartrateLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setValue(self, humidity):
self.heartrateLable.set_text(str(int(humidity)))
def setXY(self, x, y):
self.iconImg.align(lv.ALIGN.TOP_LEFT, x, y)
self.heartrateLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel.align_to(self.heartrateLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel.align_to(self.heartrateLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setScale(self, scale):
print("To be done")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/heartrate.py
|
Python
|
apache-2.0
| 1,935
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
class Humidity:
scr = None
iconImg = None
humidityLable = None
unityLabel = None
tipLabel = None
def __init__(self, screen):
self.scr = screen
self.createHumidityItem(self.scr, RESOURCES_ROOT + "humidity.png", "TDS")
def createHumidityItem(self, parent, iconPath, tips):
self.iconImg = lv.img(parent)
self.iconImg.set_src(iconPath)
self.iconImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
self.humidityLable = lv.label(parent)
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.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel = lv.label(parent)
self.unityLabel.set_text(" PPM")
self.unityLabel.set_style_text_color(lv.color_white(), 0)
self.unityLabel.set_style_text_font(lv.font_montserrat_18, 0)
self.unityLabel.align_to(self.humidityLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel = lv.label(parent)
self.tipLabel.set_text(tips)
self.tipLabel.set_style_text_color(lv.color_make(0xCC, 0xCC, 0xCC), 0)
self.tipLabel.set_style_text_font(lv.font_montserrat_14, 0)
self.tipLabel.align_to(self.humidityLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setValue(self, humidity):
self.humidityLable.set_text(str(int(humidity)))
def setXY(self, x, y):
self.iconImg.align(lv.ALIGN.TOP_LEFT, x, y)
self.humidityLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel.align_to(self.humidityLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel.align_to(self.humidityLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setScale(self, scale):
print("To be done")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/humidity.py
|
Python
|
apache-2.0
| 1,920
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/"
environment_alive = False
functionImage = [
RESOURCES_ROOT + "images/refrigeration.png",
RESOURCES_ROOT + "images/heating.png",
RESOURCES_ROOT + "images/dehumidification.png",
RESOURCES_ROOT + "images/ventilation.png"]
functionImageSelected = [
RESOURCES_ROOT + "images/refrigeration_selected.png",
RESOURCES_ROOT + "images/heating_selected.png",
RESOURCES_ROOT + "images/dehumidification_selected.png",
RESOURCES_ROOT + "images/ventilation_selected.png"]
currentFunc = 0
currentSelected = None
hvac_alive = False
def hvac_back_click_callback(e, win):
global hvac_alive
if (hvac_alive):
from smart_panel import load_smart_panel
load_smart_panel()
hvac_alive = False
def hvac_back_press_callback(e, image):
image.set_zoom(280)
def hvac_back_release_callback(e, image):
image.set_zoom(250)
def sub_pressed_cb(e, self):
print("sub")
if (self.value > 16):
self.value -= 1
print("value %d" % (self.value))
self.label.set_text(str(self.value))
def add_pressed_cb(e, self):
print("add")
if (self.value < 30):
self.value += 1
print("value %d" % (self.value))
self.label.set_text(str(self.value))
def func_pressed_cb(e, index):
global currentFunc
global currentSelected
print(index)
if (index != currentFunc):
currentSelected.set_src(functionImage[currentFunc])
selectedImage = e.get_target()
currentFunc = index
selectedImage.set_src(functionImageSelected[currentFunc])
currentSelected = selectedImage
class Hvac:
value = 25
def createPage(self):
global currentFunc
global currentSelected
global hvac_alive
print("Enter Hvac")
# 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)
# --------- value container ---------
col_dsc = [60, 65, 40, 60, lv.GRID_TEMPLATE.LAST]
row_dsc = [48, lv.GRID_TEMPLATE.LAST]
valueLayout = lv.obj(win)
valueLayout.set_layout(lv.LAYOUT_GRID.value)
valueLayout.set_style_bg_opa(0, 0)
valueLayout.set_style_border_opa(0, 0)
valueLayout.set_size(lv.SIZE.CONTENT, lv.SIZE.CONTENT)
valueLayout.set_grid_align(lv.GRID_ALIGN.SPACE_BETWEEN, lv.GRID_ALIGN.SPACE_BETWEEN)
valueLayout.set_style_grid_column_dsc_array(col_dsc, 0)
valueLayout.set_style_grid_row_dsc_array(row_dsc, 0)
valueLayout.set_style_pad_top(20, 0)
valueLayout.set_style_align(lv.ALIGN.TOP_MID, 0)
# ----------- - --------------
subImage = lv.img(valueLayout)
subImage.set_src(RESOURCES_ROOT + "images/subtraction.png")
subImage.set_grid_cell(lv.GRID_ALIGN.START, 0, 1, lv.GRID_ALIGN.CENTER, 0, 1)
subImage.add_flag(lv.obj.FLAG.CLICKABLE)
subImage.add_event_cb(lambda e: sub_pressed_cb(e, self), lv.EVENT.PRESSED, None)
# subImage.add_event_cb(lambda e: hvac_back_press_callback(e, subImage), lv.EVENT.PRESSED, None)
# subImage.add_event_cb(lambda e: hvac_back_release_callback(e, subImage), lv.EVENT.RELEASED, None)
subImage.set_ext_click_area(40)
# ----------- value -----------
self.label = lv.label(valueLayout)
self.label.set_text(str(self.value))
self.label.set_style_text_color(lv.color_white(), 0)
self.label.set_style_text_font(lv.font_montserrat_48, 0)
self.label.set_grid_cell(lv.GRID_ALIGN.CENTER, 1, 1, lv.GRID_ALIGN.CENTER, 0, 1)
# ----------- ºC ------------
centigradeImage = lv.img(valueLayout)
centigradeImage.set_src(RESOURCES_ROOT + "images/centigrade_s.png")
centigradeImage.set_style_pad_bottom(8, 0)
centigradeImage.set_grid_cell(lv.GRID_ALIGN.START, 2, 1, lv.GRID_ALIGN.END, 0, 1)
# ----------- + ----------------
addImage = lv.img(valueLayout)
addImage.set_src(RESOURCES_ROOT + "images/addition.png")
addImage.set_grid_cell(lv.GRID_ALIGN.CENTER, 3, 1, lv.GRID_ALIGN.CENTER, 0, 1)
addImage.add_flag(lv.obj.FLAG.CLICKABLE)
addImage.add_event_cb(lambda e: add_pressed_cb(e, self), lv.EVENT.PRESSED, None)
# addImage.add_event_cb(lambda e: hvac_back_press_callback(e, addImage), lv.EVENT.PRESSED, None)
# addImage.add_event_cb(lambda e: hvac_back_release_callback(e, addImage), lv.EVENT.RELEASED, None)
addImage.set_ext_click_area(40)
# ----------- tips ----------
tips = lv.label(win)
tips.set_text("Temperature")
tips.set_style_text_color(lv.color_make(0xCC, 0xCC, 0xCC), 0)
tips.set_style_pad_bottom(20, 0)
tips.set_align(lv.ALIGN.CENTER)
# ----------- function ----------
func_col_dsc = [70, 70, 70, 70, lv.GRID_TEMPLATE.LAST]
func_row_dsc = [40, lv.GRID_TEMPLATE.LAST]
funcContainer = lv.obj(win)
funcContainer.set_style_bg_opa(0, 0)
funcContainer.set_style_border_opa(0, 0)
funcContainer.set_grid_dsc_array(func_col_dsc, func_row_dsc)
funcContainer.set_width(300)
funcContainer.set_height(90)
funcContainer.set_layout(lv.LAYOUT_GRID.value)
funcContainer.set_align(lv.ALIGN.BOTTOM_MID)
funcContainer.set_grid_align(lv.GRID_ALIGN.SPACE_BETWEEN, lv.GRID_ALIGN.SPACE_BETWEEN)
image = lv.img(funcContainer)
image.set_src(functionImage[0])
image.add_flag(lv.obj.FLAG.CLICKABLE)
image.set_ext_click_area(20)
image.add_event_cb(lambda e: func_pressed_cb(e, 0), lv.EVENT.PRESSED, None)
image.set_grid_cell(lv.GRID_ALIGN.CENTER, 0, 1, lv.GRID_ALIGN.CENTER, 0, 1)
currentSelected = image
currentSelected.set_src(functionImageSelected[0])
image1 = lv.img(funcContainer)
image1.set_src(functionImage[1])
image1.add_flag(lv.obj.FLAG.CLICKABLE)
image1.set_ext_click_area(20)
image1.add_event_cb(lambda e: func_pressed_cb(e, 1), lv.EVENT.PRESSED, None)
image1.set_grid_cell(lv.GRID_ALIGN.CENTER, 1, 1, lv.GRID_ALIGN.CENTER, 0, 1)
image2 = lv.img(funcContainer)
image2.set_src(functionImage[2])
image2.add_flag(lv.obj.FLAG.CLICKABLE)
image2.set_ext_click_area(20)
image2.add_event_cb(lambda e: func_pressed_cb(e, 2), lv.EVENT.PRESSED, None)
image2.set_grid_cell(lv.GRID_ALIGN.CENTER, 2, 1, lv.GRID_ALIGN.CENTER, 0, 1)
image3 = lv.img(funcContainer)
image3.set_src(functionImage[3])
image3.add_flag(lv.obj.FLAG.CLICKABLE)
image3.set_ext_click_area(20)
image3.add_event_cb(lambda e: func_pressed_cb(e, 3), lv.EVENT.PRESSED, None)
image3.set_grid_cell(lv.GRID_ALIGN.CENTER, 3, 1, lv.GRID_ALIGN.CENTER, 0, 1)
# for i in range(4):
# image = lv.img(funcContainer)
# image.set_src(functionImage[i])
# image.add_flag(lv.obj.FLAG.CLICKABLE)
# image.set_ext_click_area(20)
# image.add_event_cb(lambda e: func_pressed_cb(e, i), lv.EVENT.PRESSED, None)
# image.set_grid_cell(lv.GRID_ALIGN.CENTER, i, 1, lv.GRID_ALIGN.CENTER, 0, 1)
# if (currentFunc == i):
# currentSelected = image
# currentSelected.set_src(functionImageSelected[i])
backImg=lv.img(win)
backImg.set_src(RESOURCES_ROOT + "images/back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: hvac_back_click_callback(e, win), lv.EVENT.CLICKED, None)
backImg.add_event_cb(lambda e: hvac_back_press_callback(e, backImg), lv.EVENT.PRESSED, None)
backImg.add_event_cb(lambda e: hvac_back_release_callback(e, backImg), lv.EVENT.RELEASED, None)
backImg.set_ext_click_area(20)
from smart_panel import needAnimation
if (needAnimation):
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.MOVE_LEFT, 500, 0, True)
else:
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.NONE, 0, 0, True)
hvac_alive = True
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/hvac.py
|
Python
|
apache-2.0
| 8,415
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
class Lux:
scr = None
iconImg = None
luxLable = None
unityLabel = None
tipLabel = None
def __init__(self, screen):
self.scr = screen
self.createLuxItem(self.scr, RESOURCES_ROOT + "lux.png", "Brightness")
def createLuxItem(self, parent, iconPath, tips):
self.iconImg = lv.img(parent)
self.iconImg.set_src(iconPath)
self.iconImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
self.luxLable = lv.label(parent)
self.luxLable.set_text("None")
self.luxLable.set_style_text_color(lv.color_white(), 0)
self.luxLable.set_style_text_font(lv.font_montserrat_48, 0)
self.luxLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel = lv.label(parent)
self.unityLabel.set_text(" %LEL")
self.unityLabel.set_style_text_color(lv.color_white(), 0)
self.unityLabel.set_style_text_font(lv.font_montserrat_18, 0)
self.unityLabel.align_to(self.luxLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel = lv.label(parent)
self.tipLabel.set_text(tips)
self.tipLabel.set_style_text_color(lv.color_make(0xCC, 0xCC, 0xCC), 0)
self.tipLabel.set_style_text_font(lv.font_montserrat_14, 0)
self.tipLabel.align_to(self.luxLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setValue(self, humidity):
self.luxLable.set_text(str(int(humidity)))
def setXY(self, x, y):
self.iconImg.align(lv.ALIGN.TOP_LEFT, x, y)
self.luxLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel.align_to(self.luxLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel.align_to(self.luxLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setScale(self, scale):
print("To be done")
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/lux.py
|
Python
|
apache-2.0
| 1,848
|
import display_driver
import page_welcome
page_welcome.load_page()
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/main.py
|
Python
|
apache-2.0
| 68
|
import lvgl as lv
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"]
currentMusic = 0
musicData = [
{
"title":"Counting Stars",
"album":"OneRepublic",
"album_url": RESOURCES_ROOT + "images/album_one_republic.jpg",
"url":"file://data/pyamp/audio/test_long.mp3",
"duration":11,
"favorite": False
},
{
"title":"Aube",
"album":"Darius",
"album_url": RESOURCES_ROOT + "images/album_darius.jpg",
"url":"file://data/pyamp/audio/test_long.mp3",
"duration":155,
"favorite": False
},
]
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
music_alive = False
def music_back_click_callback(e, win):
global anim_timeline
global start
global player
global music_alive
start = False
# stop animation
if (anim_timeline != None):
lv.anim_timeline_stop(anim_timeline)
lv.anim_timeline_del(anim_timeline)
anim_timeline = None
if (player != None):
player.pause()
player.close()
player = None
# load smart panel desktop
if (music_alive):
from smart_panel import load_smart_panel
load_smart_panel()
music_alive = False
def music_back_press_callback(e, image):
image.set_zoom(280)
def music_back_release_callback(e, image):
image.set_zoom(250)
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")
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()
elif (func == "fav"):
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"):
currentMusic += 1
if (len(musicData) == currentMusic):
currentMusic = 0
reset_music()
elif (func == "prev"):
currentMusic -= 1
if (currentMusic < 0):
currentMusic = len(musicData) - 1
reset_music()
class Music:
def createPage(self):
global anim
global playedTime
global durationTime
global slider
global audio_src
global player
global image
global music_alive
global currentMusic
global albumCover
global songTitle
global albumTitle
global totalTime
global anim_timeline
global scr
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)
backImg=lv.img(win)
backImg.set_src(RESOURCES_ROOT + "images/back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: music_back_click_callback(e, win), lv.EVENT.CLICKED, None)
backImg.add_event_cb(lambda e: music_back_press_callback(e, backImg), lv.EVENT.PRESSED, None)
backImg.add_event_cb(lambda e: music_back_release_callback(e, backImg), lv.EVENT.RELEASED, None)
backImg.set_ext_click_area(30)
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()
from smart_panel import needAnimation
if (needAnimation):
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.MOVE_LEFT, 500, 0, True)
else:
lv.scr_load_anim(scr, lv.SCR_LOAD_ANIM.NONE, 0, 0, True)
music_alive = True
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/music.py
|
Python
|
apache-2.0
| 12,889
|
import lvgl as lv
import uos
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
def environment_back_click_callback(e, win):
import page_settings
page_settings.load_page()
def environment_back_press_callback(e, back_image):
back_image.set_zoom(280)
def environment_back_release_callback(e, back_image):
back_image.set_zoom(250)
def load_page():
scr = lv.obj()
scr.set_style_bg_color(lv.color_black(), 0)
backImg=lv.img(scr)
backImg.set_src(RESOURCES_ROOT + "back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: environment_back_click_callback(e, scr), lv.EVENT.CLICKED, None)
backImg.add_event_cb(lambda e: environment_back_press_callback(e, backImg), lv.EVENT.PRESSED, None)
backImg.add_event_cb(lambda e: environment_back_release_callback(e, backImg), lv.EVENT.RELEASED, None)
backImg.set_ext_click_area(30)
#bg_color = lv.palette_lighten(lv.PALETTE.LIGHT_BLUE, 5)
#fg_color = lv.palette_darken(lv.PALETTE.BLUE, 4)
#qr1 = lv.qrcode(scr, 130, fg_color, bg_color)
#data1 = "https://haas.iot.aliyun.com/solution"
#qr1.update(data1,len(data1))
#qr1.align(lv.ALIGN.CENTTER, -10, -20)
#qr1.set_style_border_color(bg_color, 0)
#qr1.set_style_border_width(5, 0)
label1 = lv.label(scr)
font_Alibaba_PuHuiTi.set_text_size(label1, 16)
label1.set_text("更多趣味案例")
label1.set_style_text_color(lv.color_make(0xcc, 0xcc, 0xcc), 0)
label1.align(lv.ALIGN.BOTTOM_MID, -70, -50)
label2 = lv.label(scr)
font_Alibaba_PuHuiTi.set_text_size(label2, 16)
label2.set_text("扫码进入钉群")
label2.set_style_text_color(lv.color_make(0xcc, 0xcc, 0xcc), 0)
label2.align(lv.ALIGN.BOTTOM_MID, 70, -50)
label3 = lv.label(scr)
font_Alibaba_PuHuiTi.set_text_size(label3, 16)
label3.set_style_text_color(lv.color_make(0, 0, 0xFF), 0)
label3.set_text("固件: ")
label3.align(lv.ALIGN.BOTTOM_LEFT, 20, -20)
label33 = lv.label(scr)
label33.set_long_mode(lv.label.LONG.SCROLL_CIRCULAR) # Circular scroll
label33.set_width(230)
label33.set_style_text_color(lv.color_make(0, 0, 0xFF), 0)
font_Alibaba_PuHuiTi.set_text_size(label33, 16)
label33.set_text(uos.version_info())
label33.align_to(label3, lv.ALIGN.OUT_RIGHT_MID, 5, 0)
lv.scr_load(scr)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/page_about.py
|
Python
|
apache-2.0
| 2,407
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
def environment_back_click_callback(e, win):
import page_sensors2
page_sensors2.load_page()
def environment_back_press_callback(e, back_image):
back_image.set_zoom(280)
def environment_back_release_callback(e, back_image):
back_image.set_zoom(250)
def set_xy(obj, v):
obj.setXY(v, v)
def set_scale(obj, v):
obj.setScale(v)
def load_page():
scr = lv.obj()
scr.set_style_bg_color(lv.color_black(), 0)
from airpressure import Airpressure
airpressure = Airpressure(scr)
airpressure.setValue(1050)
airpressure.setXY(0, 0)
a1 = lv.anim_t()
a1.init()
a1.set_var(airpressure)
a1.set_custom_exec_cb(lambda a,val: set_xy(airpressure, val))
a1.set_values(0, 130)
a1.set_time(5000)
a1.set_repeat_count(lv.ANIM_REPEAT.INFINITE)
lv.anim_t.start(a1)
backImg=lv.img(scr)
backImg.set_src(RESOURCES_ROOT + "back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: environment_back_click_callback(e, scr), lv.EVENT.CLICKED, None)
backImg.add_event_cb(lambda e: environment_back_press_callback(e, backImg), lv.EVENT.PRESSED, None)
backImg.add_event_cb(lambda e: environment_back_release_callback(e, backImg), lv.EVENT.RELEASED, None)
backImg.set_ext_click_area(20)
lv.scr_load(scr)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/page_airpressure.py
|
Python
|
apache-2.0
| 1,417
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
def environment_back_click_callback(e, win):
import page_sensors1
page_sensors1.load_page()
def environment_back_press_callback(e, back_image):
back_image.set_zoom(280)
def environment_back_release_callback(e, back_image):
back_image.set_zoom(250)
def set_xy(obj, v):
obj.setXY(v, v)
def set_scale(obj, v):
obj.setScale(v)
def load_page():
scr = lv.obj()
scr.set_style_bg_color(lv.color_black(), 0)
from angle import Angle
angle = Angle(scr)
angle.setValue(56)
angle.setXY(0, 0)
a1 = lv.anim_t()
a1.init()
a1.set_var(angle)
a1.set_custom_exec_cb(lambda a,val: set_xy(angle, val))
a1.set_values(0, 130)
a1.set_time(5000)
a1.set_repeat_count(lv.ANIM_REPEAT.INFINITE)
lv.anim_t.start(a1)
backImg=lv.img(scr)
backImg.set_src(RESOURCES_ROOT + "back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: environment_back_click_callback(e, scr), lv.EVENT.CLICKED, None)
backImg.add_event_cb(lambda e: environment_back_press_callback(e, backImg), lv.EVENT.PRESSED, None)
backImg.add_event_cb(lambda e: environment_back_release_callback(e, backImg), lv.EVENT.RELEASED, None)
backImg.set_ext_click_area(20)
lv.scr_load(scr)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/page_angle.py
|
Python
|
apache-2.0
| 1,367
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
def back_click_callback(e, win):
import page_basic
page_basic.load_page()
def load_page():
scr = lv.obj()
scr.set_style_bg_color(lv.color_black(), 0)
backImg=lv.img(scr)
backImg.set_src(RESOURCES_ROOT + "back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: back_click_callback(e, scr), lv.EVENT.CLICKED, None)
backImg.set_ext_click_area(20)
# 创建Arc对象，设置其末端的角度、尺寸及位置
arc = lv.arc(scr)
arc.set_end_angle(200)
arc.set_size(150, 150)
arc.center()
# 将控件显示在屏幕上
lv.scr_load(scr)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/page_arc.py
|
Python
|
apache-2.0
| 736
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
def back_click_callback(e, win):
import page_basic
page_basic.load_page()
def load_page():
scr = lv.obj()
scr.set_style_bg_color(lv.color_black(), 0)
backImg=lv.img(scr)
backImg.set_src(RESOURCES_ROOT + "back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: back_click_callback(e, scr), lv.EVENT.CLICKED, None)
backImg.set_ext_click_area(20)
# 创建bar, 设置其大小、摆放位置和进度位置
bar1 = lv.bar(scr)
bar1.set_size(200, 20)
bar1.center()
bar1.set_value(70, lv.ANIM.OFF)
# 将控件显示在屏幕上
lv.scr_load(scr)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/page_bar.py
|
Python
|
apache-2.0
| 743
|
import lvgl as lv
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
titles = ["line", "label", "image",
"button", "bar", "arc",
"btnmatrix", "checkbox", "dropdown",
"roller", "slider", "switch",
"table", "keyboard", "calendar",
"led", "list", "meter",
"msgbox", "spans", "tabview"]
def element_pressed_cb(e):
print('pressed')
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0x39, 0x39, 0x39), 0)
def element_released_cb(e):
print('released')
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0xf, 0xf, 0xf), 0)
def element_click_cb(e, name):
print("click: ", name)
if (name == "line"):
import page_line
page_line.load_page()
if (name == "label"):
import page_label
page_label.load_page()
if (name == "image"):
import page_image
page_image.load_page()
if (name == "button"):
import page_button
page_button.load_page()
if (name == "bar"):
import page_bar
page_bar.load_page()
if (name == "arc"):
import page_arc
page_arc.load_page()
if (name == "btnmatrix"):
import page_btnmatrix
page_btnmatrix.load_page()
if (name == "checkbox"):
import page_checkbox
page_checkbox.load_page()
if (name == "dropdown"):
import page_dropdown
page_dropdown.load_page()
if (name == "roller"):
import page_roller
page_roller.load_page()
if (name == "slider"):
import page_slider
page_slider.load_page()
if (name == "switch"):
import page_switch
page_switch.load_page()
if (name == "table"):
import page_table
page_table.load_page()
if (name == "keyboard"):
import page_keyboard
page_keyboard.load_page()
if (name == "calendar"):
import page_calendar
page_calendar.load_page()
if (name == "led"):
import page_led
page_led.load_page()
if (name == "list"):
import page_list
page_list.load_page()
if (name == "meter"):
import page_meter
page_meter.load_page()
if (name == "msgbox"):
import page_msgbox
page_msgbox.load_page()
if (name == "spans"):
import page_spans
page_spans.load_page()
if (name == "tabview"):
import page_tabview
page_tabview.load_page()
def backImg_click_callback(e, win):
import page_haas
page_haas.load_page()
def nextImg_click_callback(e, win):
import page_sensors2
page_sensors2.load_page()
def load_page():
scr = lv.obj()
scr.set_style_bg_color(lv.color_black(), 0)
backImg=lv.img(scr)
backImg.set_src(RESOURCES_ROOT + "back.png")
backImg.align(lv.ALIGN.LEFT_MID, 0, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: backImg_click_callback(e, scr), lv.EVENT.CLICKED, None)
backImg.set_ext_click_area(20)
style = lv.style_t()
style.init()
style.set_flex_flow(lv.FLEX_FLOW.ROW_WRAP)
style.set_flex_main_place(lv.FLEX_ALIGN.SPACE_EVENLY)
style.set_layout(lv.LAYOUT_FLEX.value)
cont = lv.obj(scr)
cont.set_size(290, 220)
cont.align_to(backImg, lv.ALIGN.OUT_RIGHT_MID, -5, 0)
cont.add_style(style, 0)
cont.set_style_bg_opa(0, 0)
cont.set_style_border_opa(0, 0)
cont.set_style_pad_left(5, 0)
cont.set_style_pad_right(5, 0)
cont.set_style_pad_top(9, 0)
cont.set_style_pad_bottom(9, 0)
for i in range(21):
obj = lv.obj(cont)
obj.set_size(85, 60)
obj.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
obj.clear_flag(lv.obj.FLAG.SCROLLABLE)
obj.set_style_bg_color(lv.color_make(0xf, 0xf, 0xf), 0)
obj.set_style_border_color(lv.color_make(0xf, 0xf, 0xf), 0)
obj.set_style_radius(0, 0)
obj.add_event_cb(element_pressed_cb, lv.EVENT.PRESSED, None)
obj.add_event_cb(element_released_cb, lv.EVENT.RELEASED, None)
if (i == 0):
obj.add_event_cb(lambda e: element_click_cb(e, "line"), lv.EVENT.CLICKED, None)
elif (i == 1):
obj.add_event_cb(lambda e: element_click_cb(e, "label"), lv.EVENT.CLICKED, None)
elif (i == 2):
obj.add_event_cb(lambda e: element_click_cb(e, "image"), lv.EVENT.CLICKED, None)
elif (i == 3):
obj.add_event_cb(lambda e: element_click_cb(e, "button"), lv.EVENT.CLICKED, None)
elif (i == 4):
obj.add_event_cb(lambda e: element_click_cb(e, "bar"), lv.EVENT.CLICKED, None)
elif (i == 5):
obj.add_event_cb(lambda e: element_click_cb(e, "arc"), lv.EVENT.CLICKED, None)
elif (i == 6):
obj.add_event_cb(lambda e: element_click_cb(e, "btnmatrix"), lv.EVENT.CLICKED, None)
elif (i == 7):
obj.add_event_cb(lambda e: element_click_cb(e, "checkbox"), lv.EVENT.CLICKED, None)
elif (i == 8):
obj.add_event_cb(lambda e: element_click_cb(e, "dropdown"), lv.EVENT.CLICKED, None)
elif (i == 9):
obj.add_event_cb(lambda e: element_click_cb(e, "roller"), lv.EVENT.CLICKED, None)
elif (i == 10):
obj.add_event_cb(lambda e: element_click_cb(e, "slider"), lv.EVENT.CLICKED, None)
elif (i == 11):
obj.add_event_cb(lambda e: element_click_cb(e, "switch"), lv.EVENT.CLICKED, None)
elif (i == 12):
obj.add_event_cb(lambda e: element_click_cb(e, "table"), lv.EVENT.CLICKED, None)
elif (i == 13):
obj.add_event_cb(lambda e: element_click_cb(e, "keyboard"), lv.EVENT.CLICKED, None)
elif (i == 14):
obj.add_event_cb(lambda e: element_click_cb(e, "calendar"), lv.EVENT.CLICKED, None)
elif (i == 15):
obj.add_event_cb(lambda e: element_click_cb(e, "led"), lv.EVENT.CLICKED, None)
elif (i == 16):
obj.add_event_cb(lambda e: element_click_cb(e, "list"), lv.EVENT.CLICKED, None)
elif (i == 17):
obj.add_event_cb(lambda e: element_click_cb(e, "meter"), lv.EVENT.CLICKED, None)
elif (i == 18):
obj.add_event_cb(lambda e: element_click_cb(e, "msgbox"), lv.EVENT.CLICKED, None)
elif (i == 19):
obj.add_event_cb(lambda e: element_click_cb(e, "spans"), lv.EVENT.CLICKED, None)
elif (i == 20):
obj.add_event_cb(lambda e: element_click_cb(e, "tabview"), lv.EVENT.CLICKED, None)
label = lv.label(obj)
label.set_text(titles[i])
label.set_style_text_color(lv.color_make(0xcc, 0xcc, 0xcc), 0)
label.center()
lv.scr_load(scr)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/page_basic.py
|
Python
|
apache-2.0
| 6,697
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
def back_click_callback(e, win):
import page_basic
page_basic.load_page()
def event_handler(evt):
code = evt.get_code()
obj = evt.get_target()
if code == lv.EVENT.VALUE_CHANGED :
id = obj.get_selected_btn()
txt = obj.get_btn_text(id)
print("%s was pressed"%txt)
def load_page():
scr = lv.obj()
scr.set_style_bg_color(lv.color_black(), 0)
backImg=lv.img(scr)
backImg.set_src(RESOURCES_ROOT + "back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: back_click_callback(e, scr), lv.EVENT.CLICKED, None)
backImg.set_ext_click_area(20)
btnm_map = ["1", "2", "3", "4", "5", "\n",
"6", "7", "8", "9", "0", "\n",
"Action1", "Action2", ""]
# 创建组合按钮，设置按钮大小，按钮上要显示的文字及按钮属性、按钮动作回调函数等
btnm1 = lv.btnmatrix(scr)
btnm1.set_map(btnm_map)
btnm1.set_btn_width(10, 2) # Make "Action1" twice as wide as "Action2"
btnm1.set_btn_ctrl(10, lv.btnmatrix.CTRL.CHECKABLE)
btnm1.set_btn_ctrl(11, lv.btnmatrix.CTRL.CHECKED)
btnm1.align(lv.ALIGN.CENTER, 0, 0)
btnm1.add_event_cb(event_handler, lv.EVENT.ALL, None)
# 将控件显示在屏幕上
lv.scr_load(scr)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/page_btnmatrix.py
|
Python
|
apache-2.0
| 1,401
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
def event_handler(evt):
code = evt.get_code()
if code == lv.EVENT.CLICKED:
print("Clicked event seen")
elif code == lv.EVENT.VALUE_CHANGED:
print("Value changed seen")
def back_click_callback(e, win):
import page_basic
page_basic.load_page()
def load_page():
scr = lv.obj()
scr.set_style_bg_color(lv.color_black(), 0)
backImg=lv.img(scr)
backImg.set_src(RESOURCES_ROOT + "back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: back_click_callback(e, scr), lv.EVENT.CLICKED, None)
backImg.set_ext_click_area(20)
# 创建一个简单按钮
btn1 = lv.btn(scr)
# 设置按钮相关事件的callback，所有按下/松开灯事件都需要送到回调函数
btn1.add_event_cb(event_handler,lv.EVENT.ALL, None)
btn1.align(lv.ALIGN.CENTER,0,-40)
label=lv.label(btn1)
label.set_text("Button")
# 创建一个状态开关按钮
btn2 = lv.btn(scr)
# 设置状态开关按钮相关事件的callback，所有按下/松开灯事件都需要送到回调函数
btn2.add_event_cb(event_handler,lv.EVENT.ALL, None)
#btn2.add_event_cb(event_handler,lv.EVENT.VALUE_CHANGED,None)
btn2.align(lv.ALIGN.CENTER,0,40)
btn2.add_flag(lv.obj.FLAG.CHECKABLE)
btn2.set_height(lv.SIZE.CONTENT)
label=lv.label(btn2)
label.set_text("Toggle")
label.center()
# 将控件显示在屏幕上
lv.scr_load(scr)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/page_button.py
|
Python
|
apache-2.0
| 1,568
|
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
calendar = None
def back_click_callback(e, win):
import page_basic
page_basic.load_page()
def event_handler(evt):
global calendar
code = evt.get_code()
if code == lv.EVENT.VALUE_CHANGED:
source = evt.get_current_target()
date = lv.calendar_date_t()
if source.get_pressed_date(date) == lv.RES.OK:
calendar.set_today_date(date.year, date.month, date.day)
print("Clicked date: %02d.%02d.%02d"%(date.day, date.month, date.year))
def load_page():
global calendar
scr = lv.obj()
scr.set_style_bg_color(lv.color_black(), 0)
backImg=lv.img(scr)
backImg.set_src(RESOURCES_ROOT + "back.png")
backImg.set_style_align(lv.ALIGN.LEFT_MID, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.add_event_cb(lambda e: back_click_callback(e, scr), lv.EVENT.CLICKED, None)
backImg.set_ext_click_area(20)
calendar = lv.calendar(scr)
calendar.set_size(280, 200)
calendar.align(lv.ALIGN.CENTER, 0, 0)
calendar.add_event_cb(event_handler, lv.EVENT.ALL, None)
calendar.set_today_date(2022, 06, 06)
calendar.set_showed_date(2022, 06)
# Highlight a few days
highlighted_days=[
lv.calendar_date_t({'year':2022, 'month':6, 'day':3}),
lv.calendar_date_t({'year':2022, 'month':6, 'day':4}),
lv.calendar_date_t({'year':2022, 'month':6, 'day':5})
]
calendar.set_highlighted_dates(highlighted_days, len(highlighted_days))
lv.calendar_header_dropdown(calendar)
# 将控件显示在屏幕上
lv.scr_load(scr)
|
YifuLiu/AliOS-Things
|
haas_lib_bundles/python/docs/examples/ui_collection/page_calendar.py
|
Python
|
apache-2.0
| 1,623
|