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 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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/lux.py | Python | apache-2.0 | 1,848 |
import display_driver
import page_welcome
page_welcome.load_page()
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/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)
#qr2 = lv.qrcode(scr, 130, fg_color, bg_color)
#data2 = "https://h5.dingtalk.com/circle/healthCheckin.html?dtaction=os&corpId=dingb846e861c83d9a57ca21756a27946a0e&5730f=56fd0&cbdbhh=qwertyuiop"
#qr2.update(data2,len(data2))
#qr2.align(lv.ALIGN.CENTTER, 10, -20)
#qr2.set_style_border_color(bg_color, 0)
#qr2.set_style_border_width(5, 0)
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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_about.py | Python | apache-2.0 | 2,769 |
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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_calendar.py | Python | apache-2.0 | 1,623 |
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(e):
code = e.get_code()
obj = e.get_target()
if code == lv.EVENT.VALUE_CHANGED:
txt = obj.get_text()
if obj.get_state() & lv.STATE.CHECKED:
state = "Checked"
else:
state = "Unchecked"
print(txt + ":" + state)
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)
# 设置画面布局样式
scr.set_flex_flow(lv.FLEX_FLOW.COLUMN)
scr.set_flex_align(lv.FLEX_ALIGN.CENTER, lv.FLEX_ALIGN.START, lv.FLEX_ALIGN.CENTER)
# 创建复选框，并设定复选框名称、属性等信息并设置复选框相关动作回调函数
cb = lv.checkbox(scr)
cb.set_text("Apple")
cb.add_event_cb(event_handler, lv.EVENT.ALL, None)
cb = lv.checkbox(scr)
cb.set_text("Banana")
cb.add_state(lv.STATE.CHECKED)
cb.add_event_cb(event_handler, lv.EVENT.ALL, None)
cb = lv.checkbox(scr)
cb.set_text("Lemon")
cb.add_state(lv.STATE.DISABLED)
cb.add_event_cb(event_handler, lv.EVENT.ALL, None)
cb = lv.checkbox(scr)
cb.add_state(lv.STATE.CHECKED | lv.STATE.DISABLED)
cb.set_text("Melon")
cb.add_event_cb(event_handler, lv.EVENT.ALL, None)
# 更新画面布局
cb.update_layout()
# 将控件显示在屏幕上
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_checkbox.py | Python | apache-2.0 | 1,747 |
import lvgl as lv
import wifi_module
import _thread
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
wifiSSID = ""
wifiPassword = ""
def wifi_connect():
global wifiSSID
global wifiPassword
result = False
result = wifi_module.wifi_connect(wifiSSID, wifiPassword)
if (result == False):
print("WARNING: Device activates failed !!")
import page_failed
page_failed.load_page()
else:
print("Device activates successllly !!")
import page_success
page_success.load_page()
def set_angle(img, v):
img.set_angle(v)
def load_page(ssid, password):
global wifiSSID
global wifiPassword
wifiSSID = ssid
wifiPassword = password
print("Wi-Fi SSID: ", wifiSSID)
print("Wi-Fi PASSWORD: ", wifiPassword)
print("Wi-Fi Connecting ...")
scr = lv.obj()
scr.set_style_bg_color(lv.color_make(20, 27, 31), 0)
loadImg =lv.img(scr)
loadImg.set_src(RESOURCES_ROOT + "loading.png")
loadImg.align(lv.ALIGN.CENTER, 0, -20)
loadImg.set_zoom(200)
a1 = lv.anim_t()
a1.init()
a1.set_var(loadImg)
a1.set_custom_exec_cb(lambda a,val: set_angle(loadImg,val))
a1.set_values(0, 3600)
a1.set_time(2000)
a1.set_repeat_count(lv.ANIM_REPEAT.INFINITE)
lv.anim_t.start(a1)
label1 = lv.label(scr)
label1.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label1, 20)
label1.set_text("#ffffff 网络连接中 #")
label1.align_to(loadImg, lv.ALIGN.OUT_BOTTOM_MID, 0, 20)
lv.scr_load(scr)
_thread.stack_size(10 * 1024)
_thread.start_new_thread(wifi_connect, ())
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_connect.py | Python | apache-2.0 | 1,637 |
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 distance import Distance
distance = Distance(scr)
distance.setValue(12.3)
distance.setXY(0, 0)
a1 = lv.anim_t()
a1.init()
a1.set_var(distance)
a1.set_custom_exec_cb(lambda a,val: set_xy(distance, 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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_distance.py | Python | apache-2.0 | 1,393 |
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(e):
code = e.get_code()
obj = e.get_target()
if code == lv.EVENT.VALUE_CHANGED:
option = " "*10 # should be large enough to store the option
obj.get_selected_str(option, len(option))
# .strip() removes trailing spaces
print("Option: \"%s\"" % option.strip())
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)
# 创建下拉列表
dd = lv.dropdown(scr)
# 设置下拉列表下拉选项
dd.set_options("\n".join([
"Apple",
"Banana",
"Orange",
"Cherry",
"Grape",
"Raspberry",
"Melon",
"Orange",
"Lemon",
"Nuts"]))
# 设置下拉选项的样式
dd.align(lv.ALIGN.TOP_MID, 0, 20)
# 设置下拉列表回调函数
dd.add_event_cb(event_handler, lv.EVENT.ALL, None)
# 将控件显示在屏幕上
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_dropdown.py | Python | apache-2.0 | 1,396 |
import lvgl as lv
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
def event1_handler(evt):
code = evt.get_code()
ele = evt.get_target()
if code == lv.EVENT.CLICKED:
import page_haas
page_haas.load_page()
elif code == lv.EVENT.PRESSED:
ele.set_style_bg_color(lv.color_make(0x39, 0x39, 0x39), 0)
elif code == lv.EVENT.RELEASED:
ele.set_style_bg_color(lv.color_make(93, 112, 141), 0)
def event2_handler(evt):
code = evt.get_code()
ele = evt.get_target()
if code == lv.EVENT.CLICKED:
import page_scan
page_scan.load_page()
elif code == lv.EVENT.PRESSED:
ele.set_style_bg_color(lv.color_make(0x39, 0x39, 0x39), 0)
elif code == lv.EVENT.RELEASED:
ele.set_style_bg_color(lv.color_make(255, 106, 0), 0)
def load_page():
scr = lv.obj()
scr.set_style_bg_color(lv.color_make(20, 27, 31), 0)
loadImg =lv.img(scr)
loadImg.set_src(RESOURCES_ROOT + "failed.png")
loadImg.align(lv.ALIGN.CENTER, 0, -50)
loadImg.set_zoom(100)
label1 = lv.label(scr)
label1.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label1, 20)
label1.set_text("#ffffff 网络连接失败，请检查网络并重试 #")
label1.align_to(loadImg, lv.ALIGN.OUT_BOTTOM_MID, 0, -20)
# create a simple button
btn1 = lv.btn(scr)
btn1.add_event_cb(event1_handler,lv.EVENT.ALL, None)
btn1.align(lv.ALIGN.BOTTOM_MID, -50, -50)
btn1.set_style_bg_color(lv.color_make(93, 112, 143), 0)
btn1.set_style_border_color(lv.color_make(255, 106, 0), 0)
btn1.set_style_radius(10, 0)
label1 = lv.label(btn1)
font_Alibaba_PuHuiTi.set_text_size(label1, 20)
label1.set_text(" 跳过 ")
# create a simple button
btn2 = lv.btn(scr)
btn2.add_event_cb(event2_handler,lv.EVENT.ALL, None)
btn2.align(lv.ALIGN.BOTTOM_MID, 50, -50)
btn2.set_style_bg_color(lv.color_make(255, 106, 0), 0)
btn2.set_style_border_color(lv.color_make(255, 106, 0), 0)
btn2.set_style_radius(10, 0)
label2=lv.label(btn2)
font_Alibaba_PuHuiTi.set_text_size(label2, 20)
label2.set_text(" 重试 ")
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_failed.py | Python | apache-2.0 | 2,176 |
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 fm import Fm
fm = Fm(scr)
fm.setValue(96.8)
fm.setXY(0, 0)
a1 = lv.anim_t()
a1.init()
a1.set_var(fm)
a1.set_custom_exec_cb(lambda a,val: set_xy(fm, 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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_fm.py | Python | apache-2.0 | 1,345 |
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 gas import Gas
gas = Gas(scr)
gas.setValue(72)
gas.setXY(0, 0)
a1 = lv.anim_t()
a1.init()
a1.set_var(gas)
a1.set_custom_exec_cb(lambda a,val: set_xy(gas, 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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_gas.py | Python | apache-2.0 | 1,351 |
import lvgl as lv
import wifi_module
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
images = [RESOURCES_ROOT + "basic_ui.png",
RESOURCES_ROOT + "sensor_ui.png",
RESOURCES_ROOT + "aiot_solution.png",
RESOURCES_ROOT + "setting.png"]
titles = ["基础UI",
"传感器UI",
"云端一体案例",
"设置"]
def element_pressed_cb(e):
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0x19, 0x19, 0x19), 0)
def element_released_cb(e):
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0xf, 0xf, 0xf), 0)
def element_click_cb(e, name):
if (name == "Settings"):
import page_settings
page_settings.load_page()
elif (name == "Basic"):
print("Basic demo to be done")
import page_basic
page_basic.load_page()
elif (name == "Sensors"):
import page_sensors1
page_sensors1.load_page()
elif (name == "Solutions"):
if (wifi_module.is_wifi_connected() == False):
import page_failed
page_failed.load_page()
else:
import page_solutions
page_solutions.load_page()
def load_page():
scr = lv.obj()
scr.set_style_bg_color(lv.color_black(), 0)
# init grid layout
col_dsc = [145, 145, lv.GRID_TEMPLATE.LAST]
row_dsc = [105, 105, 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_style_pad_left(10, 0)
gridLayout.set_style_pad_right(10, 0)
gridLayout.set_style_pad_top(10, 0)
gridLayout.set_style_pad_bottom(10, 0)
gridLayout.set_layout(lv.LAYOUT_GRID.value)
gridLayout.set_size(scr.get_width(), scr.get_height())
gridLayout.align(lv.ALIGN.CENTER, 0, 0)
for i in range(4):
col = i % 2
row = i // 2
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)
img=lv.img(element)
img.set_src(images[i])
img.align(lv.ALIGN.CENTER, 0, -20)
label = lv.label(element)
font_Alibaba_PuHuiTi.set_text_size(label, 16)
label.set_text(titles[i])
label.set_style_text_color(lv.color_make(0xcc, 0xcc, 0xcc), 0)
label.align_to(img, lv.ALIGN.OUT_BOTTOM_MID, 0, -5)
if (titles[i] == "设置"):
element.add_event_cb(lambda e: element_click_cb(e, "Settings"), lv.EVENT.CLICKED, None)
elif (titles[i] == "基础UI"):
element.add_event_cb(lambda e: element_click_cb(e, "Basic"), lv.EVENT.CLICKED, None)
elif (titles[i] == "传感器UI"):
element.add_event_cb(lambda e: element_click_cb(e, "Sensors"), lv.EVENT.CLICKED, None)
elif (titles[i] == "云端一体案例"):
element.add_event_cb(lambda e: element_click_cb(e, "Solutions"), lv.EVENT.CLICKED, None)
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_haas.py | Python | apache-2.0 | 3,725 |
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 hcho import Hcho
hcho = Hcho(scr)
hcho.setValue(0.150)
hcho.setXY(0, 0)
a1 = lv.anim_t()
a1.init()
a1.set_var(hcho)
a1.set_custom_exec_cb(lambda a,val: set_xy(hcho, 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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_hcho.py | Python | apache-2.0 | 1,362 |
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 heartrate import Heartrate
heartrate = Heartrate(scr)
heartrate.setValue(65)
heartrate.setXY(0, 0)
a1 = lv.anim_t()
a1.init()
a1.set_var(heartrate)
a1.set_custom_exec_cb(lambda a,val: set_xy(heartrate, 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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_heartrate.py | Python | apache-2.0 | 1,399 |
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 humidity import Humidity
humidity = Humidity(scr)
humidity.setValue(308)
humidity.setXY(0, 0)
a1 = lv.anim_t()
a1.init()
a1.set_var(humidity)
a1.set_custom_exec_cb(lambda a,val: set_xy(humidity, 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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_humidity.py | Python | apache-2.0 | 1,392 |
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 humidity import Humidity
humidity = Humidity(scr)
humidity.setValue(86)
humidity.setXY(0, 0)
a1 = lv.anim_t()
a1.init()
a1.set_var(humidity)
a1.set_custom_exec_cb(lambda a,val: set_xy(humidity, 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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_humiture.py | Python | apache-2.0 | 1,391 |
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)
img1 = lv.img(scr)
img1.set_src(RESOURCES_ROOT + "setting.png")
img1.align(lv.ALIGN.CENTER, 0, -20)
img1.set_size(200, 200)
img2 = lv.img(scr)
img2.set_src(lv.SYMBOL.OK + "Accept")
img2.align_to(img1, lv.ALIGN.OUT_BOTTOM_MID, 0, 20)
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_image.py | Python | apache-2.0 | 804 |
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
def back_click_callback(e, win):
import page_basic
page_basic.load_page()
def ta_event_cb(e,kb):
code = e.get_code()
ta = e.get_target()
if code == lv.EVENT.FOCUSED:
kb.set_textarea(ta)
kb.clear_flag(lv.obj.FLAG.HIDDEN)
if code == lv.EVENT.DEFOCUSED:
kb.set_textarea(None)
kb.add_flag(lv.obj.FLAG.HIDDEN)
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)
# Create a keyboard to use it with one of the text areas
kb = lv.keyboard(scr)
# Create a text area. The keyboard will write here
ta = lv.textarea(scr)
ta.set_width(140)
ta.set_height(100)
ta.align(lv.ALIGN.TOP_LEFT, 10, 10)
ta.add_event_cb(lambda e: ta_event_cb(e,kb), lv.EVENT.ALL, None)
ta.set_placeholder_text("Hello")
ta = lv.textarea(scr)
ta.set_width(140)
ta.set_height(100)
ta.align(lv.ALIGN.TOP_RIGHT, -10, 10)
ta.add_event_cb(lambda e: ta_event_cb(e,kb), lv.EVENT.ALL, None)
kb.set_textarea(ta)
# 将控件显示在屏幕上
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_keyboard.py | Python | apache-2.0 | 1,425 |
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)
#
# Show line wrap, re-color, line align and text scrolling.
#
label1 = lv.label(scr)
label1.set_long_mode(lv.label.LONG.WRAP) # Break the long lines*/
label1.set_recolor(True) # Enable re-coloring by commands in the text
label1.set_text("#0000ff Re-color# #ff00ff words# #ff0000 of a# label, align the lines to the center"
"and wrap long text automatically.")
label1.set_width(150) # Set smaller width to make the lines wrap
label1.set_style_text_align(lv.ALIGN.CENTER, 0)
label1.align(lv.ALIGN.CENTER, 0, -40)
label2 = lv.label(scr)
label2.set_long_mode(lv.label.LONG.SCROLL_CIRCULAR) # Circular scroll
label2.set_width(150)
label2.set_text("It is a circularly scrolling text. ")
label2.align(lv.ALIGN.CENTER, 0, 40)
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_label.py | Python | apache-2.0 | 1,401 |
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)
# Create a LED and switch it OFF
led1 = lv.led(scr)
led1.align(lv.ALIGN.CENTER, -80, 0)
led1.off()
# Copy the previous LED and set a brightness
led2 = lv.led(scr)
led2.align(lv.ALIGN.CENTER, 0, 0)
led2.set_brightness(150)
led2.set_color(lv.palette_main(lv.PALETTE.RED))
# Copy the previous LED and switch it ON
led3 = lv.led(scr)
led3.align(lv.ALIGN.CENTER, 80, 0)
led3.on()
# 将控件显示在屏幕上
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_led.py | Python | apache-2.0 | 1,008 |
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)
line_points = [ {"x":5, "y":5},
{"x":70, "y":70},
{"x":120, "y":10},
{"x":180, "y":60},
{"x":240, "y":10}]
# Create style
style_line = lv.style_t()
style_line.init()
style_line.set_line_width(8)
style_line.set_line_color(lv.palette_main(lv.PALETTE.BLUE))
style_line.set_line_rounded(True)
# Create a line and apply the new style
line1 = lv.line(scr)
line1.set_points(line_points, 5) # Set the points
line1.add_style(style_line, 0)
line1.center()
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_line.py | Python | apache-2.0 | 1,106 |
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
list1 = None
def back_click_callback(e, win):
import page_basic
page_basic.load_page()
def event_handler(e):
global list1
code = e.get_code()
obj = e.get_target()
if code == lv.EVENT.CLICKED:
print("Clicked: list1." + list1.get_btn_text(obj))
def load_page():
global list1
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)
# Create a list
list1 = lv.list(scr)
list1.set_size(180, 220)
list1.center()
# Add buttons to the list
list1.add_text("File")
btn_new = list1.add_btn(lv.SYMBOL.FILE, "New")
btn_new.add_event_cb(event_handler,lv.EVENT.ALL, None)
btn_open = list1.add_btn(lv.SYMBOL.DIRECTORY, "Open")
btn_open.add_event_cb(event_handler,lv.EVENT.ALL, None)
btn_save = list1.add_btn(lv.SYMBOL.SAVE, "Save")
btn_save.add_event_cb(event_handler,lv.EVENT.ALL, None)
btn_delete = list1.add_btn(lv.SYMBOL.CLOSE, "Delete")
btn_delete.add_event_cb(event_handler,lv.EVENT.ALL, None)
btn_edit = list1.add_btn(lv.SYMBOL.EDIT, "Edit")
btn_edit.add_event_cb(event_handler,lv.EVENT.ALL, None)
list1.add_text("Connectivity")
btn_bluetooth = list1.add_btn(lv.SYMBOL.BLUETOOTH, "Bluetooth")
btn_bluetooth.add_event_cb(event_handler,lv.EVENT.ALL, None)
btn_navig = list1.add_btn(lv.SYMBOL.GPS, "Navigation")
btn_navig.add_event_cb(event_handler,lv.EVENT.ALL, None)
btn_USB = list1.add_btn(lv.SYMBOL.USB, "USB")
btn_USB.add_event_cb(event_handler,lv.EVENT.ALL, None)
btn_battery = list1.add_btn(lv.SYMBOL.BATTERY_FULL, "Battery")
btn_battery.add_event_cb(event_handler,lv.EVENT.ALL, None)
list1.add_text("Exit")
btn_apply = list1.add_btn(lv.SYMBOL.OK, "Apply")
btn_apply.add_event_cb(event_handler,lv.EVENT.ALL, None)
btn_close = list1.add_btn(lv.SYMBOL.CLOSE, "Close")
btn_close.add_event_cb(event_handler,lv.EVENT.ALL, None)
# 将控件显示在屏幕上
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_list.py | Python | apache-2.0 | 2,303 |
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 lux import Lux
lux = Lux(scr)
lux.setValue(1200)
lux.setXY(0, 0)
a1 = lv.anim_t()
a1.init()
a1.set_var(lux)
a1.set_custom_exec_cb(lambda a,val: set_xy(lux, 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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_lux.py | Python | apache-2.0 | 1,353 |
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
meter = None
def back_click_callback(e, win):
import page_basic
page_basic.load_page()
def set_value(indic, v):
global meter
meter.set_indicator_value(indic, v)
def load_page():
global meter
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)
# A simple meter
meter = lv.meter(scr)
meter.center()
meter.set_size(200, 200)
# Add a scale first
scale = meter.add_scale()
meter.set_scale_ticks(scale, 51, 2, 10, lv.palette_main(lv.PALETTE.GREY))
meter.set_scale_major_ticks(scale, 10, 4, 15, lv.color_black(), 10)
indic = lv.meter_indicator_t()
# Add a blue arc to the start
indic = meter.add_arc(scale, 3, lv.palette_main(lv.PALETTE.BLUE), 0)
meter.set_indicator_start_value(indic, 0)
meter.set_indicator_end_value(indic, 20)
# Make the tick lines blue at the start of the scale
indic = meter.add_scale_lines(scale, lv.palette_main(lv.PALETTE.BLUE), lv.palette_main(lv.PALETTE.BLUE), False, 0)
meter.set_indicator_start_value(indic, 0)
meter.set_indicator_end_value(indic, 20)
# Add a red arc to the end
indic = meter.add_arc(scale, 3, lv.palette_main(lv.PALETTE.RED), 0)
meter.set_indicator_start_value(indic, 80)
meter.set_indicator_end_value(indic, 100)
# Make the tick lines red at the end of the scale
indic = meter.add_scale_lines(scale, lv.palette_main(lv.PALETTE.RED), lv.palette_main(lv.PALETTE.RED), False, 0)
meter.set_indicator_start_value(indic, 80)
meter.set_indicator_end_value(indic, 100)
# Add a needle line indicator
indic = meter.add_needle_line(scale, 4, lv.palette_main(lv.PALETTE.GREY), -10)
# Create an animation to set the value
a = lv.anim_t()
a.init()
a.set_var(indic)
a.set_values(0, 100)
a.set_time(2000)
a.set_repeat_delay(100)
a.set_playback_time(500)
a.set_playback_delay(100)
a.set_repeat_count(lv.ANIM_REPEAT.INFINITE)
a.set_custom_exec_cb(lambda a,val: set_value(indic,val))
lv.anim_t.start(a)
# 将控件显示在屏幕上
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_meter.py | Python | apache-2.0 | 2,436 |
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_cb(e):
mbox = e.get_current_target()
print("Button %s clicked" % mbox.get_active_btn_text())
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)
btns = ["Apply", "Close", ""]
mbox1 = lv.msgbox(scr, "Hello", "This is a message box with two buttons.", btns, True)
mbox1.add_event_cb(event_cb, lv.EVENT.VALUE_CHANGED, None)
mbox1.center()
# 将控件显示在屏幕上
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_msgbox.py | Python | apache-2.0 | 896 |
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(e):
code = e.get_code()
obj = e.get_target()
if code == lv.EVENT.VALUE_CHANGED:
option = " "*10
obj.get_selected_str(option, len(option))
print("Selected month: " + option.strip())
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)
roller1 = lv.roller(scr)
roller1.set_options("\n".join([
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December"]),lv.roller.MODE.INFINITE)
roller1.set_visible_row_count(4)
roller1.center()
roller1.add_event_cb(event_handler, lv.EVENT.ALL, None)
# 将控件显示在屏幕上
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_roller.py | Python | apache-2.0 | 1,240 |
import lvgl as lv
import _thread
import wifi_module
from driver import TIMER
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
tim0 = None
ap_list = None
WIFI_SCAN_CHECK_PERIOD_MS = 2000 # ms
WIFI_SCAN_TIMEOUT_MS = 6000 # ms
wifi_scan_fail_count = 0
def element_click_callback(e, name):
global tim0
tim0.stop()
tim0.close()
print("intent: ", name)
if (name == "back"):
import page_welcome
page_welcome.load_page()
elif (name == "skip"):
import page_haas
page_haas.load_page()
def set_angle(img, v):
img.set_angle(v)
def wifi_scan():
global ap_list
ap_list = wifi_module.wifi_scan()
print("ap_list:", ap_list)
def oneshot_callback(args):
global ap_list
global wifi_scan_fail_count
if (ap_list == None):
print("wifi scan not finished.")
wifi_scan_fail_count += 1
if (wifi_scan_fail_count == WIFI_SCAN_TIMEOUT_MS/ WIFI_SCAN_CHECK_PERIOD_MS):
import page_scanfail
page_scanfail.load_page()
else:
tim0.open(mode=tim0.ONE_SHOT, period = WIFI_SCAN_CHECK_PERIOD_MS, callback=oneshot_callback)
tim0.start()
return
tim0.stop()
tim0.close()
num = len(ap_list)
print(ap_list)
for ap in ap_list:
print('ssid: ', bytes.decode(ap[0]))
if (bytes.decode(ap[0]) == ""):
ap_list.remove(ap)
ap = ap_list[0]
num = len(ap_list)
print(ap_list)
if (num > 0):
if (num > 4):
num = 4
import page_wifi0
page_wifi0.load_page(ap_list, num)
else:
import page_scanfail
page_scanfail.load_page()
def load_page():
global elementList
global tim0
global wifi_scan_fail_count
_thread.stack_size(10 * 1024)
_thread.start_new_thread(wifi_scan, ())
wifi_scan_fail_count = 0
tim0 = TIMER(0)
tim0.open(mode=tim0.ONE_SHOT, period = WIFI_SCAN_CHECK_PERIOD_MS, callback=oneshot_callback)
tim0.start()
scr = lv.obj()
scr.set_style_bg_color(lv.color_make(20, 27, 31), 0)
rtnImg =lv.img(scr)
rtnImg.set_src(RESOURCES_ROOT + "return.png")
rtnImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
rtnImg.add_flag(lv.obj.FLAG.CLICKABLE)
rtnImg.add_event_cb(lambda e: element_click_callback(e, "back"), lv.EVENT.CLICKED, None)
rtnImg.set_zoom(150)
label1 = lv.label(scr)
label1.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label1, 22)
label1.set_text("#ffffff Wi-Fi #")
label1.align_to(rtnImg, lv.ALIGN.OUT_RIGHT_MID, 0, 0)
# label1.align(lv.ALIGN.TOP_LEFT, 50, 13)
# create a simple button
obj = lv.obj(scr)
obj.set_size(70, 50)
obj.set_style_bg_color(lv.color_make(20, 27, 31), 0)
obj.set_style_border_color(lv.color_make(20, 27, 31), 0)
obj.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
obj.clear_flag(lv.obj.FLAG.SCROLLABLE)
obj.align(lv.ALIGN.TOP_RIGHT, -10, -5)
obj.add_flag(lv.obj.FLAG.CLICKABLE)
obj.set_ext_click_area(50)
obj.add_event_cb(lambda e: element_click_callback(e, "skip"), lv.EVENT.CLICKED, None)
label2 = lv.label(obj)
label2.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label2, 22)
label2.set_text("#ffffff 跳过 #")
loadImg =lv.img(scr)
loadImg.set_src(RESOURCES_ROOT + "loading.png")
loadImg.align(lv.ALIGN.CENTER, 0, -10)
loadImg.set_zoom(200)
label3 = lv.label(scr)
label3.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label3, 20)
label3.set_text("#ffffff 搜索Wi-Fi中 #")
label3.align_to(loadImg, lv.ALIGN.OUT_BOTTOM_MID, 0, 10)
label3.add_event_cb(lambda e: element_click_callback(e, "scan"), lv.EVENT.CLICKED, None)
a1 = lv.anim_t()
a1.init()
a1.set_var(loadImg)
a1.set_custom_exec_cb(lambda a,val: set_angle(loadImg,val))
a1.set_values(0, 3600)
a1.set_time(WIFI_SCAN_CHECK_PERIOD_MS)
a1.set_repeat_count(int(WIFI_SCAN_TIMEOUT_MS/ WIFI_SCAN_CHECK_PERIOD_MS))
lv.anim_t.start(a1)
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_scan.py | Python | apache-2.0 | 4,042 |
import lvgl as lv
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
def element_click_callback(e, name):
print("intent: ", name)
if (name == "back" or name == "retry"):
import page_scan
page_scan.load_page()
elif (name == "skip"):
import page_haas
page_haas.load_page()
def load_page():
global elementList
scr = lv.obj()
scr.set_style_bg_color(lv.color_make(20, 27, 31), 0)
rtnImg =lv.img(scr)
rtnImg.set_src(RESOURCES_ROOT + "return.png")
rtnImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
rtnImg.add_flag(lv.obj.FLAG.CLICKABLE)
rtnImg.add_event_cb(lambda e: element_click_callback(e, "back"), lv.EVENT.CLICKED, None)
rtnImg.set_zoom(150)
label1 = lv.label(scr)
label1.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label1, 22)
label1.set_text("#ffffff Wi-Fi #")
label1.align_to(rtnImg, lv.ALIGN.OUT_RIGHT_MID, 0, 0)
# label1.align(lv.ALIGN.TOP_LEFT, 50, 13)
# create a simple button
obj = lv.obj(scr)
obj.set_size(70, 50)
obj.set_style_bg_color(lv.color_make(20, 27, 31), 0)
obj.set_style_border_color(lv.color_make(20, 27, 31), 0)
obj.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
obj.clear_flag(lv.obj.FLAG.SCROLLABLE)
obj.align(lv.ALIGN.TOP_RIGHT, -10, -5)
obj.add_flag(lv.obj.FLAG.CLICKABLE)
obj.set_ext_click_area(50)
obj.add_event_cb(lambda e: element_click_callback(e, "skip"), lv.EVENT.CLICKED, None)
label2 = lv.label(obj)
label2.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label2, 22)
label2.set_text("#ffffff 跳过 #")
loadImg =lv.img(scr)
loadImg.set_src(RESOURCES_ROOT + "failed.png")
loadImg.align(lv.ALIGN.CENTER, 0, -20)
loadImg.set_zoom(120)
label3 = lv.label(scr)
label3.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label3, 20)
label3.set_text("#ffffff 附近没有可用的Wi-Fi #")
label3.align_to(loadImg, lv.ALIGN.OUT_BOTTOM_MID, 0, -20)
# create a simple button
btn1 = lv.btn(scr)
btn1.add_event_cb(lambda e: element_click_callback(e, "retry"), lv.EVENT.CLICKED, None)
btn1.align(lv.ALIGN.BOTTOM_MID, 0, -20)
btn1.set_style_bg_color(lv.color_make(93, 112, 141), 0)
btn1.set_style_border_color(lv.color_make(93, 112, 141), 0)
btn1.set_style_radius(10, 0)
label1=lv.label(btn1)
font_Alibaba_PuHuiTi.set_text_size(label1, 20)
label1.set_text(" 重试 ")
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_scanfail.py | Python | apache-2.0 | 2,480 |
import lvgl as lv
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
images = [RESOURCES_ROOT + "temperature.png",
RESOURCES_ROOT + "humidity.png",
RESOURCES_ROOT + "gas.png",
RESOURCES_ROOT + "heartrate.png",
RESOURCES_ROOT + "waterlevel.png",
RESOURCES_ROOT + "angle.png"]
titles = ["温度",
"湿度",
"燃气",
"心率",
"水位",
"舵机"]
def element_pressed_cb(e):
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0x39, 0x39, 0x39), 0)
def element_released_cb(e):
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0xf, 0xf, 0xf), 0)
def element_click_cb(e, name):
if (name == "Temperature"):
import page_temperature
page_temperature.load_page()
elif (name == "Humiture"):
import page_humiture
page_humiture.load_page()
elif (name == "Gas"):
import page_gas
page_gas.load_page()
elif (name == "Heartrate"):
import page_heartrate
page_heartrate.load_page()
elif (name == "Waterlevel"):
import page_waterlevel
page_waterlevel.load_page()
elif (name == "Angle"):
import page_angle
page_angle.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)
# init grid layout
col_dsc = [89, 89, 89, 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(20, 0)
gridLayout.set_style_pad_right(20, 0)
gridLayout.set_style_pad_top(9, 0)
gridLayout.set_style_pad_bottom(8, 0)
gridLayout.set_layout(lv.LAYOUT_GRID.value)
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)
nextImg=lv.img(scr)
nextImg.set_src(RESOURCES_ROOT + "forward.png")
nextImg.align(lv.ALIGN.RIGHT_MID, 0, 0)
nextImg.add_flag(lv.obj.FLAG.CLICKABLE)
nextImg.add_event_cb(lambda e: nextImg_click_callback(e, scr), lv.EVENT.CLICKED, None)
nextImg.set_ext_click_area(20)
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)
img=lv.img(element)
img.set_src(images[i])
label = lv.label(element)
font_Alibaba_PuHuiTi.set_text_size(label, 13)
label.set_text(titles[i])
label.set_style_text_color(lv.color_make(0xcc, 0xcc, 0xcc), 0)
label.align_to(img, lv.ALIGN.OUT_BOTTOM_MID, 0, 0)
if (titles[i] == "温度"):
element.add_event_cb(lambda e: element_click_cb(e, "Temperature"), lv.EVENT.CLICKED, None)
elif (titles[i] == "湿度"):
element.add_event_cb(lambda e: element_click_cb(e, "Humiture"), lv.EVENT.CLICKED, None)
elif (titles[i] == "燃气"):
element.add_event_cb(lambda e: element_click_cb(e, "Gas"), lv.EVENT.CLICKED, None)
elif (titles[i] == "心率"):
element.add_event_cb(lambda e: element_click_cb(e, "Heartrate"), lv.EVENT.CLICKED, None)
elif (titles[i] == "水位"):
element.add_event_cb(lambda e: element_click_cb(e, "Waterlevel"), lv.EVENT.CLICKED, None)
elif (titles[i] == "舵机"):
element.add_event_cb(lambda e: element_click_cb(e, "Angle"), lv.EVENT.CLICKED, None)
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_sensors1.py | Python | apache-2.0 | 4,736 |
import lvgl as lv
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
images = [RESOURCES_ROOT + "FM.png",
RESOURCES_ROOT + "humidity.png",
RESOURCES_ROOT + "lux.png",
RESOURCES_ROOT + "distance.png",
RESOURCES_ROOT + "airpressure.png",
RESOURCES_ROOT + "hcho.png"]
titles = ["调频收音机",
"水质",
"光照",
"超声测距",
"气压",
"甲醛"]
def element_pressed_cb(e):
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0x39, 0x39, 0x39), 0)
def element_released_cb(e):
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0xf, 0xf, 0xf), 0)
def element_click_cb(e, name):
if (name == "FM"):
import page_fm
page_fm.load_page()
elif (name == "Humidity"):
import page_humidity
page_humidity.load_page()
elif (name == "Lux"):
import page_lux
page_lux.load_page()
elif (name == "Distance"):
import page_distance
page_distance.load_page()
elif (name == "Airpressure"):
import page_airpressure
page_airpressure.load_page()
elif (name == "Hcho"):
import page_hcho
page_hcho.load_page()
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 load_page():
scr = lv.obj()
scr.set_style_bg_color(lv.color_black(), 0)
# init grid layout
col_dsc = [89, 89, 89, 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(20, 0)
gridLayout.set_style_pad_right(20, 0)
gridLayout.set_style_pad_top(9, 0)
gridLayout.set_style_pad_bottom(8, 0)
gridLayout.set_layout(lv.LAYOUT_GRID.value)
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: 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)
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)
img=lv.img(element)
img.set_src(images[i])
label = lv.label(element)
font_Alibaba_PuHuiTi.set_text_size(label, 13)
label.set_text(titles[i])
label.set_style_text_color(lv.color_make(0xcc, 0xcc, 0xcc), 0)
label.align_to(img, lv.ALIGN.OUT_BOTTOM_MID, 0, 0)
if (titles[i] == "调频收音机"):
element.add_event_cb(lambda e: element_click_cb(e, "FM"), lv.EVENT.CLICKED, None)
elif (titles[i] == "水质"):
element.add_event_cb(lambda e: element_click_cb(e, "Humidity"), lv.EVENT.CLICKED, None)
elif (titles[i] == "光照"):
element.add_event_cb(lambda e: element_click_cb(e, "Lux"), lv.EVENT.CLICKED, None)
elif (titles[i] == "超声测距"):
element.add_event_cb(lambda e: element_click_cb(e, "Distance"), lv.EVENT.CLICKED, None)
elif (titles[i] == "气压"):
element.add_event_cb(lambda e: element_click_cb(e, "Airpressure"), lv.EVENT.CLICKED, None)
elif (titles[i] == "甲醛"):
element.add_event_cb(lambda e: element_click_cb(e, "Hcho"), lv.EVENT.CLICKED, None)
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_sensors2.py | Python | apache-2.0 | 4,736 |
import lvgl as lv
from driver import TIMER
RESOURCES_ROOT = "S:/data/pyamp/images/"
images = [RESOURCES_ROOT + "wifi.png",
RESOURCES_ROOT + "bluetooth.png",
RESOURCES_ROOT + "brightness.png",
RESOURCES_ROOT + "about.png"]
titles = ["Wi-Fi",
"Bluetooth",
"Brightness",
"About"]
wifiImg = None
btImg = None
wifiSwitch = False
btSwitch = False
tim0 = None
def oneshot_callback(args):
global tim0
tim0.stop()
tim0.close()
import page_scan
page_scan.load_page()
def switch_click_callback(e, para):
global wifiImg
global btImg
global wifiSwitch
global btSwitch
global tim0
print("params: ", para)
if (para == "wifi"):
if (wifiSwitch == False):
wifiSwitch = True
wifiImg.set_src(RESOURCES_ROOT + "on.png")
tim0 = TIMER(0)
tim0.open(mode=tim0.ONE_SHOT, period=1000, callback=oneshot_callback)
tim0.start()
else:
wifiSwitch = False
wifiImg.set_src(RESOURCES_ROOT + "off.png")
elif (para == "about"):
import page_about
page_about.load_page()
else:
if (btSwitch == False):
btSwitch = True
btImg.set_src(RESOURCES_ROOT + "on.png")
else:
btSwitch = False
btImg.set_src(RESOURCES_ROOT + "off.png")
def element_pressed_cb(e):
print("back pressed")
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0x39, 0x39, 0x39), 0)
def element_released_cb(e):
print("back released")
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0xf, 0xf, 0xf), 0)
def element_click_callback(e, name):
import page_haas
page_haas.load_page()
def load_page():
global wifiImg
global btImg
global wifiSwitch
global wifiSwitch
scr = lv.obj()
scr.set_style_bg_color(lv.color_black(), 0)
# init grid layout
col_dsc = [20, 50, 150, scr.get_width()-225, lv.GRID_TEMPLATE.LAST]
row_dsc = [54, 54, 54, 54, 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(0, 0)
gridLayout.set_style_pad_right(0, 0)
gridLayout.set_style_pad_top(3, 0)
gridLayout.set_style_pad_bottom(3, 0)
gridLayout.set_layout(lv.LAYOUT_GRID.value)
gridLayout.align(lv.ALIGN.RIGHT_MID, 0, 0)
for i in range(16):
col = i % 4 # 列
row = i // 4 # 行
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_radius(0, 0)
if (col == 0):
element.set_style_bg_color(lv.color_black(), 0)
element.set_grid_cell(lv.GRID_ALIGN.STRETCH, 0, 1, lv.GRID_ALIGN.STRETCH, 1, 2)
backImg=lv.img(element)
backImg.set_src(RESOURCES_ROOT + "back.png")
backImg.align(lv.ALIGN.CENTER, 0, 0)
backImg.add_flag(lv.obj.FLAG.CLICKABLE)
backImg.set_ext_click_area(20)
backImg.add_event_cb(element_pressed_cb, lv.EVENT.PRESSED, None)
backImg.add_event_cb(element_released_cb, lv.EVENT.RELEASED, None)
backImg.add_event_cb(lambda e: element_click_callback(e, scr), lv.EVENT.CLICKED, None)
else:
element.set_style_bg_color(lv.color_make(0xf, 0xf, 0xf), 0)
element.set_grid_cell(lv.GRID_ALIGN.STRETCH, col, 1, lv.GRID_ALIGN.STRETCH, row, 1)
if (col == 1):
img=lv.img(element)
img.set_src(images[row])
if (col == 2):
label = lv.label(scr)
label.set_text(titles[row])
label.set_style_text_color(lv.color_make(0xcc, 0xcc, 0xcc), 0)
label.set_style_text_font(lv.font_montserrat_18, 0)
label.align_to(element, lv.ALIGN.LEFT_MID, 0, 0)
if (row == 3):
element.add_event_cb(lambda e: switch_click_callback(e, "about"), lv.EVENT.CLICKED, None)
if (col == 3):
if (row == 0):
wifiImg=lv.img(element)
if (wifiSwitch == False):
wifiImg.set_src(RESOURCES_ROOT + "off.png")
else:
wifiImg.set_src(RESOURCES_ROOT + "on.png")
wifiImg.set_zoom(220)
wifiImg.align(lv.ALIGN.CENTER, 0, 0)
wifiImg.add_flag(lv.obj.FLAG.CLICKABLE)
wifiImg.add_event_cb(lambda e: switch_click_callback(e, "wifi"), lv.EVENT.CLICKED, None)
wifiImg.set_ext_click_area(20)
if (row == 1):
btImg=lv.img(element)
if (btSwitch == False):
btImg.set_src(RESOURCES_ROOT + "off.png")
else:
btImg.set_src(RESOURCES_ROOT + "on.png")
btImg.set_zoom(220)
btImg.align(lv.ALIGN.CENTER, 0, 0)
btImg.add_flag(lv.obj.FLAG.CLICKABLE)
btImg.add_event_cb(lambda e: switch_click_callback(e, "bt"), lv.EVENT.CLICKED, None)
btImg.set_ext_click_area(20)
if (row == 2):
label = lv.label(element)
label.set_text('65%')
label.set_style_text_color(lv.color_make(0xcc, 0xcc, 0xcc), 0)
label.set_style_text_font(lv.font_montserrat_20, 0)
label.align(lv.ALIGN.RIGHT_MID, 0, 0)
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_settings.py | Python | apache-2.0 | 5,979 |
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
slider_label = None
def back_click_callback(e, win):
import page_basic
page_basic.load_page()
def slider_event_cb(e):
global slider_label
slider = e.get_target()
slider_label.set_text("{:d}%".format(slider.get_value()))
slider_label.align_to(slider, lv.ALIGN.OUT_BOTTOM_MID, 0, 10)
def load_page():
global slider_label
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)
# Create a slider in the center of the display
slider = lv.slider(scr)
slider.center()
slider.add_event_cb(slider_event_cb, lv.EVENT.VALUE_CHANGED, None)
# Create a label below the slider
slider_label = lv.label(scr)
slider_label.set_text("0%")
slider_label.align_to(slider, lv.ALIGN.OUT_BOTTOM_MID, 0, 10)
# 将控件显示在屏幕上
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_slider.py | Python | apache-2.0 | 1,167 |
import lvgl as lv
from aliyunIoT import Device
import _thread
import ujson as json
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
IMAGE_NAME = "plate.jpg"
label11 = None
label22 = None
device = None
def element_pressed_cb(e):
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0x39, 0x39, 0x39), 0)
def element_released_cb(e):
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0xf, 0xf, 0xf), 0)
def backImg_click_callback(e, win):
import page_haas
page_haas.load_page()
def nextImg_click_callback(e, win):
import page_haas
page_haas.load_page()
def __cb_lk_service(data):
global label11
global label22
if data != None :
params = json.loads(data['params'])
ext = json.loads(params['ext'])
print("confidence: ", ext['confidence'])
print("plateNumber: ", ext['plateNumber'])
print("plateType: ", ext['plateType'])
label11.set_text(ext['plateNumber'])
label22.set_text(ext['plateType'])
def ai_recognition():
global device
if (device == None):
device = Device()
ret = device.default(__cb_lk_service)
if (ret == -1):
print("otaput connection not existed, please check it.")
return
fileName = IMAGE_NAME
file = open("/data/pyamp/images/" + IMAGE_NAME)
frame = file.read()
fileid = device.uploadContent(fileName, frame, None)
file.close()
if fileid != None:
ext = { 'filePosition':'lp', 'fileName': fileName, 'fileId': fileid }
ext_str = json.dumps(ext)
all_params = {'id': 1, 'version': '1.0', 'params': { 'eventType': 'haas.faas', 'eventName': "ocrCarNo", 'argInt': 1, 'ext': ext_str }}
all_params_str = json.dumps(all_params)
print(all_params_str)
upload_file = {
'topic': '/sys/' + 'xxx' + '/' + 'xxx' + '/thing/event/hli_event/post',
'qos': 1,
'payload': all_params_str
}
# 上传完成通知HaaS聚合平台
print('upload--->' + str(upload_file))
device.publish(upload_file)
else:
print('filedid is none, upload content fail')
def load_page():
global label11
global label22
global thread_id
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)
img = lv.img(scr)
img.set_src(RESOURCES_ROOT + IMAGE_NAME)
img.set_style_align(lv.ALIGN.TOP_MID, 0)
img.set_size(280, 180)
label1 = lv.label(scr)
font_Alibaba_PuHuiTi.set_text_size(label1, 16)
label1.set_text("车牌:")
label1.set_style_text_color(lv.color_white(), 0)
label1.align_to(img, lv.ALIGN.OUT_BOTTOM_LEFT, 10, 20)
label11 = lv.label(scr)
font_Alibaba_PuHuiTi.set_text_size(label11, 16)
label11.set_text("...")
label11.set_style_text_color(lv.color_white(), 0)
label11.align_to(label1, lv.ALIGN.OUT_RIGHT_MID, 5, 0)
label2 = lv.label(scr)
font_Alibaba_PuHuiTi.set_text_size(label2, 16)
label2.set_text("类型:")
label2.set_style_text_color(lv.color_white(), 0)
label2.align_to(img, lv.ALIGN.OUT_BOTTOM_LEFT, 160, 20)
label22 = lv.label(scr)
font_Alibaba_PuHuiTi.set_text_size(label22, 16)
label22.set_text("...")
label22.set_style_text_color(lv.color_white(), 0)
label22.align_to(label2, lv.ALIGN.OUT_RIGHT_MID, 5, 0)
# 将控件显示在屏幕上
lv.scr_load(scr)
_thread.stack_size(10 * 1024)
_thread.start_new_thread(ai_recognition, ())
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_solutions.py | Python | apache-2.0 | 3,767 |
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)
# Create span
style = lv.style_t()
style.init()
style.set_border_width(1)
style.set_border_color(lv.palette_main(lv.PALETTE.ORANGE))
style.set_pad_all(2)
spans = lv.spangroup(scr)
spans.set_width(300)
spans.set_height(200)
spans.center()
spans.add_style(style, 0)
spans.set_align(lv.TEXT_ALIGN.CENTER)
spans.set_overflow(lv.SPAN_OVERFLOW.CLIP)
spans.set_indent(20)
spans.set_mode(lv.SPAN_MODE.BREAK)
span = spans.new_span()
span.set_text("china is a beautiful country.")
span.style.set_text_color(lv.palette_main(lv.PALETTE.RED))
span.style.set_text_decor(lv.TEXT_DECOR.STRIKETHROUGH | lv.TEXT_DECOR.UNDERLINE)
span.style.set_text_opa(lv.OPA._30)
span = spans.new_span()
span.set_text_static("good good study, day day up.")
span.style.set_text_color(lv.palette_main(lv.PALETTE.GREEN))
span = spans.new_span()
span.set_text_static("LVGL is an open-source graphics library.")
span.style.set_text_color(lv.palette_main(lv.PALETTE.BLUE))
span = spans.new_span()
span.set_text_static("the boy no name.")
span.style.set_text_color(lv.palette_main(lv.PALETTE.GREEN))
span.style.set_text_decor(lv.TEXT_DECOR.UNDERLINE)
span = spans.new_span()
span.set_text("I have a dream that hope to come true.")
spans.refr_mode()
# 将控件显示在屏幕上
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_spans.py | Python | apache-2.0 | 1,925 |
import lvgl as lv
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
def event2_handler(evt):
code = evt.get_code()
ele = evt.get_target()
if code == lv.EVENT.CLICKED:
import page_haas
page_haas.load_page()
elif code == lv.EVENT.PRESSED:
ele.set_style_bg_color(lv.color_make(0x39, 0x39, 0x39), 0)
elif code == lv.EVENT.RELEASED:
ele.set_style_bg_color(lv.color_make(255, 106, 0), 0)
def load_page():
scr = lv.obj()
scr.set_style_bg_color(lv.color_make(20, 27, 31), 0)
loadImg =lv.img(scr)
loadImg.set_src(RESOURCES_ROOT + "success.png")
loadImg.align(lv.ALIGN.CENTER, 0, -50)
loadImg.set_zoom(100)
label1 = lv.label(scr)
label1.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label1, 20)
label1.set_text("#ffffff 设备连接激活成功 #")
label1.align_to(loadImg, lv.ALIGN.OUT_BOTTOM_MID, 0, -20)
# create a simple button
btn2 = lv.btn(scr)
btn2.add_event_cb(event2_handler,lv.EVENT.ALL, None)
btn2.align(lv.ALIGN.BOTTOM_MID, 0, -50)
btn2.set_style_bg_color(lv.color_make(255, 106, 0), 0)
btn2.set_style_border_color(lv.color_make(255, 106, 0), 0)
btn2.set_style_radius(10, 0)
label2=lv.label(btn2)
font_Alibaba_PuHuiTi.set_text_size(label2, 20)
label2.set_text("HaaSPython案例中心")
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_success.py | Python | apache-2.0 | 1,378 |
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(e):
code = e.get_code()
obj = e.get_target()
if code == lv.EVENT.VALUE_CHANGED:
if obj.has_state(lv.STATE.CHECKED):
print("State: on")
else:
print("State: off")
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)
scr.set_flex_flow(lv.FLEX_FLOW.COLUMN)
scr.set_flex_align(lv.FLEX_ALIGN.CENTER, lv.FLEX_ALIGN.CENTER, lv.FLEX_ALIGN.CENTER)
sw = lv.switch(scr)
sw.add_event_cb(event_handler,lv.EVENT.ALL, None)
sw = lv.switch(scr)
sw.add_state(lv.STATE.CHECKED)
sw.add_event_cb(event_handler, lv.EVENT.ALL, None)
sw = lv.switch(scr)
sw.add_state(lv.STATE.DISABLED)
sw.add_event_cb(event_handler, lv.EVENT.ALL, None)
sw = lv.switch(scr)
sw.add_state(lv.STATE.CHECKED | lv.STATE.DISABLED)
sw.add_event_cb(event_handler, lv.EVENT.ALL, None)
# 将控件显示在屏幕上
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_switch.py | Python | apache-2.0 | 1,385 |
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
def back_click_callback(e, win):
import page_basic
page_basic.load_page()
def draw_part_event_cb(e):
obj = e.get_target()
dsc = lv.obj_draw_part_dsc_t.__cast__(e.get_param())
# If the cells are drawn../
if dsc.part == lv.PART.ITEMS:
row = dsc.id // obj.get_col_cnt()
col = dsc.id - row * obj.get_col_cnt()
# Make the texts in the first cell center aligned
if row == 0:
dsc.label_dsc.align = lv.TEXT_ALIGN.CENTER
dsc.rect_dsc.bg_color = lv.palette_main(lv.PALETTE.BLUE).color_mix(dsc.rect_dsc.bg_color, lv.OPA._20)
dsc.rect_dsc.bg_opa = lv.OPA.COVER
# In the first column align the texts to the right
elif col == 0:
dsc.label_dsc.flag = lv.TEXT_ALIGN.RIGHT
# Make every 2nd row grayish
if row != 0 and (row % 2) == 0:
dsc.rect_dsc.bg_color = lv.palette_main(lv.PALETTE.GREY).color_mix(dsc.rect_dsc.bg_color, lv.OPA._10)
dsc.rect_dsc.bg_opa = lv.OPA.COVER
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)
table = lv.table(scr)
# Fill the first column
table.set_cell_value(0, 0, "Name")
table.set_cell_value(1, 0, "Apple")
table.set_cell_value(2, 0, "Banana")
table.set_cell_value(3, 0, "Lemon")
table.set_cell_value(4, 0, "Grape")
table.set_cell_value(5, 0, "Melon")
table.set_cell_value(6, 0, "Peach")
table.set_cell_value(7, 0, "Nuts")
# Fill the second column
table.set_cell_value(0, 1, "Price")
table.set_cell_value(1, 1, "$7")
table.set_cell_value(2, 1, "$4")
table.set_cell_value(3, 1, "$6")
table.set_cell_value(4, 1, "$2")
table.set_cell_value(5, 1, "$5")
table.set_cell_value(6, 1, "$1")
table.set_cell_value(7, 1, "$9")
# Set a smaller height to the table. It'll make it scrollable
table.set_height(200)
table.center()
# Add an event callback to apply some custom drawing
table.add_event_cb(draw_part_event_cb, lv.EVENT.DRAW_PART_BEGIN, None)
# 将控件显示在屏幕上
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_table.py | Python | apache-2.0 | 2,461 |
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)
# Create a Tab view object
tabview = lv.tabview(scr, lv.DIR.TOP, 50)
tabview.align(lv.ALIGN.CENTER, 0, 0)
tabview.set_size(280, 220)
# Add 3 tabs (the tabs are page (lv_page) and can be scrolled
tab1 = tabview.add_tab("Tab 1")
tab2 = tabview.add_tab("Tab 2")
tab3 = tabview.add_tab("Tab 3")
# Add content to the tabs
label = lv.label(tab1)
label.set_text("""This the first tab
If the content
of a tab
becomes too
longer
than the
container
then it
automatically
becomes
scrollable.
Can you see it?""")
label = lv.label(tab2)
label.set_text("Second tab")
label = lv.label(tab3)
label.set_text("Third tab");
label.scroll_to_view_recursive(lv.ANIM.ON)
# 将控件显示在屏幕上
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_tabview.py | Python | apache-2.0 | 1,294 |
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 temperature import Temperature
temperature = Temperature(scr)
temperature.setValue(25)
temperature.setXY(0, 0)
a1 = lv.anim_t()
a1.init()
a1.set_var(temperature)
a1.set_custom_exec_cb(lambda a,val: set_xy(temperature, 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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_temperature.py | Python | apache-2.0 | 1,416 |
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 waterlevel import Waterlevel
waterlevel = Waterlevel(scr)
waterlevel.setValue(2.6)
waterlevel.setXY(0, 0)
a1 = lv.anim_t()
a1.init()
a1.set_var(waterlevel)
a1.set_custom_exec_cb(lambda a,val: set_xy(waterlevel, 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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_waterlevel.py | Python | apache-2.0 | 1,408 |
import lvgl as lv
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
def element_pressed_cb(e):
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0x39, 0x39, 0x39), 0)
def element_released_cb(e):
ele = e.get_target()
ele.set_style_bg_color(lv.color_make(0xf, 0xf, 0xf), 0)
def element_click_callback(e, name):
import page_scan
page_scan.load_page()
def load_page():
scr = lv.obj()
scr.set_style_bg_color(lv.color_make(20, 27, 31), 0)
label1 = lv.label(scr)
label1.set_recolor(True) # Enable re-coloring by commands in the text
font_Alibaba_PuHuiTi.set_text_size(label1, 38)
label1.set_text("欢迎使用HaaS")
label1.set_style_text_color(lv.color_make(0xff, 0xff, 0xff), 0)
label1.align(lv.ALIGN.CENTER, 0, -60)
label2 = lv.label(scr)
label2.set_recolor(True) # Enable re-coloring by commands in the text
font_Alibaba_PuHuiTi.set_text_size(label2, 16)
label2.set_text("请先连接网络激活设备")
label2.set_style_text_color(lv.color_make(0xff, 0xff, 0xff), 0)
label2.align(lv.ALIGN.CENTER, 0, -20)
nextImg=lv.img(scr)
nextImg.set_src(RESOURCES_ROOT + "next.png")
nextImg.align(lv.ALIGN.CENTER, 0, 60)
nextImg.add_flag(lv.obj.FLAG.CLICKABLE)
nextImg.add_event_cb(element_pressed_cb, lv.EVENT.PRESSED, None)
nextImg.add_event_cb(element_released_cb, lv.EVENT.RELEASED, None)
nextImg.add_event_cb(lambda e: element_click_callback(e, scr), lv.EVENT.CLICKED, None)
nextImg.set_zoom(150)
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_welcome.py | Python | apache-2.0 | 1,598 |
import lvgl as lv
import kv
import wifi_module
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
wifiImg = [RESOURCES_ROOT + "wifi0.png",
RESOURCES_ROOT + "wifi1.png",
RESOURCES_ROOT + "wifi2.png",
RESOURCES_ROOT + "wifi3.png"]
rssi = [3, 2, 1, 0]
ssidInfoList = [[0, "其他...", False, False],
[0, "其他...", False, False],
[0, "其他...", False, False],
[0, "其他...", False, False],
[0, "其他...", False, False]]
elementList = [None, None, None, None, None]
def element_pressed_cb(e, row):
global elementList
element = elementList[row]
element.set_style_bg_color(lv.color_make(0x39, 0x39, 0x39), 0)
def element_released_cb(e, row):
global elementList
element = elementList[row]
element.set_style_bg_color(lv.color_make(52, 63, 80), 0)
def element_click_callback(e, name):
print("intent: ", name)
if (name == "back"):
import page_scan
page_scan.load_page()
elif (name == "skip"):
import page_haas
page_haas.load_page()
elif (name == "其他..."):
import page_wifi3
page_wifi3.load_page()
else:
import page_wifi2
page_wifi2.load_page(name)
def load_page(ap_list, num):
global elementList
scr = lv.obj()
scr.set_style_bg_color(lv.color_make(20, 27, 31), 0)
rtnImg =lv.img(scr)
rtnImg.set_src(RESOURCES_ROOT + "return.png")
rtnImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
rtnImg.add_flag(lv.obj.FLAG.CLICKABLE)
rtnImg.add_event_cb(lambda e: element_click_callback(e, "back"), lv.EVENT.CLICKED, None)
rtnImg.set_zoom(150)
label1 = lv.label(scr)
label1.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label1, 22)
label1.set_text("#ffffff Wi-Fi #")
label1.align_to(rtnImg, lv.ALIGN.OUT_RIGHT_MID, 0, 0)
# label1.align(lv.ALIGN.TOP_LEFT, 50, 13)
# create a simple button
obj = lv.obj(scr)
obj.set_size(70, 50)
obj.set_style_bg_color(lv.color_make(20, 27, 31), 0)
obj.set_style_border_color(lv.color_make(20, 27, 31), 0)
obj.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
obj.clear_flag(lv.obj.FLAG.SCROLLABLE)
obj.align(lv.ALIGN.TOP_RIGHT, -10, -5)
obj.add_event_cb(lambda e: element_click_callback(e, "skip"), lv.EVENT.CLICKED, None)
obj.add_flag(lv.obj.FLAG.CLICKABLE)
obj.set_ext_click_area(50)
label2 = lv.label(obj)
label2.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label2, 22)
label2.set_text("#ffffff 跳过 #")
col_dsc = [300, lv.GRID_TEMPLATE.LAST]
row_dsc = [30, 30, 30, 30, 30, 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(306, 180)
gridLayout.set_style_pad_left(0, 0)
gridLayout.set_style_pad_right(0, 0)
gridLayout.set_style_pad_top(3, 0)
gridLayout.set_style_pad_bottom(3, 0)
gridLayout.align(lv.ALIGN.BOTTOM_MID, 0, -10)
gridLayout.set_layout(lv.LAYOUT_GRID.value)
last_ssid = kv.get('_amp_wifi_ssid')
for i in range(num + 1):
col = 0 # 列
row = i # 行
element = lv.obj(gridLayout)
elementList[i] = element
element.set_style_border_opa(0, 0)
element.set_style_bg_color(lv.color_make(52, 63, 80), 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_radius(10, 0)
element.set_grid_cell(lv.GRID_ALIGN.STRETCH, col, 1, lv.GRID_ALIGN.STRETCH, row, 1)
if (row < num):
# ssid
ssidInfoList[row][1] = bytes.decode(ap_list[i][0])
# auth mode: 0 (open mode), 1 (wep mode), 2 (wpa), 3 (wpa2), 4 (wpa_wpa2), 5 (enterprise)
if (ap_list[i][4] == 0):
ssidInfoList[row][3] = False
else:
ssidInfoList[row][3] = True
# rssi
if (ap_list[i][3] > -80):
ssidInfoList[row][0] = 3
elif (ap_list[i][3] > -85):
ssidInfoList[row][0] = 2
elif (ap_list[i][3] > -90):
ssidInfoList[row][0] = 1
else:
ssidInfoList[row][0] = 0
print("-- AP: ", row)
print(" -- ssid: ", ssidInfoList[row][1])
print(" -- power: ", ssidInfoList[row][0])
print(" -- security: ", ssidInfoList[row][3])
if wifi_module.is_wifi_connected() and (last_ssid == ssidInfoList[row][1]):
ssidInfoList[row][2] = True
else:
ssidInfoList[row][2] = False
if (row == 0):
element.add_event_cb(lambda e: element_pressed_cb(e, 0), lv.EVENT.PRESSED, None)
element.add_event_cb(lambda e: element_released_cb(e, 0), lv.EVENT.RELEASED, None)
element.add_event_cb(lambda e: element_click_callback(e, ssidInfoList[0][1]), lv.EVENT.CLICKED, None)
elif (row == 1):
element.add_event_cb(lambda e: element_pressed_cb(e, 1), lv.EVENT.PRESSED, None)
element.add_event_cb(lambda e: element_released_cb(e, 1), lv.EVENT.RELEASED, None)
element.add_event_cb(lambda e: element_click_callback(e, ssidInfoList[1][1]), lv.EVENT.CLICKED, None)
elif (row == 2):
element.add_event_cb(lambda e: element_pressed_cb(e, 2), lv.EVENT.PRESSED, None)
element.add_event_cb(lambda e: element_released_cb(e, 2), lv.EVENT.RELEASED, None)
element.add_event_cb(lambda e: element_click_callback(e, ssidInfoList[2][1]), lv.EVENT.CLICKED, None)
elif (row == 3):
element.add_event_cb(lambda e: element_pressed_cb(e, 3), lv.EVENT.PRESSED, None)
element.add_event_cb(lambda e: element_released_cb(e, 3), lv.EVENT.RELEASED, None)
element.add_event_cb(lambda e: element_click_callback(e, ssidInfoList[3][1]), lv.EVENT.CLICKED, None)
elif (row == 4):
element.add_event_cb(lambda e: element_pressed_cb(e, 4), lv.EVENT.PRESSED, None)
element.add_event_cb(lambda e: element_released_cb(e, 4), lv.EVENT.RELEASED, None)
element.add_event_cb(lambda e: element_click_callback(e, ssidInfoList[4][1]), lv.EVENT.CLICKED, None)
# wifi signal
img0=lv.img(scr)
img0.set_src(wifiImg[ssidInfoList[row][0]])
img0.align_to(element, lv.ALIGN.LEFT_MID, -10, 0)
img0.set_zoom(120)
# ssid name
label = lv.label(scr)
font_Alibaba_PuHuiTi.set_text_size(label, 16)
label.set_text(ssidInfoList[row][1])
label.set_style_text_color(lv.color_make(0xcc, 0xcc, 0xcc), 0)
label.align_to(element, lv.ALIGN.LEFT_MID, 35, 0)
# wifi select
if (ssidInfoList[row][2] == True):
img1 =lv.img(scr)
img1.set_src(RESOURCES_ROOT + "correct.png")
img1.align_to(element, lv.ALIGN.RIGHT_MID, -25, 0)
img1.set_zoom(120)
# wifi secure
if (ssidInfoList[row][3] == True):
img2 =lv.img(scr)
img2.set_src(RESOURCES_ROOT + "lock.png")
img2.align_to(element, lv.ALIGN.RIGHT_MID, 10, 0)
img2.set_zoom(120)
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_wifi0.py | Python | apache-2.0 | 7,630 |
import lvgl as lv
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
wifiImg = [RESOURCES_ROOT + "wifi0.png",
RESOURCES_ROOT + "wifi1.png",
RESOURCES_ROOT + "wifi2.png",
RESOURCES_ROOT + "wifi3.png"]
rssi = [3, 2, 1, 0]
ssidInfoList = [[3, "alibaba-inc", False, True],
[3, "alibaba-guest", False, True],
[2, "HaaS-IoT", False, True],
[1, "CMCC-P4re", True, True],
[0, "其他...", False, False]]
elementList = [None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None]
def element_pressed_cb(e, row):
global elementList
for i in range(4):
element = elementList[row * 4 + i]
element.set_style_bg_color(lv.color_make(0x39, 0x39, 0x39), 0)
def element_released_cb(e, row):
global elementList
for i in range(4):
element = elementList[row * 4 + i]
element.set_style_bg_color(lv.color_make(52, 63, 80), 0)
def element_click_callback(e, name):
print("intent: ", name)
if (name == "back"):
import page_welcome
page_welcome.load_page()
elif (name == "skip"):
import page_welcome
page_welcome.load_page()
elif (name == "其他..."):
import page_wifi3
page_wifi3.load_page()
else:
import page_wifi2
page_wifi2.load_page(name)
def set_angle(img, v):
img.set_angle(v)
def load_page():
global elementList
scr = lv.obj()
scr.set_style_bg_color(lv.color_make(20, 27, 31), 0)
rtnImg =lv.img(scr)
rtnImg.set_src(RESOURCES_ROOT + "return.png")
rtnImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
rtnImg.add_flag(lv.obj.FLAG.CLICKABLE)
rtnImg.add_event_cb(lambda e: element_click_callback(e, "back"), lv.EVENT.CLICKED, None)
rtnImg.set_zoom(150)
label1 = lv.label(scr)
label1.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label1, 22)
label1.set_text("#ffffff Wi-Fi #")
label1.align_to(rtnImg, lv.ALIGN.OUT_RIGHT_MID, 0, 0)
# label1.align(lv.ALIGN.TOP_LEFT, 50, 13)
# create a simple button
obj = lv.obj(scr)
obj.set_size(70, 50)
obj.set_style_bg_color(lv.color_make(20, 27, 31), 0)
obj.set_style_border_color(lv.color_make(20, 27, 31), 0)
obj.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
obj.clear_flag(lv.obj.FLAG.SCROLLABLE)
obj.align(lv.ALIGN.TOP_RIGHT, -10, -5)
obj.add_flag(lv.obj.FLAG.CLICKABLE)
obj.set_ext_click_area(50)
obj.add_event_cb(lambda e: element_click_callback(e, "skip"), lv.EVENT.CLICKED, None)
label2 = lv.label(obj)
label2.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label2, 22)
label2.set_text("#ffffff 跳过 #")
loadImg =lv.img(scr)
loadImg.set_src(RESOURCES_ROOT + "loading.png")
loadImg.align(lv.ALIGN.TOP_MID, 0, 25)
loadImg.set_zoom(120)
a1 = lv.anim_t()
a1.init()
a1.set_var(loadImg)
a1.set_custom_exec_cb(lambda a,val: set_angle(loadImg,val))
a1.set_values(0, 3600)
a1.set_time(2000)
a1.set_repeat_count(lv.ANIM_REPEAT.INFINITE)
lv.anim_t.start(a1)
col_dsc = [40, 185, 40, 40, lv.GRID_TEMPLATE.LAST]
row_dsc = [30, 30, 30, 30, 30, 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(310, 175)
gridLayout.set_style_pad_left(0, 0)
gridLayout.set_style_pad_right(0, 0)
gridLayout.set_style_pad_top(3, 0)
gridLayout.set_style_pad_bottom(3, 0)
# gridLayout.align_to(loadImg, lv.ALIGN.OUT_BOTTOM_MID, 0, 0)
gridLayout.align(lv.ALIGN.BOTTOM_MID, 3, 0)
gridLayout.set_layout(lv.LAYOUT_GRID.value)
# gridLayout.align(lv.ALIGN.RIGHT_MID, 0, 0)
# gridLayout.set_size(scr.get_width(), scr.get_height())
for i in range(20):
col = i % 4 # 列
row = i // 4 # 行
element = lv.obj(gridLayout)
elementList[i] = element
element.set_style_border_opa(0, 0)
element.set_style_bg_color(lv.color_make(52, 63, 80), 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_radius(0, 0)
element.set_grid_cell(lv.GRID_ALIGN.STRETCH, col, 1, lv.GRID_ALIGN.STRETCH, row, 1)
if (col == 0):
img=lv.img(element)
img.set_src(wifiImg[ssidInfoList[row][0]])
img.align(lv.ALIGN.CENTER, 0, 0)
img.set_zoom(120)
if (col == 1):
label = lv.label(scr)
font_Alibaba_PuHuiTi.set_text_size(label, 16)
label.set_text(ssidInfoList[row][1])
label.set_style_text_color(lv.color_make(0xcc, 0xcc, 0xcc), 0)
label.align_to(element, lv.ALIGN.LEFT_MID, 0, 0)
if (row == 0):
element.add_event_cb(lambda e: element_pressed_cb(e, 0), lv.EVENT.PRESSED, None)
element.add_event_cb(lambda e: element_released_cb(e, 0), lv.EVENT.RELEASED, None)
element.add_event_cb(lambda e: element_click_callback(e, ssidInfoList[0][1]), lv.EVENT.CLICKED, None)
elif (row == 1):
element.add_event_cb(lambda e: element_pressed_cb(e, 1), lv.EVENT.PRESSED, None)
element.add_event_cb(lambda e: element_released_cb(e, 1), lv.EVENT.RELEASED, None)
element.add_event_cb(lambda e: element_click_callback(e, ssidInfoList[1][1]), lv.EVENT.CLICKED, None)
elif (row == 2):
element.add_event_cb(lambda e: element_pressed_cb(e, 2), lv.EVENT.PRESSED, None)
element.add_event_cb(lambda e: element_released_cb(e, 2), lv.EVENT.RELEASED, None)
element.add_event_cb(lambda e: element_click_callback(e, ssidInfoList[2][1]), lv.EVENT.CLICKED, None)
elif (row == 3):
element.add_event_cb(lambda e: element_pressed_cb(e, 3), lv.EVENT.PRESSED, None)
element.add_event_cb(lambda e: element_released_cb(e, 3), lv.EVENT.RELEASED, None)
element.add_event_cb(lambda e: element_click_callback(e, ssidInfoList[3][1]), lv.EVENT.CLICKED, None)
elif (row == 4):
element.add_event_cb(lambda e: element_pressed_cb(e, 4), lv.EVENT.PRESSED, None)
element.add_event_cb(lambda e: element_released_cb(e, 4), lv.EVENT.RELEASED, None)
element.add_event_cb(lambda e: element_click_callback(e, ssidInfoList[4][1]), lv.EVENT.CLICKED, None)
if (col == 2):
if (ssidInfoList[row][2] == True):
img=lv.img(element)
img.set_src(RESOURCES_ROOT + "correct.png")
img.align(lv.ALIGN.CENTER, 0, 0)
img.set_zoom(120)
if (col == 3):
if (ssidInfoList[row][3] == True):
img=lv.img(element)
img.set_src(RESOURCES_ROOT + "lock.png")
img.align(lv.ALIGN.CENTER, 0, 0)
img.set_zoom(120)
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_wifi1.py | Python | apache-2.0 | 7,417 |
import lvgl as lv
import kv
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
hidenImg = None
hiden = False
wifiSSID = ""
wifiPswd = ""
def element_click_callback(e, name):
if (name == "back"):
import page_scan
page_scan.load_page()
elif (name == "correct"):
if (wifiSSID != "" and wifiPswd != ""):
import page_connect
page_connect.load_page(wifiSSID, wifiPswd)
def ta_event_cb(e, kb):
global wifiPswd
code = e.get_code()
ta = e.get_target()
if (code == lv.EVENT.VALUE_CHANGED or code == lv.EVENT.READY):
wifiPswd = ta.get_text()
def hiden_event_cb(e, ta):
global hiden
global hidenImg
if hiden == True:
hiden = False
hidenImg.set_src(RESOURCES_ROOT + "visable.png")
else:
hiden = True
hidenImg.set_src(RESOURCES_ROOT + "hiden.png")
ta.set_password_mode(hiden)
print("hiden: ", hiden)
def load_page(ssid):
global hiden
global hidenImg
global wifiSSID
wifiSSID = ssid
scr = lv.obj()
scr.set_style_bg_color(lv.color_make(20, 27, 31), 0)
closeImg =lv.img(scr)
closeImg.set_src(RESOURCES_ROOT + "close.png")
closeImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
closeImg.add_flag(lv.obj.FLAG.CLICKABLE)
closeImg.add_event_cb(lambda e: element_click_callback(e, "back"), lv.EVENT.CLICKED, None)
closeImg.set_zoom(120)
closeImg.add_flag(lv.obj.FLAG.CLICKABLE)
label1 = lv.label(scr)
label1.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label1, 22)
label1.set_text("#ffffff 输入Wi-Fi密码 #")
label1.align_to(closeImg, lv.ALIGN.OUT_RIGHT_MID, 0, 0)
choseImg =lv.img(scr)
choseImg.set_src(RESOURCES_ROOT + "correct.png")
choseImg.align(lv.ALIGN.TOP_RIGHT, 0, 8)
choseImg.add_flag(lv.obj.FLAG.CLICKABLE)
choseImg.add_event_cb(lambda e: element_click_callback(e, "correct"), lv.EVENT.CLICKED, None)
choseImg.set_zoom(180)
choseImg.add_flag(lv.obj.FLAG.CLICKABLE)
kb = lv.keyboard(scr)
kb.align(lv.ALIGN.BOTTOM_MID, 0, 0)
kb.set_width(318)
kb.set_height(120)
kb.set_style_bg_color(lv.color_make(0, 0, 0), 0)
ta = lv.textarea(scr)
ta.set_width(300)
ta.set_height(40)
ta.align(lv.ALIGN.TOP_MID, 0, 60)
ta.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
ta.clear_flag(lv.obj.FLAG.SCROLLABLE)
ta.set_password_mode(hiden)
# ta.set_one_line(True)
ta.set_password_show_time(200) # 200ms
ta.add_event_cb(lambda e: ta_event_cb(e,kb), lv.EVENT.ALL, None)
ta.set_style_bg_color(lv.color_make(52, 63, 80), 0)
ta.set_style_border_color(lv.color_make(52, 63, 80), 0)
if (ssid == kv.get('_amp_wifi_ssid')):
ta.set_text(kv.get('_amp_wifi_passwd'))
kb.set_textarea(ta)
hidenImg =lv.img(ta)
if (hiden):
hidenImg.set_src(RESOURCES_ROOT + "hiden.png")
else:
hidenImg.set_src(RESOURCES_ROOT + "visable.png")
hidenImg.align_to(ta, lv.ALIGN.RIGHT_MID, 0, 0)
# delImg.align(lv.ALIGN.TOP_RIGHT, 50, 8)
hidenImg.add_flag(lv.obj.FLAG.CLICKABLE)
hidenImg.add_event_cb(lambda e: hiden_event_cb(e, ta), lv.EVENT.CLICKED, None)
hidenImg.set_zoom(150)
hidenImg.add_flag(lv.obj.FLAG.CLICKABLE)
hidenImg.set_ext_click_area(20)
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_wifi2.py | Python | apache-2.0 | 3,304 |
import lvgl as lv
import font_Alibaba_PuHuiTi
RESOURCES_ROOT = "S:/data/pyamp/images/"
hidenImg = None
hiden = False
wifiSSID = ""
wifiPswd = ""
def element_click_callback(e, name):
if (name == "back"):
import page_scan
page_scan.load_page()
elif (name == "correct"):
if (wifiSSID != "" and wifiPswd != ""):
import page_connect
page_connect.load_page(wifiSSID, wifiPswd)
def ta1_event_cb(e, kb):
global wifiSSID
code = e.get_code()
ta = e.get_target()
if (code == lv.EVENT.VALUE_CHANGED or code == lv.EVENT.READY):
wifiSSID = ta.get_text()
elif (code == lv.EVENT.FOCUSED):
kb.set_textarea(ta)
elif (code == lv.EVENT.DEFOCUSED):
kb.set_textarea(None)
def ta3_event_cb(e, kb):
global wifiPswd
code = e.get_code()
ta = e.get_target()
if (code == lv.EVENT.VALUE_CHANGED or code == lv.EVENT.READY):
wifiPswd = ta.get_text()
elif (code == lv.EVENT.FOCUSED):
kb.set_textarea(ta)
elif (code == lv.EVENT.DEFOCUSED):
kb.set_textarea(None)
def hiden_event_cb(e, ta):
global hiden
global hidenImg
if hiden == True:
hiden = False
hidenImg.set_src(RESOURCES_ROOT + "visable.png")
else:
hiden = True
hidenImg.set_src(RESOURCES_ROOT + "hiden.png")
ta.set_password_mode(hiden)
print("hiden: ", hiden)
def load_page():
global hidenImg
scr = lv.obj()
scr.set_style_bg_color(lv.color_make(20, 27, 31), 0)
closeImg =lv.img(scr)
closeImg.set_src(RESOURCES_ROOT + "close.png")
closeImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
closeImg.add_flag(lv.obj.FLAG.CLICKABLE)
closeImg.add_event_cb(lambda e: element_click_callback(e, "back"), lv.EVENT.CLICKED, None)
closeImg.set_zoom(120)
closeImg.add_flag(lv.obj.FLAG.CLICKABLE)
label1 = lv.label(scr)
label1.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label1, 22)
label1.set_text("#ffffff 其他网络 #")
label1.align_to(closeImg, lv.ALIGN.OUT_RIGHT_MID, -5, 0)
choseImg =lv.img(scr)
choseImg.set_src(RESOURCES_ROOT + "correct.png")
choseImg.align(lv.ALIGN.TOP_RIGHT, 0, 8)
choseImg.add_flag(lv.obj.FLAG.CLICKABLE)
choseImg.add_event_cb(lambda e: element_click_callback(e, "correct"), lv.EVENT.CLICKED, None)
choseImg.set_zoom(180)
closeImg.add_flag(lv.obj.FLAG.CLICKABLE)
kb = lv.keyboard(scr)
kb.align(lv.ALIGN.BOTTOM_MID, 0, 0)
kb.set_width(318)
kb.set_height(110)
kb.set_style_bg_color(lv.color_make(0, 0, 0), 0)
ta0 = lv.textarea(scr)
ta0.set_width(60)
ta0.set_height(35)
ta0.align(lv.ALIGN.TOP_LEFT, 10, 45)
ta0.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
ta0.clear_flag(lv.obj.FLAG.SCROLLABLE)
ta0.set_style_bg_color(lv.color_make(52, 63, 80), 0)
ta0.set_style_border_color(lv.color_make(52, 63, 80), 0)
label2 = lv.label(scr)
label2.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label2, 16)
label2.set_text("#ffffff 账号: #")
label2.align_to(ta0, lv.ALIGN.CENTER, 0, 0)
ta1 = lv.textarea(scr)
ta1.set_width(250)
ta1.set_height(35)
ta1.align_to(ta0, lv.ALIGN.OUT_RIGHT_MID, -10, 0)
ta1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
ta1.clear_flag(lv.obj.FLAG.SCROLLABLE)
ta1.add_event_cb(lambda e: ta1_event_cb(e,kb), lv.EVENT.ALL, None)
ta1.set_style_bg_color(lv.color_make(52, 63, 80), 0)
ta1.set_style_border_color(lv.color_make(52, 63, 80), 0)
ta2 = lv.textarea(scr)
ta2.set_width(60)
ta2.set_height(35)
ta2.align(lv.ALIGN.TOP_LEFT, 10, 85)
ta2.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
ta2.clear_flag(lv.obj.FLAG.SCROLLABLE)
ta2.set_style_bg_color(lv.color_make(52, 63, 80), 0)
ta2.set_style_border_color(lv.color_make(52, 63, 80), 0)
label3 = lv.label(scr)
label3.set_recolor(True)
font_Alibaba_PuHuiTi.set_text_size(label3, 16)
label3.set_text("#ffffff 密码: #")
label3.align_to(ta2, lv.ALIGN.CENTER, 0, 0)
ta3 = lv.textarea(scr)
ta3.set_width(250)
ta3.set_height(35)
ta3.align_to(ta2, lv.ALIGN.OUT_RIGHT_MID, -10, 0)
ta3.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
ta3.clear_flag(lv.obj.FLAG.SCROLLABLE)
ta3.set_password_mode(True)
ta3.set_password_show_time(500) # 500ms
ta3.add_event_cb(lambda e: ta3_event_cb(e,kb), lv.EVENT.ALL, None)
ta3.set_style_bg_color(lv.color_make(52, 63, 80), 0)
ta3.set_style_border_color(lv.color_make(52, 63, 80), 0)
hidenImg =lv.img(ta3)
hidenImg.set_src(RESOURCES_ROOT + "hiden.png")
hidenImg.align_to(ta3, lv.ALIGN.RIGHT_MID, 0, 0)
# delImg.align(lv.ALIGN.TOP_RIGHT, 50, 8)
hidenImg.add_flag(lv.obj.FLAG.CLICKABLE)
hidenImg.add_event_cb(lambda e: hiden_event_cb(e, ta3), lv.EVENT.CLICKED, None)
hidenImg.set_zoom(150)
hidenImg.add_flag(lv.obj.FLAG.CLICKABLE)
hidenImg.set_ext_click_area(20)
lv.scr_load(scr)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/page_wifi3.py | Python | apache-2.0 | 4,941 |
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()
# # 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 = True
# 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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/smart_panel.py | Python | apache-2.0 | 6,684 |
import lvgl as lv
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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/soundttf.py | Python | apache-2.0 | 3,885 |
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
class Temperature:
scr = None
iconImg = None
temperatureLable = None
unityImg = None
tipLabel = None
def __init__(self, screen):
self.scr = screen
self.createTemperatureItem(self.scr, RESOURCES_ROOT + "temperature.png",
RESOURCES_ROOT + "centigrade_l.png", "Temperature")
def createTemperatureItem(self, parent, iconPath, unityPath, tips):
self.iconImg = lv.img(parent)
self.iconImg.set_src(iconPath)
self.iconImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
self.temperatureLable = lv.label(parent)
self.temperatureLable.set_text("None")
self.temperatureLable.set_style_text_color(lv.color_white(), 0)
self.temperatureLable.set_style_text_font(lv.font_montserrat_48, 0)
self.temperatureLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityImg = lv.img(parent)
self.unityImg.set_src(unityPath)
self.unityImg.set_zoom(100)
self.unityImg.align_to(self.temperatureLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, 0)
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.temperatureLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setValue(self, temperature):
self.temperatureLable.set_text(str(int(temperature)))
def setXY(self, x, y):
self.iconImg.align(lv.ALIGN.TOP_LEFT, x, y)
self.temperatureLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityImg.align_to(self.temperatureLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, 0)
self.tipLabel.align_to(self.temperatureLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setScale(self, scale):
print("To be done")
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/temperature.py | Python | apache-2.0 | 1,932 |
import lvgl as lv
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 | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/timer.py | Python | apache-2.0 | 14,598 |
import lvgl as lv
RESOURCES_ROOT = "S:/data/pyamp/images/"
class Waterlevel:
scr = None
iconImg = None
waterlevelLable = None
unityLabel = None
tipLabel = None
def __init__(self, screen):
self.scr = screen
self.createWaterlevelItem(self.scr, RESOURCES_ROOT + "waterlevel.png", "Water level")
def createWaterlevelItem(self, parent, iconPath, tips):
self.iconImg = lv.img(parent)
self.iconImg.set_src(iconPath)
self.iconImg.align(lv.ALIGN.TOP_LEFT, 0, 0)
self.waterlevelLable = lv.label(parent)
self.waterlevelLable.set_text("None")
self.waterlevelLable.set_style_text_color(lv.color_white(), 0)
self.waterlevelLable.set_style_text_font(lv.font_montserrat_48, 0)
self.waterlevelLable.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.waterlevelLable, 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.waterlevelLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setValue(self, humidity):
self.waterlevelLable.set_text(str(int(humidity)))
def setXY(self, x, y):
self.iconImg.align(lv.ALIGN.TOP_LEFT, x, y)
self.waterlevelLable.align_to(self.iconImg, lv.ALIGN.OUT_RIGHT_TOP, 0, 0)
self.unityLabel.align_to(self.waterlevelLable, lv.ALIGN.OUT_RIGHT_BOTTOM, 0, -5)
self.tipLabel.align_to(self.waterlevelLable, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 0)
def setScale(self, scale):
print("To be done")
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/waterlevel.py | Python | apache-2.0 | 1,957 |
import utime
import sys
def wifi_scan():
print('start wifi scan ...')
import network
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
return(sta_if.scan())
def wifi_connect(wifiSSID, wifiPassword):
print('start wifi connect ', wifiSSID)
retry = 0
if (sys.platform == "esp32"):
import network
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
if not sta_if.isconnected():
sta_if.connect(wifiSSID, wifiPassword)
while not sta_if.isconnected():
utime.sleep_ms(1000)
retry = retry + 1
if (retry > 10):
return False
print('Wi-Fi connected', sta_if.ifconfig())
return True
else:
import netmgr as nm
nm.init()
wifi_connected = nm.getStatus()
if wifi_connected != 5:
nm.connect(wifiSSID, wifiPassword)
while True :
if wifi_connected == 5: # nm.getStatus()返回5代表连线成功
break
else:
wifi_connected = nm.getStatus() # 获取Wi-Fi连接路由器的状态信息
utime.sleep_ms(1000)
retry = retry + 1
if (retry > 10):
return False
print('Wi-Fi connected', nm.getInfo()['ip'])
return True
def is_wifi_connected():
if (sys.platform == "esp32"):
import network
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
if sta_if.isconnected():
return True
else:
return False
else:
import netmgr as nm
nm.init()
wifi_connected = nm.getStatus()
if wifi_connected == 5:
return True
else:
return False
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/data/pyamp/wifi_module.py | Python | apache-2.0 | 1,832 |
from micropython import const
import ustruct
import i2c_bus
import utime as time
# import deviceCfg
_BTN_IRQ = const(0x46)
def map_value(value, input_min, input_max, aims_min, aims_max):
value = min(max(input_min, value), input_max)
value_deal = (value - input_min) * (aims_max - aims_min) / (input_max - input_min) + aims_min
return value_deal
class Axp192:
CURRENT_100MA = const(0b0000)
CURRENT_190MA = const(0b0001)
CURRENT_280MA = const(0b0010)
CURRENT_360MA = const(0b0011)
CURRENT_450MA = const(0b0100)
CURRENT_550MA = const(0b0101)
CURRENT_630MA = const(0b0110)
CURRENT_700MA = const(0b0111)
def __init__(self):
self.addr = 0x34
self.i2c = i2c_bus.get(i2c_bus.M_BUS, device_in=True)
def powerAll(self):
regchar = self._regChar
# axp: vbus limit off
regchar(0x30, (self._read8bit(0x30) & 0x04) | 0x02)
# AXP192 GPIO1:OD OUTPUT
regchar(0x92, self._read8bit(0x92) & 0xf8)
# AXP192 GPIO2:OD OUTPUT
regchar(0x93, self._read8bit(0x93) & 0xf8)
# AXP192 RTC CHG
regchar(0x35, (self._read8bit(0x35) & 0x1c) | 0xa3)
# ESP voltage:3.35V
self.setESPVoltage(3350)
# LCD backlight voltage:3.3V
# self.setLCDBacklightVoltage(3300)
# Periph power voltage preset (LCD_logic, SD card)
self.setLDOVoltage(2, 3300)
# Vibrator power voltage preset
self.setLDOVoltage(3, 2000)
# Eanble LCD SD power
self.setLDOEnable(2, True)
# Set charge current:100ma
# self.setChargeCurrent(CURRENT_100MA)
# self.setChargeCurrent(deviceCfg.get_bat_charge_current())
# AXP192 GPIO4
regchar(0x95, (self._read8bit(0x95) & 0x72) | 0x84)
regchar(0x36, 0x4C)
regchar(0x82, 0xff)
self.setLCDReset(0)
time.sleep(0.1)
self.setLCDReset(1)
time.sleep(0.1)
#if deviceCfg.get_comx_status():
# self.setBusPowerMode(1) # disable M-Bus 5V output if use COM.X module.
#else:
self.setBusPowerMode(0) # enable M-Bus 5V output as default.
def powerOff(self):
self._regChar(0x32, self._regChar(0x32) | 0x80)
# AXP192 Status getting function
def getTempInAXP192(self):
return (self._read12Bit(0x5e)) * 0.1 - 144.7
def getChargeState(self):
return True if self._regChar(0x01) & 0x40 else False
def getBatVoltage(self):
return (self._read12Bit(0x78)) * 1.1 / 1000
def getBatCurrent(self):
currentIn = self._read13Bit(0x7A)
currentOut = self._read13Bit(0x7C)
return (currentIn - currentOut) * 0.5
def getVinVoltage(self):
return (self._read12Bit(0x56)) * 1.7 / 1000
def getVinCurrent(self):
return (self._read12Bit(0x58)) * 0.625
def getVBusVoltage(self):
return (self._read12Bit(0x5A)) * 1.7 / 1000
def getVBusCurrent(self):
return (self._read12Bit(0x5C)) * 0.375
# AXP192 Status setting function
def setChargeState(self, state):
pass
def setChargeCurrent(self, current):
buf = self._regChar(0x33)
buf = (buf & 0xf0) | (current & 0x0f)
self._regChar(0x33, buf)
def setBusPowerMode(self, mode):
"""
0: M-BUS 5V output mode.
1: M-BUS 5V input mode.
"""
if mode == 0:
self._regChar(0x91, (self._read8bit(0x91) & 0x0F) | 0xF0)
self._regChar(0x90, (self._read8bit(0x90) & 0xF8) | 0x02)
self._regChar(0x12, (self._read8bit(0x12) | 0x40))
else:
self._regChar(0x12, self._read8bit(0x12) & 0xBF)
self._regChar(0x90, (self._read8bit(0x90) & 0xF8) | 0x01)
def setLDOVoltage(self, number, voltage):
# print("number: " + str(number) + " voltage: " + str(voltage))
if voltage > 3300:
vol = 15
else:
vol = (int)((voltage / 100) - 18)
regchar = self._regChar
if number == 2:
regchar(0x28, ((self._read8bit(0x28) & 0x0F) | (vol << 4)))
if number == 3:
regchar(0x28, ((self._read8bit(0x28) & 0xF0) | vol))
def setLDOEnable(self, number, state):
mask = 0x01
if number < 2 or number > 3:
return
mask = mask << number
if(state):
self._regChar(0x12, self._read8bit(0x12) | mask)
else:
self._regChar(0x12, self._read8bit(0x12) & (~ mask))
def setDCVoltage(self, number, voltage):
addr = [0, 0x26, 0x25, 0x27]
regchar = self._regChar
if number < 1 and number > 3:
return
vol = (int)(0 if voltage < 700 else (voltage - 700) / 25)
regchar(addr[number], (self._read8bit(addr[number]) & 0x80) | (vol & 0x7F))
def disableAllIRQ(self):
for i in [0x40, 0x41, 0x42, 0x43, 0x4a]:
self._regChar(i, 0x00)
def clearAllIRQ(self):
for i in [0x44, 0x45, 0x46, 0x47, 0x4d]:
self._regChar(i, 0xff)
def enableBtnIRQ(self):
self._regChar(0x42, 0x02)
# ESP32 Voltage
def setESPVoltage(self, voltage):
if voltage >= 3000 and voltage <= 3400:
self.setDCVoltage(1, voltage)
# LCD backlight Voltage
def setLCDBacklightVoltage(self, voltage):
voltage = voltage * 1000
if voltage >= 2400 and voltage <= 3300:
self.setDCVoltage(3, voltage)
def setLCDEnable(self, state):
self.setLDOEnable(2, state)
# LCD Brightness
def setLCDBrightness(self, brightness):
vol = map_value(brightness, 0, 100, 2400, 3300)
self.setDCVoltage(3, vol)
# LCD Reset
def setLCDReset(self, state):
mask = 0x02
if state:
self._regChar(0x96, self._read8bit(0x96) | mask)
else:
self._regChar(0x96, self._read8bit(0x96) & (~ mask))
# Set Power LED
def setPowerLED(self, state):
if state:
self._regChar(0x94, self._read8bit(0x94) & 0xFD)
else:
self._regChar(0x94, self._read8bit(0x94) | 0x02)
def setSpkEnable(self, state):
gpio_bit = 0x04
data = self._read8bit(0x94)
if state:
data = data | gpio_bit
else:
data = data & (~gpio_bit)
self._regChar(0x94, data)
# It seem not useful for Vibration motor.
# LDO3: 1.8v ~ 3.3v
def setVibrationIntensity(self, value):
vol = map_value(value, 0, 100, 1800, 3300)
self.setLDOVoltage(3, vol)
def setVibrationEnable(self, state):
self.setLDOEnable(3, state)
# I2C read and write function
def _regChar(self, reg, value=None, buf=bytearray(1)):
if value is None:
self.i2c.readfrom_mem_into(self.addr, reg, buf)
return buf[0]
ustruct.pack_into('<b', buf, 0, value)
return self.i2c.writeto_mem(self.addr, reg, buf)
def _read8bit(self, reg):
buf = bytearray(1)
self.i2c.readfrom_mem_into(self.addr, reg, buf)
return buf[0]
def _read12Bit(self, reg):
buf = bytearray(2)
self.i2c.readfrom_mem_into(self.addr, reg, buf)
return (buf[0] << 4) | buf[1]
def _read13Bit(self, reg):
buf = bytearray(2)
self.i2c.readfrom_mem_into(self.addr, reg, buf)
return (buf[0] << 5) | buf[1]
def _read16Bit(self, reg):
buf = bytearray(2)
self.i2c.readfrom_mem_into(self.addr, reg, buf)
return (buf[0] << 8) | buf[1]
def deinit(self):
pass
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/lib/axp192.py | Python | apache-2.0 | 7,575 |
from machine import I2C
from machine import Pin
from micropython import const
import struct
#import unit
#PORTA = (unit.PORTA)
PAHUB0 = (0, None)
PAHUB1 = (1, None)
PAHUB2 = (2, None)
PAHUB3 = (3, None)
PAHUB4 = (4, None)
PAHUB5 = (5, None)
M_BUS = (21, 22)
UINT8LE = const((0 << 6) | (1 << 4) | 1)
UINT16LE = const((0 << 6) | (1 << 4) | 2)
UINT32LE = const((0 << 6) | (1 << 4) | 4)
INT8LE = const((0 << 6) | (0 << 4) | 1)
INT16LE = const((0 << 6) | (0 << 4) | 2)
INT32LE = const((0 << 6) | (0 << 4) | 4)
UINT8BE = const((1 << 6) | (1 << 4) | 1)
UINT16BE = const((1 << 6) | (1 << 4) | 2)
UINT32BE = const((1 << 6) | (1 << 4) | 4)
INT8BE = const((1 << 6) | (0 << 4) | 1)
INT16BE = const((1 << 6) | (0 << 4) | 2)
INT32BE = const((1 << 6) | (0 << 4) | 4)
def get(port, pos=0, freq=400000, device_in=False):
if port[1] is None:
return Pahub_I2C(port[0])
if device_in or port == (21, 22):
return I2C(1, sda=Pin(port[0]), scl=Pin(port[1]), freq=freq)
else:
return I2C(0, sda=Pin(port[0]), scl=Pin(port[1]), freq=freq)
class easyI2C():
def __init__(self, port, addr, freq=400000):
self.i2c = get(port, pos=0, freq=freq)
self.addr = addr
def write_u8(self, reg, data):
buf = bytearray(1)
buf[0] = data
self.i2c.writeto_mem(self.addr, reg, buf)
def write_u16(self, reg, data, byteorder='big'):
buf = bytearray(2)
encode = '<h' if byteorder == 'little' else '>h'
struct.pack_into(encode, buf, 0, data)
self.i2c.writeto_mem(self.addr, reg, buf)
def write_u32(self, reg, data, byteorder='big'):
buf = bytearray(4)
encode = '<i' if byteorder == 'little' else '>i'
struct.pack_into(encode, buf, 0, data)
self.i2c.writeto_mem(self.addr, reg, buf)
def read_u8(self, reg):
return self.i2c.readfrom_mem(self.addr, reg, 1)[0]
def read_u16(self, reg, byteorder='big'):
buf = bytearray(2)
self.i2c.readfrom_mem_into(self.addr, reg, buf)
encode = '<h' if byteorder == 'little' else '>h'
return struct.unpack(encode, buf)[0]
def read_u32(self, reg, byteorder='big'):
buf = bytearray(4)
self.i2c.readfrom_mem_into(self.addr, reg, buf)
encode = '<i' if byteorder == 'little' else '>i'
return struct.unpack(encode, buf)[0]
def read(self, num):
return self.i2c.readfrom(self.addr, num)
def read_reg(self, reg, num):
return self.i2c.readfrom_mem(self.addr, reg, num)
@staticmethod
def _get_format_str(format_type):
format_str = '>' if (format_type & (1 << 6)) else '<'
format_str += {1: 'b', 2: 'h', 4: 'i'}.get(format_type & 0x0f)
format_str = format_str.upper() if (format_type & (1 << 4)) else format_str
return format_str
def write_mem_data(self, reg, data, format_type):
format_str = self._get_format_str(format_type)
buf = bytearray(struct.pack(format_str, data))
self.i2c.writeto_mem(self.addr, reg, buf)
def write_data(self, data, format_type):
format_str = self._get_format_str(format_type)
buf = bytearray(struct.pack(format_str, data))
self.i2c.writeto(self.addr, buf)
def write_list(self, data):
buf = bytearray(data)
self.i2c.writeto(self.addr, buf)
def write_mem_list(self, reg, data, num):
buf = bytearray(data)
self.i2c.writeto_mem(self.addr, reg, buf)
def read_data(self, num, format_type):
format_str = self._get_format_str(format_type)
format_str = format_str[0] + format_str[1] * num
buf = bytearray((format_type & 0x0f) * num)
self.i2c.readfrom_into(self.addr, buf)
return struct.unpack(format_str, buf)
def read_mem_data(self, reg, num, format_type):
format_str = self._get_format_str(format_type)
format_str = format_str[0] + format_str[1] * num
buf = bytearray((format_type & 0x0f) * num)
self.i2c.readfrom_mem_into(self.addr, reg, buf)
return struct.unpack(format_str, buf)
def scan(self):
return self.i2c.scan()
def available(self):
return self.i2c.is_ready(self.addr)
class Pahub_I2C:
def __init__(self, pos, port=(32, 33), freq=100000): # PORTA (32, 33)
from units import _pahub
self.pahub = _pahub.Pahub(port)
self.i2c = get(port, freq=freq)
self.pos = pos
def readfrom(self, addr, num):
self.pahub.select_only_on(self.pos)
data = self.i2c.readfrom(addr, num)
return data
def readfrom_into(self, addr, buf):
buf_in = bytearray(len(buf))
self.pahub.select_only_on(self.pos)
self.i2c.readfrom_into(addr, buf_in)
for i in range(len(buf)):
buf[i] = buf_in[i]
def readfrom_mem_into(self, addr, reg, buf):
buf_in = bytearray(len(buf))
self.pahub.select_only_on(self.pos)
self.i2c.readfrom_mem_into(addr, reg, buf_in)
for i in range(len(buf)):
buf[i] = buf_in[i]
def readfrom_mem(self, addr, reg, num):
self.pahub.select_only_on(self.pos)
data = self.i2c.readfrom_mem(addr, reg, num)
return data
def writeto_mem(self, addr, reg, data):
self.pahub.select_only_on(self.pos)
self.i2c.writeto_mem(addr, reg, data)
def writeto(self, addr, data):
self.pahub.select_only_on(self.pos)
self.i2c.writeto(addr, data)
def is_ready(self, addr):
self.pahub.select_only_on(self.pos)
data = self.i2c.is_ready(addr)
return data
def scan(self):
self.pahub.select_only_on(self.pos)
data = self.i2c.scan()
return data
def available(self):
return self.i2c.is_ready(self.addr)
def deinit(self):
pass
class Unit(Exception):
pass
class UnitI2C:
def __init__(self, port, freq, addr):
self.i2c = easyI2C(port, addr, freq)
def _check_device(self):
if self.i2c.available() or self.i2c.available():
pass
else:
raise Unit("{} unit not found".format(self.__qualname__.upper()))
def deinit(self):
pass
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/lib/i2c_bus.py | Python | apache-2.0 | 6,200 |
# -*- encoding: utf-8 -*-
'''
@File : Player.py
@Time : 2021/12/08 20:32:10
@Author : zeta.zz
@License : (C)Copyright 2015-2021, M5STACK
@Desc : Player I2S driver.
'''
from machine import I2S
from machine import Pin
from axp192 import Axp192
from micropython import const
import io
import math
import struct
import gc
import urequests
BCK_PIN = Pin(12)
WS_PIN = Pin(0)
SDOUT_PIN = Pin(2)
PI = 3.141592653
I2S0 = const(0)
F16B = const(16)
F24B = const(24)
F32B = const(32)
class Player:
def __init__(self):
self.power = Axp192()
self.power.powerAll()
def open(self):
pass
def play(self, wav_file, rate=None, data_format=None, channel=None):
"""
Parameter:
wav_file
Return:
False Not WAV format file
"""
if type(wav_file) is str:
try:
wav = open(wav_file, 'rb')
except Exception as e:
print('Audio file open caught exception: {} {}'.format(
type(e).__name__, e))
return
elif type(wav_file) is bytes:
wav = io.BytesIO(len(wav_file))
wav.write(wav_file)
wav.seek(0)
else:
return "Unknow file type"
wav_head = wav.read(44)
if wav_head[0:4] != b"RIFF" and wav_head[8:12] != b"WAVE":
return "Wrong WAV format file"
if rate and data_format and channel:
channels = channel
samplerate = rate
dataformat = data_format
else:
channels = (wav_head[0x17] << 8) | (wav_head[0x16])
if channels == 1:
channels = I2S.MONO
elif channels == 2:
channels = I2S.STEREO
samplerate = (wav_head[0x1B] << 24) | (wav_head[0x1A] << 16) | (wav_head[0x19] << 8) | (wav_head[0x18])
dataformat = (wav_head[0x23] << 8) | (wav_head[0x22])
audio_out = I2S(
I2S0,
sck=BCK_PIN, ws=WS_PIN, sd=SDOUT_PIN,
mode=I2S.TX,
bits=dataformat,
format=channels,
rate=samplerate,
ibuf=3*1024)
# advance to first byte of Data section in WAV file
# wav.seek(44)
# allocate sample arrays
# memoryview used to reduce heap allocation in while loop
wav_samples = bytearray(1024)
wav_samples_mv = memoryview(wav_samples)
# continuously read audio samples from the WAV file
# and write them to an I2S DAC
self.power.setSpkEnable(True)
try:
while True:
# try:
num_read = wav.readinto(wav_samples_mv)
num_written = 0
if num_read == 0:
# pos = wav.seek(44)
# exit
break
else:
while num_written < num_read:
num_written += audio_out.write(
wav_samples_mv[num_written:num_read])
except (KeyboardInterrupt, Exception) as e:
print('Player caught exception: {} {}'.format(type(e).__name__, e))
self.power.setSpkEnable(False)
raise
finally:
self.power.setSpkEnable(False)
audio_out.deinit()
wav.close()
del wav
del wav_samples_mv
del wav_samples
gc.collect()
def playCloudWAV(self, url):
"""
Parameter:
url: WAV format file URL
Return:
False
None
"""
request = urequests.get(url)
if (request.status_code) == 200:
self.playWAV(request.content)
else:
return "Request WAV file fail"
def playTone(self, freq, beta, rate=44100, data_format=F16B, channel=I2S.STEREO):
"""
Parameter:
freq = frequency
duration = time in secods
Return:
"""
wave_data = io.BytesIO()
freq_rate = (freq / rate)
# Calculate a period of sine wave
cycle = rate / freq
for i in range(0, cycle):
# 6.283185 = 2 * PI
x = 6.283185 * freq_rate * i
data = int(32767 * math.sin(x))
wave_data.write(bytes(struct.pack('h', data)))
audio_out = I2S(
I2S0,
sck=BCK_PIN, ws=WS_PIN, sd=SDOUT_PIN,
mode=I2S.TX,
bits=data_format,
format=channel,
rate=rate,
ibuf=3 * 1024)
wave_data.seek(0)
# One cycle sine wave data length
length = (len(wave_data.read()))
wave_data.seek(0)
# Calculate how many cycles
cycles = int((rate * beta) / cycle)
wave_samples = bytearray(length)
wave_samples_mv = memoryview(wave_samples)
self.power.setSpkEnable(True)
try:
for i in range(0, cycles):
num_read = wave_data.readinto(wave_samples_mv)
num_written = 0
if num_read == 0:
wave_data.seek(0)
else:
while num_written < num_read:
num_written += audio_out.write(wave_samples_mv[num_written:num_read])
# print(num_written)
except (KeyboardInterrupt, Exception) as e:
print('Player caught exception: {} {}'.format(type(e).__name__, e))
self.power.setSpkEnable(False)
raise
finally:
self.power.setSpkEnable(False)
audio_out.deinit()
wave_data.close()
del wave_data
del wave_samples_mv
del wave_samples
gc.collect()
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/lib/pcm.py | Python | apache-2.0 | 5,818 |
from minicv import ML
AI_ENGINE_ALIYUN = 1
AI_ENGINE_NATIVE = 2
class AI:
def __init__(self, type=AI_ENGINE_NATIVE, accessKey=None, accessSecret=None, ossEndpoint=None, ossBucket=None):
self.type = type
self.ml = ML()
if (self.type == AI_ENGINE_ALIYUN):
self.ml.open(self.ml.ML_ENGINE_CLOUD)
if not accessKey or not accessSecret:
print('access key can not be null')
return
else:
self.ml.config(accessKey, accessSecret, ossEndpoint, ossBucket)
else:
print('now only support cloud ai, not support nativate ai yet')
print("Please use example: ai = AI(AI.AI_ENGINE_CLOUD, 'Your-Access-Key', 'Your-Access-Secret')")
# 人脸比对
def compareFace(self, imagePath, compareFacePath):
self.ml.setInputData(imagePath, compareFacePath)
self.ml.loadNet("FacebodyComparing")
self.ml.predict()
resp = self.ml.getPredictResponses(None)
self.ml.unLoadNet()
return resp
# 人体检测
def detectPedestrian(self, imagePath):
self.ml.setInputData(imagePath)
self.ml.loadNet("DetectPedestrian")
self.ml.predict()
resp = self.ml.getPredictResponses(None)
self.ml.unLoadNet()
return resp
# 水果检测
def detectFruits(self, imagePath):
self.ml.setInputData(imagePath, None)
self.ml.loadNet("DetectFruits")
self.ml.predict()
resp = self.ml.getPredictResponses(None)
self.ml.unLoadNet()
return resp
# 车牌识别
def recognizeLicensePlate(self, imagePath):
self.ml.setInputData(imagePath)
self.ml.loadNet("RecognizeLicensePlate")
self.ml.predict()
resp = self.ml.getPredictResponses(None)
self.ml.unLoadNet()
return resp
def __del__(self):
try:
self.ml.close()
del self.type
del self.ml
except Exception:
pass
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/m5stackcore2/lib/uai.py | Python | apache-2.0 | 2,033 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2017 Nick Moore
* Copyright (c) 2021 Jonathan Hogg
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include "esp_log.h"
#include "driver/gpio.h"
#include "driver/adc.h"
#include "py/runtime.h"
#include "py/mphal.h"
#include "modmachine.h"
#include "machine_adc.h"
#define ADCBLOCK1 (&madcblock_obj[0])
#define ADCBLOCK2 (&madcblock_obj[1])
STATIC const madc_obj_t madc_obj[] = {
#if CONFIG_IDF_TARGET_ESP32
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_0, GPIO_NUM_36},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_1, GPIO_NUM_37},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_2, GPIO_NUM_38},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_3, GPIO_NUM_39},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_4, GPIO_NUM_32},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_5, GPIO_NUM_33},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_6, GPIO_NUM_34},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_7, GPIO_NUM_35},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_0, GPIO_NUM_4},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_1, GPIO_NUM_0},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_2, GPIO_NUM_2},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_3, GPIO_NUM_15},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_4, GPIO_NUM_13},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_5, GPIO_NUM_12},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_6, GPIO_NUM_14},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_7, GPIO_NUM_27},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_8, GPIO_NUM_25},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_9, GPIO_NUM_26},
#elif CONFIG_IDF_TARGET_ESP32C3
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_0, GPIO_NUM_0},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_1, GPIO_NUM_1},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_2, GPIO_NUM_2},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_3, GPIO_NUM_3},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_4, GPIO_NUM_4},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_0, GPIO_NUM_5},
#elif CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_0, GPIO_NUM_1},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_1, GPIO_NUM_2},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_2, GPIO_NUM_3},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_3, GPIO_NUM_4},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_4, GPIO_NUM_5},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_5, GPIO_NUM_6},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_6, GPIO_NUM_7},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_7, GPIO_NUM_8},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_8, GPIO_NUM_9},
{{&machine_adc_type}, ADCBLOCK1, ADC_CHANNEL_9, GPIO_NUM_10},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_0, GPIO_NUM_11},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_1, GPIO_NUM_12},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_2, GPIO_NUM_13},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_3, GPIO_NUM_14},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_4, GPIO_NUM_15},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_5, GPIO_NUM_16},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_6, GPIO_NUM_17},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_7, GPIO_NUM_18},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_8, GPIO_NUM_19},
{{&machine_adc_type}, ADCBLOCK2, ADC_CHANNEL_9, GPIO_NUM_20},
#endif
};
// These values are initialised to 0, which means the corresponding ADC channel is not initialised.
// The madc_atten_get/madc_atten_set functions store (atten+1) here so that the uninitialised state
// can be distinguished from the initialised state.
STATIC uint8_t madc_obj_atten[MP_ARRAY_SIZE(madc_obj)];
static inline adc_atten_t madc_atten_get(const madc_obj_t *self) {
uint8_t value = madc_obj_atten[self - &madc_obj[0]];
return value == 0 ? ADC_ATTEN_MAX : value - 1;
}
static inline void madc_atten_set(const madc_obj_t *self, adc_atten_t atten) {
madc_obj_atten[self - &madc_obj[0]] = atten + 1;
}
const madc_obj_t *madc_search_helper(madcblock_obj_t *block, adc_channel_t channel_id, gpio_num_t gpio_id) {
for (int i = 0; i < MP_ARRAY_SIZE(madc_obj); i++) {
const madc_obj_t *adc = &madc_obj[i];
if ((block == NULL || block == adc->block) && (channel_id == -1 || channel_id == adc->channel_id) && (gpio_id == -1 || gpio_id == adc->gpio_id)) {
return adc;
}
}
return NULL;
}
STATIC void madc_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
const madc_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "ADC(Pin(%u), atten=%u)", self->gpio_id, madc_atten_get(self));
}
STATIC void madc_atten_helper(const madc_obj_t *self, mp_int_t atten) {
esp_err_t err;
if (self->block->unit_id == ADC_UNIT_1) {
err = adc1_config_channel_atten(self->channel_id, atten);
} else {
err = adc2_config_channel_atten(self->channel_id, atten);
}
if (err != ESP_OK) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid atten"));
}
madc_atten_set(self, atten);
}
void madc_init_helper(const madc_obj_t *self, size_t n_pos_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum {
ARG_atten,
};
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_atten, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_pos_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
mp_int_t atten = args[ARG_atten].u_int;
if (atten != -1) {
madc_atten_helper(self, atten);
} else if (madc_atten_get(self) == ADC_ATTEN_MAX) {
madc_atten_helper(self, ADC_ATTEN_DB_0);
}
}
STATIC mp_obj_t madc_make_new(const mp_obj_type_t *type, size_t n_pos_args, size_t n_kw_args, const mp_obj_t *args) {
mp_arg_check_num(n_pos_args, n_kw_args, 1, MP_OBJ_FUN_ARGS_MAX, true);
gpio_num_t gpio_id = machine_pin_get_id(args[0]);
const madc_obj_t *self = madc_search_helper(NULL, -1, gpio_id);
if (!self) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid pin"));
}
if (self->block->width == -1) {
madcblock_bits_helper(self->block, self->block->bits);
}
mp_map_t kw_args;
mp_map_init_fixed_table(&kw_args, n_kw_args, args + n_pos_args);
madc_init_helper(self, n_pos_args - 1, args + 1, &kw_args);
return MP_OBJ_FROM_PTR(self);
}
STATIC mp_obj_t madc_init(size_t n_pos_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
const madc_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
madc_init_helper(self, n_pos_args - 1, pos_args + 1, kw_args);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(madc_init_obj, 1, madc_init);
STATIC mp_obj_t madc_block(mp_obj_t self_in) {
const madc_obj_t *self = MP_OBJ_TO_PTR(self_in);
return MP_OBJ_FROM_PTR(self->block);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(madc_block_obj, madc_block);
STATIC mp_obj_t madc_read(mp_obj_t self_in) {
const madc_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_int_t raw = madcblock_read_helper(self->block, self->channel_id);
return MP_OBJ_NEW_SMALL_INT(raw);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(madc_read_obj, madc_read);
STATIC mp_obj_t madc_read_u16(mp_obj_t self_in) {
const madc_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_uint_t raw = madcblock_read_helper(self->block, self->channel_id);
// Scale raw reading to 16 bit value using a Taylor expansion (for 8 <= bits <= 16)
mp_int_t bits = self->block->bits;
mp_uint_t u16 = raw << (16 - bits) | raw >> (2 * bits - 16);
return MP_OBJ_NEW_SMALL_INT(u16);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(madc_read_u16_obj, madc_read_u16);
STATIC mp_obj_t madc_read_uv(mp_obj_t self_in) {
const madc_obj_t *self = MP_OBJ_TO_PTR(self_in);
adc_atten_t atten = madc_atten_get(self);
return MP_OBJ_NEW_SMALL_INT(madcblock_read_uv_helper(self->block, self->channel_id, atten));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(madc_read_uv_obj, madc_read_uv);
STATIC mp_obj_t madc_atten(mp_obj_t self_in, mp_obj_t atten_in) {
const madc_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_int_t atten = mp_obj_get_int(atten_in);
madc_atten_helper(self, atten);
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(madc_atten_obj, madc_atten);
STATIC mp_obj_t madc_width(mp_obj_t self_in, mp_obj_t bits_in) {
const madc_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_int_t bits = mp_obj_get_int(bits_in);
madcblock_bits_helper(self->block, bits);
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(madc_width_obj, madc_width);
STATIC const mp_rom_map_elem_t madc_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&madc_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_block), MP_ROM_PTR(&madc_block_obj) },
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&madc_read_obj) },
{ MP_ROM_QSTR(MP_QSTR_read_u16), MP_ROM_PTR(&madc_read_u16_obj) },
{ MP_ROM_QSTR(MP_QSTR_read_uv), MP_ROM_PTR(&madc_read_uv_obj) },
// Legacy API methods:
{ MP_ROM_QSTR(MP_QSTR_atten), MP_ROM_PTR(&madc_atten_obj) },
{ MP_ROM_QSTR(MP_QSTR_width), MP_ROM_PTR(&madc_width_obj) },
{ MP_ROM_QSTR(MP_QSTR_ATTN_0DB), MP_ROM_INT(ADC_ATTEN_DB_0) },
{ MP_ROM_QSTR(MP_QSTR_ATTN_2_5DB), MP_ROM_INT(ADC_ATTEN_DB_2_5) },
{ MP_ROM_QSTR(MP_QSTR_ATTN_6DB), MP_ROM_INT(ADC_ATTEN_DB_6) },
{ MP_ROM_QSTR(MP_QSTR_ATTN_11DB), MP_ROM_INT(ADC_ATTEN_DB_11) },
#if CONFIG_IDF_TARGET_ESP32
{ MP_ROM_QSTR(MP_QSTR_WIDTH_9BIT), MP_ROM_INT(9) },
{ MP_ROM_QSTR(MP_QSTR_WIDTH_10BIT), MP_ROM_INT(10) },
{ MP_ROM_QSTR(MP_QSTR_WIDTH_11BIT), MP_ROM_INT(11) },
#endif
#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3
{ MP_ROM_QSTR(MP_QSTR_WIDTH_12BIT), MP_ROM_INT(12) },
#endif
#if CONFIG_IDF_TARGET_ESP32S2
{ MP_ROM_QSTR(MP_QSTR_WIDTH_13BIT), MP_ROM_INT(13) },
#endif
};
STATIC MP_DEFINE_CONST_DICT(madc_locals_dict, madc_locals_dict_table);
const mp_obj_type_t machine_adc_type = {
{ &mp_type_type },
.name = MP_QSTR_ADC,
.print = madc_print,
.make_new = madc_make_new,
.locals_dict = (mp_obj_t)&madc_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_adc.c | C | apache-2.0 | 11,369 |
#ifndef MICROPY_INCLUDED_MACHINE_ADC_H
#define MICROPY_INCLUDED_MACHINE_ADC_H
#include "machine_adcblock.h"
typedef struct _madc_obj_t {
mp_obj_base_t base;
madcblock_obj_t *block;
adc_channel_t channel_id;
gpio_num_t gpio_id;
} madc_obj_t;
extern const madc_obj_t *madc_search_helper(madcblock_obj_t *block, adc_channel_t channel_id, gpio_num_t gpio_id);
extern void madc_init_helper(const madc_obj_t *self, size_t n_pos_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
#endif // MICROPY_INCLUDED_MACHINE_ADC_H
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_adc.h | C | apache-2.0 | 535 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2021 Jonathan Hogg
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include "esp_log.h"
#include "driver/gpio.h"
#include "driver/adc.h"
#include "py/runtime.h"
#include "py/mphal.h"
#include "modmachine.h"
#include "machine_adc.h"
#include "machine_adcblock.h"
#define DEFAULT_VREF 1100
madcblock_obj_t madcblock_obj[] = {
#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3
{{&machine_adcblock_type}, ADC_UNIT_1, 12, -1, {0}},
{{&machine_adcblock_type}, ADC_UNIT_2, 12, -1, {0}},
#elif CONFIG_IDF_TARGET_ESP32S2
{{&machine_adcblock_type}, ADC_UNIT_1, 13, -1, {0}},
{{&machine_adcblock_type}, ADC_UNIT_2, 13, -1, {0}},
#endif
};
STATIC void madcblock_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
madcblock_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "ADCBlock(%u, bits=%u)", self->unit_id, self->bits);
}
void madcblock_bits_helper(madcblock_obj_t *self, mp_int_t bits) {
switch (bits) {
#if CONFIG_IDF_TARGET_ESP32
case 9:
self->width = ADC_WIDTH_BIT_9;
break;
case 10:
self->width = ADC_WIDTH_BIT_10;
break;
case 11:
self->width = ADC_WIDTH_BIT_11;
break;
#endif
#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3
case 12:
self->width = ADC_WIDTH_BIT_12;
break;
#endif
#if CONFIG_IDF_TARGET_ESP32S2
case 13:
self->width = ADC_WIDTH_BIT_13;
break;
#endif
default:
mp_raise_ValueError(MP_ERROR_TEXT("invalid bits"));
}
self->bits = bits;
if (self->unit_id == ADC_UNIT_1) {
adc1_config_width(self->width);
}
for (adc_atten_t atten = ADC_ATTEN_DB_0; atten < ADC_ATTEN_MAX; atten++) {
if (self->characteristics[atten] != NULL) {
esp_adc_cal_characterize(self->unit_id, atten, self->width, DEFAULT_VREF, self->characteristics[atten]);
}
}
}
STATIC void madcblock_init_helper(madcblock_obj_t *self, size_t n_pos_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum {
ARG_bits,
};
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_bits, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_pos_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
mp_int_t bits = args[ARG_bits].u_int;
if (bits != -1) {
madcblock_bits_helper(self, bits);
} else if (self->width == -1) {
madcblock_bits_helper(self, self->bits);
}
}
STATIC mp_obj_t madcblock_make_new(const mp_obj_type_t *type, size_t n_pos_args, size_t n_kw_args, const mp_obj_t *args) {
mp_arg_check_num(n_pos_args, n_kw_args, 1, MP_OBJ_FUN_ARGS_MAX, true);
adc_unit_t unit = mp_obj_get_int(args[0]);
madcblock_obj_t *self = NULL;
for (int i = 0; i < MP_ARRAY_SIZE(madcblock_obj); i++) {
if (unit == madcblock_obj[i].unit_id) {
self = &madcblock_obj[i];
break;
}
}
if (!self) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid block id"));
}
mp_map_t kw_args;
mp_map_init_fixed_table(&kw_args, n_kw_args, args + n_pos_args);
madcblock_init_helper(self, n_pos_args - 1, args + 1, &kw_args);
return MP_OBJ_FROM_PTR(self);
}
STATIC mp_obj_t madcblock_init(size_t n_pos_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
madcblock_obj_t *self = pos_args[0];
madcblock_init_helper(self, n_pos_args - 1, pos_args + 1, kw_args);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(madcblock_init_obj, 1, madcblock_init);
STATIC mp_obj_t madcblock_connect(size_t n_pos_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
madcblock_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
adc_channel_t channel_id = -1;
gpio_num_t gpio_id = -1;
if (n_pos_args == 2) {
if (mp_obj_is_int(pos_args[1])) {
channel_id = mp_obj_get_int(pos_args[1]);
} else {
gpio_id = machine_pin_get_id(pos_args[1]);
}
} else if (n_pos_args == 3) {
channel_id = mp_obj_get_int(pos_args[1]);
gpio_id = machine_pin_get_id(pos_args[2]);
} else {
mp_raise_TypeError(MP_ERROR_TEXT("too many positional args"));
}
const madc_obj_t *adc = madc_search_helper(self, channel_id, gpio_id);
if (adc != NULL) {
madc_init_helper(adc, 0, pos_args + n_pos_args, kw_args);
return MP_OBJ_FROM_PTR(adc);
}
mp_raise_ValueError(MP_ERROR_TEXT("no matching ADC"));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(madcblock_connect_obj, 2, madcblock_connect);
mp_int_t madcblock_read_helper(madcblock_obj_t *self, adc_channel_t channel_id) {
int raw;
if (self->unit_id == ADC_UNIT_1) {
raw = adc1_get_raw(channel_id);
} else {
check_esp_err(adc2_get_raw(channel_id, self->width, &raw));
}
return raw;
}
mp_int_t madcblock_read_uv_helper(madcblock_obj_t *self, adc_channel_t channel_id, adc_atten_t atten) {
int raw = madcblock_read_helper(self, channel_id);
esp_adc_cal_characteristics_t *adc_chars = self->characteristics[atten];
if (adc_chars == NULL) {
adc_chars = malloc(sizeof(esp_adc_cal_characteristics_t));
esp_adc_cal_characterize(self->unit_id, atten, self->width, DEFAULT_VREF, adc_chars);
self->characteristics[atten] = adc_chars;
}
mp_int_t uv = esp_adc_cal_raw_to_voltage(raw, adc_chars) * 1000;
return uv;
}
STATIC const mp_rom_map_elem_t madcblock_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&madcblock_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&madcblock_connect_obj) },
};
STATIC MP_DEFINE_CONST_DICT(madcblock_locals_dict, madcblock_locals_dict_table);
const mp_obj_type_t machine_adcblock_type = {
{ &mp_type_type },
.name = MP_QSTR_ADCBlock,
.print = madcblock_print,
.make_new = madcblock_make_new,
.locals_dict = (mp_obj_t)&madcblock_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_adcblock.c | C | apache-2.0 | 7,319 |
#ifndef MICROPY_INCLUDED_MACHINE_ADCBLOCK_H
#define MICROPY_INCLUDED_MACHINE_ADCBLOCK_H
#include "esp_adc_cal.h"
typedef struct _madcblock_obj_t {
mp_obj_base_t base;
adc_unit_t unit_id;
mp_int_t bits;
adc_bits_width_t width;
esp_adc_cal_characteristics_t *characteristics[ADC_ATTEN_MAX];
} madcblock_obj_t;
extern madcblock_obj_t madcblock_obj[];
extern void madcblock_bits_helper(madcblock_obj_t *self, mp_int_t bits);
extern mp_int_t madcblock_read_helper(madcblock_obj_t *self, adc_channel_t channel_id);
extern mp_int_t madcblock_read_uv_helper(madcblock_obj_t *self, adc_channel_t channel_id, adc_atten_t atten);
#endif // MICROPY_INCLUDED_MACHINE_ADCBLOCK_H
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_adcblock.h | C | apache-2.0 | 690 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2021 Jim Mussared
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
// This is a translation of the cycle counter implementation in ports/stm32/machine_bitstream.c.
#include "py/mpconfig.h"
#include "py/mphal.h"
#if MICROPY_PY_MACHINE_BITSTREAM
#define NS_TICKS_OVERHEAD (6)
void IRAM_ATTR machine_bitstream_high_low(mp_hal_pin_obj_t pin, uint32_t *timing_ns, const uint8_t *buf, size_t len) {
uint32_t pin_mask, gpio_reg_set, gpio_reg_clear;
#if !CONFIG_IDF_TARGET_ESP32C3
if (pin >= 32) {
pin_mask = 1 << (pin - 32);
gpio_reg_set = GPIO_OUT1_W1TS_REG;
gpio_reg_clear = GPIO_OUT1_W1TC_REG;
} else
#endif
{
pin_mask = 1 << pin;
gpio_reg_set = GPIO_OUT_W1TS_REG;
gpio_reg_clear = GPIO_OUT_W1TC_REG;
}
// Convert ns to cpu ticks [high_time_0, period_0, high_time_1, period_1].
uint32_t fcpu_mhz = ets_get_cpu_frequency();
for (size_t i = 0; i < 4; ++i) {
timing_ns[i] = fcpu_mhz * timing_ns[i] / 1000;
if (timing_ns[i] > NS_TICKS_OVERHEAD) {
timing_ns[i] -= NS_TICKS_OVERHEAD;
}
if (i % 2 == 1) {
// Convert low_time to period (i.e. add high_time).
timing_ns[i] += timing_ns[i - 1];
}
}
uint32_t irq_state = mp_hal_quiet_timing_enter();
for (size_t i = 0; i < len; ++i) {
uint8_t b = buf[i];
for (size_t j = 0; j < 8; ++j) {
GPIO_REG_WRITE(gpio_reg_set, pin_mask);
uint32_t start_ticks = mp_hal_ticks_cpu();
uint32_t *t = &timing_ns[b >> 6 & 2];
while (mp_hal_ticks_cpu() - start_ticks < t[0]) {
;
}
GPIO_REG_WRITE(gpio_reg_clear, pin_mask);
b <<= 1;
while (mp_hal_ticks_cpu() - start_ticks < t[1]) {
;
}
}
}
mp_hal_quiet_timing_exit(irq_state);
}
#endif // MICROPY_PY_MACHINE_BITSTREAM
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_bitstream.c | C | apache-2.0 | 3,096 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2017 Nick Moore
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include "py/runtime.h"
#include "py/mphal.h"
#include "modmachine.h"
#if MICROPY_PY_MACHINE_DAC
#include "driver/gpio.h"
#include "driver/dac.h"
typedef struct _mdac_obj_t {
mp_obj_base_t base;
gpio_num_t gpio_id;
dac_channel_t dac_id;
} mdac_obj_t;
STATIC const mdac_obj_t mdac_obj[] = {
#if CONFIG_IDF_TARGET_ESP32
{{&machine_dac_type}, GPIO_NUM_25, DAC_CHANNEL_1},
{{&machine_dac_type}, GPIO_NUM_26, DAC_CHANNEL_2},
#else
{{&machine_dac_type}, GPIO_NUM_17, DAC_CHANNEL_1},
{{&machine_dac_type}, GPIO_NUM_18, DAC_CHANNEL_2},
#endif
};
STATIC mp_obj_t mdac_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw,
const mp_obj_t *args) {
mp_arg_check_num(n_args, n_kw, 1, 1, true);
gpio_num_t pin_id = machine_pin_get_id(args[0]);
const mdac_obj_t *self = NULL;
for (int i = 0; i < MP_ARRAY_SIZE(mdac_obj); i++) {
if (pin_id == mdac_obj[i].gpio_id) {
self = &mdac_obj[i];
break;
}
}
if (!self) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid Pin for DAC"));
}
esp_err_t err = dac_output_enable(self->dac_id);
if (err == ESP_OK) {
err = dac_output_voltage(self->dac_id, 0);
}
if (err == ESP_OK) {
return MP_OBJ_FROM_PTR(self);
}
mp_raise_ValueError(MP_ERROR_TEXT("parameter error"));
}
STATIC void mdac_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
mdac_obj_t *self = self_in;
mp_printf(print, "DAC(Pin(%u))", self->gpio_id);
}
STATIC mp_obj_t mdac_write(mp_obj_t self_in, mp_obj_t value_in) {
mdac_obj_t *self = self_in;
int value = mp_obj_get_int(value_in);
if (value < 0 || value > 255) {
mp_raise_ValueError(MP_ERROR_TEXT("value out of range"));
}
esp_err_t err = dac_output_voltage(self->dac_id, value);
if (err == ESP_OK) {
return mp_const_none;
}
mp_raise_ValueError(MP_ERROR_TEXT("parameter error"));
}
MP_DEFINE_CONST_FUN_OBJ_2(mdac_write_obj, mdac_write);
STATIC const mp_rom_map_elem_t mdac_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mdac_write_obj) },
};
STATIC MP_DEFINE_CONST_DICT(mdac_locals_dict, mdac_locals_dict_table);
const mp_obj_type_t machine_dac_type = {
{ &mp_type_type },
.name = MP_QSTR_DAC,
.print = mdac_print,
.make_new = mdac_make_new,
.locals_dict = (mp_obj_t)&mdac_locals_dict,
};
#endif // MICROPY_PY_MACHINE_DAC
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_dac.c | C | apache-2.0 | 3,697 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2017 "Eric Poulsen" <eric@zyxod.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "py/runtime.h"
#include "py/stream.h"
#include "py/mphal.h"
#include "extmod/machine_spi.h"
#include "modmachine.h"
#include "driver/spi_master.h"
// SPI mappings by device, naming used by IDF old/new
// upython | ESP32 | ESP32S2 | ESP32S3 | ESP32C3
// ----------+-----------+-----------+---------+---------
// SPI(id=1) | HSPI/SPI2 | FSPI/SPI2 | SPI2 | SPI2
// SPI(id=2) | VSPI/SPI3 | HSPI/SPI3 | SPI3 | err
// Default pins for SPI(id=1) aka IDF SPI2, can be overridden by a board
#ifndef MICROPY_HW_SPI1_SCK
#ifdef SPI2_IOMUX_PIN_NUM_CLK
// Use IO_MUX pins by default.
// If SPI lines are routed to other pins through GPIO matrix
// routing adds some delay and lower limit applies to SPI clk freq
#define MICROPY_HW_SPI1_SCK SPI2_IOMUX_PIN_NUM_CLK // pin 14 on ESP32
#define MICROPY_HW_SPI1_MOSI SPI2_IOMUX_PIN_NUM_MOSI // pin 13 on ESP32
#define MICROPY_HW_SPI1_MISO SPI2_IOMUX_PIN_NUM_MISO // pin 12 on ESP32
// Only for compatibility with IDF 4.2 and older
#elif CONFIG_IDF_TARGET_ESP32S2
#define MICROPY_HW_SPI1_SCK FSPI_IOMUX_PIN_NUM_CLK
#define MICROPY_HW_SPI1_MOSI FSPI_IOMUX_PIN_NUM_MOSI
#define MICROPY_HW_SPI1_MISO FSPI_IOMUX_PIN_NUM_MISO
#else
#define MICROPY_HW_SPI1_SCK HSPI_IOMUX_PIN_NUM_CLK
#define MICROPY_HW_SPI1_MOSI HSPI_IOMUX_PIN_NUM_MOSI
#define MICROPY_HW_SPI1_MISO HSPI_IOMUX_PIN_NUM_MISO
#endif
#endif
// Default pins for SPI(id=2) aka IDF SPI3, can be overridden by a board
#ifndef MICROPY_HW_SPI2_SCK
#if CONFIG_IDF_TARGET_ESP32
// ESP32 has IO_MUX pins for VSPI/SPI3 lines, use them as defaults
#define MICROPY_HW_SPI2_SCK VSPI_IOMUX_PIN_NUM_CLK // pin 18
#define MICROPY_HW_SPI2_MOSI VSPI_IOMUX_PIN_NUM_MOSI // pin 23
#define MICROPY_HW_SPI2_MISO VSPI_IOMUX_PIN_NUM_MISO // pin 19
#elif CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
// ESP32S2 and S3 uses GPIO matrix for SPI3 pins, no IO_MUX possible
// Set defaults to the pins used by SPI2 in Octal mode
#define MICROPY_HW_SPI2_SCK (36)
#define MICROPY_HW_SPI2_MOSI (35)
#define MICROPY_HW_SPI2_MISO (37)
#endif
#endif
#define MP_HW_SPI_MAX_XFER_BYTES (4092)
#define MP_HW_SPI_MAX_XFER_BITS (MP_HW_SPI_MAX_XFER_BYTES * 8) // Has to be an even multiple of 8
#if CONFIG_IDF_TARGET_ESP32C3
#define HSPI_HOST SPI2_HOST
#elif CONFIG_IDF_TARGET_ESP32S3
#define HSPI_HOST SPI3_HOST
#define FSPI_HOST SPI2_HOST
#endif
typedef struct _machine_hw_spi_default_pins_t {
int8_t sck;
int8_t mosi;
int8_t miso;
} machine_hw_spi_default_pins_t;
typedef struct _machine_hw_spi_obj_t {
mp_obj_base_t base;
spi_host_device_t host;
uint32_t baudrate;
uint8_t polarity;
uint8_t phase;
uint8_t bits;
uint8_t firstbit;
int8_t sck;
int8_t mosi;
int8_t miso;
spi_device_handle_t spi;
enum {
MACHINE_HW_SPI_STATE_NONE,
MACHINE_HW_SPI_STATE_INIT,
MACHINE_HW_SPI_STATE_DEINIT
} state;
} machine_hw_spi_obj_t;
// Default pin mappings for the hardware SPI instances
STATIC const machine_hw_spi_default_pins_t machine_hw_spi_default_pins[2] = {
{ .sck = MICROPY_HW_SPI1_SCK, .mosi = MICROPY_HW_SPI1_MOSI, .miso = MICROPY_HW_SPI1_MISO },
#ifdef MICROPY_HW_SPI2_SCK
{ .sck = MICROPY_HW_SPI2_SCK, .mosi = MICROPY_HW_SPI2_MOSI, .miso = MICROPY_HW_SPI2_MISO },
#endif
};
// Static objects mapping to HSPI and VSPI hardware peripherals
STATIC machine_hw_spi_obj_t machine_hw_spi_obj[2];
STATIC void machine_hw_spi_deinit_internal(machine_hw_spi_obj_t *self) {
switch (spi_bus_remove_device(self->spi)) {
case ESP_ERR_INVALID_ARG:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid configuration"));
return;
case ESP_ERR_INVALID_STATE:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("SPI device already freed"));
return;
}
switch (spi_bus_free(self->host)) {
case ESP_ERR_INVALID_ARG:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid configuration"));
return;
case ESP_ERR_INVALID_STATE:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("SPI bus already freed"));
return;
}
int8_t pins[3] = {self->miso, self->mosi, self->sck};
for (int i = 0; i < 3; i++) {
if (pins[i] != -1) {
gpio_pad_select_gpio(pins[i]);
gpio_matrix_out(pins[i], SIG_GPIO_OUT_IDX, false, false);
gpio_set_direction(pins[i], GPIO_MODE_INPUT);
}
}
}
STATIC void machine_hw_spi_init_internal(
machine_hw_spi_obj_t *self,
int8_t host,
int32_t baudrate,
int8_t polarity,
int8_t phase,
int8_t bits,
int8_t firstbit,
int8_t sck,
int8_t mosi,
int8_t miso) {
// if we're not initialized, then we're
// implicitly 'changed', since this is the init routine
bool changed = self->state != MACHINE_HW_SPI_STATE_INIT;
esp_err_t ret;
machine_hw_spi_obj_t old_self = *self;
if (host != -1 && host != self->host) {
self->host = host;
changed = true;
}
if (baudrate != -1) {
// calculate the actual clock frequency that the SPI peripheral can produce
baudrate = spi_get_actual_clock(APB_CLK_FREQ, baudrate, 0);
if (baudrate != self->baudrate) {
self->baudrate = baudrate;
changed = true;
}
}
if (polarity != -1 && polarity != self->polarity) {
self->polarity = polarity;
changed = true;
}
if (phase != -1 && phase != self->phase) {
self->phase = phase;
changed = true;
}
if (bits != -1 && bits != self->bits) {
self->bits = bits;
changed = true;
}
if (firstbit != -1 && firstbit != self->firstbit) {
self->firstbit = firstbit;
changed = true;
}
if (sck != -2 && sck != self->sck) {
self->sck = sck;
changed = true;
}
if (mosi != -2 && mosi != self->mosi) {
self->mosi = mosi;
changed = true;
}
if (miso != -2 && miso != self->miso) {
self->miso = miso;
changed = true;
}
if (self->host != HSPI_HOST
#ifdef FSPI_HOST
&& self->host != FSPI_HOST
#endif
#ifdef VSPI_HOST
&& self->host != VSPI_HOST
#endif
) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("SPI(%d) doesn't exist"), self->host);
}
if (changed) {
if (self->state == MACHINE_HW_SPI_STATE_INIT) {
self->state = MACHINE_HW_SPI_STATE_DEINIT;
machine_hw_spi_deinit_internal(&old_self);
}
} else {
return; // no changes
}
spi_bus_config_t buscfg = {
.miso_io_num = self->miso,
.mosi_io_num = self->mosi,
.sclk_io_num = self->sck,
.quadwp_io_num = -1,
.quadhd_io_num = -1
};
spi_device_interface_config_t devcfg = {
.clock_speed_hz = self->baudrate,
.mode = self->phase | (self->polarity << 1),
.spics_io_num = -1, // No CS pin
.queue_size = 2,
.flags = self->firstbit == MICROPY_PY_MACHINE_SPI_LSB ? SPI_DEVICE_TXBIT_LSBFIRST | SPI_DEVICE_RXBIT_LSBFIRST : 0,
.pre_cb = NULL
};
// Initialize the SPI bus
// Select DMA channel based on the hardware SPI host
int dma_chan = 0;
if (self->host == HSPI_HOST) {
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
dma_chan = 3;
#else
dma_chan = 1;
#endif
#ifdef FSPI_HOST
} else if (self->host == FSPI_HOST) {
dma_chan = 1;
#endif
#ifdef VSPI_HOST
} else if (self->host == VSPI_HOST) {
dma_chan = 2;
#endif
}
ret = spi_bus_initialize(self->host, &buscfg, dma_chan);
switch (ret) {
case ESP_ERR_INVALID_ARG:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid configuration"));
return;
case ESP_ERR_INVALID_STATE:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("SPI host already in use"));
return;
}
ret = spi_bus_add_device(self->host, &devcfg, &self->spi);
switch (ret) {
case ESP_ERR_INVALID_ARG:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid configuration"));
spi_bus_free(self->host);
return;
case ESP_ERR_NO_MEM:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("out of memory"));
spi_bus_free(self->host);
return;
case ESP_ERR_NOT_FOUND:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("no free slots"));
spi_bus_free(self->host);
return;
}
self->state = MACHINE_HW_SPI_STATE_INIT;
}
STATIC void machine_hw_spi_deinit(mp_obj_base_t *self_in) {
machine_hw_spi_obj_t *self = (machine_hw_spi_obj_t *)self_in;
if (self->state == MACHINE_HW_SPI_STATE_INIT) {
self->state = MACHINE_HW_SPI_STATE_DEINIT;
machine_hw_spi_deinit_internal(self);
}
}
STATIC mp_uint_t gcd(mp_uint_t x, mp_uint_t y) {
while (x != y) {
if (x > y) {
x -= y;
} else {
y -= x;
}
}
return x;
}
STATIC void machine_hw_spi_transfer(mp_obj_base_t *self_in, size_t len, const uint8_t *src, uint8_t *dest) {
machine_hw_spi_obj_t *self = MP_OBJ_TO_PTR(self_in);
if (self->state == MACHINE_HW_SPI_STATE_DEINIT) {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("transfer on deinitialized SPI"));
return;
}
// Round to nearest whole set of bits
int bits_to_send = len * 8 / self->bits * self->bits;
if (!bits_to_send) {
mp_raise_ValueError(MP_ERROR_TEXT("buffer too short"));
}
if (len <= 4) {
spi_transaction_t transaction = { 0 };
if (src != NULL) {
memcpy(&transaction.tx_data, src, len);
}
transaction.flags = SPI_TRANS_USE_TXDATA | SPI_TRANS_USE_RXDATA;
transaction.length = bits_to_send;
spi_device_transmit(self->spi, &transaction);
if (dest != NULL) {
memcpy(dest, &transaction.rx_data, len);
}
} else {
int offset = 0;
int bits_remaining = bits_to_send;
int optimum_word_size = 8 * self->bits / gcd(8, self->bits);
int max_transaction_bits = MP_HW_SPI_MAX_XFER_BITS / optimum_word_size * optimum_word_size;
spi_transaction_t *transaction, *result, transactions[2];
int i = 0;
spi_device_acquire_bus(self->spi, portMAX_DELAY);
while (bits_remaining) {
transaction = transactions + i++ % 2;
memset(transaction, 0, sizeof(spi_transaction_t));
transaction->length =
bits_remaining > max_transaction_bits ? max_transaction_bits : bits_remaining;
if (src != NULL) {
transaction->tx_buffer = src + offset;
}
if (dest != NULL) {
transaction->rx_buffer = dest + offset;
}
spi_device_queue_trans(self->spi, transaction, portMAX_DELAY);
bits_remaining -= transaction->length;
if (offset > 0) {
// wait for previously queued transaction
MP_THREAD_GIL_EXIT();
spi_device_get_trans_result(self->spi, &result, portMAX_DELAY);
MP_THREAD_GIL_ENTER();
}
// doesn't need ceil(); loop ends when bits_remaining is 0
offset += transaction->length / 8;
}
// wait for last transaction
MP_THREAD_GIL_EXIT();
spi_device_get_trans_result(self->spi, &result, portMAX_DELAY);
MP_THREAD_GIL_ENTER();
spi_device_release_bus(self->spi);
}
}
/******************************************************************************/
// MicroPython bindings for hw_spi
STATIC void machine_hw_spi_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
machine_hw_spi_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "SPI(id=%u, baudrate=%u, polarity=%u, phase=%u, bits=%u, firstbit=%u, sck=%d, mosi=%d, miso=%d)",
self->host, self->baudrate, self->polarity,
self->phase, self->bits, self->firstbit,
self->sck, self->mosi, self->miso);
}
STATIC void machine_hw_spi_init(mp_obj_base_t *self_in, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
machine_hw_spi_obj_t *self = (machine_hw_spi_obj_t *)self_in;
enum { ARG_id, ARG_baudrate, ARG_polarity, ARG_phase, ARG_bits, ARG_firstbit, ARG_sck, ARG_mosi, ARG_miso };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_id, MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_baudrate, MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_polarity, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_phase, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_bits, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_firstbit, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_sck, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_mosi, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_miso, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args),
allowed_args, args);
int8_t sck, mosi, miso;
if (args[ARG_sck].u_obj == MP_OBJ_NULL) {
sck = -2;
} else if (args[ARG_sck].u_obj == mp_const_none) {
sck = -1;
} else {
sck = machine_pin_get_id(args[ARG_sck].u_obj);
}
if (args[ARG_miso].u_obj == MP_OBJ_NULL) {
miso = -2;
} else if (args[ARG_miso].u_obj == mp_const_none) {
miso = -1;
} else {
miso = machine_pin_get_id(args[ARG_miso].u_obj);
}
if (args[ARG_mosi].u_obj == MP_OBJ_NULL) {
mosi = -2;
} else if (args[ARG_mosi].u_obj == mp_const_none) {
mosi = -1;
} else {
mosi = machine_pin_get_id(args[ARG_mosi].u_obj);
}
machine_hw_spi_init_internal(self, args[ARG_id].u_int, args[ARG_baudrate].u_int,
args[ARG_polarity].u_int, args[ARG_phase].u_int, args[ARG_bits].u_int,
args[ARG_firstbit].u_int, sck, mosi, miso);
}
mp_obj_t machine_hw_spi_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
MP_MACHINE_SPI_CHECK_FOR_LEGACY_SOFTSPI_CONSTRUCTION(n_args, n_kw, all_args);
enum { ARG_id, ARG_baudrate, ARG_polarity, ARG_phase, ARG_bits, ARG_firstbit, ARG_sck, ARG_mosi, ARG_miso };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_id, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_baudrate, MP_ARG_INT, {.u_int = 500000} },
{ MP_QSTR_polarity, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
{ MP_QSTR_phase, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
{ MP_QSTR_bits, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 8} },
{ MP_QSTR_firstbit, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = MICROPY_PY_MACHINE_SPI_MSB} },
{ MP_QSTR_sck, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_mosi, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_miso, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
machine_hw_spi_obj_t *self;
const machine_hw_spi_default_pins_t *default_pins;
if (args[ARG_id].u_int == 1) { // SPI2_HOST which is FSPI_HOST on ESP32Sx, HSPI_HOST on others
self = &machine_hw_spi_obj[0];
default_pins = &machine_hw_spi_default_pins[0];
} else {
self = &machine_hw_spi_obj[1];
default_pins = &machine_hw_spi_default_pins[1];
}
self->base.type = &machine_hw_spi_type;
int8_t sck, mosi, miso;
if (args[ARG_sck].u_obj == MP_OBJ_NULL) {
sck = default_pins->sck;
} else if (args[ARG_sck].u_obj == mp_const_none) {
sck = -1;
} else {
sck = machine_pin_get_id(args[ARG_sck].u_obj);
}
if (args[ARG_mosi].u_obj == MP_OBJ_NULL) {
mosi = default_pins->mosi;
} else if (args[ARG_mosi].u_obj == mp_const_none) {
mosi = -1;
} else {
mosi = machine_pin_get_id(args[ARG_mosi].u_obj);
}
if (args[ARG_miso].u_obj == MP_OBJ_NULL) {
miso = default_pins->miso;
} else if (args[ARG_miso].u_obj == mp_const_none) {
miso = -1;
} else {
miso = machine_pin_get_id(args[ARG_miso].u_obj);
}
machine_hw_spi_init_internal(
self,
args[ARG_id].u_int,
args[ARG_baudrate].u_int,
args[ARG_polarity].u_int,
args[ARG_phase].u_int,
args[ARG_bits].u_int,
args[ARG_firstbit].u_int,
sck,
mosi,
miso);
return MP_OBJ_FROM_PTR(self);
}
STATIC const mp_machine_spi_p_t machine_hw_spi_p = {
.init = machine_hw_spi_init,
.deinit = machine_hw_spi_deinit,
.transfer = machine_hw_spi_transfer,
};
const mp_obj_type_t machine_hw_spi_type = {
{ &mp_type_type },
.name = MP_QSTR_SPI,
.print = machine_hw_spi_print,
.make_new = machine_hw_spi_make_new,
.protocol = &machine_hw_spi_p,
.locals_dict = (mp_obj_dict_t *)&mp_machine_spi_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_hw_spi.c | C | apache-2.0 | 18,762 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2019 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "py/runtime.h"
#include "py/mphal.h"
#include "py/mperrno.h"
#include "extmod/machine_i2c.h"
#include "modmachine.h"
#include "driver/i2c.h"
#ifndef MICROPY_HW_I2C0_SCL
#define MICROPY_HW_I2C0_SCL (GPIO_NUM_18)
#define MICROPY_HW_I2C0_SDA (GPIO_NUM_19)
#endif
#ifndef MICROPY_HW_I2C1_SCL
#if CONFIG_IDF_TARGET_ESP32
#define MICROPY_HW_I2C1_SCL (GPIO_NUM_25)
#define MICROPY_HW_I2C1_SDA (GPIO_NUM_26)
#else
#define MICROPY_HW_I2C1_SCL (GPIO_NUM_9)
#define MICROPY_HW_I2C1_SDA (GPIO_NUM_8)
#endif
#endif
#define I2C_DEFAULT_TIMEOUT_US (10000) // 10ms
typedef struct _machine_hw_i2c_obj_t {
mp_obj_base_t base;
i2c_port_t port : 8;
gpio_num_t scl : 8;
gpio_num_t sda : 8;
} machine_hw_i2c_obj_t;
STATIC machine_hw_i2c_obj_t machine_hw_i2c_obj[I2C_NUM_MAX];
STATIC void machine_hw_i2c_init(machine_hw_i2c_obj_t *self, uint32_t freq, uint32_t timeout_us, bool first_init) {
if (!first_init) {
i2c_driver_delete(self->port);
}
i2c_config_t conf = {
.mode = I2C_MODE_MASTER,
.sda_io_num = self->sda,
.sda_pullup_en = GPIO_PULLUP_ENABLE,
.scl_io_num = self->scl,
.scl_pullup_en = GPIO_PULLUP_ENABLE,
.master.clk_speed = freq,
};
i2c_param_config(self->port, &conf);
i2c_set_timeout(self->port, I2C_APB_CLK_FREQ / 1000000 * timeout_us);
i2c_driver_install(self->port, I2C_MODE_MASTER, 0, 0, 0);
}
int machine_hw_i2c_transfer(mp_obj_base_t *self_in, uint16_t addr, size_t n, mp_machine_i2c_buf_t *bufs, unsigned int flags) {
machine_hw_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
i2c_master_start(cmd);
i2c_master_write_byte(cmd, addr << 1 | (flags & MP_MACHINE_I2C_FLAG_READ), true);
int data_len = 0;
for (; n--; ++bufs) {
if (flags & MP_MACHINE_I2C_FLAG_READ) {
i2c_master_read(cmd, bufs->buf, bufs->len, n == 0 ? I2C_MASTER_LAST_NACK : I2C_MASTER_ACK);
} else {
if (bufs->len != 0) {
i2c_master_write(cmd, bufs->buf, bufs->len, true);
}
}
data_len += bufs->len;
}
if (flags & MP_MACHINE_I2C_FLAG_STOP) {
i2c_master_stop(cmd);
}
// TODO proper timeout
esp_err_t err = i2c_master_cmd_begin(self->port, cmd, 100 * (1 + data_len) / portTICK_RATE_MS);
i2c_cmd_link_delete(cmd);
if (err == ESP_FAIL) {
return -MP_ENODEV;
} else if (err == ESP_ERR_TIMEOUT) {
return -MP_ETIMEDOUT;
} else if (err != ESP_OK) {
return -abs(err);
}
return data_len;
}
/******************************************************************************/
// MicroPython bindings for machine API
STATIC void machine_hw_i2c_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
machine_hw_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
int h, l;
i2c_get_period(self->port, &h, &l);
mp_printf(print, "I2C(%u, scl=%u, sda=%u, freq=%u)",
self->port, self->scl, self->sda, I2C_APB_CLK_FREQ / (h + l));
}
mp_obj_t machine_hw_i2c_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
MP_MACHINE_I2C_CHECK_FOR_LEGACY_SOFTI2C_CONSTRUCTION(n_args, n_kw, all_args);
// Parse args
enum { ARG_id, ARG_scl, ARG_sda, ARG_freq, ARG_timeout };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_id, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_scl, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_sda, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_freq, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 400000} },
{ MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = I2C_DEFAULT_TIMEOUT_US} },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
// Get I2C bus
mp_int_t i2c_id = mp_obj_get_int(args[ARG_id].u_obj);
if (!(I2C_NUM_0 <= i2c_id && i2c_id < I2C_NUM_MAX)) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("I2C(%d) doesn't exist"), i2c_id);
}
// Get static peripheral object
machine_hw_i2c_obj_t *self = (machine_hw_i2c_obj_t *)&machine_hw_i2c_obj[i2c_id];
bool first_init = false;
if (self->base.type == NULL) {
// Created for the first time, set default pins
self->base.type = &machine_hw_i2c_type;
self->port = i2c_id;
if (self->port == I2C_NUM_0) {
self->scl = MICROPY_HW_I2C0_SCL;
self->sda = MICROPY_HW_I2C0_SDA;
} else {
self->scl = MICROPY_HW_I2C1_SCL;
self->sda = MICROPY_HW_I2C1_SDA;
}
first_init = true;
}
// Set SCL/SDA pins if given
if (args[ARG_scl].u_obj != MP_OBJ_NULL) {
self->scl = mp_hal_get_pin_obj(args[ARG_scl].u_obj);
}
if (args[ARG_sda].u_obj != MP_OBJ_NULL) {
self->sda = mp_hal_get_pin_obj(args[ARG_sda].u_obj);
}
// Initialise the I2C peripheral
machine_hw_i2c_init(self, args[ARG_freq].u_int, args[ARG_timeout].u_int, first_init);
return MP_OBJ_FROM_PTR(self);
}
STATIC const mp_machine_i2c_p_t machine_hw_i2c_p = {
.transfer = machine_hw_i2c_transfer,
};
const mp_obj_type_t machine_hw_i2c_type = {
{ &mp_type_type },
.name = MP_QSTR_I2C,
.print = machine_hw_i2c_print,
.make_new = machine_hw_i2c_make_new,
.protocol = &machine_hw_i2c_p,
.locals_dict = (mp_obj_dict_t *)&mp_machine_i2c_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_i2c.c | C | apache-2.0 | 6,798 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2021 Mike Teachman
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include "py/obj.h"
#include "py/runtime.h"
#include "py/misc.h"
#include "py/stream.h"
#include "py/objstr.h"
#include "modmachine.h"
#include "mphalport.h"
#if MICROPY_PY_MACHINE_I2S
#include "driver/i2s.h"
#include "soc/i2s_reg.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "esp_task.h"
// The I2S module has 3 modes of operation:
//
// Mode1: Blocking
// - readinto() and write() methods block until the supplied buffer is filled (read) or emptied (write)
// - this is the default mode of operation
//
// Mode2: Non-Blocking
// - readinto() and write() methods return immediately.
// - buffer filling and emptying happens asynchronously to the main MicroPython task
// - a callback function is called when the supplied buffer has been filled (read) or emptied (write)
// - non-blocking mode is enabled when a callback is set with the irq() method
// - a FreeRTOS task is created to implement the asynchronous background operations
// - a FreeRTOS queue is used to transfer the supplied buffer to the background task
//
// Mode3: Uasyncio
// - implements the stream protocol
// - uasyncio mode is enabled when the ioctl() function is called
// - the I2S event queue is used to detect that I2S samples can be read or written from/to DMA memory
//
// The samples contained in the app buffer supplied for the readinto() and write() methods have the following convention:
// Mono: little endian format
// Stereo: little endian format, left channel first
//
// I2S terms:
// "frame": consists of two audio samples (Left audio sample + Right audio sample)
//
// Misc:
// - for Mono configuration:
// - readinto method: samples are gathered from the L channel only
// - write method: every sample is output to both the L and R channels
// - for readinto method the I2S hardware is read using 8-byte frames
// (this is standard for almost all I2S hardware, such as MEMS microphones)
// - all sample data transfers use DMA
#define I2S_TASK_PRIORITY (ESP_TASK_PRIO_MIN + 1)
#define I2S_TASK_STACK_SIZE (2048)
#define DMA_BUF_LEN_IN_I2S_FRAMES (256)
// The transform buffer is used with the readinto() method to bridge the opaque DMA memory on the ESP devices
// with the app buffer. It facilitates audio sample transformations. e.g. 32-bits samples to 16-bit samples.
// The size of 240 bytes is an engineering optimum that balances transfer performance with an acceptable use of heap space
#define SIZEOF_TRANSFORM_BUFFER_IN_BYTES (240)
#define NUM_I2S_USER_FORMATS (4)
#define I2S_RX_FRAME_SIZE_IN_BYTES (8)
typedef enum {
MONO,
STEREO
} format_t;
typedef enum {
BLOCKING,
NON_BLOCKING,
UASYNCIO
} io_mode_t;
typedef enum {
I2S_TX_TRANSFER,
I2S_RX_TRANSFER,
} direction_t;
typedef struct _non_blocking_descriptor_t {
mp_buffer_info_t appbuf;
mp_obj_t callback;
direction_t direction;
} non_blocking_descriptor_t;
typedef struct _machine_i2s_obj_t {
mp_obj_base_t base;
i2s_port_t port;
mp_hal_pin_obj_t sck;
mp_hal_pin_obj_t ws;
mp_hal_pin_obj_t sd;
int8_t mode;
i2s_bits_per_sample_t bits;
format_t format;
int32_t rate;
int32_t ibuf;
mp_obj_t callback_for_non_blocking;
io_mode_t io_mode;
uint8_t transform_buffer[SIZEOF_TRANSFORM_BUFFER_IN_BYTES];
QueueHandle_t i2s_event_queue;
QueueHandle_t non_blocking_mode_queue;
TaskHandle_t non_blocking_mode_task;
} machine_i2s_obj_t;
STATIC mp_obj_t machine_i2s_deinit(mp_obj_t self_in);
// The frame map is used with the readinto() method to transform the audio sample data coming
// from DMA memory (32-bit stereo, with the L and R channels reversed) to the format specified
// in the I2S constructor. e.g. 16-bit mono
STATIC const int8_t i2s_frame_map[NUM_I2S_USER_FORMATS][I2S_RX_FRAME_SIZE_IN_BYTES] = {
{ 6, 7, -1, -1, -1, -1, -1, -1 }, // Mono, 16-bits
{ 4, 5, 6, 7, -1, -1, -1, -1 }, // Mono, 32-bits
{ 6, 7, 2, 3, -1, -1, -1, -1 }, // Stereo, 16-bits
{ 4, 5, 6, 7, 0, 1, 2, 3 }, // Stereo, 32-bits
};
void machine_i2s_init0() {
for (i2s_port_t p = 0; p < I2S_NUM_MAX; p++) {
MP_STATE_PORT(machine_i2s_obj)[p] = NULL;
}
}
// The following function takes a sample buffer and swaps L/R channels
//
// Background: For 32-bit stereo, the ESP-IDF API has a L/R channel orientation that breaks
// convention with other ESP32 channel formats
//
// appbuf[] = [L_0-7, L_8-15, L_16-23, L_24-31, R_0-7, R_8-15, R_16-23, R_24-31] = [Left channel, Right channel]
// dma[] = [R_0-7, R_8-15, R_16-23, R_24-31, L_0-7, L_8-15, L_16-23, L_24-31] = [Right channel, Left channel]
//
// where:
// L_0-7 is the least significant byte of the 32 bit sample in the Left channel
// L_24-31 is the most significant byte of the 32 bit sample in the Left channel
//
// Example:
//
// appbuf[] = [0x99, 0xBB, 0x11, 0x22, 0x44, 0x55, 0xAB, 0x77] = [Left channel, Right channel]
// dma[] = [0x44, 0x55, 0xAB, 0x77, 0x99, 0xBB, 0x11, 0x22] = [Right channel, Left channel]
// where:
// LEFT Channel = 0x99, 0xBB, 0x11, 0x22
// RIGHT Channel = 0x44, 0x55, 0xAB, 0x77
//
// samples in appbuf are in little endian format:
// 0x77 is the most significant byte of the 32-bit sample
// 0x44 is the least significant byte of the 32-bit sample
STATIC void swap_32_bit_stereo_channels(mp_buffer_info_t *bufinfo) {
int32_t swap_sample;
int32_t *sample = bufinfo->buf;
uint32_t num_samples = bufinfo->len / 4;
for (uint32_t i = 0; i < num_samples; i += 2) {
swap_sample = sample[i + 1];
sample[i + 1] = sample[i];
sample[i] = swap_sample;
}
}
STATIC int8_t get_frame_mapping_index(i2s_bits_per_sample_t bits, format_t format) {
if (format == MONO) {
if (bits == I2S_BITS_PER_SAMPLE_16BIT) {
return 0;
} else { // 32 bits
return 1;
}
} else { // STEREO
if (bits == I2S_BITS_PER_SAMPLE_16BIT) {
return 2;
} else { // 32 bits
return 3;
}
}
}
STATIC i2s_bits_per_sample_t get_dma_bits(uint8_t mode, i2s_bits_per_sample_t bits) {
if (mode == (I2S_MODE_MASTER | I2S_MODE_TX)) {
return bits;
} else { // Master Rx
// read 32 bit samples for I2S hardware. e.g. MEMS microphones
return I2S_BITS_PER_SAMPLE_32BIT;
}
}
STATIC i2s_channel_fmt_t get_dma_format(uint8_t mode, format_t format) {
if (mode == (I2S_MODE_MASTER | I2S_MODE_TX)) {
if (format == MONO) {
return I2S_CHANNEL_FMT_ONLY_LEFT;
} else { // STEREO
return I2S_CHANNEL_FMT_RIGHT_LEFT;
}
} else { // Master Rx
// read stereo frames for all I2S hardware
return I2S_CHANNEL_FMT_RIGHT_LEFT;
}
}
STATIC uint32_t get_dma_buf_count(uint8_t mode, i2s_bits_per_sample_t bits, format_t format, int32_t ibuf) {
// calculate how many DMA buffers need to be allocated
uint32_t dma_frame_size_in_bytes =
(get_dma_bits(mode, bits) / 8) * (get_dma_format(mode, format) == I2S_CHANNEL_FMT_RIGHT_LEFT ? 2: 1);
uint32_t dma_buf_count = ibuf / (DMA_BUF_LEN_IN_I2S_FRAMES * dma_frame_size_in_bytes);
return dma_buf_count;
}
STATIC uint32_t fill_appbuf_from_dma(machine_i2s_obj_t *self, mp_buffer_info_t *appbuf) {
// copy audio samples from DMA memory to the app buffer
// audio samples are read from DMA memory in chunks
// loop, reading and copying chunks until the app buffer is filled
// For uasyncio mode, the loop will make an early exit if DMA memory becomes empty
// Example:
// a MicroPython I2S object is configured for 16-bit mono (2 bytes per audio sample).
// For every frame coming from DMA (8 bytes), 2 bytes are "cherry picked" and
// copied to the supplied app buffer.
// Thus, for every 1 byte copied to the app buffer, 4 bytes are read from DMA memory.
// If a 8kB app buffer is supplied, 32kB of audio samples is read from DMA memory.
uint32_t a_index = 0;
uint8_t *app_p = appbuf->buf;
uint8_t appbuf_sample_size_in_bytes = (self->bits / 8) * (self->format == STEREO ? 2: 1);
uint32_t num_bytes_needed_from_dma = appbuf->len * (I2S_RX_FRAME_SIZE_IN_BYTES / appbuf_sample_size_in_bytes);
while (num_bytes_needed_from_dma) {
size_t num_bytes_requested_from_dma = MIN(sizeof(self->transform_buffer), num_bytes_needed_from_dma);
size_t num_bytes_received_from_dma = 0;
TickType_t delay;
if (self->io_mode == UASYNCIO) {
delay = 0; // stop i2s_read() operation if DMA memory becomes empty
} else {
delay = portMAX_DELAY; // block until supplied buffer is filled
}
esp_err_t ret = i2s_read(
self->port,
self->transform_buffer,
num_bytes_requested_from_dma,
&num_bytes_received_from_dma,
delay);
// the following is a workaround for a bug in ESP-IDF v4.4
// https://github.com/espressif/esp-idf/issues/8121
#if (ESP_IDF_VERSION_MAJOR == 4) && (ESP_IDF_VERSION_MINOR >= 4)
if ((delay != portMAX_DELAY) && (ret == ESP_ERR_TIMEOUT)) {
ret = ESP_OK;
}
#endif
check_esp_err(ret);
// process the transform buffer one frame at a time.
// copy selected bytes from the transform buffer into the user supplied appbuf.
// Example:
// a MicroPython I2S object is configured for 16-bit mono. This configuration associates to
// a frame map index of 0 = { 6, 7, -1, -1, -1, -1, -1, -1 } in the i2s_frame_map array
// This mapping indicates:
// appbuf[x+0] = frame[6]
// appbuf[x+1] = frame[7]
// frame bytes 0-5 are not used
uint32_t t_index = 0;
uint8_t f_index = get_frame_mapping_index(self->bits, self->format);
while (t_index < num_bytes_received_from_dma) {
uint8_t *transform_p = self->transform_buffer + t_index;
for (uint8_t i = 0; i < I2S_RX_FRAME_SIZE_IN_BYTES; i++) {
int8_t t_to_a_mapping = i2s_frame_map[f_index][i];
if (t_to_a_mapping != -1) {
*app_p++ = transform_p[t_to_a_mapping];
a_index++;
}
t_index++;
}
}
num_bytes_needed_from_dma -= num_bytes_received_from_dma;
if ((self->io_mode == UASYNCIO) && (num_bytes_received_from_dma < num_bytes_requested_from_dma)) {
// Unable to fill the entire app buffer from DMA memory. This indicates all DMA RX buffers are empty.
// Clear the I2S event queue so ioctl() indicates that the I2S object cannot currently
// supply more audio samples
xQueueReset(self->i2s_event_queue);
break;
}
}
return a_index;
}
STATIC size_t copy_appbuf_to_dma(machine_i2s_obj_t *self, mp_buffer_info_t *appbuf) {
if ((self->bits == I2S_BITS_PER_SAMPLE_32BIT) && (self->format == STEREO)) {
swap_32_bit_stereo_channels(appbuf);
}
size_t num_bytes_written = 0;
TickType_t delay;
if (self->io_mode == UASYNCIO) {
delay = 0; // stop i2s_write() operation if DMA memory becomes full
} else {
delay = portMAX_DELAY; // block until supplied buffer is emptied
}
esp_err_t ret = i2s_write(self->port, appbuf->buf, appbuf->len, &num_bytes_written, delay);
// the following is a workaround for a bug in ESP-IDF v4.4
// https://github.com/espressif/esp-idf/issues/8121
#if (ESP_IDF_VERSION_MAJOR == 4) && (ESP_IDF_VERSION_MINOR >= 4)
if ((delay != portMAX_DELAY) && (ret == ESP_ERR_TIMEOUT)) {
ret = ESP_OK;
}
#endif
check_esp_err(ret);
if ((self->io_mode == UASYNCIO) && (num_bytes_written < appbuf->len)) {
// Unable to empty the entire app buffer into DMA memory. This indicates all DMA TX buffers are full.
// Clear the I2S event queue so ioctl() indicates that the I2S object cannot currently
// accept more audio samples
xQueueReset(self->i2s_event_queue);
// Undo the swap transformation as the buffer has not been completely emptied.
// The uasyncio stream writer will use the same buffer in a future write call.
if ((self->bits == I2S_BITS_PER_SAMPLE_32BIT) && (self->format == STEREO)) {
swap_32_bit_stereo_channels(appbuf);
}
}
return num_bytes_written;
}
// FreeRTOS task used for non-blocking mode
STATIC void task_for_non_blocking_mode(void *self_in) {
machine_i2s_obj_t *self = (machine_i2s_obj_t *)self_in;
non_blocking_descriptor_t descriptor;
for (;;) {
if (xQueueReceive(self->non_blocking_mode_queue, &descriptor, portMAX_DELAY)) {
if (descriptor.direction == I2S_TX_TRANSFER) {
copy_appbuf_to_dma(self, &descriptor.appbuf);
} else { // RX
fill_appbuf_from_dma(self, &descriptor.appbuf);
}
mp_sched_schedule(descriptor.callback, MP_OBJ_FROM_PTR(self));
}
}
}
STATIC void machine_i2s_init_helper(machine_i2s_obj_t *self, size_t n_pos_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum {
ARG_sck,
ARG_ws,
ARG_sd,
ARG_mode,
ARG_bits,
ARG_format,
ARG_rate,
ARG_ibuf,
};
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_sck, MP_ARG_KW_ONLY | MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_ws, MP_ARG_KW_ONLY | MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_sd, MP_ARG_KW_ONLY | MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_mode, MP_ARG_KW_ONLY | MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_bits, MP_ARG_KW_ONLY | MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_format, MP_ARG_KW_ONLY | MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_rate, MP_ARG_KW_ONLY | MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_ibuf, MP_ARG_KW_ONLY | MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = -1} },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_pos_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
//
// ---- Check validity of arguments ----
//
// are Pins valid?
int8_t sck = args[ARG_sck].u_obj == MP_OBJ_NULL ? -1 : mp_hal_get_pin_obj(args[ARG_sck].u_obj);
int8_t ws = args[ARG_ws].u_obj == MP_OBJ_NULL ? -1 : mp_hal_get_pin_obj(args[ARG_ws].u_obj);
int8_t sd = args[ARG_sd].u_obj == MP_OBJ_NULL ? -1 : mp_hal_get_pin_obj(args[ARG_sd].u_obj);
// is Mode valid?
i2s_mode_t mode = args[ARG_mode].u_int;
if ((mode != (I2S_MODE_MASTER | I2S_MODE_RX)) &&
(mode != (I2S_MODE_MASTER | I2S_MODE_TX))) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid mode"));
}
// is Bits valid?
i2s_bits_per_sample_t bits = args[ARG_bits].u_int;
if ((bits != I2S_BITS_PER_SAMPLE_16BIT) &&
(bits != I2S_BITS_PER_SAMPLE_32BIT)) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid bits"));
}
// is Format valid?
format_t format = args[ARG_format].u_int;
if ((format != STEREO) &&
(format != MONO)) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid format"));
}
// is Rate valid?
// Not checked: ESP-IDF I2S API does not indicate a valid range for sample rate
// is Ibuf valid?
// Not checked: ESP-IDF I2S API will return error if requested buffer size exceeds available memory
self->sck = sck;
self->ws = ws;
self->sd = sd;
self->mode = mode;
self->bits = bits;
self->format = format;
self->rate = args[ARG_rate].u_int;
self->ibuf = args[ARG_ibuf].u_int;
self->callback_for_non_blocking = MP_OBJ_NULL;
self->i2s_event_queue = NULL;
self->non_blocking_mode_queue = NULL;
self->non_blocking_mode_task = NULL;
self->io_mode = BLOCKING;
i2s_config_t i2s_config;
i2s_config.communication_format = I2S_COMM_FORMAT_I2S;
i2s_config.mode = mode;
i2s_config.bits_per_sample = get_dma_bits(mode, bits);
i2s_config.channel_format = get_dma_format(mode, format);
i2s_config.sample_rate = self->rate;
i2s_config.intr_alloc_flags = ESP_INTR_FLAG_LOWMED;
i2s_config.dma_buf_count = get_dma_buf_count(mode, bits, format, self->ibuf);
i2s_config.dma_buf_len = DMA_BUF_LEN_IN_I2S_FRAMES;
i2s_config.use_apll = false;
i2s_config.tx_desc_auto_clear = true;
i2s_config.fixed_mclk = 0;
#if (ESP_IDF_VERSION_MAJOR == 4) && (ESP_IDF_VERSION_MINOR >= 4)
i2s_config.mclk_multiple = I2S_MCLK_MULTIPLE_DEFAULT;
i2s_config.bits_per_chan = 0;
#endif
// I2S queue size equals the number of DMA buffers
check_esp_err(i2s_driver_install(self->port, &i2s_config, i2s_config.dma_buf_count, &self->i2s_event_queue));
// apply low-level workaround for bug in some ESP-IDF versions that swap
// the left and right channels
// https://github.com/espressif/esp-idf/issues/6625
#if CONFIG_IDF_TARGET_ESP32S3
REG_SET_BIT(I2S_TX_CONF_REG(self->port), I2S_TX_MSB_SHIFT);
REG_SET_BIT(I2S_TX_CONF_REG(self->port), I2S_RX_MSB_SHIFT);
#else
REG_SET_BIT(I2S_CONF_REG(self->port), I2S_TX_MSB_RIGHT);
REG_SET_BIT(I2S_CONF_REG(self->port), I2S_RX_MSB_RIGHT);
#endif
i2s_pin_config_t pin_config;
#if (ESP_IDF_VERSION_MAJOR == 4) && (ESP_IDF_VERSION_MINOR >= 4)
pin_config.mck_io_num = I2S_PIN_NO_CHANGE;
#endif
pin_config.bck_io_num = self->sck;
pin_config.ws_io_num = self->ws;
if (mode == (I2S_MODE_MASTER | I2S_MODE_RX)) {
pin_config.data_in_num = self->sd;
pin_config.data_out_num = I2S_PIN_NO_CHANGE;
} else { // TX
pin_config.data_in_num = I2S_PIN_NO_CHANGE;
pin_config.data_out_num = self->sd;
}
check_esp_err(i2s_set_pin(self->port, &pin_config));
}
STATIC void machine_i2s_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
machine_i2s_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "I2S(id=%u,\n"
"sck="MP_HAL_PIN_FMT ",\n"
"ws="MP_HAL_PIN_FMT ",\n"
"sd="MP_HAL_PIN_FMT ",\n"
"mode=%u,\n"
"bits=%u, format=%u,\n"
"rate=%d, ibuf=%d)",
self->port,
mp_hal_pin_name(self->sck),
mp_hal_pin_name(self->ws),
mp_hal_pin_name(self->sd),
self->mode,
self->bits, self->format,
self->rate, self->ibuf
);
}
STATIC mp_obj_t machine_i2s_make_new(const mp_obj_type_t *type, size_t n_pos_args, size_t n_kw_args, const mp_obj_t *args) {
mp_arg_check_num(n_pos_args, n_kw_args, 1, MP_OBJ_FUN_ARGS_MAX, true);
i2s_port_t port = mp_obj_get_int(args[0]);
if (port < 0 || port >= I2S_NUM_MAX) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid id"));
}
machine_i2s_obj_t *self;
if (MP_STATE_PORT(machine_i2s_obj)[port] == NULL) {
self = m_new_obj(machine_i2s_obj_t);
MP_STATE_PORT(machine_i2s_obj)[port] = self;
self->base.type = &machine_i2s_type;
self->port = port;
} else {
self = MP_STATE_PORT(machine_i2s_obj)[port];
machine_i2s_deinit(self);
}
mp_map_t kw_args;
mp_map_init_fixed_table(&kw_args, n_kw_args, args + n_pos_args);
machine_i2s_init_helper(self, n_pos_args - 1, args + 1, &kw_args);
return MP_OBJ_FROM_PTR(self);
}
STATIC mp_obj_t machine_i2s_obj_init(size_t n_pos_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
machine_i2s_obj_t *self = pos_args[0];
machine_i2s_deinit(self);
machine_i2s_init_helper(self, n_pos_args - 1, pos_args + 1, kw_args);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_i2s_init_obj, 1, machine_i2s_obj_init);
STATIC mp_obj_t machine_i2s_deinit(mp_obj_t self_in) {
machine_i2s_obj_t *self = MP_OBJ_TO_PTR(self_in);
i2s_driver_uninstall(self->port);
if (self->non_blocking_mode_task != NULL) {
vTaskDelete(self->non_blocking_mode_task);
self->non_blocking_mode_task = NULL;
}
if (self->non_blocking_mode_queue != NULL) {
vQueueDelete(self->non_blocking_mode_queue);
self->non_blocking_mode_queue = NULL;
}
self->i2s_event_queue = NULL;
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_i2s_deinit_obj, machine_i2s_deinit);
STATIC mp_obj_t machine_i2s_irq(mp_obj_t self_in, mp_obj_t handler) {
machine_i2s_obj_t *self = MP_OBJ_TO_PTR(self_in);
if (handler != mp_const_none && !mp_obj_is_callable(handler)) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid callback"));
}
if (handler != mp_const_none) {
self->io_mode = NON_BLOCKING;
// create a queue linking the MicroPython task to a FreeRTOS task
// that manages the non blocking mode of operation
self->non_blocking_mode_queue = xQueueCreate(1, sizeof(non_blocking_descriptor_t));
// non-blocking mode requires a background FreeRTOS task
if (xTaskCreatePinnedToCore(
task_for_non_blocking_mode,
"i2s_non_blocking",
I2S_TASK_STACK_SIZE,
self,
I2S_TASK_PRIORITY,
(TaskHandle_t *)&self->non_blocking_mode_task,
MP_TASK_COREID) != pdPASS) {
mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("failed to create I2S task"));
}
} else {
if (self->non_blocking_mode_task != NULL) {
vTaskDelete(self->non_blocking_mode_task);
self->non_blocking_mode_task = NULL;
}
if (self->non_blocking_mode_queue != NULL) {
vQueueDelete(self->non_blocking_mode_queue);
self->non_blocking_mode_queue = NULL;
}
self->io_mode = BLOCKING;
}
self->callback_for_non_blocking = handler;
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(machine_i2s_irq_obj, machine_i2s_irq);
// Shift() is typically used as a volume control.
// shift=1 increases volume by 6dB, shift=-1 decreases volume by 6dB
STATIC mp_obj_t machine_i2s_shift(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum { ARG_buf, ARG_bits, ARG_shift};
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_buf, MP_ARG_REQUIRED | MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
{ MP_QSTR_bits, MP_ARG_REQUIRED | MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_shift, MP_ARG_REQUIRED | MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
};
// parse args
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(args[ARG_buf].u_obj, &bufinfo, MP_BUFFER_RW);
int16_t *buf_16 = bufinfo.buf;
int32_t *buf_32 = bufinfo.buf;
uint8_t bits = args[ARG_bits].u_int;
int8_t shift = args[ARG_shift].u_int;
uint32_t num_audio_samples;
switch (bits) {
case 16:
num_audio_samples = bufinfo.len / 2;
break;
case 32:
num_audio_samples = bufinfo.len / 4;
break;
default:
mp_raise_ValueError(MP_ERROR_TEXT("invalid bits"));
break;
}
for (uint32_t i = 0; i < num_audio_samples; i++) {
switch (bits) {
case 16:
if (shift >= 0) {
buf_16[i] = buf_16[i] << shift;
} else {
buf_16[i] = buf_16[i] >> abs(shift);
}
break;
case 32:
if (shift >= 0) {
buf_32[i] = buf_32[i] << shift;
} else {
buf_32[i] = buf_32[i] >> abs(shift);
}
break;
}
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_i2s_shift_fun_obj, 0, machine_i2s_shift);
STATIC MP_DEFINE_CONST_STATICMETHOD_OBJ(machine_i2s_shift_obj, MP_ROM_PTR(&machine_i2s_shift_fun_obj));
STATIC const mp_rom_map_elem_t machine_i2s_locals_dict_table[] = {
// Methods
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_i2s_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
{ MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_i2s_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_irq), MP_ROM_PTR(&machine_i2s_irq_obj) },
// Static method
{ MP_ROM_QSTR(MP_QSTR_shift), MP_ROM_PTR(&machine_i2s_shift_obj) },
// Constants
{ MP_ROM_QSTR(MP_QSTR_RX), MP_ROM_INT(I2S_MODE_MASTER | I2S_MODE_RX) },
{ MP_ROM_QSTR(MP_QSTR_TX), MP_ROM_INT(I2S_MODE_MASTER | I2S_MODE_TX) },
{ MP_ROM_QSTR(MP_QSTR_STEREO), MP_ROM_INT(STEREO) },
{ MP_ROM_QSTR(MP_QSTR_MONO), MP_ROM_INT(MONO) },
};
MP_DEFINE_CONST_DICT(machine_i2s_locals_dict, machine_i2s_locals_dict_table);
STATIC mp_uint_t machine_i2s_stream_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, int *errcode) {
machine_i2s_obj_t *self = MP_OBJ_TO_PTR(self_in);
if (self->mode != (I2S_MODE_MASTER | I2S_MODE_RX)) {
*errcode = MP_EPERM;
return MP_STREAM_ERROR;
}
uint8_t appbuf_sample_size_in_bytes = (self->bits / 8) * (self->format == STEREO ? 2: 1);
if (size % appbuf_sample_size_in_bytes != 0) {
*errcode = MP_EINVAL;
return MP_STREAM_ERROR;
}
if (size == 0) {
return 0;
}
if (self->io_mode == NON_BLOCKING) {
non_blocking_descriptor_t descriptor;
descriptor.appbuf.buf = (void *)buf_in;
descriptor.appbuf.len = size;
descriptor.callback = self->callback_for_non_blocking;
descriptor.direction = I2S_RX_TRANSFER;
// send the descriptor to the task that handles non-blocking mode
xQueueSend(self->non_blocking_mode_queue, &descriptor, 0);
return size;
} else { // blocking or uasyncio mode
mp_buffer_info_t appbuf;
appbuf.buf = (void *)buf_in;
appbuf.len = size;
uint32_t num_bytes_read = fill_appbuf_from_dma(self, &appbuf);
return num_bytes_read;
}
}
STATIC mp_uint_t machine_i2s_stream_write(mp_obj_t self_in, const void *buf_in, mp_uint_t size, int *errcode) {
machine_i2s_obj_t *self = MP_OBJ_TO_PTR(self_in);
if (self->mode != (I2S_MODE_MASTER | I2S_MODE_TX)) {
*errcode = MP_EPERM;
return MP_STREAM_ERROR;
}
if (size == 0) {
return 0;
}
if (self->io_mode == NON_BLOCKING) {
non_blocking_descriptor_t descriptor;
descriptor.appbuf.buf = (void *)buf_in;
descriptor.appbuf.len = size;
descriptor.callback = self->callback_for_non_blocking;
descriptor.direction = I2S_TX_TRANSFER;
// send the descriptor to the task that handles non-blocking mode
xQueueSend(self->non_blocking_mode_queue, &descriptor, 0);
return size;
} else { // blocking or uasyncio mode
mp_buffer_info_t appbuf;
appbuf.buf = (void *)buf_in;
appbuf.len = size;
size_t num_bytes_written = copy_appbuf_to_dma(self, &appbuf);
return num_bytes_written;
}
}
STATIC mp_uint_t machine_i2s_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
machine_i2s_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_uint_t ret;
mp_uint_t flags = arg;
self->io_mode = UASYNCIO; // a call to ioctl() is an indication that uasyncio is being used
if (request == MP_STREAM_POLL) {
ret = 0;
if (flags & MP_STREAM_POLL_RD) {
if (self->mode != (I2S_MODE_MASTER | I2S_MODE_RX)) {
*errcode = MP_EPERM;
return MP_STREAM_ERROR;
}
i2s_event_t i2s_event;
// check event queue to determine if a DMA buffer has been filled
// (which is an indication that at least one DMA buffer is available to be read)
// note: timeout = 0 so the call is non-blocking
if (xQueueReceive(self->i2s_event_queue, &i2s_event, 0)) {
if (i2s_event.type == I2S_EVENT_RX_DONE) {
// getting here means that at least one DMA buffer is now full
// indicating that audio samples can be read from the I2S object
ret |= MP_STREAM_POLL_RD;
}
}
}
if (flags & MP_STREAM_POLL_WR) {
if (self->mode != (I2S_MODE_MASTER | I2S_MODE_TX)) {
*errcode = MP_EPERM;
return MP_STREAM_ERROR;
}
i2s_event_t i2s_event;
// check event queue to determine if a DMA buffer has been emptied
// (which is an indication that at least one DMA buffer is available to be written)
// note: timeout = 0 so the call is non-blocking
if (xQueueReceive(self->i2s_event_queue, &i2s_event, 0)) {
if (i2s_event.type == I2S_EVENT_TX_DONE) {
// getting here means that at least one DMA buffer is now empty
// indicating that audio samples can be written to the I2S object
ret |= MP_STREAM_POLL_WR;
}
}
}
} else {
*errcode = MP_EINVAL;
ret = MP_STREAM_ERROR;
}
return ret;
}
STATIC const mp_stream_p_t i2s_stream_p = {
.read = machine_i2s_stream_read,
.write = machine_i2s_stream_write,
.ioctl = machine_i2s_ioctl,
.is_text = false,
};
const mp_obj_type_t machine_i2s_type = {
{ &mp_type_type },
.name = MP_QSTR_I2S,
.print = machine_i2s_print,
.getiter = mp_identity_getiter,
.iternext = mp_stream_unbuffered_iter,
.protocol = &i2s_stream_p,
.make_new = machine_i2s_make_new,
.locals_dict = (mp_obj_dict_t *)&machine_i2s_locals_dict,
};
#endif // MICROPY_PY_MACHINE_I2S
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_i2s.c | C | apache-2.0 | 31,628 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include <string.h>
#include "driver/gpio.h"
#include "driver/rtc_io.h"
#include "py/runtime.h"
#include "py/mphal.h"
#include "mphalport.h"
#include "modmachine.h"
#include "extmod/virtpin.h"
#include "machine_rtc.h"
#include "modesp32.h"
#if CONFIG_IDF_TARGET_ESP32C3
#include "hal/gpio_ll.h"
#endif
// Used to implement a range of pull capabilities
#define GPIO_PULL_DOWN (1)
#define GPIO_PULL_UP (2)
#define GPIO_PULL_HOLD (4)
#if CONFIG_IDF_TARGET_ESP32
#define GPIO_FIRST_NON_OUTPUT (34)
#elif CONFIG_IDF_TARGET_ESP32S2
#define GPIO_FIRST_NON_OUTPUT (46)
#endif
typedef struct _machine_pin_obj_t {
mp_obj_base_t base;
gpio_num_t id;
} machine_pin_obj_t;
typedef struct _machine_pin_irq_obj_t {
mp_obj_base_t base;
gpio_num_t id;
} machine_pin_irq_obj_t;
STATIC const machine_pin_obj_t machine_pin_obj[] = {
#if CONFIG_IDF_TARGET_ESP32
{{&machine_pin_type}, GPIO_NUM_0},
{{&machine_pin_type}, GPIO_NUM_1},
{{&machine_pin_type}, GPIO_NUM_2},
{{&machine_pin_type}, GPIO_NUM_3},
{{&machine_pin_type}, GPIO_NUM_4},
{{&machine_pin_type}, GPIO_NUM_5},
{{&machine_pin_type}, GPIO_NUM_6},
{{&machine_pin_type}, GPIO_NUM_7},
{{&machine_pin_type}, GPIO_NUM_8},
{{&machine_pin_type}, GPIO_NUM_9},
{{&machine_pin_type}, GPIO_NUM_10},
{{&machine_pin_type}, GPIO_NUM_11},
{{&machine_pin_type}, GPIO_NUM_12},
{{&machine_pin_type}, GPIO_NUM_13},
{{&machine_pin_type}, GPIO_NUM_14},
{{&machine_pin_type}, GPIO_NUM_15},
{{&machine_pin_type}, GPIO_NUM_16},
{{&machine_pin_type}, GPIO_NUM_17},
{{&machine_pin_type}, GPIO_NUM_18},
{{&machine_pin_type}, GPIO_NUM_19},
{{NULL}, -1},
{{&machine_pin_type}, GPIO_NUM_21},
{{&machine_pin_type}, GPIO_NUM_22},
{{&machine_pin_type}, GPIO_NUM_23},
{{NULL}, -1},
{{&machine_pin_type}, GPIO_NUM_25},
{{&machine_pin_type}, GPIO_NUM_26},
{{&machine_pin_type}, GPIO_NUM_27},
{{NULL}, -1},
{{NULL}, -1},
{{NULL}, -1},
{{NULL}, -1},
{{&machine_pin_type}, GPIO_NUM_32},
{{&machine_pin_type}, GPIO_NUM_33},
{{&machine_pin_type}, GPIO_NUM_34},
{{&machine_pin_type}, GPIO_NUM_35},
{{&machine_pin_type}, GPIO_NUM_36},
{{&machine_pin_type}, GPIO_NUM_37},
{{&machine_pin_type}, GPIO_NUM_38},
{{&machine_pin_type}, GPIO_NUM_39},
#elif CONFIG_IDF_TARGET_ESP32C3
{{&machine_pin_type}, GPIO_NUM_0},
{{&machine_pin_type}, GPIO_NUM_1},
{{&machine_pin_type}, GPIO_NUM_2},
{{&machine_pin_type}, GPIO_NUM_3},
{{&machine_pin_type}, GPIO_NUM_4},
{{&machine_pin_type}, GPIO_NUM_5},
{{&machine_pin_type}, GPIO_NUM_6},
{{&machine_pin_type}, GPIO_NUM_7},
{{&machine_pin_type}, GPIO_NUM_8},
{{&machine_pin_type}, GPIO_NUM_9},
{{&machine_pin_type}, GPIO_NUM_10},
{{&machine_pin_type}, GPIO_NUM_11},
{{&machine_pin_type}, GPIO_NUM_12},
{{&machine_pin_type}, GPIO_NUM_13},
{{NULL}, -1}, // 14 FLASH
{{NULL}, -1}, // 15 FLASH
{{NULL}, -1}, // 16 FLASH
{{NULL}, -1}, // 17 FLASH
#if CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG
{{NULL}, -1}, // 18 is for native USB D-
{{NULL}, -1}, // 19 is for native USB D+
#else
{{&machine_pin_type}, GPIO_NUM_18},
{{&machine_pin_type}, GPIO_NUM_19},
#endif
{{&machine_pin_type}, GPIO_NUM_20},
{{&machine_pin_type}, GPIO_NUM_21},
#elif CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
{{&machine_pin_type}, GPIO_NUM_0},
{{&machine_pin_type}, GPIO_NUM_1},
{{&machine_pin_type}, GPIO_NUM_2},
{{&machine_pin_type}, GPIO_NUM_3},
{{&machine_pin_type}, GPIO_NUM_4},
{{&machine_pin_type}, GPIO_NUM_5},
{{&machine_pin_type}, GPIO_NUM_6},
{{&machine_pin_type}, GPIO_NUM_7},
{{&machine_pin_type}, GPIO_NUM_8},
{{&machine_pin_type}, GPIO_NUM_9},
{{&machine_pin_type}, GPIO_NUM_10},
{{&machine_pin_type}, GPIO_NUM_11},
{{&machine_pin_type}, GPIO_NUM_12},
{{&machine_pin_type}, GPIO_NUM_13},
{{&machine_pin_type}, GPIO_NUM_14},
{{&machine_pin_type}, GPIO_NUM_15},
{{&machine_pin_type}, GPIO_NUM_16},
{{&machine_pin_type}, GPIO_NUM_17},
{{&machine_pin_type}, GPIO_NUM_18},
#if CONFIG_USB_CDC_ENABLED
{{NULL}, -1}, // 19 is for native USB D-
{{NULL}, -1}, // 20 is for native USB D-
#else
{{&machine_pin_type}, GPIO_NUM_19},
{{&machine_pin_type}, GPIO_NUM_20},
#endif
{{&machine_pin_type}, GPIO_NUM_21},
{{NULL}, -1}, // 22 not a pin
{{NULL}, -1}, // 23 not a pin
{{NULL}, -1}, // 24 not a pin
{{NULL}, -1}, // 25 not a pin
{{NULL}, -1}, // 26 FLASH/PSRAM
{{NULL}, -1}, // 27 FLASH/PSRAM
{{NULL}, -1}, // 28 FLASH/PSRAM
{{NULL}, -1}, // 29 FLASH/PSRAM
{{NULL}, -1}, // 30 FLASH/PSRAM
{{NULL}, -1}, // 31 FLASH/PSRAM
{{NULL}, -1}, // 32 FLASH/PSRAM
{{&machine_pin_type}, GPIO_NUM_33},
{{&machine_pin_type}, GPIO_NUM_34},
{{&machine_pin_type}, GPIO_NUM_35},
{{&machine_pin_type}, GPIO_NUM_36},
{{&machine_pin_type}, GPIO_NUM_37},
{{&machine_pin_type}, GPIO_NUM_38},
{{&machine_pin_type}, GPIO_NUM_39}, // MTCLK
{{&machine_pin_type}, GPIO_NUM_40}, // MTDO
{{&machine_pin_type}, GPIO_NUM_41}, // MTDI
{{&machine_pin_type}, GPIO_NUM_42}, // MTMS
{{&machine_pin_type}, GPIO_NUM_43}, // U0TXD
{{&machine_pin_type}, GPIO_NUM_44}, // U0RXD
{{&machine_pin_type}, GPIO_NUM_45},
{{&machine_pin_type}, GPIO_NUM_46},
#endif
};
// forward declaration
STATIC const machine_pin_irq_obj_t machine_pin_irq_object[];
void machine_pins_init(void) {
static bool did_install = false;
if (!did_install) {
gpio_install_isr_service(0);
did_install = true;
}
memset(&MP_STATE_PORT(machine_pin_irq_handler[0]), 0, sizeof(MP_STATE_PORT(machine_pin_irq_handler)));
}
void machine_pins_deinit(void) {
for (int i = 0; i < MP_ARRAY_SIZE(machine_pin_obj); ++i) {
if (machine_pin_obj[i].id != (gpio_num_t)-1) {
gpio_isr_handler_remove(machine_pin_obj[i].id);
}
}
}
STATIC void machine_pin_isr_handler(void *arg) {
machine_pin_obj_t *self = arg;
mp_obj_t handler = MP_STATE_PORT(machine_pin_irq_handler)[self->id];
mp_sched_schedule(handler, MP_OBJ_FROM_PTR(self));
mp_hal_wake_main_task_from_isr();
}
gpio_num_t machine_pin_get_id(mp_obj_t pin_in) {
if (mp_obj_get_type(pin_in) != &machine_pin_type) {
mp_raise_ValueError(MP_ERROR_TEXT("expecting a pin"));
}
machine_pin_obj_t *self = pin_in;
return self->id;
}
STATIC void machine_pin_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
machine_pin_obj_t *self = self_in;
mp_printf(print, "Pin(%u)", self->id);
}
// pin.init(mode, pull=None, *, value)
STATIC mp_obj_t machine_pin_obj_init_helper(const machine_pin_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum { ARG_mode, ARG_pull, ARG_value };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_mode, MP_ARG_OBJ, {.u_obj = mp_const_none}},
{ MP_QSTR_pull, MP_ARG_OBJ, {.u_obj = MP_OBJ_NEW_SMALL_INT(-1)}},
{ MP_QSTR_value, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL}},
};
// parse args
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
// reset the pin to digital if this is a mode-setting init (grab it back from ADC)
if (args[ARG_mode].u_obj != mp_const_none) {
if (rtc_gpio_is_valid_gpio(self->id)) {
#if !CONFIG_IDF_TARGET_ESP32C3
rtc_gpio_deinit(self->id);
#endif
}
}
#if CONFIG_IDF_TARGET_ESP32C3
if (self->id == 18 || self->id == 19) {
CLEAR_PERI_REG_MASK(USB_DEVICE_CONF0_REG, USB_DEVICE_USB_PAD_ENABLE);
}
#endif
// configure the pin for gpio
gpio_pad_select_gpio(self->id);
// set initial value (do this before configuring mode/pull)
if (args[ARG_value].u_obj != MP_OBJ_NULL) {
gpio_set_level(self->id, mp_obj_is_true(args[ARG_value].u_obj));
}
// configure mode
if (args[ARG_mode].u_obj != mp_const_none) {
mp_int_t pin_io_mode = mp_obj_get_int(args[ARG_mode].u_obj);
#ifdef GPIO_FIRST_NON_OUTPUT
if (self->id >= GPIO_FIRST_NON_OUTPUT && (pin_io_mode & GPIO_MODE_DEF_OUTPUT)) {
mp_raise_ValueError(MP_ERROR_TEXT("pin can only be input"));
}
#endif
gpio_set_direction(self->id, pin_io_mode);
}
// configure pull
if (args[ARG_pull].u_obj != MP_OBJ_NEW_SMALL_INT(-1)) {
int mode = 0;
if (args[ARG_pull].u_obj != mp_const_none) {
mode = mp_obj_get_int(args[ARG_pull].u_obj);
}
if (mode & GPIO_PULL_DOWN) {
gpio_pulldown_en(self->id);
} else {
gpio_pulldown_dis(self->id);
}
if (mode & GPIO_PULL_UP) {
gpio_pullup_en(self->id);
} else {
gpio_pullup_dis(self->id);
}
if (mode & GPIO_PULL_HOLD) {
gpio_hold_en(self->id);
} else if (GPIO_IS_VALID_OUTPUT_GPIO(self->id)) {
gpio_hold_dis(self->id);
}
}
return mp_const_none;
}
// constructor(id, ...)
mp_obj_t mp_pin_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
// get the wanted pin object
int wanted_pin = mp_obj_get_int(args[0]);
const machine_pin_obj_t *self = NULL;
if (0 <= wanted_pin && wanted_pin < MP_ARRAY_SIZE(machine_pin_obj)) {
self = (machine_pin_obj_t *)&machine_pin_obj[wanted_pin];
}
if (self == NULL || self->base.type == NULL) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid pin"));
}
if (n_args > 1 || n_kw > 0) {
// pin mode given, so configure this GPIO
mp_map_t kw_args;
mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
machine_pin_obj_init_helper(self, n_args - 1, args + 1, &kw_args);
}
return MP_OBJ_FROM_PTR(self);
}
// fast method for getting/setting pin value
STATIC mp_obj_t machine_pin_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
mp_arg_check_num(n_args, n_kw, 0, 1, false);
machine_pin_obj_t *self = self_in;
if (n_args == 0) {
// get pin
return MP_OBJ_NEW_SMALL_INT(gpio_get_level(self->id));
} else {
// set pin
gpio_set_level(self->id, mp_obj_is_true(args[0]));
return mp_const_none;
}
}
// pin.init(mode, pull)
STATIC mp_obj_t machine_pin_obj_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
return machine_pin_obj_init_helper(args[0], n_args - 1, args + 1, kw_args);
}
MP_DEFINE_CONST_FUN_OBJ_KW(machine_pin_init_obj, 1, machine_pin_obj_init);
// pin.value([value])
STATIC mp_obj_t machine_pin_value(size_t n_args, const mp_obj_t *args) {
return machine_pin_call(args[0], n_args - 1, 0, args + 1);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_pin_value_obj, 1, 2, machine_pin_value);
// pin.off()
STATIC mp_obj_t machine_pin_off(mp_obj_t self_in) {
machine_pin_obj_t *self = MP_OBJ_TO_PTR(self_in);
gpio_set_level(self->id, 0);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_pin_off_obj, machine_pin_off);
// pin.on()
STATIC mp_obj_t machine_pin_on(mp_obj_t self_in) {
machine_pin_obj_t *self = MP_OBJ_TO_PTR(self_in);
gpio_set_level(self->id, 1);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_pin_on_obj, machine_pin_on);
// pin.irq(handler=None, trigger=IRQ_FALLING|IRQ_RISING)
STATIC mp_obj_t machine_pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum { ARG_handler, ARG_trigger, ARG_wake };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_handler, MP_ARG_OBJ, {.u_obj = mp_const_none} },
{ MP_QSTR_trigger, MP_ARG_INT, {.u_int = GPIO_PIN_INTR_POSEDGE | GPIO_PIN_INTR_NEGEDGE} },
{ MP_QSTR_wake, MP_ARG_OBJ, {.u_obj = mp_const_none} },
};
machine_pin_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
if (n_args > 1 || kw_args->used != 0) {
// configure irq
mp_obj_t handler = args[ARG_handler].u_obj;
uint32_t trigger = args[ARG_trigger].u_int;
mp_obj_t wake_obj = args[ARG_wake].u_obj;
if ((trigger == GPIO_PIN_INTR_LOLEVEL || trigger == GPIO_PIN_INTR_HILEVEL) && wake_obj != mp_const_none) {
mp_int_t wake;
if (mp_obj_get_int_maybe(wake_obj, &wake)) {
if (wake < 2 || wake > 7) {
mp_raise_ValueError(MP_ERROR_TEXT("bad wake value"));
}
} else {
mp_raise_ValueError(MP_ERROR_TEXT("bad wake value"));
}
if (machine_rtc_config.wake_on_touch) { // not compatible
mp_raise_ValueError(MP_ERROR_TEXT("no resources"));
}
if (!RTC_IS_VALID_EXT_PIN(self->id)) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid pin for wake"));
}
if (machine_rtc_config.ext0_pin == -1) {
machine_rtc_config.ext0_pin = self->id;
} else if (machine_rtc_config.ext0_pin != self->id) {
mp_raise_ValueError(MP_ERROR_TEXT("no resources"));
}
machine_rtc_config.ext0_level = trigger == GPIO_PIN_INTR_LOLEVEL ? 0 : 1;
machine_rtc_config.ext0_wake_types = wake;
} else {
if (machine_rtc_config.ext0_pin == self->id) {
machine_rtc_config.ext0_pin = -1;
}
if (handler == mp_const_none) {
handler = MP_OBJ_NULL;
trigger = 0;
}
gpio_isr_handler_remove(self->id);
MP_STATE_PORT(machine_pin_irq_handler)[self->id] = handler;
gpio_set_intr_type(self->id, trigger);
gpio_isr_handler_add(self->id, machine_pin_isr_handler, (void *)self);
}
}
// return the irq object
return MP_OBJ_FROM_PTR(&machine_pin_irq_object[self->id]);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_pin_irq_obj, 1, machine_pin_irq);
STATIC const mp_rom_map_elem_t machine_pin_locals_dict_table[] = {
// instance methods
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_pin_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_value), MP_ROM_PTR(&machine_pin_value_obj) },
{ MP_ROM_QSTR(MP_QSTR_off), MP_ROM_PTR(&machine_pin_off_obj) },
{ MP_ROM_QSTR(MP_QSTR_on), MP_ROM_PTR(&machine_pin_on_obj) },
{ MP_ROM_QSTR(MP_QSTR_irq), MP_ROM_PTR(&machine_pin_irq_obj) },
// class constants
{ MP_ROM_QSTR(MP_QSTR_IN), MP_ROM_INT(GPIO_MODE_INPUT) },
{ MP_ROM_QSTR(MP_QSTR_OUT), MP_ROM_INT(GPIO_MODE_INPUT_OUTPUT) },
{ MP_ROM_QSTR(MP_QSTR_OPEN_DRAIN), MP_ROM_INT(GPIO_MODE_INPUT_OUTPUT_OD) },
{ MP_ROM_QSTR(MP_QSTR_PULL_UP), MP_ROM_INT(GPIO_PULL_UP) },
{ MP_ROM_QSTR(MP_QSTR_PULL_DOWN), MP_ROM_INT(GPIO_PULL_DOWN) },
{ MP_ROM_QSTR(MP_QSTR_PULL_HOLD), MP_ROM_INT(GPIO_PULL_HOLD) },
{ MP_ROM_QSTR(MP_QSTR_IRQ_RISING), MP_ROM_INT(GPIO_PIN_INTR_POSEDGE) },
{ MP_ROM_QSTR(MP_QSTR_IRQ_FALLING), MP_ROM_INT(GPIO_PIN_INTR_NEGEDGE) },
{ MP_ROM_QSTR(MP_QSTR_WAKE_LOW), MP_ROM_INT(GPIO_PIN_INTR_LOLEVEL) },
{ MP_ROM_QSTR(MP_QSTR_WAKE_HIGH), MP_ROM_INT(GPIO_PIN_INTR_HILEVEL) },
};
STATIC mp_uint_t pin_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
(void)errcode;
machine_pin_obj_t *self = self_in;
switch (request) {
case MP_PIN_READ: {
return gpio_get_level(self->id);
}
case MP_PIN_WRITE: {
gpio_set_level(self->id, arg);
return 0;
}
}
return -1;
}
STATIC MP_DEFINE_CONST_DICT(machine_pin_locals_dict, machine_pin_locals_dict_table);
STATIC const mp_pin_p_t pin_pin_p = {
.ioctl = pin_ioctl,
};
const mp_obj_type_t machine_pin_type = {
{ &mp_type_type },
.name = MP_QSTR_Pin,
.print = machine_pin_print,
.make_new = mp_pin_make_new,
.call = machine_pin_call,
.protocol = &pin_pin_p,
.locals_dict = (mp_obj_t)&machine_pin_locals_dict,
};
/******************************************************************************/
// Pin IRQ object
STATIC const mp_obj_type_t machine_pin_irq_type;
STATIC const machine_pin_irq_obj_t machine_pin_irq_object[] = {
#if CONFIG_IDF_TARGET_ESP32
{{&machine_pin_irq_type}, GPIO_NUM_0},
{{&machine_pin_irq_type}, GPIO_NUM_1},
{{&machine_pin_irq_type}, GPIO_NUM_2},
{{&machine_pin_irq_type}, GPIO_NUM_3},
{{&machine_pin_irq_type}, GPIO_NUM_4},
{{&machine_pin_irq_type}, GPIO_NUM_5},
{{&machine_pin_irq_type}, GPIO_NUM_6},
{{&machine_pin_irq_type}, GPIO_NUM_7},
{{&machine_pin_irq_type}, GPIO_NUM_8},
{{&machine_pin_irq_type}, GPIO_NUM_9},
{{&machine_pin_irq_type}, GPIO_NUM_10},
{{&machine_pin_irq_type}, GPIO_NUM_11},
{{&machine_pin_irq_type}, GPIO_NUM_12},
{{&machine_pin_irq_type}, GPIO_NUM_13},
{{&machine_pin_irq_type}, GPIO_NUM_14},
{{&machine_pin_irq_type}, GPIO_NUM_15},
{{&machine_pin_irq_type}, GPIO_NUM_16},
{{&machine_pin_irq_type}, GPIO_NUM_17},
{{&machine_pin_irq_type}, GPIO_NUM_18},
{{&machine_pin_irq_type}, GPIO_NUM_19},
{{NULL}, -1},
{{&machine_pin_irq_type}, GPIO_NUM_21},
{{&machine_pin_irq_type}, GPIO_NUM_22},
{{&machine_pin_irq_type}, GPIO_NUM_23},
{{NULL}, -1},
{{&machine_pin_irq_type}, GPIO_NUM_25},
{{&machine_pin_irq_type}, GPIO_NUM_26},
{{&machine_pin_irq_type}, GPIO_NUM_27},
{{NULL}, -1},
{{NULL}, -1},
{{NULL}, -1},
{{NULL}, -1},
{{&machine_pin_irq_type}, GPIO_NUM_32},
{{&machine_pin_irq_type}, GPIO_NUM_33},
{{&machine_pin_irq_type}, GPIO_NUM_34},
{{&machine_pin_irq_type}, GPIO_NUM_35},
{{&machine_pin_irq_type}, GPIO_NUM_36},
{{&machine_pin_irq_type}, GPIO_NUM_37},
{{&machine_pin_irq_type}, GPIO_NUM_38},
{{&machine_pin_irq_type}, GPIO_NUM_39},
#elif CONFIG_IDF_TARGET_ESP32C3
{{&machine_pin_irq_type}, GPIO_NUM_0},
{{&machine_pin_irq_type}, GPIO_NUM_1},
{{&machine_pin_irq_type}, GPIO_NUM_2},
{{&machine_pin_irq_type}, GPIO_NUM_3},
{{&machine_pin_irq_type}, GPIO_NUM_4},
{{&machine_pin_irq_type}, GPIO_NUM_5},
{{&machine_pin_irq_type}, GPIO_NUM_6},
{{&machine_pin_irq_type}, GPIO_NUM_7},
{{&machine_pin_irq_type}, GPIO_NUM_8},
{{&machine_pin_irq_type}, GPIO_NUM_9},
{{&machine_pin_irq_type}, GPIO_NUM_10},
{{&machine_pin_irq_type}, GPIO_NUM_11},
{{&machine_pin_irq_type}, GPIO_NUM_12},
{{&machine_pin_irq_type}, GPIO_NUM_13},
{{&machine_pin_irq_type}, GPIO_NUM_14},
{{&machine_pin_irq_type}, GPIO_NUM_15},
{{&machine_pin_irq_type}, GPIO_NUM_16},
{{&machine_pin_irq_type}, GPIO_NUM_17},
{{&machine_pin_irq_type}, GPIO_NUM_18},
{{&machine_pin_irq_type}, GPIO_NUM_19},
{{&machine_pin_irq_type}, GPIO_NUM_20},
{{&machine_pin_irq_type}, GPIO_NUM_21},
#elif CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
{{&machine_pin_irq_type}, GPIO_NUM_0},
{{&machine_pin_irq_type}, GPIO_NUM_1},
{{&machine_pin_irq_type}, GPIO_NUM_2},
{{&machine_pin_irq_type}, GPIO_NUM_3},
{{&machine_pin_irq_type}, GPIO_NUM_4},
{{&machine_pin_irq_type}, GPIO_NUM_5},
{{&machine_pin_irq_type}, GPIO_NUM_6},
{{&machine_pin_irq_type}, GPIO_NUM_7},
{{&machine_pin_irq_type}, GPIO_NUM_8},
{{&machine_pin_irq_type}, GPIO_NUM_9},
{{&machine_pin_irq_type}, GPIO_NUM_10},
{{&machine_pin_irq_type}, GPIO_NUM_11},
{{&machine_pin_irq_type}, GPIO_NUM_12},
{{&machine_pin_irq_type}, GPIO_NUM_13},
{{&machine_pin_irq_type}, GPIO_NUM_14},
{{&machine_pin_irq_type}, GPIO_NUM_15},
{{&machine_pin_irq_type}, GPIO_NUM_16},
{{&machine_pin_irq_type}, GPIO_NUM_17},
{{&machine_pin_irq_type}, GPIO_NUM_18},
#if CONFIG_USB_CDC_ENABLED
{{NULL}, -1}, // 19 is for native USB D-
{{NULL}, -1}, // 20 is for native USB D-
#else
{{&machine_pin_irq_type}, GPIO_NUM_19},
{{&machine_pin_irq_type}, GPIO_NUM_20},
#endif
{{&machine_pin_irq_type}, GPIO_NUM_21},
{{NULL}, -1}, // 22 not a pin
{{NULL}, -1}, // 23 not a pin
{{NULL}, -1}, // 24 not a pin
{{NULL}, -1}, // 25 not a pin
{{NULL}, -1}, // 26 FLASH/PSRAM
{{NULL}, -1}, // 27 FLASH/PSRAM
{{NULL}, -1}, // 28 FLASH/PSRAM
{{NULL}, -1}, // 29 FLASH/PSRAM
{{NULL}, -1}, // 30 FLASH/PSRAM
{{NULL}, -1}, // 31 FLASH/PSRAM
{{NULL}, -1}, // 32 FLASH/PSRAM
{{&machine_pin_irq_type}, GPIO_NUM_33},
{{&machine_pin_irq_type}, GPIO_NUM_34},
{{&machine_pin_irq_type}, GPIO_NUM_35},
{{&machine_pin_irq_type}, GPIO_NUM_36},
{{&machine_pin_irq_type}, GPIO_NUM_37},
{{&machine_pin_irq_type}, GPIO_NUM_38},
{{&machine_pin_irq_type}, GPIO_NUM_39},
{{&machine_pin_irq_type}, GPIO_NUM_40},
{{&machine_pin_irq_type}, GPIO_NUM_41},
{{&machine_pin_irq_type}, GPIO_NUM_42},
{{&machine_pin_irq_type}, GPIO_NUM_43},
{{&machine_pin_irq_type}, GPIO_NUM_44},
{{&machine_pin_irq_type}, GPIO_NUM_45},
#endif
};
STATIC mp_obj_t machine_pin_irq_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
machine_pin_irq_obj_t *self = self_in;
mp_arg_check_num(n_args, n_kw, 0, 0, false);
machine_pin_isr_handler((void *)&machine_pin_obj[self->id]);
return mp_const_none;
}
STATIC mp_obj_t machine_pin_irq_trigger(size_t n_args, const mp_obj_t *args) {
machine_pin_irq_obj_t *self = args[0];
uint32_t orig_trig = GPIO.pin[self->id].int_type;
if (n_args == 2) {
// set trigger
gpio_set_intr_type(self->id, mp_obj_get_int(args[1]));
}
// return original trigger value
return MP_OBJ_NEW_SMALL_INT(orig_trig);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_pin_irq_trigger_obj, 1, 2, machine_pin_irq_trigger);
STATIC const mp_rom_map_elem_t machine_pin_irq_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_trigger), MP_ROM_PTR(&machine_pin_irq_trigger_obj) },
};
STATIC MP_DEFINE_CONST_DICT(machine_pin_irq_locals_dict, machine_pin_irq_locals_dict_table);
STATIC const mp_obj_type_t machine_pin_irq_type = {
{ &mp_type_type },
.name = MP_QSTR_IRQ,
.call = machine_pin_irq_call,
.locals_dict = (mp_obj_dict_t *)&machine_pin_irq_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_pin.c | C | apache-2.0 | 23,901 |
/*
* This file is part of the Micro Python project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include "driver/ledc.h"
#include "esp_err.h"
#include "py/nlr.h"
#include "py/runtime.h"
#include "modmachine.h"
#include "mphalport.h"
// Forward dec'l
extern const mp_obj_type_t machine_pwm_type;
typedef struct _esp32_pwm_obj_t {
mp_obj_base_t base;
gpio_num_t pin;
uint8_t active;
uint8_t channel;
} esp32_pwm_obj_t;
// Which channel has which GPIO pin assigned?
// (-1 if not assigned)
STATIC int chan_gpio[LEDC_CHANNEL_MAX];
// Params for PW operation
// 5khz
#define PWFREQ (5000)
// High speed mode
#if CONFIG_IDF_TARGET_ESP32
#define PWMODE (LEDC_HIGH_SPEED_MODE)
#else
#define PWMODE (LEDC_LOW_SPEED_MODE)
#endif
// 10-bit resolution (compatible with esp8266 PWM)
#define PWRES (LEDC_TIMER_10_BIT)
// Timer 1
#define PWTIMER (LEDC_TIMER_1)
// Config of timer upon which we run all PWM'ed GPIO pins
STATIC bool pwm_inited = false;
STATIC ledc_timer_config_t timer_cfg = {
.duty_resolution = PWRES,
.freq_hz = PWFREQ,
.speed_mode = PWMODE,
.timer_num = PWTIMER
};
STATIC void pwm_init(void) {
// Initial condition: no channels assigned
for (int x = 0; x < LEDC_CHANNEL_MAX; ++x) {
chan_gpio[x] = -1;
}
// Init with default timer params
ledc_timer_config(&timer_cfg);
}
STATIC int set_freq(int newval) {
int ores = timer_cfg.duty_resolution;
int oval = timer_cfg.freq_hz;
// Find the highest bit resolution for the requested frequency
if (newval <= 0) {
newval = 1;
}
unsigned int res = 0;
for (unsigned int i = LEDC_APB_CLK_HZ / newval; i > 1; i >>= 1, ++res) {
}
if (res == 0) {
res = 1;
} else if (res > PWRES) {
// Limit resolution to PWRES to match units of our duty
res = PWRES;
}
// Configure the new resolution and frequency
timer_cfg.duty_resolution = res;
timer_cfg.freq_hz = newval;
if (ledc_timer_config(&timer_cfg) != ESP_OK) {
timer_cfg.duty_resolution = ores;
timer_cfg.freq_hz = oval;
return 0;
}
return 1;
}
/******************************************************************************/
// MicroPython bindings for PWM
STATIC void esp32_pwm_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
esp32_pwm_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "PWM(%u", self->pin);
if (self->active) {
mp_printf(print, ", freq=%u, duty=%u", timer_cfg.freq_hz,
ledc_get_duty(PWMODE, self->channel));
}
mp_printf(print, ")");
}
STATIC void esp32_pwm_init_helper(esp32_pwm_obj_t *self,
size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum { ARG_freq, ARG_duty };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_freq, MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_duty, MP_ARG_INT, {.u_int = -1} },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args,
MP_ARRAY_SIZE(allowed_args), allowed_args, args);
int channel;
int avail = -1;
// Find a free PWM channel, also spot if our pin is
// already mentioned.
for (channel = 0; channel < LEDC_CHANNEL_MAX; ++channel) {
if (chan_gpio[channel] == self->pin) {
break;
}
if ((avail == -1) && (chan_gpio[channel] == -1)) {
avail = channel;
}
}
if (channel >= LEDC_CHANNEL_MAX) {
if (avail == -1) {
mp_raise_ValueError(MP_ERROR_TEXT("out of PWM channels"));
}
channel = avail;
}
self->channel = channel;
// New PWM assignment
self->active = 1;
if (chan_gpio[channel] == -1) {
ledc_channel_config_t cfg = {
.channel = channel,
.duty = (1 << timer_cfg.duty_resolution) / 2,
.gpio_num = self->pin,
.intr_type = LEDC_INTR_DISABLE,
.speed_mode = PWMODE,
.timer_sel = PWTIMER,
};
if (ledc_channel_config(&cfg) != ESP_OK) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("PWM not supported on pin %d"), self->pin);
}
chan_gpio[channel] = self->pin;
}
// Maybe change PWM timer
int tval = args[ARG_freq].u_int;
if (tval != -1) {
if (tval != timer_cfg.freq_hz) {
if (!set_freq(tval)) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("bad frequency %d"), tval);
}
}
}
// Set duty cycle?
int dval = args[ARG_duty].u_int;
if (dval != -1) {
dval &= ((1 << PWRES) - 1);
dval >>= PWRES - timer_cfg.duty_resolution;
ledc_set_duty(PWMODE, channel, dval);
ledc_update_duty(PWMODE, channel);
}
}
STATIC mp_obj_t esp32_pwm_make_new(const mp_obj_type_t *type,
size_t n_args, size_t n_kw, const mp_obj_t *args) {
mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
gpio_num_t pin_id = machine_pin_get_id(args[0]);
// create PWM object from the given pin
esp32_pwm_obj_t *self = m_new_obj(esp32_pwm_obj_t);
self->base.type = &machine_pwm_type;
self->pin = pin_id;
self->active = 0;
self->channel = -1;
// start the PWM subsystem if it's not already running
if (!pwm_inited) {
pwm_init();
pwm_inited = true;
}
// start the PWM running for this channel
mp_map_t kw_args;
mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
esp32_pwm_init_helper(self, n_args - 1, args + 1, &kw_args);
return MP_OBJ_FROM_PTR(self);
}
STATIC mp_obj_t esp32_pwm_init(size_t n_args,
const mp_obj_t *args, mp_map_t *kw_args) {
esp32_pwm_init_helper(args[0], n_args - 1, args + 1, kw_args);
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_KW(esp32_pwm_init_obj, 1, esp32_pwm_init);
STATIC mp_obj_t esp32_pwm_deinit(mp_obj_t self_in) {
esp32_pwm_obj_t *self = MP_OBJ_TO_PTR(self_in);
int chan = self->channel;
// Valid channel?
if ((chan >= 0) && (chan < LEDC_CHANNEL_MAX)) {
// Mark it unused, and tell the hardware to stop routing
chan_gpio[chan] = -1;
ledc_stop(PWMODE, chan, 0);
self->active = 0;
self->channel = -1;
gpio_matrix_out(self->pin, SIG_GPIO_OUT_IDX, false, false);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp32_pwm_deinit_obj, esp32_pwm_deinit);
STATIC mp_obj_t esp32_pwm_freq(size_t n_args, const mp_obj_t *args) {
if (n_args == 1) {
// get
return MP_OBJ_NEW_SMALL_INT(timer_cfg.freq_hz);
}
// set
int tval = mp_obj_get_int(args[1]);
if (!set_freq(tval)) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("bad frequency %d"), tval);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp32_pwm_freq_obj, 1, 2, esp32_pwm_freq);
STATIC mp_obj_t esp32_pwm_duty(size_t n_args, const mp_obj_t *args) {
esp32_pwm_obj_t *self = MP_OBJ_TO_PTR(args[0]);
int duty;
if (n_args == 1) {
// get
duty = ledc_get_duty(PWMODE, self->channel);
duty <<= PWRES - timer_cfg.duty_resolution;
return MP_OBJ_NEW_SMALL_INT(duty);
}
// set
duty = mp_obj_get_int(args[1]);
duty &= ((1 << PWRES) - 1);
duty >>= PWRES - timer_cfg.duty_resolution;
ledc_set_duty(PWMODE, self->channel, duty);
ledc_update_duty(PWMODE, self->channel);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp32_pwm_duty_obj,
1, 2, esp32_pwm_duty);
STATIC const mp_rom_map_elem_t esp32_pwm_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&esp32_pwm_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&esp32_pwm_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_freq), MP_ROM_PTR(&esp32_pwm_freq_obj) },
{ MP_ROM_QSTR(MP_QSTR_duty), MP_ROM_PTR(&esp32_pwm_duty_obj) },
};
STATIC MP_DEFINE_CONST_DICT(esp32_pwm_locals_dict,
esp32_pwm_locals_dict_table);
const mp_obj_type_t machine_pwm_type = {
{ &mp_type_type },
.name = MP_QSTR_PWM,
.print = esp32_pwm_print,
.make_new = esp32_pwm_make_new,
.locals_dict = (mp_obj_dict_t *)&esp32_pwm_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_pwm.c | C | apache-2.0 | 9,373 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2017 "Eric Poulsen" <eric@zyxod.com>
* Copyright (c) 2017 "Tom Manning" <tom@manningetal.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sys/time.h>
#include "driver/gpio.h"
#include "py/nlr.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "py/mphal.h"
#include "shared/timeutils/timeutils.h"
#include "modmachine.h"
#include "machine_rtc.h"
typedef struct _machine_rtc_obj_t {
mp_obj_base_t base;
} machine_rtc_obj_t;
/* There is 8K of rtc_slow_memory, but some is used by the system software
If the MICROPY_HW_RTC_USER_MEM_MAX is set too high, the following compile error will happen:
region `rtc_slow_seg' overflowed by N bytes
The current system software allows almost 4096 to be used.
To avoid running into issues if the system software uses more, 2048 was picked as a max length
You can also change this max length at compile time by defining MICROPY_HW_RTC_USER_MEM_MAX
either on your make line, or in your board config.
If MICROPY_HW_RTC_USER_MEM_MAX is set to 0, the RTC.memory() functionality will be not
be compiled which frees some extra flash and RTC memory.
*/
#ifndef MICROPY_HW_RTC_USER_MEM_MAX
#define MICROPY_HW_RTC_USER_MEM_MAX 2048
#endif
// Optionally compile user memory functionality if the size of memory is greater than 0
#if MICROPY_HW_RTC_USER_MEM_MAX > 0
#define MEM_MAGIC 0x75507921
RTC_DATA_ATTR uint32_t rtc_user_mem_magic;
RTC_DATA_ATTR uint16_t rtc_user_mem_len;
RTC_DATA_ATTR uint8_t rtc_user_mem_data[MICROPY_HW_RTC_USER_MEM_MAX];
#endif
// singleton RTC object
STATIC const machine_rtc_obj_t machine_rtc_obj = {{&machine_rtc_type}};
machine_rtc_config_t machine_rtc_config = {
.ext1_pins = 0,
.ext0_pin = -1
};
STATIC mp_obj_t machine_rtc_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
// check arguments
mp_arg_check_num(n_args, n_kw, 0, 0, false);
// return constant object
return (mp_obj_t)&machine_rtc_obj;
}
STATIC mp_obj_t machine_rtc_datetime_helper(mp_uint_t n_args, const mp_obj_t *args) {
if (n_args == 1) {
// Get time
struct timeval tv;
gettimeofday(&tv, NULL);
timeutils_struct_time_t tm;
timeutils_seconds_since_epoch_to_struct_time(tv.tv_sec, &tm);
mp_obj_t tuple[8] = {
mp_obj_new_int(tm.tm_year),
mp_obj_new_int(tm.tm_mon),
mp_obj_new_int(tm.tm_mday),
mp_obj_new_int(tm.tm_wday),
mp_obj_new_int(tm.tm_hour),
mp_obj_new_int(tm.tm_min),
mp_obj_new_int(tm.tm_sec),
mp_obj_new_int(tv.tv_usec)
};
return mp_obj_new_tuple(8, tuple);
} else {
// Set time
mp_obj_t *items;
mp_obj_get_array_fixed_n(args[1], 8, &items);
struct timeval tv = {0};
tv.tv_sec = timeutils_seconds_since_epoch(mp_obj_get_int(items[0]), mp_obj_get_int(items[1]), mp_obj_get_int(items[2]), mp_obj_get_int(items[4]), mp_obj_get_int(items[5]), mp_obj_get_int(items[6]));
tv.tv_usec = mp_obj_get_int(items[7]);
settimeofday(&tv, NULL);
return mp_const_none;
}
}
STATIC mp_obj_t machine_rtc_datetime(size_t n_args, const mp_obj_t *args) {
return machine_rtc_datetime_helper(n_args, args);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_rtc_datetime_obj, 1, 2, machine_rtc_datetime);
STATIC mp_obj_t machine_rtc_init(mp_obj_t self_in, mp_obj_t date) {
mp_obj_t args[2] = {self_in, date};
machine_rtc_datetime_helper(2, args);
#if MICROPY_HW_RTC_USER_MEM_MAX > 0
if (rtc_user_mem_magic != MEM_MAGIC) {
rtc_user_mem_magic = MEM_MAGIC;
rtc_user_mem_len = 0;
}
#endif
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(machine_rtc_init_obj, machine_rtc_init);
#if MICROPY_HW_RTC_USER_MEM_MAX > 0
STATIC mp_obj_t machine_rtc_memory(size_t n_args, const mp_obj_t *args) {
if (n_args == 1) {
// read RTC memory
uint8_t rtcram[MICROPY_HW_RTC_USER_MEM_MAX];
memcpy((char *)rtcram, (char *)rtc_user_mem_data, rtc_user_mem_len);
return mp_obj_new_bytes(rtcram, rtc_user_mem_len);
} else {
// write RTC memory
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ);
if (bufinfo.len > MICROPY_HW_RTC_USER_MEM_MAX) {
mp_raise_ValueError(MP_ERROR_TEXT("buffer too long"));
}
memcpy((char *)rtc_user_mem_data, (char *)bufinfo.buf, bufinfo.len);
rtc_user_mem_len = bufinfo.len;
return mp_const_none;
}
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_rtc_memory_obj, 1, 2, machine_rtc_memory);
#endif
STATIC const mp_rom_map_elem_t machine_rtc_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_rtc_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_datetime), MP_ROM_PTR(&machine_rtc_datetime_obj) },
#if MICROPY_HW_RTC_USER_MEM_MAX > 0
{ MP_ROM_QSTR(MP_QSTR_memory), MP_ROM_PTR(&machine_rtc_memory_obj) },
#endif
};
STATIC MP_DEFINE_CONST_DICT(machine_rtc_locals_dict, machine_rtc_locals_dict_table);
const mp_obj_type_t machine_rtc_type = {
{ &mp_type_type },
.name = MP_QSTR_RTC,
.make_new = machine_rtc_make_new,
.locals_dict = (mp_obj_t)&machine_rtc_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_rtc.c | C | apache-2.0 | 6,539 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2017 "Eric Poulsen" <eric@zyxod.com>
* Copyright (c) 2017 "Tom Manning" <tom@manningetal.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef MICROPY_INCLUDED_ESP32_MACHINE_RTC_H
#define MICROPY_INCLUDED_ESP32_MACHINE_RTC_H
#include "modmachine.h"
typedef struct {
uint64_t ext1_pins; // set bit == pin#
int8_t ext0_pin; // just the pin#, -1 == None
bool wake_on_touch : 1;
bool ext0_level : 1;
wake_type_t ext0_wake_types;
bool ext1_level : 1;
} machine_rtc_config_t;
extern machine_rtc_config_t machine_rtc_config;
#endif
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_rtc.h | C | apache-2.0 | 1,719 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2019 Nicko van Someren
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <string.h>
#include "py/runtime.h"
#include "py/mphal.h"
#include "py/mperrno.h"
#include "extmod/vfs_fat.h"
#if MICROPY_HW_ENABLE_SDCARD
#include "driver/sdmmc_host.h"
#include "driver/sdspi_host.h"
#include "sdmmc_cmd.h"
#include "esp_log.h"
#define DEBUG 0
#if DEBUG
#define DEBUG_printf(...) ESP_LOGI("modsdcard", __VA_ARGS__)
#else
#define DEBUG_printf(...) (void)0
#endif
//
// There are three layers of abstraction: host, slot and card.
// Creating an SD Card object will initialise the host and slot.
// Cards gets initialised by ioctl op==1 and de-inited by ioctl 2
// Hosts are de-inited in __del__. Slots do not need de-initing.
//
// Forward declaration
const mp_obj_type_t machine_sdcard_type;
typedef struct _sdcard_obj_t {
mp_obj_base_t base;
mp_int_t flags;
sdmmc_host_t host;
// The card structure duplicates the host. It's not clear if we
// can avoid this given the way that it is copied.
sdmmc_card_t card;
} sdcard_card_obj_t;
#define SDCARD_CARD_FLAGS_HOST_INIT_DONE 0x01
#define SDCARD_CARD_FLAGS_CARD_INIT_DONE 0x02
#define _SECTOR_SIZE(self) (self->card.csd.sector_size)
STATIC gpio_num_t pin_or_int(const mp_obj_t arg) {
if (mp_obj_is_small_int(arg)) {
return MP_OBJ_SMALL_INT_VALUE(arg);
} else {
// This raises a value error if the argument is not a Pin.
return machine_pin_get_id(arg);
}
}
#define SET_CONFIG_PIN(config, pin_var, arg_id) \
if (arg_vals[arg_id].u_obj != mp_const_none) \
config.pin_var = pin_or_int(arg_vals[arg_id].u_obj)
STATIC esp_err_t sdcard_ensure_card_init(sdcard_card_obj_t *self, bool force) {
if (force || !(self->flags & SDCARD_CARD_FLAGS_CARD_INIT_DONE)) {
DEBUG_printf(" Calling card init");
esp_err_t err = sdmmc_card_init(&(self->host), &(self->card));
if (err == ESP_OK) {
self->flags |= SDCARD_CARD_FLAGS_CARD_INIT_DONE;
} else {
self->flags &= ~SDCARD_CARD_FLAGS_CARD_INIT_DONE;
}
DEBUG_printf(" Card init returned: %i", err);
return err;
} else {
return ESP_OK;
}
}
/******************************************************************************/
// MicroPython bindings
//
// Expose the SD card or MMC as an object with the block protocol.
// Create a new SDCard object
// The driver supports either the host SD/MMC controller (default) or SPI mode
// In both cases there are two "slots". Slot 0 on the SD/MMC controller is
// typically tied up with the flash interface in most ESP32 modules but in
// theory supports 1, 4 or 8-bit transfers. Slot 1 supports only 1 and 4-bit
// transfers. Only 1-bit is supported on the SPI interfaces.
// card = SDCard(slot=1, width=None, present_pin=None, wp_pin=None)
STATIC mp_obj_t machine_sdcard_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
// check arguments
enum {
ARG_slot,
ARG_width,
ARG_cd,
ARG_wp,
ARG_miso,
ARG_mosi,
ARG_sck,
ARG_cs,
ARG_freq,
};
STATIC const mp_arg_t allowed_args[] = {
{ MP_QSTR_slot, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} },
{ MP_QSTR_width, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} },
{ MP_QSTR_cd, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
{ MP_QSTR_wp, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
// These are only needed if using SPI mode
{ MP_QSTR_miso, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
{ MP_QSTR_mosi, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
{ MP_QSTR_sck, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
{ MP_QSTR_cs, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
// freq is valid for both SPI and SDMMC interfaces
{ MP_QSTR_freq, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 20000000} },
};
mp_arg_val_t arg_vals[MP_ARRAY_SIZE(allowed_args)];
mp_map_t kw_args;
DEBUG_printf("Making new SDCard:n");
DEBUG_printf(" Unpacking arguments");
mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
mp_arg_parse_all(n_args, args, &kw_args,
MP_ARRAY_SIZE(allowed_args), allowed_args, arg_vals);
DEBUG_printf(" slot=%d, width=%d, cd=%p, wp=%p",
arg_vals[ARG_slot].u_int, arg_vals[ARG_width].u_int,
arg_vals[ARG_cd].u_obj, arg_vals[ARG_wp].u_obj);
DEBUG_printf(" miso=%p, mosi=%p, sck=%p, cs=%p",
arg_vals[ARG_miso].u_obj, arg_vals[ARG_mosi].u_obj,
arg_vals[ARG_sck].u_obj, arg_vals[ARG_cs].u_obj);
int slot_num = arg_vals[ARG_slot].u_int;
if (slot_num < 0 || slot_num > 3) {
mp_raise_ValueError(MP_ERROR_TEXT("slot number must be between 0 and 3 inclusive"));
}
// Slots 0 and 1 are native SD/MMC, slots 2 and 3 are SPI
bool is_spi = (slot_num >= 2);
if (is_spi) {
slot_num -= 2;
}
DEBUG_printf(" Setting up host configuration");
sdcard_card_obj_t *self = m_new_obj_with_finaliser(sdcard_card_obj_t);
self->base.type = &machine_sdcard_type;
self->flags = 0;
// Note that these defaults are macros that expand to structure
// constants so we can't directly assign them to fields.
int freq = arg_vals[ARG_freq].u_int;
if (is_spi) {
sdmmc_host_t _temp_host = SDSPI_HOST_DEFAULT();
_temp_host.max_freq_khz = freq / 1000;
self->host = _temp_host;
} else {
sdmmc_host_t _temp_host = SDMMC_HOST_DEFAULT();
_temp_host.max_freq_khz = freq / 1000;
self->host = _temp_host;
}
if (is_spi) {
#if CONFIG_IDF_TARGET_ESP32S3
self->host.slot = slot_num ? SPI3_HOST : SPI2_HOST;
#else
self->host.slot = slot_num ? HSPI_HOST : VSPI_HOST;
#endif
}
DEBUG_printf(" Calling host.init()");
check_esp_err(self->host.init());
self->flags |= SDCARD_CARD_FLAGS_HOST_INIT_DONE;
if (is_spi) {
// SPI interface
#if CONFIG_IDF_TARGET_ESP32S3
STATIC const sdspi_slot_config_t slot_defaults[2] = {
{
.gpio_miso = GPIO_NUM_36,
.gpio_mosi = GPIO_NUM_35,
.gpio_sck = GPIO_NUM_37,
.gpio_cs = GPIO_NUM_34,
.gpio_cd = SDSPI_SLOT_NO_CD,
.gpio_wp = SDSPI_SLOT_NO_WP,
.dma_channel = 2
},
SDSPI_SLOT_CONFIG_DEFAULT()
};
#else
STATIC const sdspi_slot_config_t slot_defaults[2] = {
{
.gpio_miso = GPIO_NUM_19,
.gpio_mosi = GPIO_NUM_23,
.gpio_sck = GPIO_NUM_18,
.gpio_cs = GPIO_NUM_5,
.gpio_cd = SDSPI_SLOT_NO_CD,
.gpio_wp = SDSPI_SLOT_NO_WP,
.dma_channel = 2
},
SDSPI_SLOT_CONFIG_DEFAULT()
};
#endif
DEBUG_printf(" Setting up SPI slot configuration");
sdspi_slot_config_t slot_config = slot_defaults[slot_num];
SET_CONFIG_PIN(slot_config, gpio_cd, ARG_cd);
SET_CONFIG_PIN(slot_config, gpio_wp, ARG_wp);
SET_CONFIG_PIN(slot_config, gpio_miso, ARG_miso);
SET_CONFIG_PIN(slot_config, gpio_mosi, ARG_mosi);
SET_CONFIG_PIN(slot_config, gpio_sck, ARG_sck);
SET_CONFIG_PIN(slot_config, gpio_cs, ARG_cs);
DEBUG_printf(" Calling init_slot()");
check_esp_err(sdspi_host_init_slot(self->host.slot, &slot_config));
} else {
// SD/MMC interface
DEBUG_printf(" Setting up SDMMC slot configuration");
sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
// Stronger external pull-ups are still needed but apparently
// it is a good idea to set the internal pull-ups anyway.
// slot_config.flags = SDMMC_SLOT_FLAG_INTERNAL_PULLUP;
SET_CONFIG_PIN(slot_config, gpio_cd, ARG_cd);
SET_CONFIG_PIN(slot_config, gpio_wp, ARG_wp);
int width = arg_vals[ARG_width].u_int;
if (width == 1 || width == 4 || (width == 8 && slot_num == 0)) {
slot_config.width = width;
} else {
mp_raise_ValueError(MP_ERROR_TEXT("width must be 1 or 4 (or 8 on slot 0)"));
}
DEBUG_printf(" Calling init_slot()");
check_esp_err(sdmmc_host_init_slot(self->host.slot, &slot_config));
}
DEBUG_printf(" Returning new card object: %p", self);
return MP_OBJ_FROM_PTR(self);
}
STATIC mp_obj_t sd_deinit(mp_obj_t self_in) {
sdcard_card_obj_t *self = self_in;
DEBUG_printf("De-init host\n");
if (self->flags & SDCARD_CARD_FLAGS_HOST_INIT_DONE) {
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 2, 0)
if (self->host.flags & SDMMC_HOST_FLAG_DEINIT_ARG) {
self->host.deinit_p(self->host.slot);
} else
#endif
{
self->host.deinit();
}
self->flags &= ~SDCARD_CARD_FLAGS_HOST_INIT_DONE;
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(sd_deinit_obj, sd_deinit);
STATIC mp_obj_t sd_info(mp_obj_t self_in) {
sdcard_card_obj_t *self = self_in;
// We could potential return a great deal more SD card data but it
// is not clear that it is worth the extra code space to do
// so. For the most part people only care about the card size and
// block size.
check_esp_err(sdcard_ensure_card_init((sdcard_card_obj_t *)self, false));
uint32_t log_block_nbr = self->card.csd.capacity;
uint32_t log_block_size = _SECTOR_SIZE(self);
mp_obj_t tuple[2] = {
mp_obj_new_int_from_ull((uint64_t)log_block_nbr * (uint64_t)log_block_size),
mp_obj_new_int_from_uint(log_block_size),
};
return mp_obj_new_tuple(2, tuple);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(sd_info_obj, sd_info);
STATIC mp_obj_t machine_sdcard_readblocks(mp_obj_t self_in, mp_obj_t block_num, mp_obj_t buf) {
sdcard_card_obj_t *self = self_in;
mp_buffer_info_t bufinfo;
esp_err_t err;
err = sdcard_ensure_card_init((sdcard_card_obj_t *)self, false);
if (err != ESP_OK) {
return false;
}
mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_WRITE);
err = sdmmc_read_sectors(&(self->card), bufinfo.buf, mp_obj_get_int(block_num), bufinfo.len / _SECTOR_SIZE(self));
return mp_obj_new_bool(err == ESP_OK);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_3(machine_sdcard_readblocks_obj, machine_sdcard_readblocks);
STATIC mp_obj_t machine_sdcard_writeblocks(mp_obj_t self_in, mp_obj_t block_num, mp_obj_t buf) {
sdcard_card_obj_t *self = self_in;
mp_buffer_info_t bufinfo;
esp_err_t err;
err = sdcard_ensure_card_init((sdcard_card_obj_t *)self, false);
if (err != ESP_OK) {
return false;
}
mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_READ);
err = sdmmc_write_sectors(&(self->card), bufinfo.buf, mp_obj_get_int(block_num), bufinfo.len / _SECTOR_SIZE(self));
return mp_obj_new_bool(err == ESP_OK);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_3(machine_sdcard_writeblocks_obj, machine_sdcard_writeblocks);
STATIC mp_obj_t machine_sdcard_ioctl(mp_obj_t self_in, mp_obj_t cmd_in, mp_obj_t arg_in) {
sdcard_card_obj_t *self = self_in;
esp_err_t err = ESP_OK;
mp_int_t cmd = mp_obj_get_int(cmd_in);
switch (cmd) {
case MP_BLOCKDEV_IOCTL_INIT:
err = sdcard_ensure_card_init(self, false);
return MP_OBJ_NEW_SMALL_INT((err == ESP_OK) ? 0 : -1);
case MP_BLOCKDEV_IOCTL_DEINIT:
// Ensure that future attempts to look at info re-read the card
self->flags &= ~SDCARD_CARD_FLAGS_CARD_INIT_DONE;
return MP_OBJ_NEW_SMALL_INT(0); // success
case MP_BLOCKDEV_IOCTL_SYNC:
// nothing to do
return MP_OBJ_NEW_SMALL_INT(0); // success
case MP_BLOCKDEV_IOCTL_BLOCK_COUNT:
err = sdcard_ensure_card_init(self, false);
if (err != ESP_OK) {
return MP_OBJ_NEW_SMALL_INT(-1);
}
return MP_OBJ_NEW_SMALL_INT(self->card.csd.capacity);
case MP_BLOCKDEV_IOCTL_BLOCK_SIZE:
err = sdcard_ensure_card_init(self, false);
if (err != ESP_OK) {
return MP_OBJ_NEW_SMALL_INT(-1);
}
return MP_OBJ_NEW_SMALL_INT(_SECTOR_SIZE(self));
default: // unknown command
return MP_OBJ_NEW_SMALL_INT(-1); // error
}
}
STATIC MP_DEFINE_CONST_FUN_OBJ_3(machine_sdcard_ioctl_obj, machine_sdcard_ioctl);
STATIC const mp_rom_map_elem_t machine_sdcard_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_info), MP_ROM_PTR(&sd_info_obj) },
{ MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&sd_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&sd_deinit_obj) },
// block device protocol
{ MP_ROM_QSTR(MP_QSTR_readblocks), MP_ROM_PTR(&machine_sdcard_readblocks_obj) },
{ MP_ROM_QSTR(MP_QSTR_writeblocks), MP_ROM_PTR(&machine_sdcard_writeblocks_obj) },
{ MP_ROM_QSTR(MP_QSTR_ioctl), MP_ROM_PTR(&machine_sdcard_ioctl_obj) },
};
STATIC MP_DEFINE_CONST_DICT(machine_sdcard_locals_dict, machine_sdcard_locals_dict_table);
const mp_obj_type_t machine_sdcard_type = {
{ &mp_type_type },
.name = MP_QSTR_SDCard,
.make_new = machine_sdcard_make_new,
.locals_dict = (mp_obj_dict_t *)&machine_sdcard_locals_dict,
};
#endif // MICROPY_HW_ENABLE_SDCARD
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_sdcard.c | C | apache-2.0 | 14,691 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2013-2015 Damien P. George
* Copyright (c) 2016 Paul Sokolovsky
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdint.h>
#include <stdio.h>
#include "py/obj.h"
#include "py/runtime.h"
#include "modmachine.h"
#include "mphalport.h"
#include "driver/timer.h"
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 1, 1)
#include "hal/timer_ll.h"
#define HAVE_TIMER_LL (1)
#endif
#define TIMER_INTR_SEL TIMER_INTR_LEVEL
#define TIMER_DIVIDER 8
// TIMER_BASE_CLK is normally 80MHz. TIMER_DIVIDER ought to divide this exactly
#define TIMER_SCALE (TIMER_BASE_CLK / TIMER_DIVIDER)
#define TIMER_FLAGS 0
typedef struct _machine_timer_obj_t {
mp_obj_base_t base;
mp_uint_t group;
mp_uint_t index;
mp_uint_t repeat;
// ESP32 timers are 64-bit
uint64_t period;
mp_obj_t callback;
intr_handle_t handle;
struct _machine_timer_obj_t *next;
} machine_timer_obj_t;
const mp_obj_type_t machine_timer_type;
STATIC void machine_timer_disable(machine_timer_obj_t *self);
void machine_timer_deinit_all(void) {
// Disable, deallocate and remove all timers from list
machine_timer_obj_t **t = &MP_STATE_PORT(machine_timer_obj_head);
while (*t != NULL) {
machine_timer_disable(*t);
machine_timer_obj_t *next = (*t)->next;
m_del_obj(machine_timer_obj_t, *t);
*t = next;
}
}
STATIC void machine_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
machine_timer_obj_t *self = self_in;
timer_config_t config;
mp_printf(print, "Timer(%p; ", self);
timer_get_config(self->group, self->index, &config);
mp_printf(print, "alarm_en=%d, ", config.alarm_en);
mp_printf(print, "auto_reload=%d, ", config.auto_reload);
mp_printf(print, "counter_en=%d)", config.counter_en);
}
STATIC mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
mp_arg_check_num(n_args, n_kw, 1, 1, false);
mp_uint_t group = (mp_obj_get_int(args[0]) >> 1) & 1;
mp_uint_t index = mp_obj_get_int(args[0]) & 1;
// Check whether the timer is already initialized, if so return it
for (machine_timer_obj_t *t = MP_STATE_PORT(machine_timer_obj_head); t; t = t->next) {
if (t->group == group && t->index == index) {
return t;
}
}
machine_timer_obj_t *self = m_new_obj(machine_timer_obj_t);
self->base.type = &machine_timer_type;
self->group = group;
self->index = index;
// Add the timer to the linked-list of timers
self->next = MP_STATE_PORT(machine_timer_obj_head);
MP_STATE_PORT(machine_timer_obj_head) = self;
return self;
}
STATIC void machine_timer_disable(machine_timer_obj_t *self) {
if (self->handle) {
timer_pause(self->group, self->index);
esp_intr_free(self->handle);
self->handle = NULL;
}
// We let the disabled timer stay in the list, as it might be
// referenced elsewhere
}
STATIC void machine_timer_isr(void *self_in) {
machine_timer_obj_t *self = self_in;
timg_dev_t *device = self->group ? &(TIMERG1) : &(TIMERG0);
#if HAVE_TIMER_LL
#if CONFIG_IDF_TARGET_ESP32 && ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
device->hw_timer[self->index].update = 1;
#else
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 4, 0)
#if CONFIG_IDF_TARGET_ESP32S3
device->hw_timer[self->index].update.tn_update = 1;
#else
device->hw_timer[self->index].update.tx_update = 1;
#endif
#else
device->hw_timer[self->index].update.update = 1;
#endif
#endif
timer_ll_clear_intr_status(device, self->index);
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
timer_ll_set_alarm_enable(device, self->index, self->repeat);
#else
timer_ll_set_alarm_value(device, self->index, self->repeat);
#endif
#else
device->hw_timer[self->index].update = 1;
if (self->index) {
device->int_clr_timers.t1 = 1;
} else {
device->int_clr_timers.t0 = 1;
}
device->hw_timer[self->index].config.alarm_en = self->repeat;
#endif
mp_sched_schedule(self->callback, self);
mp_hal_wake_main_task_from_isr();
}
STATIC void machine_timer_enable(machine_timer_obj_t *self) {
timer_config_t config;
config.alarm_en = TIMER_ALARM_EN;
config.auto_reload = self->repeat;
config.counter_dir = TIMER_COUNT_UP;
config.divider = TIMER_DIVIDER;
config.intr_type = TIMER_INTR_LEVEL;
config.counter_en = TIMER_PAUSE;
check_esp_err(timer_init(self->group, self->index, &config));
check_esp_err(timer_set_counter_value(self->group, self->index, 0x00000000));
check_esp_err(timer_set_alarm_value(self->group, self->index, self->period));
check_esp_err(timer_enable_intr(self->group, self->index));
check_esp_err(timer_isr_register(self->group, self->index, machine_timer_isr, (void *)self, TIMER_FLAGS, &self->handle));
check_esp_err(timer_start(self->group, self->index));
}
STATIC mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum {
ARG_mode,
ARG_callback,
ARG_period,
ARG_tick_hz,
ARG_freq,
};
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_mode, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} },
{ MP_QSTR_callback, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
{ MP_QSTR_period, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0xffffffff} },
{ MP_QSTR_tick_hz, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1000} },
#if MICROPY_PY_BUILTINS_FLOAT
{ MP_QSTR_freq, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
#else
{ MP_QSTR_freq, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0xffffffff} },
#endif
};
machine_timer_disable(self);
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
#if MICROPY_PY_BUILTINS_FLOAT
if (args[ARG_freq].u_obj != mp_const_none) {
self->period = (uint64_t)(TIMER_SCALE / mp_obj_get_float(args[ARG_freq].u_obj));
}
#else
if (args[ARG_freq].u_int != 0xffffffff) {
self->period = TIMER_SCALE / ((uint64_t)args[ARG_freq].u_int);
}
#endif
else {
self->period = (((uint64_t)args[ARG_period].u_int) * TIMER_SCALE) / args[ARG_tick_hz].u_int;
}
self->repeat = args[ARG_mode].u_int;
self->callback = args[ARG_callback].u_obj;
self->handle = NULL;
machine_timer_enable(self);
return mp_const_none;
}
STATIC mp_obj_t machine_timer_deinit(mp_obj_t self_in) {
machine_timer_disable(self_in);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_timer_deinit_obj, machine_timer_deinit);
STATIC mp_obj_t machine_timer_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
return machine_timer_init_helper(args[0], n_args - 1, args + 1, kw_args);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_timer_init_obj, 1, machine_timer_init);
STATIC mp_obj_t machine_timer_value(mp_obj_t self_in) {
machine_timer_obj_t *self = self_in;
double result;
timer_get_counter_time_sec(self->group, self->index, &result);
return MP_OBJ_NEW_SMALL_INT((mp_uint_t)(result * 1000)); // value in ms
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_timer_value_obj, machine_timer_value);
STATIC const mp_rom_map_elem_t machine_timer_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&machine_timer_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_timer_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_timer_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_value), MP_ROM_PTR(&machine_timer_value_obj) },
{ MP_ROM_QSTR(MP_QSTR_ONE_SHOT), MP_ROM_INT(false) },
{ MP_ROM_QSTR(MP_QSTR_PERIODIC), MP_ROM_INT(true) },
};
STATIC MP_DEFINE_CONST_DICT(machine_timer_locals_dict, machine_timer_locals_dict_table);
const mp_obj_type_t machine_timer_type = {
{ &mp_type_type },
.name = MP_QSTR_Timer,
.print = machine_timer_print,
.make_new = machine_timer_make_new,
.locals_dict = (mp_obj_t)&machine_timer_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_timer.c | C | apache-2.0 | 9,528 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2017 Nick Moore
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "py/runtime.h"
#include "py/mphal.h"
#include "modmachine.h"
#if CONFIG_IDF_TARGET_ESP32
#include "driver/gpio.h"
#if CONFIG_IDF_TARGET_ESP32
#include "driver/touch_pad.h"
#elif CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
#include "driver/touch_sensor.h"
#endif
typedef struct _mtp_obj_t {
mp_obj_base_t base;
gpio_num_t gpio_id;
touch_pad_t touchpad_id;
} mtp_obj_t;
#if CONFIG_IDF_TARGET_ESP32
STATIC const mtp_obj_t touchpad_obj[] = {
{{&machine_touchpad_type}, GPIO_NUM_4, TOUCH_PAD_NUM0},
{{&machine_touchpad_type}, GPIO_NUM_0, TOUCH_PAD_NUM1},
{{&machine_touchpad_type}, GPIO_NUM_2, TOUCH_PAD_NUM2},
{{&machine_touchpad_type}, GPIO_NUM_15, TOUCH_PAD_NUM3},
{{&machine_touchpad_type}, GPIO_NUM_13, TOUCH_PAD_NUM4},
{{&machine_touchpad_type}, GPIO_NUM_12, TOUCH_PAD_NUM5},
{{&machine_touchpad_type}, GPIO_NUM_14, TOUCH_PAD_NUM6},
{{&machine_touchpad_type}, GPIO_NUM_27, TOUCH_PAD_NUM7},
{{&machine_touchpad_type}, GPIO_NUM_33, TOUCH_PAD_NUM8},
{{&machine_touchpad_type}, GPIO_NUM_32, TOUCH_PAD_NUM9},
};
#elif CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
STATIC const mtp_obj_t touchpad_obj[] = {
{{&machine_touchpad_type}, GPIO_NUM_1, TOUCH_PAD_NUM1},
{{&machine_touchpad_type}, GPIO_NUM_2, TOUCH_PAD_NUM2},
{{&machine_touchpad_type}, GPIO_NUM_3, TOUCH_PAD_NUM3},
{{&machine_touchpad_type}, GPIO_NUM_4, TOUCH_PAD_NUM4},
{{&machine_touchpad_type}, GPIO_NUM_5, TOUCH_PAD_NUM5},
{{&machine_touchpad_type}, GPIO_NUM_6, TOUCH_PAD_NUM6},
{{&machine_touchpad_type}, GPIO_NUM_7, TOUCH_PAD_NUM7},
{{&machine_touchpad_type}, GPIO_NUM_8, TOUCH_PAD_NUM8},
{{&machine_touchpad_type}, GPIO_NUM_9, TOUCH_PAD_NUM9},
{{&machine_touchpad_type}, GPIO_NUM_10, TOUCH_PAD_NUM10},
{{&machine_touchpad_type}, GPIO_NUM_11, TOUCH_PAD_NUM11},
{{&machine_touchpad_type}, GPIO_NUM_12, TOUCH_PAD_NUM12},
{{&machine_touchpad_type}, GPIO_NUM_13, TOUCH_PAD_NUM13},
{{&machine_touchpad_type}, GPIO_NUM_14, TOUCH_PAD_NUM14},
};
#endif
STATIC mp_obj_t mtp_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw,
const mp_obj_t *args) {
mp_arg_check_num(n_args, n_kw, 1, 1, true);
gpio_num_t pin_id = machine_pin_get_id(args[0]);
const mtp_obj_t *self = NULL;
for (int i = 0; i < MP_ARRAY_SIZE(touchpad_obj); i++) {
if (pin_id == touchpad_obj[i].gpio_id) {
self = &touchpad_obj[i];
break;
}
}
if (!self) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid pin for touchpad"));
}
static int initialized = 0;
if (!initialized) {
touch_pad_init();
touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER);
initialized = 1;
}
esp_err_t err = touch_pad_config(self->touchpad_id, 0);
if (err == ESP_OK) {
return MP_OBJ_FROM_PTR(self);
}
mp_raise_ValueError(MP_ERROR_TEXT("Touch pad error"));
}
STATIC mp_obj_t mtp_config(mp_obj_t self_in, mp_obj_t value_in) {
mtp_obj_t *self = self_in;
uint16_t value = mp_obj_get_int(value_in);
esp_err_t err = touch_pad_config(self->touchpad_id, value);
if (err == ESP_OK) {
return mp_const_none;
}
mp_raise_ValueError(MP_ERROR_TEXT("Touch pad error"));
}
MP_DEFINE_CONST_FUN_OBJ_2(mtp_config_obj, mtp_config);
STATIC mp_obj_t mtp_read(mp_obj_t self_in) {
mtp_obj_t *self = self_in;
uint16_t value;
esp_err_t err = touch_pad_read(self->touchpad_id, &value);
if (err == ESP_OK) {
return MP_OBJ_NEW_SMALL_INT(value);
}
mp_raise_ValueError(MP_ERROR_TEXT("Touch pad error"));
}
MP_DEFINE_CONST_FUN_OBJ_1(mtp_read_obj, mtp_read);
STATIC const mp_rom_map_elem_t mtp_locals_dict_table[] = {
// instance methods
{ MP_ROM_QSTR(MP_QSTR_config), MP_ROM_PTR(&mtp_config_obj) },
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mtp_read_obj) },
};
STATIC MP_DEFINE_CONST_DICT(mtp_locals_dict, mtp_locals_dict_table);
const mp_obj_type_t machine_touchpad_type = {
{ &mp_type_type },
.name = MP_QSTR_TouchPad,
.make_new = mtp_make_new,
.locals_dict = (mp_obj_t)&mtp_locals_dict,
};
#endif // CONFIG_IDF_TARGET_ESP32
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_touchpad.c | C | apache-2.0 | 5,383 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "driver/uart.h"
#include "freertos/FreeRTOS.h"
#include "py/runtime.h"
#include "py/stream.h"
#include "py/mperrno.h"
#include "modmachine.h"
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(4, 1, 0)
#define UART_INV_TX UART_INVERSE_TXD
#define UART_INV_RX UART_INVERSE_RXD
#define UART_INV_RTS UART_INVERSE_RTS
#define UART_INV_CTS UART_INVERSE_CTS
#else
#define UART_INV_TX UART_SIGNAL_TXD_INV
#define UART_INV_RX UART_SIGNAL_RXD_INV
#define UART_INV_RTS UART_SIGNAL_RTS_INV
#define UART_INV_CTS UART_SIGNAL_CTS_INV
#endif
#define UART_INV_MASK (UART_INV_TX | UART_INV_RX | UART_INV_RTS | UART_INV_CTS)
typedef struct _machine_uart_obj_t {
mp_obj_base_t base;
uart_port_t uart_num;
uart_hw_flowcontrol_t flowcontrol;
uint8_t bits;
uint8_t parity;
uint8_t stop;
int8_t tx;
int8_t rx;
int8_t rts;
int8_t cts;
uint16_t txbuf;
uint16_t rxbuf;
uint16_t timeout; // timeout waiting for first char (in ms)
uint16_t timeout_char; // timeout waiting between chars (in ms)
uint32_t invert; // lines to invert
} machine_uart_obj_t;
STATIC const char *_parity_name[] = {"None", "1", "0"};
/******************************************************************************/
// MicroPython bindings for UART
STATIC void machine_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
uint32_t baudrate;
uart_get_baudrate(self->uart_num, &baudrate);
mp_printf(print, "UART(%u, baudrate=%u, bits=%u, parity=%s, stop=%u, tx=%d, rx=%d, rts=%d, cts=%d, txbuf=%u, rxbuf=%u, timeout=%u, timeout_char=%u",
self->uart_num, baudrate, self->bits, _parity_name[self->parity],
self->stop, self->tx, self->rx, self->rts, self->cts, self->txbuf, self->rxbuf, self->timeout, self->timeout_char);
if (self->invert) {
mp_printf(print, ", invert=");
uint32_t invert_mask = self->invert;
if (invert_mask & UART_INV_TX) {
mp_printf(print, "INV_TX");
invert_mask &= ~UART_INV_TX;
if (invert_mask) {
mp_printf(print, "|");
}
}
if (invert_mask & UART_INV_RX) {
mp_printf(print, "INV_RX");
invert_mask &= ~UART_INV_RX;
if (invert_mask) {
mp_printf(print, "|");
}
}
if (invert_mask & UART_INV_RTS) {
mp_printf(print, "INV_RTS");
invert_mask &= ~UART_INV_RTS;
if (invert_mask) {
mp_printf(print, "|");
}
}
if (invert_mask & UART_INV_CTS) {
mp_printf(print, "INV_CTS");
}
}
if (self->flowcontrol) {
mp_printf(print, ", flow=");
uint32_t flow_mask = self->flowcontrol;
if (flow_mask & UART_HW_FLOWCTRL_RTS) {
mp_printf(print, "RTS");
flow_mask &= ~UART_HW_FLOWCTRL_RTS;
if (flow_mask) {
mp_printf(print, "|");
}
}
if (flow_mask & UART_HW_FLOWCTRL_CTS) {
mp_printf(print, "CTS");
}
}
mp_printf(print, ")");
}
STATIC void machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum { ARG_baudrate, ARG_bits, ARG_parity, ARG_stop, ARG_tx, ARG_rx, ARG_rts, ARG_cts, ARG_txbuf, ARG_rxbuf, ARG_timeout, ARG_timeout_char, ARG_invert, ARG_flow };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_baudrate, MP_ARG_INT, {.u_int = 0} },
{ MP_QSTR_bits, MP_ARG_INT, {.u_int = 0} },
{ MP_QSTR_parity, MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_stop, MP_ARG_INT, {.u_int = 0} },
{ MP_QSTR_tx, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} },
{ MP_QSTR_rx, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} },
{ MP_QSTR_rts, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} },
{ MP_QSTR_cts, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} },
{ MP_QSTR_txbuf, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_rxbuf, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
{ MP_QSTR_timeout_char, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
{ MP_QSTR_invert, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
{ MP_QSTR_flow, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
// wait for all data to be transmitted before changing settings
uart_wait_tx_done(self->uart_num, pdMS_TO_TICKS(1000));
if (args[ARG_txbuf].u_int >= 0 || args[ARG_rxbuf].u_int >= 0) {
// must reinitialise driver to change the tx/rx buffer size
if (args[ARG_txbuf].u_int >= 0) {
self->txbuf = args[ARG_txbuf].u_int;
}
if (args[ARG_rxbuf].u_int >= 0) {
self->rxbuf = args[ARG_rxbuf].u_int;
}
uart_config_t uartcfg = {
.flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
.rx_flow_ctrl_thresh = 0
};
uint32_t baudrate;
uart_get_baudrate(self->uart_num, &baudrate);
uartcfg.baud_rate = baudrate;
uart_get_word_length(self->uart_num, &uartcfg.data_bits);
uart_get_parity(self->uart_num, &uartcfg.parity);
uart_get_stop_bits(self->uart_num, &uartcfg.stop_bits);
uart_driver_delete(self->uart_num);
uart_param_config(self->uart_num, &uartcfg);
uart_driver_install(self->uart_num, self->rxbuf, self->txbuf, 0, NULL, 0);
}
// set baudrate
uint32_t baudrate = 115200;
if (args[ARG_baudrate].u_int > 0) {
uart_set_baudrate(self->uart_num, args[ARG_baudrate].u_int);
uart_get_baudrate(self->uart_num, &baudrate);
}
uart_set_pin(self->uart_num, args[ARG_tx].u_int, args[ARG_rx].u_int, args[ARG_rts].u_int, args[ARG_cts].u_int);
if (args[ARG_tx].u_int != UART_PIN_NO_CHANGE) {
self->tx = args[ARG_tx].u_int;
}
if (args[ARG_rx].u_int != UART_PIN_NO_CHANGE) {
self->rx = args[ARG_rx].u_int;
}
if (args[ARG_rts].u_int != UART_PIN_NO_CHANGE) {
self->rts = args[ARG_rts].u_int;
}
if (args[ARG_cts].u_int != UART_PIN_NO_CHANGE) {
self->cts = args[ARG_cts].u_int;
}
// set data bits
switch (args[ARG_bits].u_int) {
case 0:
break;
case 5:
uart_set_word_length(self->uart_num, UART_DATA_5_BITS);
self->bits = 5;
break;
case 6:
uart_set_word_length(self->uart_num, UART_DATA_6_BITS);
self->bits = 6;
break;
case 7:
uart_set_word_length(self->uart_num, UART_DATA_7_BITS);
self->bits = 7;
break;
case 8:
uart_set_word_length(self->uart_num, UART_DATA_8_BITS);
self->bits = 8;
break;
default:
mp_raise_ValueError(MP_ERROR_TEXT("invalid data bits"));
break;
}
// set parity
if (args[ARG_parity].u_obj != MP_OBJ_NULL) {
if (args[ARG_parity].u_obj == mp_const_none) {
uart_set_parity(self->uart_num, UART_PARITY_DISABLE);
self->parity = 0;
} else {
mp_int_t parity = mp_obj_get_int(args[ARG_parity].u_obj);
if (parity & 1) {
uart_set_parity(self->uart_num, UART_PARITY_ODD);
self->parity = 1;
} else {
uart_set_parity(self->uart_num, UART_PARITY_EVEN);
self->parity = 2;
}
}
}
// set stop bits
switch (args[ARG_stop].u_int) {
// FIXME: ESP32 also supports 1.5 stop bits
case 0:
break;
case 1:
uart_set_stop_bits(self->uart_num, UART_STOP_BITS_1);
self->stop = 1;
break;
case 2:
uart_set_stop_bits(self->uart_num, UART_STOP_BITS_2);
self->stop = 2;
break;
default:
mp_raise_ValueError(MP_ERROR_TEXT("invalid stop bits"));
break;
}
// set timeout
self->timeout = args[ARG_timeout].u_int;
// set timeout_char
// make sure it is at least as long as a whole character (13 bits to be safe)
self->timeout_char = args[ARG_timeout_char].u_int;
uint32_t min_timeout_char = 13000 / baudrate + 1;
if (self->timeout_char < min_timeout_char) {
self->timeout_char = min_timeout_char;
}
// set line inversion
if (args[ARG_invert].u_int & ~UART_INV_MASK) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid inversion mask"));
}
self->invert = args[ARG_invert].u_int;
uart_set_line_inverse(self->uart_num, self->invert);
// set hardware flow control
if (args[ARG_flow].u_int & ~UART_HW_FLOWCTRL_CTS_RTS) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid flow control mask"));
}
self->flowcontrol = args[ARG_flow].u_int;
uart_set_hw_flow_ctrl(self->uart_num, self->flowcontrol, UART_FIFO_LEN - UART_FIFO_LEN / 4);
}
STATIC mp_obj_t machine_uart_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
// get uart id
mp_int_t uart_num = mp_obj_get_int(args[0]);
if (uart_num < 0 || uart_num >= UART_NUM_MAX) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("UART(%d) does not exist"), uart_num);
}
// Attempts to use UART0 from Python has resulted in all sorts of fun errors.
// FIXME: UART0 is disabled for now.
if (uart_num == UART_NUM_0) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("UART(%d) is disabled (dedicated to REPL)"), uart_num);
}
// Defaults
uart_config_t uartcfg = {
.baud_rate = 115200,
.data_bits = UART_DATA_8_BITS,
.parity = UART_PARITY_DISABLE,
.stop_bits = UART_STOP_BITS_1,
.flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
.rx_flow_ctrl_thresh = 0
};
// create instance
machine_uart_obj_t *self = m_new_obj(machine_uart_obj_t);
self->base.type = &machine_uart_type;
self->uart_num = uart_num;
self->bits = 8;
self->parity = 0;
self->stop = 1;
self->rts = UART_PIN_NO_CHANGE;
self->cts = UART_PIN_NO_CHANGE;
self->txbuf = 256;
self->rxbuf = 256; // IDF minimum
self->timeout = 0;
self->timeout_char = 0;
switch (uart_num) {
case UART_NUM_0:
self->rx = UART_PIN_NO_CHANGE; // GPIO 3
self->tx = UART_PIN_NO_CHANGE; // GPIO 1
break;
case UART_NUM_1:
self->rx = 9;
self->tx = 10;
break;
#if SOC_UART_NUM > 2
case UART_NUM_2:
self->rx = 16;
self->tx = 17;
break;
#endif
}
// Remove any existing configuration
uart_driver_delete(self->uart_num);
// init the peripheral
// Setup
uart_param_config(self->uart_num, &uartcfg);
uart_driver_install(uart_num, self->rxbuf, self->txbuf, 0, NULL, 0);
mp_map_t kw_args;
mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
machine_uart_init_helper(self, n_args - 1, args + 1, &kw_args);
// Make sure pins are connected.
uart_set_pin(self->uart_num, self->tx, self->rx, self->rts, self->cts);
return MP_OBJ_FROM_PTR(self);
}
STATIC mp_obj_t machine_uart_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
machine_uart_init_helper(args[0], n_args - 1, args + 1, kw_args);
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_KW(machine_uart_init_obj, 1, machine_uart_init);
STATIC mp_obj_t machine_uart_deinit(mp_obj_t self_in) {
machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
uart_driver_delete(self->uart_num);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_uart_deinit_obj, machine_uart_deinit);
STATIC mp_obj_t machine_uart_any(mp_obj_t self_in) {
machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
size_t rxbufsize;
uart_get_buffered_data_len(self->uart_num, &rxbufsize);
return MP_OBJ_NEW_SMALL_INT(rxbufsize);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_uart_any_obj, machine_uart_any);
STATIC mp_obj_t machine_uart_sendbreak(mp_obj_t self_in) {
machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
// Save settings
uart_word_length_t word_length;
uart_parity_t parity;
uart_get_word_length(self->uart_num, &word_length);
uart_get_parity(self->uart_num, &parity);
// Synthesise the break condition by either a longer word or using even parity
uart_wait_tx_done(self->uart_num, pdMS_TO_TICKS(1000));
if (word_length != UART_DATA_8_BITS) {
uart_set_word_length(self->uart_num, UART_DATA_8_BITS);
} else if (parity == UART_PARITY_DISABLE) {
uart_set_parity(self->uart_num, UART_PARITY_EVEN);
} else {
// Cannot synthesise break
mp_raise_OSError(MP_EPERM);
}
char buf[1] = {0};
uart_write_bytes(self->uart_num, buf, 1);
uart_wait_tx_done(self->uart_num, pdMS_TO_TICKS(1000));
// Restore original settings
uart_set_word_length(self->uart_num, word_length);
uart_set_parity(self->uart_num, parity);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_uart_sendbreak_obj, machine_uart_sendbreak);
STATIC const mp_rom_map_elem_t machine_uart_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_uart_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_uart_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_any), MP_ROM_PTR(&machine_uart_any_obj) },
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
{ MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
{ MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
{ MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
{ MP_ROM_QSTR(MP_QSTR_sendbreak), MP_ROM_PTR(&machine_uart_sendbreak_obj) },
{ MP_ROM_QSTR(MP_QSTR_INV_TX), MP_ROM_INT(UART_INV_TX) },
{ MP_ROM_QSTR(MP_QSTR_INV_RX), MP_ROM_INT(UART_INV_RX) },
{ MP_ROM_QSTR(MP_QSTR_INV_RTS), MP_ROM_INT(UART_INV_RTS) },
{ MP_ROM_QSTR(MP_QSTR_INV_CTS), MP_ROM_INT(UART_INV_CTS) },
{ MP_ROM_QSTR(MP_QSTR_RTS), MP_ROM_INT(UART_HW_FLOWCTRL_RTS) },
{ MP_ROM_QSTR(MP_QSTR_CTS), MP_ROM_INT(UART_HW_FLOWCTRL_CTS) },
};
STATIC MP_DEFINE_CONST_DICT(machine_uart_locals_dict, machine_uart_locals_dict_table);
STATIC mp_uint_t machine_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, int *errcode) {
machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
// make sure we want at least 1 char
if (size == 0) {
return 0;
}
TickType_t time_to_wait;
if (self->timeout == 0) {
time_to_wait = 0;
} else {
time_to_wait = pdMS_TO_TICKS(self->timeout);
}
int bytes_read = uart_read_bytes(self->uart_num, buf_in, size, time_to_wait);
if (bytes_read <= 0) {
*errcode = MP_EAGAIN;
return MP_STREAM_ERROR;
}
return bytes_read;
}
STATIC mp_uint_t machine_uart_write(mp_obj_t self_in, const void *buf_in, mp_uint_t size, int *errcode) {
machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
int bytes_written = uart_write_bytes(self->uart_num, buf_in, size);
if (bytes_written < 0) {
*errcode = MP_EAGAIN;
return MP_STREAM_ERROR;
}
// return number of bytes written
return bytes_written;
}
STATIC mp_uint_t machine_uart_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
machine_uart_obj_t *self = self_in;
mp_uint_t ret;
if (request == MP_STREAM_POLL) {
mp_uint_t flags = arg;
ret = 0;
size_t rxbufsize;
uart_get_buffered_data_len(self->uart_num, &rxbufsize);
if ((flags & MP_STREAM_POLL_RD) && rxbufsize > 0) {
ret |= MP_STREAM_POLL_RD;
}
if ((flags & MP_STREAM_POLL_WR) && 1) { // FIXME: uart_tx_any_room(self->uart_num)
ret |= MP_STREAM_POLL_WR;
}
} else {
*errcode = MP_EINVAL;
ret = MP_STREAM_ERROR;
}
return ret;
}
STATIC const mp_stream_p_t uart_stream_p = {
.read = machine_uart_read,
.write = machine_uart_write,
.ioctl = machine_uart_ioctl,
.is_text = false,
};
const mp_obj_type_t machine_uart_type = {
{ &mp_type_type },
.name = MP_QSTR_UART,
.print = machine_uart_print,
.make_new = machine_uart_make_new,
.getiter = mp_identity_getiter,
.iternext = mp_stream_unbuffered_iter,
.protocol = &uart_stream_p,
.locals_dict = (mp_obj_dict_t *)&machine_uart_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_uart.c | C | apache-2.0 | 18,222 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Paul Sokolovsky
* Copyright (c) 2017 Eric Poulsen
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <string.h>
#include "py/nlr.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "esp_task_wdt.h"
const mp_obj_type_t machine_wdt_type;
typedef struct _machine_wdt_obj_t {
mp_obj_base_t base;
} machine_wdt_obj_t;
STATIC machine_wdt_obj_t wdt_default = {{&machine_wdt_type}};
STATIC mp_obj_t machine_wdt_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
enum { ARG_id, ARG_timeout };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_id, MP_ARG_INT, {.u_int = 0} },
{ MP_QSTR_timeout, MP_ARG_INT, {.u_int = 5000} }
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
if (args[ARG_id].u_int != 0) {
mp_raise_ValueError(NULL);
}
// Convert milliseconds to seconds (esp_task_wdt_init needs seconds)
args[ARG_timeout].u_int /= 1000;
if (args[ARG_timeout].u_int <= 0) {
mp_raise_ValueError(MP_ERROR_TEXT("WDT timeout too short"));
}
mp_int_t rs_code = esp_task_wdt_init(args[ARG_timeout].u_int, true);
if (rs_code != ESP_OK) {
mp_raise_OSError(rs_code);
}
esp_task_wdt_add(NULL);
return &wdt_default;
}
STATIC mp_obj_t machine_wdt_feed(mp_obj_t self_in) {
(void)self_in;
esp_task_wdt_reset();
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_wdt_feed_obj, machine_wdt_feed);
STATIC const mp_rom_map_elem_t machine_wdt_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_feed), MP_ROM_PTR(&machine_wdt_feed_obj) },
};
STATIC MP_DEFINE_CONST_DICT(machine_wdt_locals_dict, machine_wdt_locals_dict_table);
const mp_obj_type_t machine_wdt_type = {
{ &mp_type_type },
.name = MP_QSTR_WDT,
.make_new = machine_wdt_make_new,
.locals_dict = (mp_obj_t)&machine_wdt_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/machine_wdt.c | C | apache-2.0 | 3,147 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "nvs_flash.h"
#include "soc/cpu.h"
#if CONFIG_IDF_TARGET_ESP32
#include "esp32/spiram.h"
#elif CONFIG_IDF_TARGET_ESP32S2
#include "esp32s2/spiram.h"
#elif CONFIG_IDF_TARGET_ESP32S3
#include "esp32s3/spiram.h"
#endif
#include <fcntl.h>
#include <unistd.h>
#include "board_config.h"
#include "esp_log.h"
#include "esp_partition.h"
#include "esp_system.h"
#include "esp_task.h"
#include "esp_vfs.h"
#include "esp_vfs_fat.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "modmachine.h"
#include "modnetwork.h"
#include "mpthreadport.h"
#include "py/compile.h"
#include "py/gc.h"
#include "py/mphal.h"
#include "py/nlr.h"
#include "py/persistentcode.h"
#include "py/repl.h"
#include "py/runtime.h"
#include "py/stackctrl.h"
#include "shared/readline/readline.h"
#include "shared/runtime/pyexec.h"
#include "uart.h"
#include "usb.h"
#include "usb_serial_jtag.h"
#include "wear_levelling.h"
#if MICROPY_BLUETOOTH_NIMBLE
#include "extmod/modbluetooth.h"
#endif
#include "extmod/vfs.h"
#if MICROPY_VFS_POSIX
#include "extmod/vfs_posix.h"
#endif
#if AOS_COMP_KV
#include "aos/kv.h"
#endif
// MicroPython runs as a task under FreeRTOS
#define MP_TASK_PRIORITY (ESP_TASK_PRIO_MIN + 1)
#define MP_TASK_STACK_SIZE (8 * 1024)
// Set the margin for detecting stack overflow, depending on the CPU architecture.
#if CONFIG_IDF_TARGET_ESP32C3
#define MP_TASK_STACK_LIMIT_MARGIN (2048)
#else
#define MP_TASK_STACK_LIMIT_MARGIN (1024)
#endif
int vprintf_null(const char *format, va_list ap)
{
// do nothing: this is used as a log target during raw repl mode
return 0;
}
// Try to mount the data on "/data" and chdir to it for the boot-up directory.
static int32_t mount_fs(char *mount_point_str)
{
#if MICROPY_VFS_POSIX
mp_obj_t mount_point = mp_obj_new_str(mount_point_str, strlen(mount_point_str));
mp_obj_t bdev = mp_type_vfs_posix.make_new(&mp_type_vfs_posix, 0, 0, NULL);
int32_t ret = mp_vfs_mount_and_chdir_protected(bdev, mount_point);
if (ret != 0) {
printf("mount_fs failed with mount_point: %s\n", mount_point_str);
return -1;
}
#else
(void)mount_point_str;
#endif
return 0;
}
static char *is_mainpy_exist()
{
// check whether main/pyamp/main.py
FILE *fd = fopen(AMP_PY_ENTRY_HAAS, "r");
if (fd != NULL) {
printf(" ==== python file check %s ====\n", AMP_PY_ENTRY_HAAS);
fclose(fd);
return AMP_PY_ENTRY_HAAS;
}
fd = fopen(AMP_PY_ENTRY_ROOT, "r");
if (fd != NULL) {
printf(" ==== python file check %s ====\n", AMP_PY_ENTRY_ROOT);
fclose(fd);
return AMP_PY_ENTRY_ROOT;
}
return NULL;
}
void mp_task(void *pvParameter)
{
volatile uint32_t sp = (uint32_t)get_sp();
int ret;
#if MICROPY_PY_THREAD
mp_thread_init(pxTaskGetStackStart(NULL), MP_TASK_STACK_SIZE / sizeof(uintptr_t));
#endif
#if CONFIG_USB_ENABLED
usb_init();
#elif CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG
usb_serial_jtag_init();
#else
uart_init();
#endif
machine_init();
// TODO: CONFIG_SPIRAM_SUPPORT is for 3.3 compatibility, remove after move to 4.0.
#if CONFIG_ESP32_SPIRAM_SUPPORT || CONFIG_SPIRAM_SUPPORT
// Try to use the entire external SPIRAM directly for the heap
size_t mp_task_heap_size;
void *mp_task_heap = (void *)0x3f800000;
switch (esp_spiram_get_chip_size()) {
case ESP_SPIRAM_SIZE_16MBITS:
#if CONFIG_SPIRAM_USE_MALLOC
mp_task_heap_size = 512 * 1024;
mp_task_heap = malloc(mp_task_heap_size);
#else
mp_task_heap_size = 2 * 1024 * 1024;
#endif
break;
case ESP_SPIRAM_SIZE_32MBITS:
case ESP_SPIRAM_SIZE_64MBITS:
#if CONFIG_SPIRAM_USE_MALLOC
mp_task_heap_size = 1 * 1024 * 1024;
mp_task_heap = malloc(mp_task_heap_size);
#else
mp_task_heap_size = 4 * 1024 * 1024;
#endif
break;
default:
// No SPIRAM, fallback to normal allocation
mp_task_heap_size = heap_caps_get_largest_free_block(MALLOC_CAP_8BIT);
mp_task_heap = malloc(mp_task_heap_size);
break;
}
#elif CONFIG_ESP32S2_SPIRAM_SUPPORT || CONFIG_ESP32S3_SPIRAM_SUPPORT
// Try to use the entire external SPIRAM directly for the heap
size_t mp_task_heap_size;
size_t esp_spiram_size = esp_spiram_get_size();
void *mp_task_heap = (void *)0x3ff80000 - esp_spiram_size;
if (esp_spiram_size > 0) {
mp_task_heap_size = esp_spiram_size;
} else {
// No SPIRAM, fallback to normal allocation
mp_task_heap_size = heap_caps_get_largest_free_block(MALLOC_CAP_8BIT);
mp_task_heap = malloc(mp_task_heap_size);
}
#else
// Allocate the uPy heap using malloc and get the largest available region
size_t mp_task_heap_size = heap_caps_get_largest_free_block(MALLOC_CAP_8BIT);
mp_task_heap_size = 96 * 1024;
void *mp_task_heap = malloc(mp_task_heap_size);
#endif
soft_reset:
// initialise the stack pointer for the main thread
mp_stack_set_top((void *)sp);
mp_stack_set_limit(MP_TASK_STACK_SIZE - MP_TASK_STACK_LIMIT_MARGIN);
gc_init(mp_task_heap, mp_task_heap + mp_task_heap_size);
mp_init();
mp_obj_list_init(mp_sys_path, 0);
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR_));
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_lib));
// add /data/pyamp to system path
char *path = MP_FS_ROOT_DIR "/pyamp";
mp_obj_list_append(mp_sys_path, mp_obj_new_str_via_qstr(path, strlen(path)));
// add /data/lib/ to system path
path = MP_FS_ROOT_DIR "/lib";
mp_obj_list_append(mp_sys_path, mp_obj_new_str_via_qstr(path, strlen(path)));
mp_obj_list_init(mp_sys_argv, 0);
#if 1
printf("mount fs\r\n");
ret = mount_fs("/");
if (ret != 0) {
printf(" !!!!!!!! %s, %d, faild to mount fs !!!!!!!!\n", __func__, __LINE__);
}
MP_STATE_VM(vfs_cur) = MP_STATE_VM(vfs_mount_table);
#endif
readline_init0();
// initialise peripherals
machine_pins_init();
#if MICROPY_PY_MACHINE_I2S
machine_i2s_init0();
#endif
// run boot-up scripts
// pyexec_frozen_module("_boot.py");
// do not delete this message, haas studio need use this message judge python status
printf(" ==== python execute bootpy ====\n");
pyexec_file_if_exists("boot.py");
if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
char *path = is_mainpy_exist();
if (path != NULL) {
// do not delete this message, haas studio need use this message judge python status
printf(" ==== python execute from %s ====\n", path);
int ret = pyexec_file_if_exists(path);
if (ret & PYEXEC_FORCED_EXIT) {
goto soft_reset_exit;
}
}
}
uint32_t esp_get_free_heap_size(void);
printf("%s-%d %d\r\n", __func__, __LINE__, esp_get_free_heap_size());
for (;;) {
if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
vprintf_like_t vprintf_log = esp_log_set_vprintf(vprintf_null);
if (pyexec_raw_repl() != 0) {
break;
}
esp_log_set_vprintf(vprintf_log);
} else {
if (pyexec_friendly_repl() != 0) {
break;
}
}
}
soft_reset_exit:
#if MICROPY_BLUETOOTH_NIMBLE
mp_bluetooth_deinit();
#endif
machine_timer_deinit_all();
#if MICROPY_PY_THREAD
mp_thread_deinit();
#endif
gc_sweep_all();
mp_hal_stdout_tx_str("MPY: soft reboot\r\n");
// deinitialise peripherals
machine_pins_deinit();
machine_deinit();
usocket_events_deinit();
mp_deinit();
fflush(stdout);
goto soft_reset;
}
static void queue_handler_task(void *p)
{
py_task_init();
while (1) {
/* loop for asynchronous operation */
if (py_task_yield(200) == 1) {
printf("pyengine task yield exit! \r\n");
break;
}
}
}
void app_main(void)
{
esp_err_t ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
nvs_flash_erase();
nvs_flash_init();
}
#if AOS_COMP_KV
ret = aos_kv_init();
if (ret) {
printf("kv init fail . ret is %d\r\n", ret);
}
#endif
ulog_init();
littlefs_register();
TaskHandle_t mp_queue_task_handle;
ret = xTaskCreatePinnedToCore(queue_handler_task, "queue_handler", 1024 * 3 / sizeof(StackType_t), NULL,
ESP_TASK_PRIO_MIN + 3, &mp_queue_task_handle, MP_TASK_COREID);
if (ret != pdPASS) {
printf("queue_handler_task creat failed!\r\n");
return;
}
ret = xTaskCreatePinnedToCore(mp_task, "mp_task", MP_TASK_STACK_SIZE / sizeof(StackType_t), NULL, MP_TASK_PRIORITY,
&mp_main_task_handle, MP_TASK_COREID);
if (ret != pdPASS) {
printf("mp_task task creat failed!\r\n");
return;
}
}
void nlr_jump_fail(void *val)
{
printf("NLR jump failed, val=%p\n", val);
esp_restart();
}
// modussl_mbedtls uses this function but it's not enabled in ESP IDF
void mbedtls_debug_set_threshold(int threshold)
{
(void)threshold;
}
void *esp_native_code_commit(void *buf, size_t len, void *reloc)
{
len = (len + 3) & ~3;
uint32_t *p = heap_caps_malloc(len, MALLOC_CAP_EXEC);
if (p == NULL) {
m_malloc_fail(len);
}
if (reloc) {
mp_native_relocate(reloc, buf, (uintptr_t)p);
}
memcpy(p, buf, len);
return p;
}
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/main.c | C | apache-2.0 | 10,918 |
# Set location of base MicroPython directory.
if(NOT MICROPY_DIR)
get_filename_component(MICROPY_DIR ${PROJECT_DIR}/../../engine ABSOLUTE)
endif()
# Include core source components.
include(${MICROPY_DIR}/../modules/portmod.cmake)
include(${MICROPY_DIR}/../external/external.cmake)
# Include port extmod component.
include(${MICROPY_DIR}/py/py.cmake)
if(NOT CMAKE_BUILD_EARLY_EXPANSION)
include(${MICROPY_DIR}/py/usermod.cmake)
include(${MICROPY_DIR}/extmod/extmod.cmake)
if(MICROPY_PY_LVGL)
include(${MICROPY_DIR}/lib/lv_bindings/mkrules.cmake)
endif()
endif()
set(MICROPY_QSTRDEFS_PORT
${PROJECT_DIR}/qstrdefsport.h
)
set(MICROPY_SOURCE_SHARED
${MICROPY_DIR}/shared/readline/readline.c
${MICROPY_DIR}/shared/netutils/netutils.c
${MICROPY_DIR}/shared/timeutils/timeutils.c
${MICROPY_DIR}/shared/runtime/interrupt_char.c
${MICROPY_DIR}/shared/runtime/stdout_helpers.c
${MICROPY_DIR}/shared/runtime/sys_stdio_mphal.c
${MICROPY_DIR}/shared/runtime/pyexec.c
)
set(MICROPY_SOURCE_LIB
${MICROPY_DIR}/lib/littlefs/lfs1.c
${MICROPY_DIR}/lib/littlefs/lfs1_util.c
${MICROPY_DIR}/lib/littlefs/lfs2.c
${MICROPY_DIR}/lib/littlefs/lfs2_util.c
${MICROPY_DIR}/lib/mbedtls_errors/mp_mbedtls_errors.c
${MICROPY_DIR}/lib/oofatfs/ff.c
${MICROPY_DIR}/lib/oofatfs/ffunicode.c
)
if(IDF_TARGET STREQUAL "esp32c3")
list(APPEND MICROPY_SOURCE_LIB ${MICROPY_DIR}/shared/runtime/gchelper_generic.c)
endif()
set(MICROPY_SOURCE_DRIVERS
${MICROPY_DIR}/drivers/bus/softspi.c
${MICROPY_DIR}/drivers/dht/dht.c
)
set(MICROPY_SOURCE_PORT
${PROJECT_DIR}/uart.c
${PROJECT_DIR}/usb.c
${PROJECT_DIR}/usb_serial_jtag.c
${PROJECT_DIR}/gccollect.c
${PROJECT_DIR}/mphalport.c
${PROJECT_DIR}/fatfs_port.c
${PROJECT_DIR}/help.c
${PROJECT_DIR}/modutime.c
${PROJECT_DIR}/moduos.c
${PROJECT_DIR}/machine_bitstream.c
${PROJECT_DIR}/machine_timer.c
${PROJECT_DIR}/machine_pin.c
${PROJECT_DIR}/machine_touchpad.c
${PROJECT_DIR}/machine_adc.c
${PROJECT_DIR}/machine_adcblock.c
${PROJECT_DIR}/machine_dac.c
${PROJECT_DIR}/machine_i2c.c
${PROJECT_DIR}/machine_i2s.c
${PROJECT_DIR}/machine_pwm.c
${PROJECT_DIR}/machine_uart.c
${PROJECT_DIR}/modmachine.c
${PROJECT_DIR}/modnetwork.c
${PROJECT_DIR}/network_lan.c
${PROJECT_DIR}/network_ppp.c
${PROJECT_DIR}/mpnimbleport.c
${PROJECT_DIR}/modsocket.c
${PROJECT_DIR}/modesp.c
${PROJECT_DIR}/esp32_nvs.c
${PROJECT_DIR}/esp32_partition.c
${PROJECT_DIR}/esp32_rmt.c
${PROJECT_DIR}/esp32_ulp.c
${PROJECT_DIR}/modesp32.c
${PROJECT_DIR}/machine_hw_spi.c
${PROJECT_DIR}/machine_wdt.c
${PROJECT_DIR}/mpthreadport.c
${PROJECT_DIR}/machine_rtc.c
${PROJECT_DIR}/machine_sdcard.c
${PROJECT_DIR}/utility.c
)
set(MICROPY_SOURCE_QSTR
${MICROPY_SOURCE_PY}
${MICROPY_SOURCE_EXTMOD}
${MICROPY_SOURCE_USERMOD}
${MICROPY_SOURCE_SHARED}
${MICROPY_SOURCE_LIB}
${MICROPY_SOURCE_PORT}
${MICROPY_SOURCE_MODULES_PORT}
${MICROPY_SOURCE_EXTERNAL}
${LV_SRC}
)
set(IDF_COMPONENTS
app_update
bootloader_support
bt
driver
esp_adc_cal
esp_common
esp_eth
esp_event
esp_http_client
esp_ringbuf
esp_rom
esp-tls
esp_wifi
#fatfs
freertos
heap
log
lwip
mbedtls
mdns
newlib
nghttp
nvs_flash
sdmmc
soc
spi_flash
tcpip_adapter
ulp
vfs
wear_levelling
xtensa
)
if(IDF_VERSION_MINOR GREATER_EQUAL 1 OR IDF_VERSION_MAJOR GREATER_EQUAL 5)
list(APPEND IDF_COMPONENTS esp_netif)
endif()
if(IDF_VERSION_MINOR GREATER_EQUAL 2 OR IDF_VERSION_MAJOR GREATER_EQUAL 5)
list(APPEND IDF_COMPONENTS esp_system)
list(APPEND IDF_COMPONENTS esp_timer)
endif()
if(IDF_VERSION_MINOR GREATER_EQUAL 3 OR IDF_VERSION_MAJOR GREATER_EQUAL 5)
list(APPEND IDF_COMPONENTS esp_hw_support)
list(APPEND IDF_COMPONENTS esp_pm)
list(APPEND IDF_COMPONENTS hal)
endif()
if(IDF_TARGET STREQUAL "esp32")
list(APPEND IDF_COMPONENTS esp32)
elseif(IDF_TARGET STREQUAL "esp32c3")
list(APPEND IDF_COMPONENTS esp32c3)
list(APPEND IDF_COMPONENTS riscv)
elseif(IDF_TARGET STREQUAL "esp32s2")
list(APPEND IDF_COMPONENTS esp32s2)
list(APPEND IDF_COMPONENTS tinyusb)
elseif(IDF_TARGET STREQUAL "esp32s3")
list(APPEND IDF_COMPONENTS esp32s3)
list(APPEND IDF_COMPONENTS tinyusb)
endif()
# Register the main IDF component.
idf_component_register(
SRCS
${MICROPY_SOURCE_PY}
${MICROPY_SOURCE_EXTMOD}
${MICROPY_SOURCE_SHARED}
${MICROPY_SOURCE_LIB}
${MICROPY_SOURCE_DRIVERS}
${MICROPY_SOURCE_PORT}
${MICROPY_SOURCE_MODULES_PORT}
${MICROPY_SOURCE_EXTERNAL}
${LV_SRC}
INCLUDE_DIRS
${MICROPY_INC_CORE}
${MICROPY_INC_USERMOD}
${MICROPY_PORT_DIR}
${MICROPY_BOARD_DIR}
${CMAKE_BINARY_DIR}
${MICROPY_INC_MODULES_PORT}
${MICROPY_INC_EXTERNAL}
${LV_INCLUDE}
REQUIRES
${IDF_COMPONENTS}
)
# Set the MicroPython target as the current (main) IDF component target.
set(MICROPY_TARGET ${COMPONENT_TARGET})
# Define mpy-cross flags, for use with frozen code.
set(MICROPY_CROSS_FLAGS -march=xtensawin)
# Set compile options for this port.
target_compile_definitions(${MICROPY_TARGET} PUBLIC
${MICROPY_DEF_MODULES_PORT}
${MICROPY_DEF_CORE}
MICROPY_ESP_IDF_4=1
ESP_PLATFORM=1
FFCONF_H=\"${MICROPY_OOFATFS_DIR}/ffconf.h\"
LFS1_NO_MALLOC LFS1_NO_DEBUG LFS1_NO_WARN LFS1_NO_ERROR LFS1_NO_ASSERT
LFS2_NO_MALLOC LFS2_NO_DEBUG LFS2_NO_WARN LFS2_NO_ERROR LFS2_NO_ASSERT
LV_KCONFIG_IGNORE
)
# Disable some warnings to keep the build output clean.
target_compile_options(${MICROPY_TARGET} PUBLIC
-Wno-clobbered
-Wno-deprecated-declarations
-Wno-missing-field-initializers
-Wno-implicit-function-declaration
-Wno-unused-const-variable
-Wno-format-truncation
-Wno-pointer-sign
-Wno-unused-local-typedefs
)
# Add additional extmod and usermod components.
target_link_libraries(${MICROPY_TARGET} micropy_extmod_btree)
target_link_libraries(${MICROPY_TARGET} usermod)
# Collect all of the include directories and compile definitions for the IDF components.
foreach(comp ${IDF_COMPONENTS})
micropy_gather_target_properties(__idf_${comp})
endforeach()
if(IDF_VERSION_MINOR GREATER_EQUAL 2)
# These paths cannot currently be found by the IDF_COMPONENTS search loop above,
# so add them explicitly.
list(APPEND MICROPY_CPP_INC_EXTRA ${IDF_PATH}/components/soc/soc/${IDF_TARGET}/include)
list(APPEND MICROPY_CPP_INC_EXTRA ${IDF_PATH}/components/soc/soc/include)
if(IDF_VERSION_MINOR GREATER_EQUAL 3)
list(APPEND MICROPY_CPP_INC_EXTRA ${IDF_PATH}/components/tinyusb/additions/include)
list(APPEND MICROPY_CPP_INC_EXTRA ${IDF_PATH}/components/tinyusb/tinyusb/src)
endif()
endif()
# Include the main MicroPython cmake rules.
include(${MICROPY_DIR}/py/mkrules.cmake)
if(MICROPY_PY_LVGL)
# Add lv_bindings rules
all_lv_bindings()
endif()
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/main/CMakeLists.txt | CMake | apache-2.0 | 7,135 |
# Combine bootloader, partition table and application into a final binary.
import os, sys
sys.path.append(os.getenv("IDF_PATH") + "/components/partition_table")
import gen_esp32part
OFFSET_BOOTLOADER_DEFAULT = 0x1000
OFFSET_PARTITIONS_DEFAULT = 0x8000
def load_sdkconfig_hex_value(filename, value, default):
value = "CONFIG_" + value + "="
with open(filename, "r") as f:
for line in f:
if line.startswith(value):
return int(line.split("=", 1)[1], 16)
return default
def load_partition_table(filename):
with open(filename, "rb") as f:
return gen_esp32part.PartitionTable.from_binary(f.read())
# Extract command-line arguments.
arg_sdkconfig = sys.argv[1]
arg_bootloader_bin = sys.argv[2]
arg_partitions_bin = sys.argv[3]
arg_application_bin = sys.argv[4]
arg_output_bin = sys.argv[5]
# Load required sdkconfig values.
offset_bootloader = load_sdkconfig_hex_value(
arg_sdkconfig, "BOOTLOADER_OFFSET_IN_FLASH", OFFSET_BOOTLOADER_DEFAULT
)
offset_partitions = load_sdkconfig_hex_value(
arg_sdkconfig, "PARTITION_TABLE_OFFSET", OFFSET_PARTITIONS_DEFAULT
)
# Load the partition table.
partition_table = load_partition_table(arg_partitions_bin)
max_size_bootloader = offset_partitions - offset_bootloader
max_size_partitions = 0
offset_application = 0
max_size_application = 0
# Inspect the partition table to find offsets and maximum sizes.
for part in partition_table:
if part.name == "nvs":
max_size_partitions = part.offset - offset_partitions
elif part.type == gen_esp32part.APP_TYPE and offset_application == 0:
offset_application = part.offset
max_size_application = part.size
# Define the input files, their location and maximum size.
files_in = [
("bootloader", offset_bootloader, max_size_bootloader, arg_bootloader_bin),
("partitions", offset_partitions, max_size_partitions, arg_partitions_bin),
("application", offset_application, max_size_application, arg_application_bin),
]
file_out = arg_output_bin
# Write output file with combined firmware.
cur_offset = offset_bootloader
with open(file_out, "wb") as fout:
for name, offset, max_size, file_in in files_in:
assert offset >= cur_offset
fout.write(b"\xff" * (offset - cur_offset))
cur_offset = offset
with open(file_in, "rb") as fin:
data = fin.read()
fout.write(data)
cur_offset += len(data)
print(
"%-12s@0x%06x % 8d (% 8d remaining)"
% (name, offset, len(data), max_size - len(data))
)
if len(data) > max_size:
print(
"ERROR: %s overflows allocated space of %d bytes by %d bytes"
% (name, max_size, len(data) - max_size)
)
sys.exit(1)
print("%-22s% 8d" % ("total", cur_offset))
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/makeimg.py | Python | apache-2.0 | 2,901 |
// this is needed for lib/crypto-algorithms/sha256.c
#include <string.h>
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/memory.h | C | apache-2.0 | 73 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2015 Paul Sokolovsky
* Copyright (c) 2016 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include "esp_log.h"
#include "esp_spi_flash.h"
#include "py/runtime.h"
#include "py/mperrno.h"
#include "py/mphal.h"
#include "drivers/dht/dht.h"
#include "modesp.h"
STATIC mp_obj_t esp_osdebug(size_t n_args, const mp_obj_t *args) {
esp_log_level_t level = LOG_LOCAL_LEVEL;
if (n_args == 2) {
level = mp_obj_get_int(args[1]);
}
if (args[0] == mp_const_none) {
// Disable logging
esp_log_level_set("*", ESP_LOG_ERROR);
} else {
// Enable logging at the given level
// TODO args[0] should set the UART to which debug is sent
esp_log_level_set("*", level);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_osdebug_obj, 1, 2, esp_osdebug);
STATIC mp_obj_t esp_flash_read(mp_obj_t offset_in, mp_obj_t buf_in) {
mp_int_t offset = mp_obj_get_int(offset_in);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_WRITE);
esp_err_t res = spi_flash_read(offset, bufinfo.buf, bufinfo.len);
if (res != ESP_OK) {
mp_raise_OSError(MP_EIO);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(esp_flash_read_obj, esp_flash_read);
STATIC mp_obj_t esp_flash_write(mp_obj_t offset_in, mp_obj_t buf_in) {
mp_int_t offset = mp_obj_get_int(offset_in);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);
esp_err_t res = spi_flash_write(offset, bufinfo.buf, bufinfo.len);
if (res != ESP_OK) {
mp_raise_OSError(MP_EIO);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(esp_flash_write_obj, esp_flash_write);
STATIC mp_obj_t esp_flash_erase(mp_obj_t sector_in) {
mp_int_t sector = mp_obj_get_int(sector_in);
esp_err_t res = spi_flash_erase_sector(sector);
if (res != ESP_OK) {
mp_raise_OSError(MP_EIO);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_flash_erase_obj, esp_flash_erase);
STATIC mp_obj_t esp_flash_size(void) {
return mp_obj_new_int_from_uint(spi_flash_get_chip_size());
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp_flash_size_obj, esp_flash_size);
STATIC mp_obj_t esp_flash_user_start(void) {
return MP_OBJ_NEW_SMALL_INT(0x200000);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp_flash_user_start_obj, esp_flash_user_start);
STATIC mp_obj_t esp_gpio_matrix_in(mp_obj_t pin, mp_obj_t sig, mp_obj_t inv) {
gpio_matrix_in(mp_obj_get_int(pin), mp_obj_get_int(sig), mp_obj_get_int(inv));
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_3(esp_gpio_matrix_in_obj, esp_gpio_matrix_in);
STATIC mp_obj_t esp_gpio_matrix_out(size_t n_args, const mp_obj_t *args) {
(void)n_args;
gpio_matrix_out(mp_obj_get_int(args[0]), mp_obj_get_int(args[1]), mp_obj_get_int(args[2]), mp_obj_get_int(args[3]));
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_gpio_matrix_out_obj, 4, 4, esp_gpio_matrix_out);
STATIC const mp_rom_map_elem_t esp_module_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_esp) },
{ MP_ROM_QSTR(MP_QSTR_osdebug), MP_ROM_PTR(&esp_osdebug_obj) },
{ MP_ROM_QSTR(MP_QSTR_flash_read), MP_ROM_PTR(&esp_flash_read_obj) },
{ MP_ROM_QSTR(MP_QSTR_flash_write), MP_ROM_PTR(&esp_flash_write_obj) },
{ MP_ROM_QSTR(MP_QSTR_flash_erase), MP_ROM_PTR(&esp_flash_erase_obj) },
{ MP_ROM_QSTR(MP_QSTR_flash_size), MP_ROM_PTR(&esp_flash_size_obj) },
{ MP_ROM_QSTR(MP_QSTR_flash_user_start), MP_ROM_PTR(&esp_flash_user_start_obj) },
{ MP_ROM_QSTR(MP_QSTR_gpio_matrix_in), MP_ROM_PTR(&esp_gpio_matrix_in_obj) },
{ MP_ROM_QSTR(MP_QSTR_gpio_matrix_out), MP_ROM_PTR(&esp_gpio_matrix_out_obj) },
{ MP_ROM_QSTR(MP_QSTR_dht_readinto), MP_ROM_PTR(&dht_readinto_obj) },
// Constants for second arg of osdebug()
{ MP_ROM_QSTR(MP_QSTR_LOG_NONE), MP_ROM_INT((mp_uint_t)ESP_LOG_NONE)},
{ MP_ROM_QSTR(MP_QSTR_LOG_ERROR), MP_ROM_INT((mp_uint_t)ESP_LOG_ERROR)},
{ MP_ROM_QSTR(MP_QSTR_LOG_WARNING), MP_ROM_INT((mp_uint_t)ESP_LOG_WARN)},
{ MP_ROM_QSTR(MP_QSTR_LOG_INFO), MP_ROM_INT((mp_uint_t)ESP_LOG_INFO)},
{ MP_ROM_QSTR(MP_QSTR_LOG_DEBUG), MP_ROM_INT((mp_uint_t)ESP_LOG_DEBUG)},
{ MP_ROM_QSTR(MP_QSTR_LOG_VERBOSE), MP_ROM_INT((mp_uint_t)ESP_LOG_VERBOSE)},
};
STATIC MP_DEFINE_CONST_DICT(esp_module_globals, esp_module_globals_table);
const mp_obj_module_t esp_module = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&esp_module_globals,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modesp.c | C | apache-2.0 | 5,809 |
void esp_neopixel_write(uint8_t pin, uint8_t *pixels, uint32_t numBytes, uint8_t timing);
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modesp.h | C | apache-2.0 | 90 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2017 "Eric Poulsen" <eric@zyxod.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sys/time.h>
#include "soc/rtc_cntl_reg.h"
#include "driver/gpio.h"
#include "driver/adc.h"
#include "esp_heap_caps.h"
#include "multi_heap.h"
#include "py/nlr.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "py/mphal.h"
#include "shared/timeutils/timeutils.h"
#include "modmachine.h"
#include "machine_rtc.h"
#include "modesp32.h"
// These private includes are needed for idf_heap_info.
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 3, 0)
#define MULTI_HEAP_FREERTOS
#include "../multi_heap_platform.h"
#endif
#include "../heap_private.h"
STATIC mp_obj_t esp32_wake_on_touch(const mp_obj_t wake) {
if (machine_rtc_config.ext0_pin != -1) {
mp_raise_ValueError(MP_ERROR_TEXT("no resources"));
}
// mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("touchpad wakeup not available for this version of ESP-IDF"));
machine_rtc_config.wake_on_touch = mp_obj_is_true(wake);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp32_wake_on_touch_obj, esp32_wake_on_touch);
STATIC mp_obj_t esp32_wake_on_ext0(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
if (machine_rtc_config.wake_on_touch) {
mp_raise_ValueError(MP_ERROR_TEXT("no resources"));
}
enum {ARG_pin, ARG_level};
const mp_arg_t allowed_args[] = {
{ MP_QSTR_pin, MP_ARG_OBJ, {.u_obj = mp_obj_new_int(machine_rtc_config.ext0_pin)} },
{ MP_QSTR_level, MP_ARG_BOOL, {.u_bool = machine_rtc_config.ext0_level} },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
if (args[ARG_pin].u_obj == mp_const_none) {
machine_rtc_config.ext0_pin = -1; // "None"
} else {
gpio_num_t pin_id = machine_pin_get_id(args[ARG_pin].u_obj);
if (pin_id != machine_rtc_config.ext0_pin) {
if (!RTC_IS_VALID_EXT_PIN(pin_id)) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid pin"));
}
machine_rtc_config.ext0_pin = pin_id;
}
}
machine_rtc_config.ext0_level = args[ARG_level].u_bool;
machine_rtc_config.ext0_wake_types = MACHINE_WAKE_SLEEP | MACHINE_WAKE_DEEPSLEEP;
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp32_wake_on_ext0_obj, 0, esp32_wake_on_ext0);
STATIC mp_obj_t esp32_wake_on_ext1(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum {ARG_pins, ARG_level};
const mp_arg_t allowed_args[] = {
{ MP_QSTR_pins, MP_ARG_OBJ, {.u_obj = mp_const_none} },
{ MP_QSTR_level, MP_ARG_BOOL, {.u_bool = machine_rtc_config.ext1_level} },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
uint64_t ext1_pins = machine_rtc_config.ext1_pins;
// Check that all pins are allowed
if (args[ARG_pins].u_obj != mp_const_none) {
size_t len = 0;
mp_obj_t *elem;
mp_obj_get_array(args[ARG_pins].u_obj, &len, &elem);
ext1_pins = 0;
for (int i = 0; i < len; i++) {
gpio_num_t pin_id = machine_pin_get_id(elem[i]);
if (!RTC_IS_VALID_EXT_PIN(pin_id)) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid pin"));
break;
}
ext1_pins |= (1ll << pin_id);
}
}
machine_rtc_config.ext1_level = args[ARG_level].u_bool;
machine_rtc_config.ext1_pins = ext1_pins;
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp32_wake_on_ext1_obj, 0, esp32_wake_on_ext1);
#if CONFIG_IDF_TARGET_ESP32
#include "soc/sens_reg.h"
STATIC mp_obj_t esp32_raw_temperature(void) {
SET_PERI_REG_BITS(SENS_SAR_MEAS_WAIT2_REG, SENS_FORCE_XPD_SAR, 3, SENS_FORCE_XPD_SAR_S);
SET_PERI_REG_BITS(SENS_SAR_TSENS_CTRL_REG, SENS_TSENS_CLK_DIV, 10, SENS_TSENS_CLK_DIV_S);
CLEAR_PERI_REG_MASK(SENS_SAR_TSENS_CTRL_REG, SENS_TSENS_POWER_UP);
CLEAR_PERI_REG_MASK(SENS_SAR_TSENS_CTRL_REG, SENS_TSENS_DUMP_OUT);
SET_PERI_REG_MASK(SENS_SAR_TSENS_CTRL_REG, SENS_TSENS_POWER_UP_FORCE);
SET_PERI_REG_MASK(SENS_SAR_TSENS_CTRL_REG, SENS_TSENS_POWER_UP);
ets_delay_us(100);
SET_PERI_REG_MASK(SENS_SAR_TSENS_CTRL_REG, SENS_TSENS_DUMP_OUT);
ets_delay_us(5);
int res = GET_PERI_REG_BITS2(SENS_SAR_SLAVE_ADDR3_REG, SENS_TSENS_OUT, SENS_TSENS_OUT_S);
return mp_obj_new_int(res);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp32_raw_temperature_obj, esp32_raw_temperature);
STATIC mp_obj_t esp32_hall_sensor(void) {
adc1_config_width(ADC_WIDTH_12Bit);
return MP_OBJ_NEW_SMALL_INT(hall_sensor_read());
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp32_hall_sensor_obj, esp32_hall_sensor);
#endif
STATIC mp_obj_t esp32_idf_heap_info(const mp_obj_t cap_in) {
mp_int_t cap = mp_obj_get_int(cap_in);
multi_heap_info_t info;
heap_t *heap;
mp_obj_t heap_list = mp_obj_new_list(0, 0);
SLIST_FOREACH(heap, ®istered_heaps, next) {
if (heap_caps_match(heap, cap)) {
multi_heap_get_info(heap->heap, &info);
mp_obj_t data[] = {
MP_OBJ_NEW_SMALL_INT(heap->end - heap->start), // total heap size
MP_OBJ_NEW_SMALL_INT(info.total_free_bytes), // total free bytes
MP_OBJ_NEW_SMALL_INT(info.largest_free_block), // largest free contiguous
MP_OBJ_NEW_SMALL_INT(info.minimum_free_bytes), // minimum free seen
};
mp_obj_t this_heap = mp_obj_new_tuple(4, data);
mp_obj_list_append(heap_list, this_heap);
}
}
return heap_list;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp32_idf_heap_info_obj, esp32_idf_heap_info);
STATIC const mp_rom_map_elem_t esp32_module_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_esp32) },
{ MP_ROM_QSTR(MP_QSTR_wake_on_touch), MP_ROM_PTR(&esp32_wake_on_touch_obj) },
{ MP_ROM_QSTR(MP_QSTR_wake_on_ext0), MP_ROM_PTR(&esp32_wake_on_ext0_obj) },
{ MP_ROM_QSTR(MP_QSTR_wake_on_ext1), MP_ROM_PTR(&esp32_wake_on_ext1_obj) },
#if CONFIG_IDF_TARGET_ESP32
{ MP_ROM_QSTR(MP_QSTR_raw_temperature), MP_ROM_PTR(&esp32_raw_temperature_obj) },
{ MP_ROM_QSTR(MP_QSTR_hall_sensor), MP_ROM_PTR(&esp32_hall_sensor_obj) },
#endif
{ MP_ROM_QSTR(MP_QSTR_idf_heap_info), MP_ROM_PTR(&esp32_idf_heap_info_obj) },
{ MP_ROM_QSTR(MP_QSTR_NVS), MP_ROM_PTR(&esp32_nvs_type) },
{ MP_ROM_QSTR(MP_QSTR_Partition), MP_ROM_PTR(&esp32_partition_type) },
{ MP_ROM_QSTR(MP_QSTR_RMT), MP_ROM_PTR(&esp32_rmt_type) },
#if CONFIG_IDF_TARGET_ESP32
{ MP_ROM_QSTR(MP_QSTR_ULP), MP_ROM_PTR(&esp32_ulp_type) },
#endif
{ MP_ROM_QSTR(MP_QSTR_WAKEUP_ALL_LOW), MP_ROM_FALSE },
{ MP_ROM_QSTR(MP_QSTR_WAKEUP_ANY_HIGH), MP_ROM_TRUE },
{ MP_ROM_QSTR(MP_QSTR_HEAP_DATA), MP_ROM_INT(MALLOC_CAP_8BIT) },
{ MP_ROM_QSTR(MP_QSTR_HEAP_EXEC), MP_ROM_INT(MALLOC_CAP_EXEC) },
};
STATIC MP_DEFINE_CONST_DICT(esp32_module_globals, esp32_module_globals_table);
const mp_obj_module_t esp32_module = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&esp32_module_globals,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modesp32.c | C | apache-2.0 | 8,436 |
#ifndef MICROPY_INCLUDED_ESP32_MODESP32_H
#define MICROPY_INCLUDED_ESP32_MODESP32_H
#define RTC_VALID_EXT_PINS \
( \
(1ll << 0) | \
(1ll << 2) | \
(1ll << 4) | \
(1ll << 12) | \
(1ll << 13) | \
(1ll << 14) | \
(1ll << 15) | \
(1ll << 25) | \
(1ll << 26) | \
(1ll << 27) | \
(1ll << 32) | \
(1ll << 33) | \
(1ll << 34) | \
(1ll << 35) | \
(1ll << 36) | \
(1ll << 37) | \
(1ll << 38) | \
(1ll << 39) \
)
#define RTC_LAST_EXT_PIN 39
#define RTC_IS_VALID_EXT_PIN(pin_id) ((1ll << (pin_id)) & RTC_VALID_EXT_PINS)
extern const mp_obj_type_t esp32_nvs_type;
extern const mp_obj_type_t esp32_partition_type;
extern const mp_obj_type_t esp32_rmt_type;
extern const mp_obj_type_t esp32_ulp_type;
#endif // MICROPY_INCLUDED_ESP32_MODESP32_H
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modesp32.h | C | apache-2.0 | 816 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2013-2015 Damien P. George
* Copyright (c) 2016 Paul Sokolovsky
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdint.h>
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_sleep.h"
#include "esp_pm.h"
#if CONFIG_IDF_TARGET_ESP32
#include "esp32/rom/rtc.h"
#include "esp32/clk.h"
#elif CONFIG_IDF_TARGET_ESP32S2
#include "esp32s2/rom/rtc.h"
#include "esp32s2/clk.h"
#elif CONFIG_IDF_TARGET_ESP32S3
#include "esp32s3/rom/rtc.h"
#include "esp32s3/clk.h"
#endif
#include "py/obj.h"
#include "py/runtime.h"
#include "shared/runtime/pyexec.h"
#include "extmod/machine_bitstream.h"
#include "extmod/machine_mem.h"
#include "extmod/machine_signal.h"
#include "extmod/machine_pulse.h"
#include "extmod/machine_i2c.h"
#include "extmod/machine_spi.h"
#include "modmachine.h"
#include "machine_rtc.h"
#if MICROPY_PY_MACHINE
typedef enum {
MP_PWRON_RESET = 1,
MP_HARD_RESET,
MP_WDT_RESET,
MP_DEEPSLEEP_RESET,
MP_SOFT_RESET
} reset_reason_t;
STATIC bool is_soft_reset = 0;
#if CONFIG_IDF_TARGET_ESP32C3
int esp_clk_cpu_freq(void);
#endif
STATIC mp_obj_t machine_freq(size_t n_args, const mp_obj_t *args) {
if (n_args == 0) {
// get
return mp_obj_new_int(esp_clk_cpu_freq());
} else {
// set
mp_int_t freq = mp_obj_get_int(args[0]) / 1000000;
if (freq != 20 && freq != 40 && freq != 80 && freq != 160 && freq != 240) {
mp_raise_ValueError(MP_ERROR_TEXT("frequency must be 20MHz, 40MHz, 80Mhz, 160MHz or 240MHz"));
}
#if CONFIG_IDF_TARGET_ESP32
esp_pm_config_esp32_t pm;
#elif CONFIG_IDF_TARGET_ESP32C3
esp_pm_config_esp32c3_t pm;
#elif CONFIG_IDF_TARGET_ESP32S2
esp_pm_config_esp32s2_t pm;
#elif CONFIG_IDF_TARGET_ESP32S3
esp_pm_config_esp32s3_t pm;
#endif
pm.max_freq_mhz = freq;
pm.min_freq_mhz = freq;
pm.light_sleep_enable = false;
esp_err_t ret = esp_pm_configure(&pm);
if (ret != ESP_OK) {
mp_raise_ValueError(NULL);
}
while (esp_clk_cpu_freq() != freq * 1000000) {
vTaskDelay(1);
}
return mp_const_none;
}
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_freq_obj, 0, 1, machine_freq);
STATIC mp_obj_t machine_sleep_helper(wake_type_t wake_type, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum {ARG_sleep_ms};
const mp_arg_t allowed_args[] = {
{ MP_QSTR_sleep_ms, MP_ARG_INT, { .u_int = 0 } },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
mp_int_t expiry = args[ARG_sleep_ms].u_int;
if (expiry != 0) {
esp_sleep_enable_timer_wakeup(((uint64_t)expiry) * 1000);
}
#if !CONFIG_IDF_TARGET_ESP32C3
if (machine_rtc_config.ext0_pin != -1 && (machine_rtc_config.ext0_wake_types & wake_type)) {
esp_sleep_enable_ext0_wakeup(machine_rtc_config.ext0_pin, machine_rtc_config.ext0_level ? 1 : 0);
}
if (machine_rtc_config.ext1_pins != 0) {
esp_sleep_enable_ext1_wakeup(
machine_rtc_config.ext1_pins,
machine_rtc_config.ext1_level ? ESP_EXT1_WAKEUP_ANY_HIGH : ESP_EXT1_WAKEUP_ALL_LOW);
}
if (machine_rtc_config.wake_on_touch) {
if (esp_sleep_enable_touchpad_wakeup() != ESP_OK) {
mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("esp_sleep_enable_touchpad_wakeup() failed"));
}
}
#endif
switch (wake_type) {
case MACHINE_WAKE_SLEEP:
esp_light_sleep_start();
break;
case MACHINE_WAKE_DEEPSLEEP:
esp_deep_sleep_start();
break;
}
return mp_const_none;
}
STATIC mp_obj_t machine_lightsleep(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
return machine_sleep_helper(MACHINE_WAKE_SLEEP, n_args, pos_args, kw_args);
};
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_lightsleep_obj, 0, machine_lightsleep);
STATIC mp_obj_t machine_deepsleep(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
return machine_sleep_helper(MACHINE_WAKE_DEEPSLEEP, n_args, pos_args, kw_args);
};
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_deepsleep_obj, 0, machine_deepsleep);
STATIC mp_obj_t machine_reset_cause(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
if (is_soft_reset) {
return MP_OBJ_NEW_SMALL_INT(MP_SOFT_RESET);
}
switch (esp_reset_reason()) {
case ESP_RST_POWERON:
case ESP_RST_BROWNOUT:
return MP_OBJ_NEW_SMALL_INT(MP_PWRON_RESET);
break;
case ESP_RST_INT_WDT:
case ESP_RST_TASK_WDT:
case ESP_RST_WDT:
return MP_OBJ_NEW_SMALL_INT(MP_WDT_RESET);
break;
case ESP_RST_DEEPSLEEP:
return MP_OBJ_NEW_SMALL_INT(MP_DEEPSLEEP_RESET);
break;
case ESP_RST_SW:
case ESP_RST_PANIC:
case ESP_RST_EXT: // Comment in ESP-IDF: "For ESP32, ESP_RST_EXT is never returned"
return MP_OBJ_NEW_SMALL_INT(MP_HARD_RESET);
break;
case ESP_RST_SDIO:
case ESP_RST_UNKNOWN:
default:
return MP_OBJ_NEW_SMALL_INT(0);
break;
}
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_reset_cause_obj, 0, machine_reset_cause);
void machine_init(void) {
is_soft_reset = 0;
}
void machine_deinit(void) {
// we are doing a soft-reset so change the reset_cause
is_soft_reset = 1;
}
STATIC mp_obj_t machine_wake_reason(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
return MP_OBJ_NEW_SMALL_INT(esp_sleep_get_wakeup_cause());
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_wake_reason_obj, 0, machine_wake_reason);
STATIC mp_obj_t machine_reset(void) {
esp_restart();
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_reset_obj, machine_reset);
STATIC mp_obj_t machine_soft_reset(void) {
pyexec_system_exit = PYEXEC_FORCED_EXIT;
mp_raise_type(&mp_type_SystemExit);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_soft_reset_obj, machine_soft_reset);
STATIC mp_obj_t machine_unique_id(void) {
uint8_t chipid[6];
esp_efuse_mac_get_default(chipid);
return mp_obj_new_bytes(chipid, 6);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_unique_id_obj, machine_unique_id);
STATIC mp_obj_t machine_idle(void) {
MP_THREAD_GIL_EXIT();
taskYIELD();
MP_THREAD_GIL_ENTER();
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_idle_obj, machine_idle);
STATIC mp_obj_t machine_disable_irq(void) {
uint32_t state = MICROPY_BEGIN_ATOMIC_SECTION();
return mp_obj_new_int(state);
}
MP_DEFINE_CONST_FUN_OBJ_0(machine_disable_irq_obj, machine_disable_irq);
STATIC mp_obj_t machine_enable_irq(mp_obj_t state_in) {
uint32_t state = mp_obj_get_int(state_in);
MICROPY_END_ATOMIC_SECTION(state);
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_1(machine_enable_irq_obj, machine_enable_irq);
STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_umachine) },
{ MP_ROM_QSTR(MP_QSTR_mem8), MP_ROM_PTR(&machine_mem8_obj) },
{ MP_ROM_QSTR(MP_QSTR_mem16), MP_ROM_PTR(&machine_mem16_obj) },
{ MP_ROM_QSTR(MP_QSTR_mem32), MP_ROM_PTR(&machine_mem32_obj) },
{ MP_ROM_QSTR(MP_QSTR_freq), MP_ROM_PTR(&machine_freq_obj) },
{ MP_ROM_QSTR(MP_QSTR_reset), MP_ROM_PTR(&machine_reset_obj) },
{ MP_ROM_QSTR(MP_QSTR_soft_reset), MP_ROM_PTR(&machine_soft_reset_obj) },
{ MP_ROM_QSTR(MP_QSTR_unique_id), MP_ROM_PTR(&machine_unique_id_obj) },
{ MP_ROM_QSTR(MP_QSTR_sleep), MP_ROM_PTR(&machine_lightsleep_obj) },
{ MP_ROM_QSTR(MP_QSTR_lightsleep), MP_ROM_PTR(&machine_lightsleep_obj) },
{ MP_ROM_QSTR(MP_QSTR_deepsleep), MP_ROM_PTR(&machine_deepsleep_obj) },
{ MP_ROM_QSTR(MP_QSTR_idle), MP_ROM_PTR(&machine_idle_obj) },
{ MP_ROM_QSTR(MP_QSTR_disable_irq), MP_ROM_PTR(&machine_disable_irq_obj) },
{ MP_ROM_QSTR(MP_QSTR_enable_irq), MP_ROM_PTR(&machine_enable_irq_obj) },
#if MICROPY_PY_MACHINE_BITSTREAM
{ MP_ROM_QSTR(MP_QSTR_bitstream), MP_ROM_PTR(&machine_bitstream_obj) },
#endif
#if MICROPY_PY_MACHINE_PULSE
{ MP_ROM_QSTR(MP_QSTR_time_pulse_us), MP_ROM_PTR(&machine_time_pulse_us_obj) },
#endif
{ MP_ROM_QSTR(MP_QSTR_Timer), MP_ROM_PTR(&machine_timer_type) },
{ MP_ROM_QSTR(MP_QSTR_WDT), MP_ROM_PTR(&machine_wdt_type) },
#if MICROPY_HW_ENABLE_SDCARD
{ MP_ROM_QSTR(MP_QSTR_SDCard), MP_ROM_PTR(&machine_sdcard_type) },
#endif
// wake abilities
{ MP_ROM_QSTR(MP_QSTR_SLEEP), MP_ROM_INT(MACHINE_WAKE_SLEEP) },
{ MP_ROM_QSTR(MP_QSTR_DEEPSLEEP), MP_ROM_INT(MACHINE_WAKE_DEEPSLEEP) },
{ MP_ROM_QSTR(MP_QSTR_Pin), MP_ROM_PTR(&machine_pin_type) },
{ MP_ROM_QSTR(MP_QSTR_Signal), MP_ROM_PTR(&machine_signal_type) },
#if CONFIG_IDF_TARGET_ESP32
{ MP_ROM_QSTR(MP_QSTR_TouchPad), MP_ROM_PTR(&machine_touchpad_type) },
#endif
{ MP_ROM_QSTR(MP_QSTR_ADC), MP_ROM_PTR(&machine_adc_type) },
{ MP_ROM_QSTR(MP_QSTR_ADCBlock), MP_ROM_PTR(&machine_adcblock_type) },
#if MICROPY_PY_MACHINE_DAC
{ MP_ROM_QSTR(MP_QSTR_DAC), MP_ROM_PTR(&machine_dac_type) },
#endif
{ MP_ROM_QSTR(MP_QSTR_I2C), MP_ROM_PTR(&machine_hw_i2c_type) },
{ MP_ROM_QSTR(MP_QSTR_SoftI2C), MP_ROM_PTR(&mp_machine_soft_i2c_type) },
#if MICROPY_PY_MACHINE_I2S
{ MP_ROM_QSTR(MP_QSTR_I2S), MP_ROM_PTR(&machine_i2s_type) },
#endif
{ MP_ROM_QSTR(MP_QSTR_PWM), MP_ROM_PTR(&machine_pwm_type) },
{ MP_ROM_QSTR(MP_QSTR_RTC), MP_ROM_PTR(&machine_rtc_type) },
{ MP_ROM_QSTR(MP_QSTR_SPI), MP_ROM_PTR(&machine_hw_spi_type) },
{ MP_ROM_QSTR(MP_QSTR_SoftSPI), MP_ROM_PTR(&mp_machine_soft_spi_type) },
{ MP_ROM_QSTR(MP_QSTR_UART), MP_ROM_PTR(&machine_uart_type) },
// Reset reasons
{ MP_ROM_QSTR(MP_QSTR_reset_cause), MP_ROM_PTR(&machine_reset_cause_obj) },
{ MP_ROM_QSTR(MP_QSTR_HARD_RESET), MP_ROM_INT(MP_HARD_RESET) },
{ MP_ROM_QSTR(MP_QSTR_PWRON_RESET), MP_ROM_INT(MP_PWRON_RESET) },
{ MP_ROM_QSTR(MP_QSTR_WDT_RESET), MP_ROM_INT(MP_WDT_RESET) },
{ MP_ROM_QSTR(MP_QSTR_DEEPSLEEP_RESET), MP_ROM_INT(MP_DEEPSLEEP_RESET) },
{ MP_ROM_QSTR(MP_QSTR_SOFT_RESET), MP_ROM_INT(MP_SOFT_RESET) },
// Wake reasons
{ MP_ROM_QSTR(MP_QSTR_wake_reason), MP_ROM_PTR(&machine_wake_reason_obj) },
{ MP_ROM_QSTR(MP_QSTR_PIN_WAKE), MP_ROM_INT(ESP_SLEEP_WAKEUP_EXT0) },
{ MP_ROM_QSTR(MP_QSTR_EXT0_WAKE), MP_ROM_INT(ESP_SLEEP_WAKEUP_EXT0) },
{ MP_ROM_QSTR(MP_QSTR_EXT1_WAKE), MP_ROM_INT(ESP_SLEEP_WAKEUP_EXT1) },
{ MP_ROM_QSTR(MP_QSTR_TIMER_WAKE), MP_ROM_INT(ESP_SLEEP_WAKEUP_TIMER) },
{ MP_ROM_QSTR(MP_QSTR_TOUCHPAD_WAKE), MP_ROM_INT(ESP_SLEEP_WAKEUP_TOUCHPAD) },
{ MP_ROM_QSTR(MP_QSTR_ULP_WAKE), MP_ROM_INT(ESP_SLEEP_WAKEUP_ULP) },
};
STATIC MP_DEFINE_CONST_DICT(machine_module_globals, machine_module_globals_table);
const mp_obj_module_t mp_module_machine = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&machine_module_globals,
};
#endif // MICROPY_PY_MACHINE
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modmachine.c | C | apache-2.0 | 12,413 |
#ifndef MICROPY_INCLUDED_ESP32_MODMACHINE_H
#define MICROPY_INCLUDED_ESP32_MODMACHINE_H
#include "py/obj.h"
typedef enum {
// MACHINE_WAKE_IDLE=0x01,
MACHINE_WAKE_SLEEP=0x02,
MACHINE_WAKE_DEEPSLEEP=0x04
} wake_type_t;
extern const mp_obj_type_t machine_timer_type;
extern const mp_obj_type_t machine_wdt_type;
extern const mp_obj_type_t machine_pin_type;
extern const mp_obj_type_t machine_touchpad_type;
extern const mp_obj_type_t machine_adc_type;
extern const mp_obj_type_t machine_adcblock_type;
extern const mp_obj_type_t machine_dac_type;
extern const mp_obj_type_t machine_pwm_type;
extern const mp_obj_type_t machine_hw_i2c_type;
extern const mp_obj_type_t machine_hw_spi_type;
extern const mp_obj_type_t machine_i2s_type;
extern const mp_obj_type_t machine_uart_type;
extern const mp_obj_type_t machine_rtc_type;
extern const mp_obj_type_t machine_sdcard_type;
void machine_init(void);
void machine_deinit(void);
void machine_pins_init(void);
void machine_pins_deinit(void);
void machine_timer_deinit_all(void);
void machine_i2s_init0();
#endif // MICROPY_INCLUDED_ESP32_MODMACHINE_H
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modmachine.h | C | apache-2.0 | 1,110 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
* and Mnemote Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2016, 2017 Nick Moore @mnemote
* Copyright (c) 2017 "Eric Poulsen" <eric@zyxod.com>
*
* Based on esp8266/modnetwork.c which is Copyright (c) 2015 Paul Sokolovsky
* And the ESP IDF example code which is Public Domain / CC0
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "py/nlr.h"
#include "py/objlist.h"
#include "py/runtime.h"
#include "py/mphal.h"
#include "py/mperrno.h"
#include "shared/netutils/netutils.h"
#include "esp_eth.h"
#include "esp_wifi.h"
#include "esp_log.h"
#include "lwip/dns.h"
#include "mdns.h"
#if !MICROPY_ESP_IDF_4
#include "esp_wifi_types.h"
#include "esp_event_loop.h"
#endif
#include "modnetwork.h"
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(4, 1, 0)
#define DNS_MAIN TCPIP_ADAPTER_DNS_MAIN
#else
#define DNS_MAIN ESP_NETIF_DNS_MAIN
#endif
#define MODNETWORK_INCLUDE_CONSTANTS (1)
NORETURN void _esp_exceptions(esp_err_t e) {
switch (e) {
case ESP_ERR_WIFI_NOT_INIT:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Initialized"));
case ESP_ERR_WIFI_NOT_STARTED:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Started"));
case ESP_ERR_WIFI_NOT_STOPPED:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Stopped"));
case ESP_ERR_WIFI_IF:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid Interface"));
case ESP_ERR_WIFI_MODE:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid Mode"));
case ESP_ERR_WIFI_STATE:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Internal State Error"));
case ESP_ERR_WIFI_CONN:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Internal Error"));
case ESP_ERR_WIFI_NVS:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Internal NVS Error"));
case ESP_ERR_WIFI_MAC:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid MAC Address"));
case ESP_ERR_WIFI_SSID:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi SSID Invalid"));
case ESP_ERR_WIFI_PASSWORD:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid Password"));
case ESP_ERR_WIFI_TIMEOUT:
mp_raise_OSError(MP_ETIMEDOUT);
case ESP_ERR_WIFI_WAKE_FAIL:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Wakeup Failure"));
case ESP_ERR_WIFI_WOULD_BLOCK:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Would Block"));
case ESP_ERR_WIFI_NOT_CONNECT:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Connected"));
case ESP_ERR_TCPIP_ADAPTER_INVALID_PARAMS:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("TCP/IP Invalid Parameters"));
case ESP_ERR_TCPIP_ADAPTER_IF_NOT_READY:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("TCP/IP IF Not Ready"));
case ESP_ERR_TCPIP_ADAPTER_DHCPC_START_FAILED:
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("TCP/IP DHCP Client Start Failed"));
case ESP_ERR_TCPIP_ADAPTER_NO_MEM:
mp_raise_OSError(MP_ENOMEM);
default:
mp_raise_msg_varg(&mp_type_RuntimeError, MP_ERROR_TEXT("Wifi Unknown Error 0x%04x"), e);
}
}
static inline void esp_exceptions(esp_err_t e) {
if (e != ESP_OK) {
_esp_exceptions(e);
}
}
#define ESP_EXCEPTIONS(x) do { esp_exceptions(x); } while (0);
typedef struct _wlan_if_obj_t {
mp_obj_base_t base;
int if_id;
} wlan_if_obj_t;
const mp_obj_type_t wlan_if_type;
STATIC const wlan_if_obj_t wlan_sta_obj = {{&wlan_if_type}, WIFI_IF_STA};
STATIC const wlan_if_obj_t wlan_ap_obj = {{&wlan_if_type}, WIFI_IF_AP};
// Set to "true" if esp_wifi_start() was called
static bool wifi_started = false;
// Set to "true" if the STA interface is requested to be connected by the
// user, used for automatic reassociation.
static bool wifi_sta_connect_requested = false;
// Set to "true" if the STA interface is connected to wifi and has IP address.
static bool wifi_sta_connected = false;
// Store the current status. 0 means None here, safe to do so as first enum value is WIFI_REASON_UNSPECIFIED=1.
static uint8_t wifi_sta_disconn_reason = 0;
#if MICROPY_HW_ENABLE_MDNS_QUERIES || MICROPY_HW_ENABLE_MDNS_RESPONDER
// Whether mDNS has been initialised or not
static bool mdns_initialised = false;
#endif
static uint8_t conf_wifi_sta_reconnects = 0;
static uint8_t wifi_sta_reconnects;
#if MICROPY_PY_CHANNEL_ENABLE
char _amp_ssid[64] = { 0 };
char _amp_password[64] = { 0 };
#endif
// This function is called by the system-event task and so runs in a different
// thread to the main MicroPython task. It must not raise any Python exceptions.
static esp_err_t event_handler(void *ctx, system_event_t *event) {
switch (event->event_id) {
case SYSTEM_EVENT_STA_START:
ESP_LOGI("wifi", "STA_START");
wifi_sta_reconnects = 0;
break;
case SYSTEM_EVENT_STA_CONNECTED:
ESP_LOGI("network", "CONNECTED");
break;
case SYSTEM_EVENT_STA_GOT_IP:
ESP_LOGI("network", "GOT_IP");
wifi_sta_connected = true;
wifi_sta_disconn_reason = 0; // Success so clear error. (in case of new error will be replaced anyway)
extern int activation_report(void);
activation_report(); // report HaaS activation info once.
#if MICROPY_PY_CHANNEL_ENABLE
extern int check_channel_enable(void);
extern int save_ssid_and_password(char *ssid, char *passwd);
extern int on_get_url(char *url);
save_ssid_and_password(_amp_ssid, _amp_password);
if (check_channel_enable() == 0) {
amp_otaput_init(on_get_url);
}
#endif
#if MICROPY_HW_ENABLE_MDNS_QUERIES || MICROPY_HW_ENABLE_MDNS_RESPONDER
if (!mdns_initialised) {
mdns_init();
#if MICROPY_HW_ENABLE_MDNS_RESPONDER
const char *hostname = NULL;
if (tcpip_adapter_get_hostname(WIFI_IF_STA, &hostname) != ESP_OK || hostname == NULL) {
hostname = "esp32";
}
mdns_hostname_set(hostname);
mdns_instance_name_set(hostname);
#endif
mdns_initialised = true;
}
#endif
break;
case SYSTEM_EVENT_STA_DISCONNECTED: {
// This is a workaround as ESP32 WiFi libs don't currently
// auto-reassociate.
system_event_sta_disconnected_t *disconn = &event->event_info.disconnected;
char *message = "";
wifi_sta_disconn_reason = disconn->reason;
switch (disconn->reason) {
case WIFI_REASON_BEACON_TIMEOUT:
// AP has dropped out; try to reconnect.
message = "\nbeacon timeout";
break;
case WIFI_REASON_NO_AP_FOUND:
// AP may not exist, or it may have momentarily dropped out; try to reconnect.
message = "\nno AP found";
break;
case WIFI_REASON_AUTH_FAIL:
// Password may be wrong, or it just failed to connect; try to reconnect.
message = "\nauthentication failed";
break;
default:
// Let other errors through and try to reconnect.
break;
}
ESP_LOGI("wifi", "STA_DISCONNECTED, reason:%d%s", disconn->reason, message);
wifi_sta_connected = false;
if (wifi_sta_connect_requested) {
wifi_mode_t mode;
if (esp_wifi_get_mode(&mode) != ESP_OK) {
break;
}
if (!(mode & WIFI_MODE_STA)) {
break;
}
if (conf_wifi_sta_reconnects) {
ESP_LOGI("wifi", "reconnect counter=%d, max=%d",
wifi_sta_reconnects, conf_wifi_sta_reconnects);
if (++wifi_sta_reconnects >= conf_wifi_sta_reconnects) {
break;
}
}
esp_err_t e = esp_wifi_connect();
if (e != ESP_OK) {
ESP_LOGI("wifi", "error attempting to reconnect: 0x%04x", e);
}
}
break;
}
case SYSTEM_EVENT_GOT_IP6:
ESP_LOGI("network", "Got IPv6");
break;
case SYSTEM_EVENT_ETH_START:
ESP_LOGI("ethernet", "start");
break;
case SYSTEM_EVENT_ETH_STOP:
ESP_LOGI("ethernet", "stop");
break;
case SYSTEM_EVENT_ETH_CONNECTED:
ESP_LOGI("ethernet", "LAN cable connected");
break;
case SYSTEM_EVENT_ETH_DISCONNECTED:
ESP_LOGI("ethernet", "LAN cable disconnected");
break;
case SYSTEM_EVENT_ETH_GOT_IP:
ESP_LOGI("ethernet", "Got IP");
break;
default:
ESP_LOGI("network", "event %d", event->event_id);
break;
}
return ESP_OK;
}
/*void error_check(bool status, const char *msg) {
if (!status) {
mp_raise_msg(&mp_type_OSError, msg);
}
}
*/
STATIC void require_if(mp_obj_t wlan_if, int if_no) {
wlan_if_obj_t *self = MP_OBJ_TO_PTR(wlan_if);
if (self->if_id != if_no) {
mp_raise_msg(&mp_type_OSError, if_no == WIFI_IF_STA ? MP_ERROR_TEXT("STA required") : MP_ERROR_TEXT("AP required"));
}
}
STATIC mp_obj_t get_wlan(size_t n_args, const mp_obj_t *args) {
static int initialized = 0;
if (!initialized) {
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
ESP_LOGD("modnetwork", "Initializing WiFi");
ESP_EXCEPTIONS(esp_wifi_init(&cfg));
ESP_EXCEPTIONS(esp_wifi_set_storage(WIFI_STORAGE_RAM));
ESP_LOGD("modnetwork", "Initialized");
initialized = 1;
}
int idx = (n_args > 0) ? mp_obj_get_int(args[0]) : WIFI_IF_STA;
if (idx == WIFI_IF_STA) {
return MP_OBJ_FROM_PTR(&wlan_sta_obj);
} else if (idx == WIFI_IF_AP) {
return MP_OBJ_FROM_PTR(&wlan_ap_obj);
} else {
mp_raise_ValueError(MP_ERROR_TEXT("invalid WLAN interface identifier"));
}
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(get_wlan_obj, 0, 1, get_wlan);
STATIC mp_obj_t esp_initialize() {
static int initialized = 0;
if (!initialized) {
ESP_LOGD("modnetwork", "Initializing TCP/IP");
tcpip_adapter_init();
ESP_LOGD("modnetwork", "Initializing Event Loop");
ESP_EXCEPTIONS(esp_event_loop_init(event_handler, NULL));
ESP_LOGD("modnetwork", "esp_event_loop_init done");
initialized = 1;
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp_initialize_obj, esp_initialize);
#if (WIFI_MODE_STA & WIFI_MODE_AP != WIFI_MODE_NULL || WIFI_MODE_STA | WIFI_MODE_AP != WIFI_MODE_APSTA)
#error WIFI_MODE_STA and WIFI_MODE_AP are supposed to be bitfields!
#endif
STATIC mp_obj_t esp_active(size_t n_args, const mp_obj_t *args) {
wlan_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
wifi_mode_t mode;
if (!wifi_started) {
mode = WIFI_MODE_NULL;
} else {
ESP_EXCEPTIONS(esp_wifi_get_mode(&mode));
}
int bit = (self->if_id == WIFI_IF_STA) ? WIFI_MODE_STA : WIFI_MODE_AP;
if (n_args > 1) {
bool active = mp_obj_is_true(args[1]);
mode = active ? (mode | bit) : (mode & ~bit);
if (mode == WIFI_MODE_NULL) {
if (wifi_started) {
ESP_EXCEPTIONS(esp_wifi_stop());
wifi_started = false;
}
} else {
ESP_EXCEPTIONS(esp_wifi_set_mode(mode));
if (!wifi_started) {
ESP_EXCEPTIONS(esp_wifi_start());
wifi_started = true;
}
}
}
return (mode & bit) ? mp_const_true : mp_const_false;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_active_obj, 1, 2, esp_active);
STATIC mp_obj_t esp_connect(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum { ARG_ssid, ARG_password, ARG_bssid };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_, MP_ARG_OBJ, {.u_obj = mp_const_none} },
{ MP_QSTR_, MP_ARG_OBJ, {.u_obj = mp_const_none} },
{ MP_QSTR_bssid, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
};
// parse args
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
wifi_config_t wifi_sta_config = {0};
// configure any parameters that are given
if (n_args > 1) {
size_t len;
const char *p;
if (args[ARG_ssid].u_obj != mp_const_none) {
p = mp_obj_str_get_data(args[ARG_ssid].u_obj, &len);
memcpy(wifi_sta_config.sta.ssid, p, MIN(len, sizeof(wifi_sta_config.sta.ssid)));
#if MICROPY_PY_CHANNEL_ENABLE
strcpy(_amp_ssid, p);
#endif
}
if (args[ARG_password].u_obj != mp_const_none) {
p = mp_obj_str_get_data(args[ARG_password].u_obj, &len);
memcpy(wifi_sta_config.sta.password, p, MIN(len, sizeof(wifi_sta_config.sta.password)));
#if MICROPY_PY_CHANNEL_ENABLE
strcpy(_amp_password, p);
#endif
}
if (args[ARG_bssid].u_obj != mp_const_none) {
p = mp_obj_str_get_data(args[ARG_bssid].u_obj, &len);
if (len != sizeof(wifi_sta_config.sta.bssid)) {
mp_raise_ValueError(NULL);
}
wifi_sta_config.sta.bssid_set = 1;
memcpy(wifi_sta_config.sta.bssid, p, sizeof(wifi_sta_config.sta.bssid));
}
ESP_EXCEPTIONS(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_sta_config));
}
wifi_sta_reconnects = 0;
// connect to the WiFi AP
MP_THREAD_GIL_EXIT();
ESP_EXCEPTIONS(esp_wifi_connect());
MP_THREAD_GIL_ENTER();
wifi_sta_connect_requested = true;
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp_connect_obj, 1, esp_connect);
STATIC mp_obj_t esp_disconnect(mp_obj_t self_in) {
wifi_sta_connect_requested = false;
ESP_EXCEPTIONS(esp_wifi_disconnect());
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_disconnect_obj, esp_disconnect);
// Cases similar to ESP8266 user_interface.h
// Error cases are referenced from wifi_err_reason_t in ESP-IDF
enum {
STAT_IDLE = 1000,
STAT_CONNECTING = 1001,
STAT_GOT_IP = 1010,
};
STATIC mp_obj_t esp_status(size_t n_args, const mp_obj_t *args) {
wlan_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
if (n_args == 1) {
if (self->if_id == WIFI_IF_STA) {
// Case of no arg is only for the STA interface
if (wifi_sta_connected) {
// Happy path, connected with IP
return MP_OBJ_NEW_SMALL_INT(STAT_GOT_IP);
} else if (wifi_sta_connect_requested
&& (conf_wifi_sta_reconnects == 0
|| wifi_sta_reconnects < conf_wifi_sta_reconnects)) {
// No connection or error, but is requested = Still connecting
return MP_OBJ_NEW_SMALL_INT(STAT_CONNECTING);
} else if (wifi_sta_disconn_reason == 0) {
// No activity, No error = Idle
return MP_OBJ_NEW_SMALL_INT(STAT_IDLE);
} else {
// Simply pass the error through from ESP-identifier
return MP_OBJ_NEW_SMALL_INT(wifi_sta_disconn_reason);
}
}
return mp_const_none;
}
// one argument: return status based on query parameter
switch ((uintptr_t)args[1]) {
case (uintptr_t)MP_OBJ_NEW_QSTR(MP_QSTR_stations): {
// return list of connected stations, only if in soft-AP mode
require_if(args[0], WIFI_IF_AP);
wifi_sta_list_t station_list;
ESP_EXCEPTIONS(esp_wifi_ap_get_sta_list(&station_list));
wifi_sta_info_t *stations = (wifi_sta_info_t *)station_list.sta;
mp_obj_t list = mp_obj_new_list(0, NULL);
for (int i = 0; i < station_list.num; ++i) {
mp_obj_tuple_t *t = mp_obj_new_tuple(1, NULL);
t->items[0] = mp_obj_new_bytes(stations[i].mac, sizeof(stations[i].mac));
mp_obj_list_append(list, t);
}
return list;
}
case (uintptr_t)MP_OBJ_NEW_QSTR(MP_QSTR_rssi): {
// return signal of AP, only in STA mode
require_if(args[0], WIFI_IF_STA);
wifi_ap_record_t info;
ESP_EXCEPTIONS(esp_wifi_sta_get_ap_info(&info));
return MP_OBJ_NEW_SMALL_INT(info.rssi);
}
default:
mp_raise_ValueError(MP_ERROR_TEXT("unknown status param"));
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_status_obj, 1, 2, esp_status);
STATIC mp_obj_t esp_scan(mp_obj_t self_in) {
// check that STA mode is active
wifi_mode_t mode;
ESP_EXCEPTIONS(esp_wifi_get_mode(&mode));
if ((mode & WIFI_MODE_STA) == 0) {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("STA must be active"));
}
mp_obj_t list = mp_obj_new_list(0, NULL);
wifi_scan_config_t config = { 0 };
config.show_hidden = true;
MP_THREAD_GIL_EXIT();
esp_err_t status = esp_wifi_scan_start(&config, 1);
MP_THREAD_GIL_ENTER();
if (status == 0) {
uint16_t count = 0;
ESP_EXCEPTIONS(esp_wifi_scan_get_ap_num(&count));
wifi_ap_record_t *wifi_ap_records = calloc(count, sizeof(wifi_ap_record_t));
ESP_EXCEPTIONS(esp_wifi_scan_get_ap_records(&count, wifi_ap_records));
for (uint16_t i = 0; i < count; i++) {
mp_obj_tuple_t *t = mp_obj_new_tuple(6, NULL);
uint8_t *x = memchr(wifi_ap_records[i].ssid, 0, sizeof(wifi_ap_records[i].ssid));
int ssid_len = x ? x - wifi_ap_records[i].ssid : sizeof(wifi_ap_records[i].ssid);
t->items[0] = mp_obj_new_bytes(wifi_ap_records[i].ssid, ssid_len);
t->items[1] = mp_obj_new_bytes(wifi_ap_records[i].bssid, sizeof(wifi_ap_records[i].bssid));
t->items[2] = MP_OBJ_NEW_SMALL_INT(wifi_ap_records[i].primary);
t->items[3] = MP_OBJ_NEW_SMALL_INT(wifi_ap_records[i].rssi);
t->items[4] = MP_OBJ_NEW_SMALL_INT(wifi_ap_records[i].authmode);
t->items[5] = mp_const_false; // XXX hidden?
mp_obj_list_append(list, MP_OBJ_FROM_PTR(t));
}
free(wifi_ap_records);
}
return list;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_scan_obj, esp_scan);
STATIC mp_obj_t esp_isconnected(mp_obj_t self_in) {
wlan_if_obj_t *self = MP_OBJ_TO_PTR(self_in);
if (self->if_id == WIFI_IF_STA) {
return mp_obj_new_bool(wifi_sta_connected);
} else {
wifi_sta_list_t sta;
esp_wifi_ap_get_sta_list(&sta);
return mp_obj_new_bool(sta.num != 0);
}
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_isconnected_obj, esp_isconnected);
STATIC mp_obj_t esp_ifconfig(size_t n_args, const mp_obj_t *args) {
wlan_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
tcpip_adapter_ip_info_t info;
tcpip_adapter_dns_info_t dns_info;
tcpip_adapter_get_ip_info(self->if_id, &info);
tcpip_adapter_get_dns_info(self->if_id, DNS_MAIN, &dns_info);
if (n_args == 1) {
// get
mp_obj_t tuple[4] = {
netutils_format_ipv4_addr((uint8_t *)&info.ip, NETUTILS_BIG),
netutils_format_ipv4_addr((uint8_t *)&info.netmask, NETUTILS_BIG),
netutils_format_ipv4_addr((uint8_t *)&info.gw, NETUTILS_BIG),
netutils_format_ipv4_addr((uint8_t *)&dns_info.ip, NETUTILS_BIG),
};
return mp_obj_new_tuple(4, tuple);
} else {
// set
if (mp_obj_is_type(args[1], &mp_type_tuple) || mp_obj_is_type(args[1], &mp_type_list)) {
mp_obj_t *items;
mp_obj_get_array_fixed_n(args[1], 4, &items);
netutils_parse_ipv4_addr(items[0], (void *)&info.ip, NETUTILS_BIG);
if (mp_obj_is_integer(items[1])) {
// allow numeric netmask, i.e.:
// 24 -> 255.255.255.0
// 16 -> 255.255.0.0
// etc...
uint32_t *m = (uint32_t *)&info.netmask;
*m = htonl(0xffffffff << (32 - mp_obj_get_int(items[1])));
} else {
netutils_parse_ipv4_addr(items[1], (void *)&info.netmask, NETUTILS_BIG);
}
netutils_parse_ipv4_addr(items[2], (void *)&info.gw, NETUTILS_BIG);
netutils_parse_ipv4_addr(items[3], (void *)&dns_info.ip, NETUTILS_BIG);
// To set a static IP we have to disable DHCP first
if (self->if_id == WIFI_IF_STA || self->if_id == ESP_IF_ETH) {
esp_err_t e = tcpip_adapter_dhcpc_stop(self->if_id);
if (e != ESP_OK && e != ESP_ERR_TCPIP_ADAPTER_DHCP_ALREADY_STOPPED) {
_esp_exceptions(e);
}
ESP_EXCEPTIONS(tcpip_adapter_set_ip_info(self->if_id, &info));
ESP_EXCEPTIONS(tcpip_adapter_set_dns_info(self->if_id, DNS_MAIN, &dns_info));
} else if (self->if_id == WIFI_IF_AP) {
esp_err_t e = tcpip_adapter_dhcps_stop(WIFI_IF_AP);
if (e != ESP_OK && e != ESP_ERR_TCPIP_ADAPTER_DHCP_ALREADY_STOPPED) {
_esp_exceptions(e);
}
ESP_EXCEPTIONS(tcpip_adapter_set_ip_info(WIFI_IF_AP, &info));
ESP_EXCEPTIONS(tcpip_adapter_set_dns_info(WIFI_IF_AP, DNS_MAIN, &dns_info));
ESP_EXCEPTIONS(tcpip_adapter_dhcps_start(WIFI_IF_AP));
}
} else {
// check for the correct string
const char *mode = mp_obj_str_get_str(args[1]);
if ((self->if_id != WIFI_IF_STA && self->if_id != ESP_IF_ETH) || strcmp("dhcp", mode)) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid arguments"));
}
ESP_EXCEPTIONS(tcpip_adapter_dhcpc_start(self->if_id));
}
return mp_const_none;
}
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_ifconfig_obj, 1, 2, esp_ifconfig);
STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
if (n_args != 1 && kwargs->used != 0) {
mp_raise_TypeError(MP_ERROR_TEXT("either pos or kw args are allowed"));
}
wlan_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
bool is_wifi = self->if_id == WIFI_IF_AP || self->if_id == WIFI_IF_STA;
wifi_config_t cfg;
if (is_wifi) {
ESP_EXCEPTIONS(esp_wifi_get_config(self->if_id, &cfg));
}
#define QS(x) (uintptr_t)MP_OBJ_NEW_QSTR(x)
if (kwargs->used != 0) {
if (!is_wifi) {
goto unknown;
}
for (size_t i = 0; i < kwargs->alloc; i++) {
if (mp_map_slot_is_filled(kwargs, i)) {
int req_if = -1;
switch ((uintptr_t)kwargs->table[i].key) {
case QS(MP_QSTR_mac): {
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(kwargs->table[i].value, &bufinfo, MP_BUFFER_READ);
if (bufinfo.len != 6) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid buffer length"));
}
ESP_EXCEPTIONS(esp_wifi_set_mac(self->if_id, bufinfo.buf));
break;
}
case QS(MP_QSTR_essid): {
req_if = WIFI_IF_AP;
size_t len;
const char *s = mp_obj_str_get_data(kwargs->table[i].value, &len);
len = MIN(len, sizeof(cfg.ap.ssid));
memcpy(cfg.ap.ssid, s, len);
cfg.ap.ssid_len = len;
break;
}
case QS(MP_QSTR_hidden): {
req_if = WIFI_IF_AP;
cfg.ap.ssid_hidden = mp_obj_is_true(kwargs->table[i].value);
break;
}
case QS(MP_QSTR_authmode): {
req_if = WIFI_IF_AP;
cfg.ap.authmode = mp_obj_get_int(kwargs->table[i].value);
break;
}
case QS(MP_QSTR_password): {
req_if = WIFI_IF_AP;
size_t len;
const char *s = mp_obj_str_get_data(kwargs->table[i].value, &len);
len = MIN(len, sizeof(cfg.ap.password) - 1);
memcpy(cfg.ap.password, s, len);
cfg.ap.password[len] = 0;
break;
}
case QS(MP_QSTR_channel): {
req_if = WIFI_IF_AP;
cfg.ap.channel = mp_obj_get_int(kwargs->table[i].value);
break;
}
case QS(MP_QSTR_dhcp_hostname): {
const char *s = mp_obj_str_get_str(kwargs->table[i].value);
ESP_EXCEPTIONS(tcpip_adapter_set_hostname(self->if_id, s));
break;
}
case QS(MP_QSTR_max_clients): {
req_if = WIFI_IF_AP;
cfg.ap.max_connection = mp_obj_get_int(kwargs->table[i].value);
break;
}
case QS(MP_QSTR_reconnects): {
int reconnects = mp_obj_get_int(kwargs->table[i].value);
req_if = WIFI_IF_STA;
// parameter reconnects == -1 means to retry forever.
// here means conf_wifi_sta_reconnects == 0 to retry forever.
conf_wifi_sta_reconnects = (reconnects == -1) ? 0 : reconnects + 1;
break;
}
default:
goto unknown;
}
// We post-check interface requirements to save on code size
if (req_if >= 0) {
require_if(args[0], req_if);
}
}
}
ESP_EXCEPTIONS(esp_wifi_set_config(self->if_id, &cfg));
return mp_const_none;
}
// Get config
if (n_args != 2) {
mp_raise_TypeError(MP_ERROR_TEXT("can query only one param"));
}
int req_if = -1;
mp_obj_t val = mp_const_none;
switch ((uintptr_t)args[1]) {
case QS(MP_QSTR_mac): {
uint8_t mac[6];
switch (self->if_id) {
case WIFI_IF_AP: // fallthrough intentional
case WIFI_IF_STA:
ESP_EXCEPTIONS(esp_wifi_get_mac(self->if_id, mac));
return mp_obj_new_bytes(mac, sizeof(mac));
default:
goto unknown;
}
}
case QS(MP_QSTR_essid):
switch (self->if_id) {
case WIFI_IF_STA:
val = mp_obj_new_str((char *)cfg.sta.ssid, strlen((char *)cfg.sta.ssid));
break;
case WIFI_IF_AP:
val = mp_obj_new_str((char *)cfg.ap.ssid, cfg.ap.ssid_len);
break;
default:
req_if = WIFI_IF_AP;
}
break;
case QS(MP_QSTR_password):
switch (self->if_id) {
case WIFI_IF_STA:
val = mp_obj_new_str((char *)cfg.sta.password, strlen((char *)cfg.sta.password));
break;
case WIFI_IF_AP:
val = mp_obj_new_str((char *)cfg.ap.password, strlen((char *)cfg.sta.password));
break;
default:
req_if = WIFI_IF_AP;
}
break;
case QS(MP_QSTR_hidden):
req_if = WIFI_IF_AP;
val = mp_obj_new_bool(cfg.ap.ssid_hidden);
break;
case QS(MP_QSTR_authmode):
req_if = WIFI_IF_AP;
val = MP_OBJ_NEW_SMALL_INT(cfg.ap.authmode);
break;
case QS(MP_QSTR_channel):
req_if = WIFI_IF_AP;
val = MP_OBJ_NEW_SMALL_INT(cfg.ap.channel);
break;
case QS(MP_QSTR_dhcp_hostname): {
const char *s;
ESP_EXCEPTIONS(tcpip_adapter_get_hostname(self->if_id, &s));
val = mp_obj_new_str(s, strlen(s));
break;
}
case QS(MP_QSTR_max_clients): {
val = MP_OBJ_NEW_SMALL_INT(cfg.ap.max_connection);
break;
}
case QS(MP_QSTR_reconnects):
req_if = WIFI_IF_STA;
int rec = conf_wifi_sta_reconnects - 1;
val = MP_OBJ_NEW_SMALL_INT(rec);
break;
default:
goto unknown;
}
#undef QS
// We post-check interface requirements to save on code size
if (req_if >= 0) {
require_if(args[0], req_if);
}
return val;
unknown:
mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
}
MP_DEFINE_CONST_FUN_OBJ_KW(esp_config_obj, 1, esp_config);
STATIC const mp_rom_map_elem_t wlan_if_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_active), MP_ROM_PTR(&esp_active_obj) },
{ MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&esp_connect_obj) },
{ MP_ROM_QSTR(MP_QSTR_disconnect), MP_ROM_PTR(&esp_disconnect_obj) },
{ MP_ROM_QSTR(MP_QSTR_status), MP_ROM_PTR(&esp_status_obj) },
{ MP_ROM_QSTR(MP_QSTR_scan), MP_ROM_PTR(&esp_scan_obj) },
{ MP_ROM_QSTR(MP_QSTR_isconnected), MP_ROM_PTR(&esp_isconnected_obj) },
{ MP_ROM_QSTR(MP_QSTR_config), MP_ROM_PTR(&esp_config_obj) },
{ MP_ROM_QSTR(MP_QSTR_ifconfig), MP_ROM_PTR(&esp_ifconfig_obj) },
};
STATIC MP_DEFINE_CONST_DICT(wlan_if_locals_dict, wlan_if_locals_dict_table);
const mp_obj_type_t wlan_if_type = {
{ &mp_type_type },
.name = MP_QSTR_WLAN,
.locals_dict = (mp_obj_t)&wlan_if_locals_dict,
};
STATIC mp_obj_t esp_phy_mode(size_t n_args, const mp_obj_t *args) {
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_phy_mode_obj, 0, 1, esp_phy_mode);
STATIC const mp_rom_map_elem_t mp_module_network_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_network) },
{ MP_ROM_QSTR(MP_QSTR___init__), MP_ROM_PTR(&esp_initialize_obj) },
{ MP_ROM_QSTR(MP_QSTR_WLAN), MP_ROM_PTR(&get_wlan_obj) },
#if (ESP_IDF_VERSION_MAJOR == 4) && (ESP_IDF_VERSION_MINOR >= 1) && (CONFIG_IDF_TARGET_ESP32)
{ MP_ROM_QSTR(MP_QSTR_LAN), MP_ROM_PTR(&get_lan_obj) },
#endif
{ MP_ROM_QSTR(MP_QSTR_PPP), MP_ROM_PTR(&ppp_make_new_obj) },
{ MP_ROM_QSTR(MP_QSTR_phy_mode), MP_ROM_PTR(&esp_phy_mode_obj) },
#if MODNETWORK_INCLUDE_CONSTANTS
{ MP_ROM_QSTR(MP_QSTR_STA_IF), MP_ROM_INT(WIFI_IF_STA)},
{ MP_ROM_QSTR(MP_QSTR_AP_IF), MP_ROM_INT(WIFI_IF_AP)},
{ MP_ROM_QSTR(MP_QSTR_MODE_11B), MP_ROM_INT(WIFI_PROTOCOL_11B) },
{ MP_ROM_QSTR(MP_QSTR_MODE_11G), MP_ROM_INT(WIFI_PROTOCOL_11G) },
{ MP_ROM_QSTR(MP_QSTR_MODE_11N), MP_ROM_INT(WIFI_PROTOCOL_11N) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_OPEN), MP_ROM_INT(WIFI_AUTH_OPEN) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_WEP), MP_ROM_INT(WIFI_AUTH_WEP) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_WPA_PSK), MP_ROM_INT(WIFI_AUTH_WPA_PSK) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_WPA2_PSK), MP_ROM_INT(WIFI_AUTH_WPA2_PSK) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_WPA_WPA2_PSK), MP_ROM_INT(WIFI_AUTH_WPA_WPA2_PSK) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_WPA2_ENTERPRISE), MP_ROM_INT(WIFI_AUTH_WPA2_ENTERPRISE) },
#if 0 // TODO: Remove this #if/#endif when lastest ISP IDF will be used
{ MP_ROM_QSTR(MP_QSTR_AUTH_WPA3_PSK), MP_ROM_INT(WIFI_AUTH_WPA3_PSK) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_WPA2_WPA3_PSK), MP_ROM_INT(WIFI_AUTH_WPA2_WPA3_PSK) },
#endif
{ MP_ROM_QSTR(MP_QSTR_AUTH_MAX), MP_ROM_INT(WIFI_AUTH_MAX) },
#if (ESP_IDF_VERSION_MAJOR == 4) && (ESP_IDF_VERSION_MINOR >= 1) && (CONFIG_IDF_TARGET_ESP32)
{ MP_ROM_QSTR(MP_QSTR_PHY_LAN8720), MP_ROM_INT(PHY_LAN8720) },
{ MP_ROM_QSTR(MP_QSTR_PHY_IP101), MP_ROM_INT(PHY_IP101) },
{ MP_ROM_QSTR(MP_QSTR_PHY_RTL8201), MP_ROM_INT(PHY_RTL8201) },
{ MP_ROM_QSTR(MP_QSTR_PHY_DP83848), MP_ROM_INT(PHY_DP83848) },
#if ESP_IDF_VERSION_MINOR >= 3
// PHY_KSZ8041 is new in ESP-IDF v4.3
{ MP_ROM_QSTR(MP_QSTR_PHY_KSZ8041), MP_ROM_INT(PHY_KSZ8041) },
#endif
{ MP_ROM_QSTR(MP_QSTR_ETH_INITIALIZED), MP_ROM_INT(ETH_INITIALIZED)},
{ MP_ROM_QSTR(MP_QSTR_ETH_STARTED), MP_ROM_INT(ETH_STARTED)},
{ MP_ROM_QSTR(MP_QSTR_ETH_STOPPED), MP_ROM_INT(ETH_STOPPED)},
{ MP_ROM_QSTR(MP_QSTR_ETH_CONNECTED), MP_ROM_INT(ETH_CONNECTED)},
{ MP_ROM_QSTR(MP_QSTR_ETH_DISCONNECTED), MP_ROM_INT(ETH_DISCONNECTED)},
{ MP_ROM_QSTR(MP_QSTR_ETH_GOT_IP), MP_ROM_INT(ETH_GOT_IP)},
#endif
{ MP_ROM_QSTR(MP_QSTR_STAT_IDLE), MP_ROM_INT(STAT_IDLE)},
{ MP_ROM_QSTR(MP_QSTR_STAT_CONNECTING), MP_ROM_INT(STAT_CONNECTING)},
{ MP_ROM_QSTR(MP_QSTR_STAT_GOT_IP), MP_ROM_INT(STAT_GOT_IP)},
// Errors from the ESP-IDF
{ MP_ROM_QSTR(MP_QSTR_STAT_NO_AP_FOUND), MP_ROM_INT(WIFI_REASON_NO_AP_FOUND)},
{ MP_ROM_QSTR(MP_QSTR_STAT_WRONG_PASSWORD), MP_ROM_INT(WIFI_REASON_AUTH_FAIL)},
{ MP_ROM_QSTR(MP_QSTR_STAT_BEACON_TIMEOUT), MP_ROM_INT(WIFI_REASON_BEACON_TIMEOUT)},
{ MP_ROM_QSTR(MP_QSTR_STAT_ASSOC_FAIL), MP_ROM_INT(WIFI_REASON_ASSOC_FAIL)},
{ MP_ROM_QSTR(MP_QSTR_STAT_HANDSHAKE_TIMEOUT), MP_ROM_INT(WIFI_REASON_HANDSHAKE_TIMEOUT)},
#endif
};
STATIC MP_DEFINE_CONST_DICT(mp_module_network_globals, mp_module_network_globals_table);
const mp_obj_module_t mp_module_network = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&mp_module_network_globals,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modnetwork.c | C | apache-2.0 | 35,477 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2017 "Eric Poulsen" <eric@zyxod.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef MICROPY_INCLUDED_ESP32_MODNETWORK_H
#define MICROPY_INCLUDED_ESP32_MODNETWORK_H
enum { PHY_LAN8720, PHY_IP101, PHY_RTL8201, PHY_DP83848, PHY_KSZ8041 };
enum { ETH_INITIALIZED, ETH_STARTED, ETH_STOPPED, ETH_CONNECTED, ETH_DISCONNECTED, ETH_GOT_IP };
MP_DECLARE_CONST_FUN_OBJ_KW(get_lan_obj);
MP_DECLARE_CONST_FUN_OBJ_1(ppp_make_new_obj);
MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(esp_ifconfig_obj);
MP_DECLARE_CONST_FUN_OBJ_KW(esp_config_obj);
void usocket_events_deinit(void);
#endif
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modnetwork.h | C | apache-2.0 | 1,731 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
* and Mnemote Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2016, 2017 Nick Moore @mnemote
*
* Based on extmod/modlwip.c
* Copyright (c) 2013, 2014 Damien P. George
* Copyright (c) 2015 Galen Hazelwood
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "py/runtime0.h"
#include "py/nlr.h"
#include "py/objlist.h"
#include "py/objstr.h"
#include "py/runtime.h"
#include "py/mperrno.h"
#include "py/mphal.h"
#include "py/stream.h"
#include "py/mperrno.h"
#include "shared/netutils/netutils.h"
#include "mdns.h"
#include "modnetwork.h"
#include "lwip/sockets.h"
#include "lwip/netdb.h"
#include "lwip/ip4.h"
#include "lwip/igmp.h"
#include "esp_log.h"
#define SOCKET_POLL_US (100000)
#define MDNS_QUERY_TIMEOUT_MS (5000)
#define MDNS_LOCAL_SUFFIX ".local"
enum {
SOCKET_STATE_NEW,
SOCKET_STATE_CONNECTED,
SOCKET_STATE_PEER_CLOSED,
};
typedef struct _socket_obj_t {
mp_obj_base_t base;
int fd;
uint8_t domain;
uint8_t type;
uint8_t proto;
uint8_t state;
unsigned int retries;
#if MICROPY_PY_USOCKET_EVENTS
mp_obj_t events_callback;
struct _socket_obj_t *events_next;
#endif
} socket_obj_t;
void _socket_settimeout(socket_obj_t *sock, uint64_t timeout_ms);
#if MICROPY_PY_USOCKET_EVENTS
// Support for callbacks on asynchronous socket events (when socket becomes readable)
// This divisor is used to reduce the load on the system, so it doesn't poll sockets too often
#define USOCKET_EVENTS_DIVISOR (8)
STATIC uint8_t usocket_events_divisor;
STATIC socket_obj_t *usocket_events_head;
void usocket_events_deinit(void) {
usocket_events_head = NULL;
}
// Assumes the socket is not already in the linked list, and adds it
STATIC void usocket_events_add(socket_obj_t *sock) {
sock->events_next = usocket_events_head;
usocket_events_head = sock;
}
// Assumes the socket is already in the linked list, and removes it
STATIC void usocket_events_remove(socket_obj_t *sock) {
for (socket_obj_t **s = &usocket_events_head;; s = &(*s)->events_next) {
if (*s == sock) {
*s = (*s)->events_next;
return;
}
}
}
// Polls all registered sockets for readability and calls their callback if they are readable
void usocket_events_handler(void) {
if (usocket_events_head == NULL) {
return;
}
if (--usocket_events_divisor) {
return;
}
usocket_events_divisor = USOCKET_EVENTS_DIVISOR;
fd_set rfds;
FD_ZERO(&rfds);
int max_fd = 0;
for (socket_obj_t *s = usocket_events_head; s != NULL; s = s->events_next) {
FD_SET(s->fd, &rfds);
max_fd = MAX(max_fd, s->fd);
}
// Poll the sockets
struct timeval timeout = { .tv_sec = 0, .tv_usec = 0 };
int r = select(max_fd + 1, &rfds, NULL, NULL, &timeout);
if (r <= 0) {
return;
}
// Call the callbacks
for (socket_obj_t *s = usocket_events_head; s != NULL; s = s->events_next) {
if (FD_ISSET(s->fd, &rfds)) {
mp_call_function_1_protected(s->events_callback, s);
}
}
}
#endif // MICROPY_PY_USOCKET_EVENTS
static inline void check_for_exceptions(void) {
mp_handle_pending(true);
}
// This function mimics lwip_getaddrinfo, with added support for mDNS queries
static int _socket_getaddrinfo3(const char *nodename, const char *servname,
const struct addrinfo *hints, struct addrinfo **res) {
#if MICROPY_HW_ENABLE_MDNS_QUERIES
int nodename_len = strlen(nodename);
const int local_len = sizeof(MDNS_LOCAL_SUFFIX) - 1;
if (nodename_len > local_len
&& strcasecmp(nodename + nodename_len - local_len, MDNS_LOCAL_SUFFIX) == 0) {
// mDNS query
char nodename_no_local[nodename_len - local_len + 1];
memcpy(nodename_no_local, nodename, nodename_len - local_len);
nodename_no_local[nodename_len - local_len] = '\0';
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(4, 1, 0)
struct ip4_addr addr = {0};
#else
esp_ip4_addr_t addr = {0};
#endif
esp_err_t err = mdns_query_a(nodename_no_local, MDNS_QUERY_TIMEOUT_MS, &addr);
if (err != ESP_OK) {
if (err == ESP_ERR_NOT_FOUND) {
*res = NULL;
return 0;
}
*res = NULL;
return err;
}
struct addrinfo *ai = memp_malloc(MEMP_NETDB);
if (ai == NULL) {
*res = NULL;
return EAI_MEMORY;
}
memset(ai, 0, sizeof(struct addrinfo) + sizeof(struct sockaddr_storage));
struct sockaddr_in *sa = (struct sockaddr_in *)((uint8_t *)ai + sizeof(struct addrinfo));
inet_addr_from_ip4addr(&sa->sin_addr, &addr);
sa->sin_family = AF_INET;
sa->sin_len = sizeof(struct sockaddr_in);
sa->sin_port = lwip_htons((u16_t)atoi(servname));
ai->ai_family = AF_INET;
ai->ai_canonname = ((char *)sa + sizeof(struct sockaddr_storage));
memcpy(ai->ai_canonname, nodename, nodename_len + 1);
ai->ai_addrlen = sizeof(struct sockaddr_storage);
ai->ai_addr = (struct sockaddr *)sa;
*res = ai;
return 0;
}
#endif
// Normal query
return lwip_getaddrinfo(nodename, servname, hints, res);
}
static int _socket_getaddrinfo2(const mp_obj_t host, const mp_obj_t portx, struct addrinfo **resp) {
const struct addrinfo hints = {
.ai_family = AF_INET,
.ai_socktype = SOCK_STREAM,
};
mp_obj_t port = portx;
if (mp_obj_is_small_int(port)) {
// This is perverse, because lwip_getaddrinfo promptly converts it back to an int, but
// that's the API we have to work with ...
port = mp_obj_str_binary_op(MP_BINARY_OP_MODULO, mp_obj_new_str_via_qstr("%s", 2), port);
}
const char *host_str = mp_obj_str_get_str(host);
const char *port_str = mp_obj_str_get_str(port);
if (host_str[0] == '\0') {
// a host of "" is equivalent to the default/all-local IP address
host_str = "0.0.0.0";
}
MP_THREAD_GIL_EXIT();
int res = _socket_getaddrinfo3(host_str, port_str, &hints, resp);
MP_THREAD_GIL_ENTER();
// Per docs: instead of raising gaierror getaddrinfo raises negative error number
if (res != 0) {
mp_raise_OSError(res > 0 ? -res : res);
}
// Somehow LwIP returns a resolution of 0.0.0.0 for failed lookups, traced it as far back
// as netconn_gethostbyname_addrtype returning OK instead of error.
if (*resp == NULL ||
(strcmp(resp[0]->ai_canonname, "0.0.0.0") == 0 && strcmp(host_str, "0.0.0.0") != 0)) {
mp_raise_OSError(-2); // name or service not known
}
return res;
}
STATIC void _socket_getaddrinfo(const mp_obj_t addrtuple, struct addrinfo **resp) {
mp_obj_t *elem;
mp_obj_get_array_fixed_n(addrtuple, 2, &elem);
_socket_getaddrinfo2(elem[0], elem[1], resp);
}
STATIC mp_obj_t socket_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
mp_arg_check_num(n_args, n_kw, 0, 3, false);
socket_obj_t *sock = m_new_obj_with_finaliser(socket_obj_t);
sock->base.type = type_in;
sock->domain = AF_INET;
sock->type = SOCK_STREAM;
sock->proto = 0;
if (n_args > 0) {
sock->domain = mp_obj_get_int(args[0]);
if (n_args > 1) {
sock->type = mp_obj_get_int(args[1]);
if (n_args > 2) {
sock->proto = mp_obj_get_int(args[2]);
}
}
}
sock->state = sock->type == SOCK_STREAM ? SOCKET_STATE_NEW : SOCKET_STATE_CONNECTED;
sock->fd = lwip_socket(sock->domain, sock->type, sock->proto);
if (sock->fd < 0) {
mp_raise_OSError(errno);
}
_socket_settimeout(sock, UINT64_MAX);
return MP_OBJ_FROM_PTR(sock);
}
STATIC mp_obj_t socket_bind(const mp_obj_t arg0, const mp_obj_t arg1) {
socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
struct addrinfo *res;
_socket_getaddrinfo(arg1, &res);
self->state = SOCKET_STATE_CONNECTED;
int r = lwip_bind(self->fd, res->ai_addr, res->ai_addrlen);
lwip_freeaddrinfo(res);
if (r < 0) {
mp_raise_OSError(errno);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_bind_obj, socket_bind);
STATIC mp_obj_t socket_listen(const mp_obj_t arg0, const mp_obj_t arg1) {
socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
int backlog = mp_obj_get_int(arg1);
self->state = SOCKET_STATE_CONNECTED;
int r = lwip_listen(self->fd, backlog);
if (r < 0) {
mp_raise_OSError(errno);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_listen_obj, socket_listen);
STATIC mp_obj_t socket_accept(const mp_obj_t arg0) {
socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
struct sockaddr addr;
socklen_t addr_len = sizeof(addr);
int new_fd = -1;
for (int i = 0; i <= self->retries; i++) {
MP_THREAD_GIL_EXIT();
new_fd = lwip_accept(self->fd, &addr, &addr_len);
MP_THREAD_GIL_ENTER();
if (new_fd >= 0) {
break;
}
if (errno != EAGAIN) {
mp_raise_OSError(errno);
}
check_for_exceptions();
}
if (new_fd < 0) {
if (self->retries == 0) {
mp_raise_OSError(MP_EAGAIN);
} else {
mp_raise_OSError(MP_ETIMEDOUT);
}
}
// create new socket object
socket_obj_t *sock = m_new_obj_with_finaliser(socket_obj_t);
sock->base.type = self->base.type;
sock->fd = new_fd;
sock->domain = self->domain;
sock->type = self->type;
sock->proto = self->proto;
sock->state = SOCKET_STATE_CONNECTED;
_socket_settimeout(sock, UINT64_MAX);
// make the return value
uint8_t *ip = (uint8_t *)&((struct sockaddr_in *)&addr)->sin_addr;
mp_uint_t port = lwip_ntohs(((struct sockaddr_in *)&addr)->sin_port);
mp_obj_tuple_t *client = mp_obj_new_tuple(2, NULL);
client->items[0] = sock;
client->items[1] = netutils_format_inet_addr(ip, port, NETUTILS_BIG);
return client;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_accept_obj, socket_accept);
STATIC mp_obj_t socket_connect(const mp_obj_t arg0, const mp_obj_t arg1) {
socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
struct addrinfo *res;
_socket_getaddrinfo(arg1, &res);
MP_THREAD_GIL_EXIT();
self->state = SOCKET_STATE_CONNECTED;
int r = lwip_connect(self->fd, res->ai_addr, res->ai_addrlen);
MP_THREAD_GIL_ENTER();
lwip_freeaddrinfo(res);
if (r != 0) {
mp_raise_OSError(errno);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_connect_obj, socket_connect);
STATIC mp_obj_t socket_setsockopt(size_t n_args, const mp_obj_t *args) {
(void)n_args; // always 4
socket_obj_t *self = MP_OBJ_TO_PTR(args[0]);
int opt = mp_obj_get_int(args[2]);
switch (opt) {
// level: SOL_SOCKET
case SO_REUSEADDR: {
int val = mp_obj_get_int(args[3]);
int ret = lwip_setsockopt(self->fd, SOL_SOCKET, opt, &val, sizeof(int));
if (ret != 0) {
mp_raise_OSError(errno);
}
break;
}
#if MICROPY_PY_USOCKET_EVENTS
// level: SOL_SOCKET
// special "register callback" option
case 20: {
if (args[3] == mp_const_none) {
if (self->events_callback != MP_OBJ_NULL) {
usocket_events_remove(self);
self->events_callback = MP_OBJ_NULL;
}
} else {
if (self->events_callback == MP_OBJ_NULL) {
usocket_events_add(self);
}
self->events_callback = args[3];
}
break;
}
#endif
// level: IPPROTO_IP
case IP_ADD_MEMBERSHIP: {
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(args[3], &bufinfo, MP_BUFFER_READ);
if (bufinfo.len != sizeof(ip4_addr_t) * 2) {
mp_raise_ValueError(NULL);
}
// POSIX setsockopt has order: group addr, if addr, lwIP has it vice-versa
err_t err = igmp_joingroup((const ip4_addr_t *)bufinfo.buf + 1, bufinfo.buf);
if (err != ERR_OK) {
mp_raise_OSError(-err);
}
break;
}
default:
mp_printf(&mp_plat_print, "Warning: lwip.setsockopt() option not implemented\n");
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_setsockopt_obj, 4, 4, socket_setsockopt);
void _socket_settimeout(socket_obj_t *sock, uint64_t timeout_ms) {
// Rather than waiting for the entire timeout specified, we wait sock->retries times
// for SOCKET_POLL_US each, checking for a MicroPython interrupt between timeouts.
// with SOCKET_POLL_MS == 100ms, sock->retries allows for timeouts up to 13 years.
// if timeout_ms == UINT64_MAX, wait forever.
sock->retries = (timeout_ms == UINT64_MAX) ? UINT_MAX : timeout_ms * 1000 / SOCKET_POLL_US;
struct timeval timeout = {
.tv_sec = 0,
.tv_usec = timeout_ms ? SOCKET_POLL_US : 0
};
lwip_setsockopt(sock->fd, SOL_SOCKET, SO_SNDTIMEO, (const void *)&timeout, sizeof(timeout));
lwip_setsockopt(sock->fd, SOL_SOCKET, SO_RCVTIMEO, (const void *)&timeout, sizeof(timeout));
lwip_fcntl(sock->fd, F_SETFL, timeout_ms ? 0 : O_NONBLOCK);
}
STATIC mp_obj_t socket_settimeout(const mp_obj_t arg0, const mp_obj_t arg1) {
socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
if (arg1 == mp_const_none) {
_socket_settimeout(self, UINT64_MAX);
} else {
#if MICROPY_PY_BUILTINS_FLOAT
_socket_settimeout(self, (uint64_t)(mp_obj_get_float(arg1) * MICROPY_FLOAT_CONST(1000.0)));
#else
_socket_settimeout(self, mp_obj_get_int(arg1) * 1000);
#endif
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_settimeout_obj, socket_settimeout);
STATIC mp_obj_t socket_setblocking(const mp_obj_t arg0, const mp_obj_t arg1) {
socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
if (mp_obj_is_true(arg1)) {
_socket_settimeout(self, UINT64_MAX);
} else {
_socket_settimeout(self, 0);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_setblocking_obj, socket_setblocking);
// XXX this can end up waiting a very long time if the content is dribbled in one character
// at a time, as the timeout resets each time a recvfrom succeeds ... this is probably not
// good behaviour.
STATIC mp_uint_t _socket_read_data(mp_obj_t self_in, void *buf, size_t size,
struct sockaddr *from, socklen_t *from_len, int *errcode) {
socket_obj_t *sock = MP_OBJ_TO_PTR(self_in);
// A new socket cannot be read from.
if (sock->state == SOCKET_STATE_NEW) {
*errcode = MP_ENOTCONN;
return MP_STREAM_ERROR;
}
// If the peer closed the connection then the lwIP socket API will only return "0" once
// from lwip_recvfrom and then block on subsequent calls. To emulate POSIX behaviour,
// which continues to return "0" for each call on a closed socket, we set a flag when
// the peer closed the socket.
if (sock->state == SOCKET_STATE_PEER_CLOSED) {
return 0;
}
// XXX Would be nicer to use RTC to handle timeouts
for (int i = 0; i <= sock->retries; ++i) {
// Poll the socket to see if it has waiting data and only release the GIL if it doesn't.
// This ensures higher performance in the case of many small reads, eg for readline.
bool release_gil;
{
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(sock->fd, &rfds);
struct timeval timeout = { .tv_sec = 0, .tv_usec = 0 };
int r = select(sock->fd + 1, &rfds, NULL, NULL, &timeout);
release_gil = r != 1;
}
if (release_gil) {
MP_THREAD_GIL_EXIT();
}
int r = lwip_recvfrom(sock->fd, buf, size, 0, from, from_len);
if (release_gil) {
MP_THREAD_GIL_ENTER();
}
if (r == 0) {
sock->state = SOCKET_STATE_PEER_CLOSED;
}
if (r >= 0) {
return r;
}
if (errno != EWOULDBLOCK) {
*errcode = errno;
return MP_STREAM_ERROR;
}
check_for_exceptions();
}
*errcode = sock->retries == 0 ? MP_EWOULDBLOCK : MP_ETIMEDOUT;
return MP_STREAM_ERROR;
}
mp_obj_t _socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in,
struct sockaddr *from, socklen_t *from_len) {
size_t len = mp_obj_get_int(len_in);
vstr_t vstr;
vstr_init_len(&vstr, len);
int errcode;
mp_uint_t ret = _socket_read_data(self_in, vstr.buf, len, from, from_len, &errcode);
if (ret == MP_STREAM_ERROR) {
mp_raise_OSError(errcode);
}
vstr.len = ret;
return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
}
STATIC mp_obj_t socket_recv(mp_obj_t self_in, mp_obj_t len_in) {
return _socket_recvfrom(self_in, len_in, NULL, NULL);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_recv_obj, socket_recv);
STATIC mp_obj_t socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in) {
struct sockaddr from;
socklen_t fromlen = sizeof(from);
mp_obj_t tuple[2];
tuple[0] = _socket_recvfrom(self_in, len_in, &from, &fromlen);
uint8_t *ip = (uint8_t *)&((struct sockaddr_in *)&from)->sin_addr;
mp_uint_t port = lwip_ntohs(((struct sockaddr_in *)&from)->sin_port);
tuple[1] = netutils_format_inet_addr(ip, port, NETUTILS_BIG);
return mp_obj_new_tuple(2, tuple);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_recvfrom_obj, socket_recvfrom);
int _socket_send(socket_obj_t *sock, const char *data, size_t datalen) {
int sentlen = 0;
for (int i = 0; i <= sock->retries && sentlen < datalen; i++) {
MP_THREAD_GIL_EXIT();
int r = lwip_write(sock->fd, data + sentlen, datalen - sentlen);
MP_THREAD_GIL_ENTER();
// lwip returns EINPROGRESS when trying to send right after a non-blocking connect
if (r < 0 && errno != EWOULDBLOCK && errno != EINPROGRESS) {
mp_raise_OSError(errno);
}
if (r > 0) {
sentlen += r;
}
check_for_exceptions();
}
if (sentlen == 0) {
mp_raise_OSError(sock->retries == 0 ? MP_EWOULDBLOCK : MP_ETIMEDOUT);
}
return sentlen;
}
STATIC mp_obj_t socket_send(const mp_obj_t arg0, const mp_obj_t arg1) {
socket_obj_t *sock = MP_OBJ_TO_PTR(arg0);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(arg1, &bufinfo, MP_BUFFER_READ);
int r = _socket_send(sock, bufinfo.buf, bufinfo.len);
return mp_obj_new_int(r);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_send_obj, socket_send);
STATIC mp_obj_t socket_sendall(const mp_obj_t arg0, const mp_obj_t arg1) {
// XXX behaviour when nonblocking (see extmod/modlwip.c)
// XXX also timeout behaviour.
socket_obj_t *sock = MP_OBJ_TO_PTR(arg0);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(arg1, &bufinfo, MP_BUFFER_READ);
int r = _socket_send(sock, bufinfo.buf, bufinfo.len);
if (r < bufinfo.len) {
mp_raise_OSError(MP_ETIMEDOUT);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_sendall_obj, socket_sendall);
STATIC mp_obj_t socket_sendto(mp_obj_t self_in, mp_obj_t data_in, mp_obj_t addr_in) {
socket_obj_t *self = MP_OBJ_TO_PTR(self_in);
// get the buffer to send
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(data_in, &bufinfo, MP_BUFFER_READ);
// create the destination address
struct sockaddr_in to;
to.sin_len = sizeof(to);
to.sin_family = AF_INET;
to.sin_port = lwip_htons(netutils_parse_inet_addr(addr_in, (uint8_t *)&to.sin_addr, NETUTILS_BIG));
// send the data
for (int i = 0; i <= self->retries; i++) {
MP_THREAD_GIL_EXIT();
int ret = lwip_sendto(self->fd, bufinfo.buf, bufinfo.len, 0, (struct sockaddr *)&to, sizeof(to));
MP_THREAD_GIL_ENTER();
if (ret > 0) {
return mp_obj_new_int_from_uint(ret);
}
if (ret == -1 && errno != EWOULDBLOCK) {
mp_raise_OSError(errno);
}
check_for_exceptions();
}
mp_raise_OSError(MP_ETIMEDOUT);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_3(socket_sendto_obj, socket_sendto);
STATIC mp_obj_t socket_fileno(const mp_obj_t arg0) {
socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
return mp_obj_new_int(self->fd);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_fileno_obj, socket_fileno);
STATIC mp_obj_t socket_makefile(size_t n_args, const mp_obj_t *args) {
(void)n_args;
return args[0];
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_makefile_obj, 1, 3, socket_makefile);
STATIC mp_uint_t socket_stream_read(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode) {
return _socket_read_data(self_in, buf, size, NULL, NULL, errcode);
}
STATIC mp_uint_t socket_stream_write(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode) {
socket_obj_t *sock = self_in;
for (int i = 0; i <= sock->retries; i++) {
MP_THREAD_GIL_EXIT();
int r = lwip_write(sock->fd, buf, size);
MP_THREAD_GIL_ENTER();
if (r > 0) {
return r;
}
// lwip returns MP_EINPROGRESS when trying to write right after a non-blocking connect
if (r < 0 && errno != EWOULDBLOCK && errno != EINPROGRESS) {
*errcode = errno;
return MP_STREAM_ERROR;
}
check_for_exceptions();
}
*errcode = sock->retries == 0 ? MP_EWOULDBLOCK : MP_ETIMEDOUT;
return MP_STREAM_ERROR;
}
STATIC mp_uint_t socket_stream_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
socket_obj_t *socket = self_in;
if (request == MP_STREAM_POLL) {
if (socket->fd == -1) {
return MP_STREAM_POLL_NVAL;
}
fd_set rfds;
FD_ZERO(&rfds);
fd_set wfds;
FD_ZERO(&wfds);
fd_set efds;
FD_ZERO(&efds);
struct timeval timeout = { .tv_sec = 0, .tv_usec = 0 };
if (arg & MP_STREAM_POLL_RD) {
FD_SET(socket->fd, &rfds);
}
if (arg & MP_STREAM_POLL_WR) {
FD_SET(socket->fd, &wfds);
}
if (arg & MP_STREAM_POLL_HUP) {
FD_SET(socket->fd, &efds);
}
int r = select((socket->fd) + 1, &rfds, &wfds, &efds, &timeout);
if (r < 0) {
*errcode = MP_EIO;
return MP_STREAM_ERROR;
}
mp_uint_t ret = 0;
if (FD_ISSET(socket->fd, &rfds)) {
ret |= MP_STREAM_POLL_RD;
}
if (FD_ISSET(socket->fd, &wfds)) {
ret |= MP_STREAM_POLL_WR;
}
if (FD_ISSET(socket->fd, &efds)) {
ret |= MP_STREAM_POLL_HUP;
}
// New (unconnected) sockets are writable and have HUP set.
if (socket->state == SOCKET_STATE_NEW) {
ret |= (arg & MP_STREAM_POLL_WR) | MP_STREAM_POLL_HUP;
}
return ret;
} else if (request == MP_STREAM_CLOSE) {
if (socket->fd >= 0) {
#if MICROPY_PY_USOCKET_EVENTS
if (socket->events_callback != MP_OBJ_NULL) {
usocket_events_remove(socket);
socket->events_callback = MP_OBJ_NULL;
}
#endif
int ret = lwip_close(socket->fd);
if (ret != 0) {
*errcode = errno;
return MP_STREAM_ERROR;
}
socket->fd = -1;
}
return 0;
}
*errcode = MP_EINVAL;
return MP_STREAM_ERROR;
}
STATIC const mp_rom_map_elem_t socket_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
{ MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
{ MP_ROM_QSTR(MP_QSTR_bind), MP_ROM_PTR(&socket_bind_obj) },
{ MP_ROM_QSTR(MP_QSTR_listen), MP_ROM_PTR(&socket_listen_obj) },
{ MP_ROM_QSTR(MP_QSTR_accept), MP_ROM_PTR(&socket_accept_obj) },
{ MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&socket_connect_obj) },
{ MP_ROM_QSTR(MP_QSTR_send), MP_ROM_PTR(&socket_send_obj) },
{ MP_ROM_QSTR(MP_QSTR_sendall), MP_ROM_PTR(&socket_sendall_obj) },
{ MP_ROM_QSTR(MP_QSTR_sendto), MP_ROM_PTR(&socket_sendto_obj) },
{ MP_ROM_QSTR(MP_QSTR_recv), MP_ROM_PTR(&socket_recv_obj) },
{ MP_ROM_QSTR(MP_QSTR_recvfrom), MP_ROM_PTR(&socket_recvfrom_obj) },
{ MP_ROM_QSTR(MP_QSTR_setsockopt), MP_ROM_PTR(&socket_setsockopt_obj) },
{ MP_ROM_QSTR(MP_QSTR_settimeout), MP_ROM_PTR(&socket_settimeout_obj) },
{ MP_ROM_QSTR(MP_QSTR_setblocking), MP_ROM_PTR(&socket_setblocking_obj) },
{ MP_ROM_QSTR(MP_QSTR_makefile), MP_ROM_PTR(&socket_makefile_obj) },
{ MP_ROM_QSTR(MP_QSTR_fileno), MP_ROM_PTR(&socket_fileno_obj) },
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
{ MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
{ MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
{ MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
};
STATIC MP_DEFINE_CONST_DICT(socket_locals_dict, socket_locals_dict_table);
STATIC const mp_stream_p_t socket_stream_p = {
.read = socket_stream_read,
.write = socket_stream_write,
.ioctl = socket_stream_ioctl
};
STATIC const mp_obj_type_t socket_type = {
{ &mp_type_type },
.name = MP_QSTR_socket,
.make_new = socket_make_new,
.protocol = &socket_stream_p,
.locals_dict = (mp_obj_t)&socket_locals_dict,
};
STATIC mp_obj_t esp_socket_getaddrinfo(size_t n_args, const mp_obj_t *args) {
// TODO support additional args beyond the first two
struct addrinfo *res = NULL;
_socket_getaddrinfo2(args[0], args[1], &res);
mp_obj_t ret_list = mp_obj_new_list(0, NULL);
for (struct addrinfo *resi = res; resi; resi = resi->ai_next) {
mp_obj_t addrinfo_objs[5] = {
mp_obj_new_int(resi->ai_family),
mp_obj_new_int(resi->ai_socktype),
mp_obj_new_int(resi->ai_protocol),
mp_obj_new_str(resi->ai_canonname, strlen(resi->ai_canonname)),
mp_const_none
};
if (resi->ai_family == AF_INET) {
struct sockaddr_in *addr = (struct sockaddr_in *)resi->ai_addr;
// This looks odd, but it's really just a u32_t
ip4_addr_t ip4_addr = { .addr = addr->sin_addr.s_addr };
char buf[16];
ip4addr_ntoa_r(&ip4_addr, buf, sizeof(buf));
mp_obj_t inaddr_objs[2] = {
mp_obj_new_str(buf, strlen(buf)),
mp_obj_new_int(ntohs(addr->sin_port))
};
addrinfo_objs[4] = mp_obj_new_tuple(2, inaddr_objs);
}
mp_obj_list_append(ret_list, mp_obj_new_tuple(5, addrinfo_objs));
}
if (res) {
lwip_freeaddrinfo(res);
}
return ret_list;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_socket_getaddrinfo_obj, 2, 6, esp_socket_getaddrinfo);
STATIC mp_obj_t esp_socket_initialize() {
static int initialized = 0;
if (!initialized) {
ESP_LOGI("modsocket", "Initializing");
tcpip_adapter_init();
initialized = 1;
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp_socket_initialize_obj, esp_socket_initialize);
STATIC const mp_rom_map_elem_t mp_module_socket_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_usocket) },
{ MP_ROM_QSTR(MP_QSTR___init__), MP_ROM_PTR(&esp_socket_initialize_obj) },
{ MP_ROM_QSTR(MP_QSTR_socket), MP_ROM_PTR(&socket_type) },
{ MP_ROM_QSTR(MP_QSTR_getaddrinfo), MP_ROM_PTR(&esp_socket_getaddrinfo_obj) },
{ MP_ROM_QSTR(MP_QSTR_AF_INET), MP_ROM_INT(AF_INET) },
{ MP_ROM_QSTR(MP_QSTR_AF_INET6), MP_ROM_INT(AF_INET6) },
{ MP_ROM_QSTR(MP_QSTR_SOCK_STREAM), MP_ROM_INT(SOCK_STREAM) },
{ MP_ROM_QSTR(MP_QSTR_SOCK_DGRAM), MP_ROM_INT(SOCK_DGRAM) },
{ MP_ROM_QSTR(MP_QSTR_SOCK_RAW), MP_ROM_INT(SOCK_RAW) },
{ MP_ROM_QSTR(MP_QSTR_IPPROTO_TCP), MP_ROM_INT(IPPROTO_TCP) },
{ MP_ROM_QSTR(MP_QSTR_IPPROTO_UDP), MP_ROM_INT(IPPROTO_UDP) },
{ MP_ROM_QSTR(MP_QSTR_IPPROTO_IP), MP_ROM_INT(IPPROTO_IP) },
{ MP_ROM_QSTR(MP_QSTR_SOL_SOCKET), MP_ROM_INT(SOL_SOCKET) },
{ MP_ROM_QSTR(MP_QSTR_SO_REUSEADDR), MP_ROM_INT(SO_REUSEADDR) },
{ MP_ROM_QSTR(MP_QSTR_IP_ADD_MEMBERSHIP), MP_ROM_INT(IP_ADD_MEMBERSHIP) },
};
STATIC MP_DEFINE_CONST_DICT(mp_module_socket_globals, mp_module_socket_globals_table);
const mp_obj_module_t mp_module_usocket = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&mp_module_socket_globals,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modsocket.c | C | apache-2.0 | 29,996 |
import gc
import uos
from flashbdev import bdev
try:
if bdev:
uos.mount(bdev, "/")
except OSError:
import inisetup
vfs = inisetup.setup()
gc.collect()
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modules/_boot.py | Python | apache-2.0 | 174 |
# APA106driver for MicroPython on ESP32
# MIT license; Copyright (c) 2016 Damien P. George
from neopixel import NeoPixel
class APA106(NeoPixel):
ORDER = (0, 1, 2, 3)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modules/apa106.py | Python | apache-2.0 | 173 |
from esp32 import Partition
bdev = Partition.find(Partition.TYPE_DATA, label="vfs")
bdev = bdev[0] if bdev else None
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modules/flashbdev.py | Python | apache-2.0 | 118 |
import uos
from flashbdev import bdev
def check_bootsec():
buf = bytearray(bdev.ioctl(5, 0)) # 5 is SEC_SIZE
bdev.readblocks(0, buf)
empty = True
for b in buf:
if b != 0xFF:
empty = False
break
if empty:
return True
fs_corrupted()
def fs_corrupted():
import time
while 1:
print(
"""\
The filesystem appears to be corrupted. If you had important data there, you
may want to make a flash snapshot to try to recover it. Otherwise, perform
factory reprogramming of MicroPython firmware (completely erase flash, followed
by firmware programming).
"""
)
time.sleep(3)
def setup():
check_bootsec()
print("Performing initial setup")
uos.VfsLfs2.mkfs(bdev)
vfs = uos.VfsLfs2(bdev)
uos.mount(vfs, "/")
with open("boot.py", "w") as f:
f.write(
"""\
# This file is executed on every boot (including wake-boot from deepsleep)
#import esp
#esp.osdebug(None)
#import webrepl
#webrepl.start()
"""
)
return vfs
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modules/inisetup.py | Python | apache-2.0 | 1,066 |
try:
import usocket as socket
except:
import socket
try:
import ustruct as struct
except:
import struct
# (date(2000, 1, 1) - date(1900, 1, 1)).days * 24*60*60
NTP_DELTA = 3155673600
# The NTP host can be configured at runtime by doing: ntptime.host = 'myhost.org'
host = "pool.ntp.org"
def time():
NTP_QUERY = bytearray(48)
NTP_QUERY[0] = 0x1B
addr = socket.getaddrinfo(host, 123)[0][-1]
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
s.settimeout(1)
res = s.sendto(NTP_QUERY, addr)
msg = s.recv(48)
finally:
s.close()
val = struct.unpack("!I", msg[40:44])[0]
return val - NTP_DELTA
# There's currently no timezone support in MicroPython, and the RTC is set in UTC time.
def settime():
t = time()
import machine
import utime
tm = utime.gmtime(t)
machine.RTC().datetime((tm[0], tm[1], tm[2], tm[6] + 1, tm[3], tm[4], tm[5], 0))
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modules/ntptime.py | Python | apache-2.0 | 946 |
from minicv import ML
AI_ENGINE_ALIYUN = 1
AI_ENGINE_NATIVE = 2
class AI:
def __init__(self, type=AI_ENGINE_NATIVE, accessKey=None, accessSecret=None, ossEndpoint=None, ossBucket=None):
self.type = type
self.ml = ML()
if (self.type == AI_ENGINE_ALIYUN):
self.ml.open(self.ml.ML_ENGINE_CLOUD)
if not accessKey or not accessSecret:
print('access key can not be null')
return
else:
self.ml.config(accessKey, accessSecret, ossEndpoint, ossBucket)
else:
print('now only support cloud ai, not support nativate ai yet')
print("Please use example: ai = AI(AI.AI_ENGINE_CLOUD, 'Your-Access-Key', 'Your-Access-Secret')")
# 人脸比对
def compareFace(self, imagePath, compareFacePath):
self.ml.setInputData(imagePath, compareFacePath)
self.ml.loadNet("FacebodyComparing")
self.ml.predict()
resp = self.ml.getPredictResponses(None)
self.ml.unLoadNet()
return resp
# 人体检测
def detectPedestrian(self, imagePath):
self.ml.setInputData(imagePath)
self.ml.loadNet("DetectPedestrian")
self.ml.predict()
resp = self.ml.getPredictResponses(None)
self.ml.unLoadNet()
return resp
# 水果检测
def detectFruits(self, imagePath):
self.ml.setInputData(imagePath, None)
self.ml.loadNet("DetectFruits")
self.ml.predict()
resp = self.ml.getPredictResponses(None)
self.ml.unLoadNet()
return resp
# 车牌识别
def recognizeLicensePlate(self, imagePath):
self.ml.setInputData(imagePath)
self.ml.loadNet("RecognizeLicensePlate")
self.ml.predict()
resp = self.ml.getPredictResponses(None)
self.ml.unLoadNet()
return resp
def __del__(self):
try:
self.ml.close()
del self.type
del self.ml
except Exception:
pass
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modules/uai.py | Python | apache-2.0 | 2,033 |