18069996051/mixly3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore(board): micropython_esp32s3调整部分py模块的缩进格式

Browse Source 
调整部分模块的缩进格式，防止构建句法树时报错
This commit is contained in:
王立帮
2025-10-24 22:35:16 +08:00
parent 714f157551
commit 17ad6d31a0
14 changed files with 1167 additions and 1053 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
boards/default_src/micropython_esp32s3/origin/build/lib/camera.py
View File

@@ -7,12 +7,14 @@ MicroPython library for the Camera(Inherit C module)
"""
import time
import base64, jpeg
import base64
import jpeg
from _camera import *
from jpeg import Encoder
from machine import SoftI2C, Pin
from mixgo_sant import onboard_bot
class Camera(Camera):
def __init__(self, frame_size=FrameSize.R240X240, pixel_format=PixelFormat.RGB565, hmirror=False, vflip=False, **kwargs):
onboard_bot.cam_en(1, 150)
@@ -21,7 +23,7 @@ class Camera(Camera):
time.sleep_ms(50)
self.set_vflip(not vflip)
time.sleep_ms(50)
SoftI2C(scl=Pin(47), sda=Pin(48), freq=400000) #恢复I2C
SoftI2C(scl=Pin(47), sda=Pin(48), freq=400000) # 恢复I2C
def deinit(self):
super().deinit()

39
boards/default_src/micropython_esp32s3/origin/build/lib/ci1302x.py
View File

@@ -7,25 +7,26 @@ MicroPython library for the CI130Xx (ASR-I2C)
"""
from ci130x import CI130X
class CI1302(CI130X):
def __init__(self, i2c_bus, func, addr=0x64):
self._device = i2c_bus
self._address = addr
self._cmd_id = None
self._func = func
def __init__(self, i2c_bus, func, addr=0x64):
self._device = i2c_bus
self._address = addr
self._cmd_id = None
self._func = func
def _wreg(self, reg):
'''Write memory address'''
try:
self._device.writeto(self._address, reg)
except:
self._func(1, 700) #Power on
self._device.writeto(self._address, reg)
def _wreg(self, reg):
'''Write memory address'''
try:
self._device.writeto(self._address, reg)
except:
self._func(1, 700) # Power on
self._device.writeto(self._address, reg)
def _rreg(self, reg, nbytes=1):
'''Read memory address'''
try:
return self._device.readfrom_mem(self._address, reg, nbytes)
except:
self._func(1, 700) #Power on
return self._device.readfrom_mem(self._address, reg, nbytes)
def _rreg(self, reg, nbytes=1):
'''Read memory address'''
try:
return self._device.readfrom_mem(self._address, reg, nbytes)
except:
self._func(1, 700) # Power on
return self._device.readfrom_mem(self._address, reg, nbytes)

152
boards/default_src/micropython_esp32s3/origin/build/lib/es8374.py
View File

@@ -25,65 +25,70 @@ class ES8374:
self.configI2SFormat(_ES_MODULE_ADC_DAC, _FMT_I2S_NORMAL)
def _readReg(self, regAddr):
return self.i2c_bus.readfrom_mem(self.i2c_addr, regAddr, 1)[0]
return self.i2c_bus.readfrom_mem(self.i2c_addr, regAddr, 1)[0]
def _writeReg(self, regAddr, data):
self.i2c_bus.writeto_mem(self.i2c_addr, regAddr, data.to_bytes(1, 'little'))
self.i2c_bus.writeto_mem(
self.i2c_addr, regAddr, data.to_bytes(1, 'little'))
def init_reg(self, ms_mode, fmt, out_channel, in_channel):
self._writeReg(0x00, 0x3F)# IC Rst start
self._writeReg(0x00, 0x03)# IC Rst stop
self._writeReg(0x01, 0x7F)# IC clk on # M ORG 7F
self._writeReg(0x0f, (self._readReg(0x0F) & 0x7f) | (ms_mode << 7))# CODEC IN I2S SLAVE MODE
self._writeReg(0x00, 0x3F) # IC Rst start
self._writeReg(0x00, 0x03) # IC Rst stop
self._writeReg(0x01, 0x7F) # IC clk on # M ORG 7F
self._writeReg(0x0f, (self._readReg(0x0F) & 0x7f) | (ms_mode << 7)) # CODEC IN I2S SLAVE MODE
self._writeReg(0x6F, 0xA0)# pll set:mode enable
self._writeReg(0x72, 0x41)# pll set:mode set
self._writeReg(0x09, 0x01)# pll set:reset on ,set start
self._writeReg(0x0C, 0x22)# pll set:k
self._writeReg(0x0D, 0x2E)# pll set:k
self._writeReg(0x0E, 0xC6)# pll set:k
self._writeReg(0x0A, 0x3A)# pll set:
self._writeReg(0x0B, 0x07)# pll set:n
self._writeReg(0x09, 0x41)# pll set:reset off ,set stop
self._writeReg(0x6F, 0xA0) # pll set:mode enable
self._writeReg(0x72, 0x41) # pll set:mode set
self._writeReg(0x09, 0x01) # pll set:reset on ,set start
self._writeReg(0x0C, 0x22) # pll set:k
self._writeReg(0x0D, 0x2E) # pll set:k
self._writeReg(0x0E, 0xC6) # pll set:k
self._writeReg(0x0A, 0x3A) # pll set:
self._writeReg(0x0B, 0x07) # pll set:n
self._writeReg(0x09, 0x41) # pll set:reset off ,set stop
self.i2sConfigClock()
self._writeReg(0x24, 0x08)# adc set
self._writeReg(0x36, 0x00)# dac set
self._writeReg(0x12, 0x30)# timming set
self._writeReg(0x13, 0x20)# timming set
self._writeReg(0x24, 0x08) # adc set
self._writeReg(0x36, 0x00) # dac set
self._writeReg(0x12, 0x30) # timming set
self._writeReg(0x13, 0x20) # timming set
self.configI2SFormat(_ES_MODULE_ADC, fmt)
self.configI2SFormat(_ES_MODULE_DAC, fmt)
self._writeReg(0x21, 0x50)# adc set: SEL LIN1 CH+PGAGAIN=0DB
self._writeReg(0x22, 0xFF)# adc set: PGA GAIN=0DB
self._writeReg(0x21, 0x14)# adc set: SEL LIN1 CH+PGAGAIN=18DB
self._writeReg(0x22, 0x55)# pga = +15db
self._writeReg(0x08, 0x21)# set class d divider = 33, to avoid the high frequency tone on laudspeaker
self._writeReg(0x00, 0x80)# IC START
self._writeReg(0x21, 0x50) # adc set: SEL LIN1 CH+PGAGAIN=0DB
self._writeReg(0x22, 0xFF) # adc set: PGA GAIN=0DB
self._writeReg(0x21, 0x14) # adc set: SEL LIN1 CH+PGAGAIN=18DB
self._writeReg(0x22, 0x55) # pga = +15db
# set class d divider = 33, to avoid the high frequency tone on laudspeaker
self._writeReg(0x08, 0x21)
self._writeReg(0x00, 0x80) # IC START
time.sleep(0.05)
self._writeReg(0x25, 0x00)# ADCVOLUME on
self._writeReg(0x38, 0x00)# DACVOLUME on
self._writeReg(0x14, 0x8A)# IC START
self._writeReg(0x15, 0x40)# IC START
self._writeReg(0x1A, 0xA0)# monoout set
self._writeReg(0x1B, 0x19)# monoout set
self._writeReg(0x1C, 0x90)# spk set
self._writeReg(0x1D, 0x01)# spk set
self._writeReg(0x1F, 0x00)# spk set
self._writeReg(0x1E, 0x20)# spk on
self._writeReg(0x28, 0x70)# alc set 0x70
#self._writeReg(0x26, 0x4E)# alc set
#self._writeReg(0x27, 0x10)# alc set
#self._writeReg(0x29, 0x00)# alc set
#self._writeReg(0x2B, 0x00)# alc set
self._writeReg(0x25, 0x00)# ADCVOLUME on
self._writeReg(0x38, 0x00)# DACVOLUME on
self._writeReg(0x37, 0x30)# dac set
self._writeReg(0x6D, 0x60)# SEL:GPIO1=DMIC CLK OUT+SEL:GPIO2=PLL CLK OUT
self._writeReg(0x71, 0x05)# for automute setting
self._writeReg(0x25, 0x00) # ADCVOLUME on
self._writeReg(0x38, 0x00) # DACVOLUME on
self._writeReg(0x14, 0x8A) # IC START
self._writeReg(0x15, 0x40) # IC START
self._writeReg(0x1A, 0xA0) # monoout set
self._writeReg(0x1B, 0x19) # monoout set
self._writeReg(0x1C, 0x90) # spk set
self._writeReg(0x1D, 0x01) # spk set
self._writeReg(0x1F, 0x00) # spk set
self._writeReg(0x1E, 0x20) # spk on
self._writeReg(0x28, 0x70) # alc set 0x70
# self._writeReg(0x26, 0x4E)# alc set
# self._writeReg(0x27, 0x10)# alc set
# self._writeReg(0x29, 0x00)# alc set
# self._writeReg(0x2B, 0x00)# alc set
self._writeReg(0x25, 0x00) # ADCVOLUME on
self._writeReg(0x38, 0x00) # DACVOLUME on
self._writeReg(0x37, 0x30) # dac set
# SEL:GPIO1=DMIC CLK OUT+SEL:GPIO2=PLL CLK OUT
self._writeReg(0x6D, 0x60)
self._writeReg(0x71, 0x05) # for automute setting
self._writeReg(0x73, 0x70)
self.configDACOutput(out_channel)# 0x3c Enable DAC and Enable Lout/Rout/1/2
self.configADCInput(in_channel)# 0x00 LINSEL & RINSEL, LIN1/RIN1 as ADC Input DSSEL,use one DS Reg11 DSR, LINPUT1-RINPUT1
# 0x3c Enable DAC and Enable Lout/Rout/1/2
self.configDACOutput(out_channel)
# 0x00 LINSEL & RINSEL, LIN1/RIN1 as ADC Input DSSEL,use one DS Reg11 DSR, LINPUT1-RINPUT1
self.configADCInput(in_channel)
self.voice_volume(95)
self._writeReg(0x37, 0x00)# dac set
self._writeReg(0x37, 0x00) # dac set
'''
reg = self._readReg(0x1a) # disable lout
reg |= 0x08
@@ -104,34 +109,37 @@ class ES8374:
self._writeReg(0x1E, 0xa0) # disable class d
self.voice_mute(0)
'''
def stop(self):
self.voice_mute(1)
self._writeReg(0x1a, self._readReg(0x1a)| 0x08)
self._writeReg(0x1a, self._readReg(0x1a)& 0xdf)
self._writeReg(0x1D, 0x12)# mute speaker
self._writeReg(0x1E, 0x20)# disable class d
self._writeReg(0x15, self._readReg(0x15)| 0x20)
self._writeReg(0x10, self._readReg(0x10)| 0xc0)
self._writeReg(0x21, self._readReg(0x21)| 0xc0)
self._writeReg(0x1a, self._readReg(0x1a) | 0x08)
self._writeReg(0x1a, self._readReg(0x1a) & 0xdf)
self._writeReg(0x1D, 0x12) # mute speaker
self._writeReg(0x1E, 0x20) # disable class d
self._writeReg(0x15, self._readReg(0x15) | 0x20)
self._writeReg(0x10, self._readReg(0x10) | 0xc0)
self._writeReg(0x21, self._readReg(0x21) | 0xc0)
def i2sConfigClock(self):
self._writeReg(0x0f, (self._readReg(0x0F) & 0xe0) | _MCLK_DIV)
self._writeReg(0x06, _LCLK_DIV >> 8)# ADCFsMode,singel SPEED,RATIO=256
self._writeReg(0x07, _LCLK_DIV & 0xFF)# ADCFsMode,singel SPEED,RATIO=256
# ADCFsMode,singel SPEED,RATIO=256
self._writeReg(0x06, _LCLK_DIV >> 8)
# ADCFsMode,singel SPEED,RATIO=256
self._writeReg(0x07, _LCLK_DIV & 0xFF)
def configI2SFormat(self, mode, fmt):
fmt_tmp = ((fmt & 0xf0) >> 4)
fmt_i2s = fmt & 0x0f
fmt_i2s = fmt & 0x0f
if (mode == _ES_MODULE_ADC or mode == _ES_MODULE_ADC_DAC):
reg = self._readReg(0x10)
reg &= 0xfc
self._writeReg(0x10, (reg|fmt_i2s))
self._writeReg(0x10, (reg | fmt_i2s))
self.setBitsPerSample(mode, 3)
if (mode == _ES_MODULE_DAC or mode == _ES_MODULE_ADC_DAC):
reg = self._readReg(0x11)
reg &= 0xfc
self._writeReg(0x11, (reg|fmt_i2s))
self._writeReg(0x11, (reg | fmt_i2s))
self.setBitsPerSample(mode, 3)
# set Bits Per Sample
@@ -140,26 +148,26 @@ class ES8374:
if (mode == _ES_MODULE_ADC or mode == _ES_MODULE_ADC_DAC):
reg = self._readReg(0x10)
reg &= 0xe3
self._writeReg(0x10, (reg| (bits << 2)))
self._writeReg(0x10, (reg | (bits << 2)))
if (mode == _ES_MODULE_DAC or mode == _ES_MODULE_ADC_DAC):
reg = self._readReg(0x11)
reg &= 0xe3
self._writeReg(0x11, (reg| (bits << 2)))
self._writeReg(0x11, (reg | (bits << 2)))
def configDACOutput(self, output):
self._writeReg(0x1d, 0x02)
reg = self._readReg(0x1c) # set spk mixer
reg = self._readReg(0x1c) # set spk mixer
reg |= 0x80
self._writeReg(0x1c, reg)
self._writeReg(0x1D, 0x02) # spk set
self._writeReg(0x1F, 0x00) # spk set
self._writeReg(0x1E, 0xA0) # spk on
self._writeReg(0x1D, 0x02) # spk set
self._writeReg(0x1F, 0x00) # spk set
self._writeReg(0x1E, 0xA0) # spk on
def configADCInput(self, input):
reg = self._readReg(0x21)
reg = (reg & 0xcf) | 0x24
self._writeReg( 0x21, reg)
self._writeReg(0x21, reg)
def mic_volume(self, volume=None):
if volume is None:
@@ -171,17 +179,17 @@ class ES8374:
if volume is None:
return round(100 - self._readReg(0x38) * 100 / 192)
else:
self._writeReg(0x38, (100 - volume) * 192 // 100)
self._writeReg(0x38, (100 - volume) * 192 // 100)
def voice_mute(self, enable=None):
if enable is None:
return True if self._readReg(0x36) & 0x40 else False
else:
self._writeReg(0x36, (self._readReg(0x36)& 0xdf) | (enable << 5))
self._writeReg(0x36, (self._readReg(0x36) & 0xdf) | (enable << 5))
def mic_gain(self, gain):
gain_n = max(min(gain, 15), 0)
self._writeReg(0x22, (gain_n | (gain_n<<4))) # MIC PGA -3.5db ~ 24db
self._writeReg(0x22, (gain_n | (gain_n << 4))) # MIC PGA -3.5db ~ 24db
def pga_enable(self, enable):
self._writeReg(0x21, (self._readReg(0x21) & 0xfb) | (enable << 2)) # MIC PGA 0db or 15db
def pga_enable(self, enable):
self._writeReg(0x21, (self._readReg(0x21) & 0xfb) | (enable << 2)) # MIC PGA 0db or 15db

358
boards/default_src/micropython_esp32s3/origin/build/lib/mixgo_nova.py
View File

@@ -10,8 +10,12 @@ Micropython library for the mixgo_zero Zi Onboard resources
dahanzimin From the Mixly Team
"""
from ws2812 import NeoPixel
from machine import *
import time, gc, st7735, math
import time
import gc
import st7735
import math
'''RTC'''
rtc_clock = RTC()
@@ -24,210 +28,228 @@ onboard_i2c_scan = onboard_i2c.scan()
'''SPI-onboard'''
try:
import _boot
onboard_spi = _boot.onboard_spi
onboard_spi.init(baudrate=50000000)
import _boot
onboard_spi = _boot.onboard_spi
onboard_spi.init(baudrate=50000000)
except:
onboard_spi = SPI(1, baudrate=50000000, polarity=0, phase=0)
onboard_spi = SPI(1, baudrate=50000000, polarity=0, phase=0)
'''TFT/128*160'''
onboard_tft = st7735.ST7735(onboard_spi, 160, 128, dc_pin=18, cs_pin=45, bl_pin=14, font_address=0x700000)
onboard_tft = st7735.ST7735(
onboard_spi, 160, 128, dc_pin=18, cs_pin=45, bl_pin=14, font_address=0x700000)
'''ACC-Sensor'''
try :
import mxc6655xa
onboard_acc = mxc6655xa.MXC6655XA(onboard_i2c, front=True)
try:
import mxc6655xa
onboard_acc = mxc6655xa.MXC6655XA(onboard_i2c, front=True)
except Exception as e:
print("Warning: Failed to communicate with MXC6655XA (ACC) or",e)
print("Warning: Failed to communicate with MXC6655XA (ACC) or", e)
'''ALS_PS-Sensor *2'''
try :
import ltr553als
onboard_als_l = ltr553als.LTR_553ALS(onboard_i2c)
try:
import ltr553als
onboard_als_l = ltr553als.LTR_553ALS(onboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with TR_553ALS (ALS&PS) or",e)
print("Warning: Failed to communicate with TR_553ALS (ALS&PS) or", e)
try :
import ltr553als
onboard_als_r = ltr553als.LTR_553ALS(onboard_i2c_soft)
try:
import ltr553als
onboard_als_r = ltr553als.LTR_553ALS(onboard_i2c_soft)
except Exception as e:
print("Warning: Failed to communicate with TR_553ALS (ALS&PS) or",e)
print("Warning: Failed to communicate with TR_553ALS (ALS&PS) or", e)
'''BPS-Sensor'''
if 0x76 in onboard_i2c_scan:
try :
import hp203x
onboard_bps = hp203x.HP203X(onboard_i2c_soft)
except Exception as e:
print("Warning: Failed to communicate with HP203X (BPS) or",e)
try:
import hp203x
onboard_bps = hp203x.HP203X(onboard_i2c_soft)
except Exception as e:
print("Warning: Failed to communicate with HP203X (BPS) or", e)
'''THS-Sensor'''
if 0x38 in onboard_i2c_scan:
try :
import ahtx0
onboard_ths = ahtx0.AHTx0(onboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with AHTx0 (THS) or",e)
try:
import ahtx0
onboard_ths = ahtx0.AHTx0(onboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with AHTx0 (THS) or", e)
if 0x70 in onboard_i2c_scan:
try :
import shtc3
onboard_ths = shtc3.SHTC3(onboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with GXHTC3 (THS) or",e)
try:
import shtc3
onboard_ths = shtc3.SHTC3(onboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with GXHTC3 (THS) or", e)
'''RFID-Sensor'''
try :
import rc522
onboard_rfid = rc522.RC522(onboard_i2c)
try:
import rc522
onboard_rfid = rc522.RC522(onboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with RC522 (RFID) or",e)
print("Warning: Failed to communicate with RC522 (RFID) or", e)
'''MGS-Sensor'''
try :
import mmc5603
onboard_mgs = mmc5603.MMC5603(onboard_i2c)
try:
import mmc5603
onboard_mgs = mmc5603.MMC5603(onboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with MMC5603 (MGS) or",e)
print("Warning: Failed to communicate with MMC5603 (MGS) or", e)
'''2RGB_WS2812'''
from ws2812 import NeoPixel
'''2RGB_WS2812'''
onboard_rgb = NeoPixel(Pin(38), 4)
'''5KEY_Sensor'''
class KEYSensor:
def __init__(self, pin, range):
self.pin = pin
self.adc = ADC(Pin(pin), atten=ADC.ATTN_0DB)
self.range = range
self.flag = True
def _value(self):
values = []
for _ in range(50):
values.append(self.adc.read())
time.sleep_us(2)
return (self.range-200) < min(values) < (self.range+200)
def __init__(self, pin, range):
self.pin = pin
self.adc = ADC(Pin(pin), atten=ADC.ATTN_0DB)
self.range = range
self.flag = True
def get_presses(self, delay = 1):
last_time,presses = time.time(), 0
while time.time() < last_time + delay:
time.sleep_ms(50)
if self.was_pressed():
presses += 1
return presses
def _value(self):
values = []
for _ in range(50):
values.append(self.adc.read())
time.sleep_us(2)
return (self.range-200) < min(values) < (self.range+200)
def is_pressed(self):
return self._value()
def get_presses(self, delay=1):
last_time, presses = time.time(), 0
while time.time() < last_time + delay:
time.sleep_ms(50)
if self.was_pressed():
presses += 1
return presses
def was_pressed(self):
if(self._value() != self.flag):
self.flag = self._value()
if self.flag :
return True
else:
return False
def is_pressed(self):
return self._value()
def was_pressed(self):
if (self._value() != self.flag):
self.flag = self._value()
if self.flag:
return True
else:
return False
def irq(self, handler, trigger):
Pin(self.pin, Pin.IN).irq(handler=handler, trigger=trigger)
def irq(self, handler, trigger):
Pin(self.pin, Pin.IN).irq(handler = handler, trigger = trigger)
'''1KEY_Button'''
class Button(KEYSensor):
def __init__(self, pin):
self.pin = pin
self.key = Pin(pin, Pin.IN)
self.flag = True
def _value(self):
return not self.key.value()
class Button(KEYSensor):
def __init__(self, pin):
self.pin = pin
self.key = Pin(pin, Pin.IN)
self.flag = True
def _value(self):
return not self.key.value()
B1key = Button(0)
B2key = KEYSensor(17,0)
A1key = KEYSensor(17,2900)
A2key = KEYSensor(17,2300)
A3key = KEYSensor(17,1650)
A4key = KEYSensor(17,850)
B2key = KEYSensor(17, 0)
A1key = KEYSensor(17, 2900)
A2key = KEYSensor(17, 2300)
A3key = KEYSensor(17, 1650)
A4key = KEYSensor(17, 850)
'''2-TouchPad'''
class Touch_Pad:
__species = {}
__first_init = True
def __new__(cls, pin, *args, **kwargs):
if pin not in cls.__species.keys():
cls.__first_init = True
cls.__species[pin]=object.__new__(cls)
return cls.__species[pin]
__species = {}
__first_init = True
def __init__(self, pin, default=30000):
if self.__first_init:
self.__first_init = False
from machine import TouchPad
self._pin = TouchPad(Pin(pin))
self.raw = self._pin.read()
if self.raw >= default * 1.5:
self.raw = default
def __new__(cls, pin, *args, **kwargs):
if pin not in cls.__species.keys():
cls.__first_init = True
cls.__species[pin] = object.__new__(cls)
return cls.__species[pin]
def touch(self,value=None ):
return self._pin.read() > value if value else self._pin.read()
def __init__(self, pin, default=30000):
if self.__first_init:
self.__first_init = False
from machine import TouchPad
self._pin = TouchPad(Pin(pin))
self.raw = self._pin.read()
if self.raw >= default * 1.5:
self.raw = default
def touch(self, value=None):
return self._pin.read() > value if value else self._pin.read()
# Touch with function call
def touched(pin, value=60000):
return Touch_Pad(pin).touch(value)
#Touch with function call
def touched(pin,value=60000):
return Touch_Pad(pin).touch(value)
def touch_slide(pina, pinb):
return ((Touch_Pad(pina).touch() - Touch_Pad(pina).raw) - (Touch_Pad(pinb).touch() - Touch_Pad(pinb).raw)) // 10
return ((Touch_Pad(pina).touch() - Touch_Pad(pina).raw) - (Touch_Pad(pinb).touch() - Touch_Pad(pinb).raw)) // 10
'''2LED-Tristate'''
class LED_T:
def __init__(self, pin, timer_id=3):
self._pin = pin
self._pwm = 0
self._index_pwm = [0,0]
Timer(timer_id, freq=2500, mode=Timer.PERIODIC, callback=self.tim_callback)
def __init__(self, pin, timer_id=3):
self._pin = pin
self._pwm = 0
self._index_pwm = [0, 0]
Timer(timer_id, freq=2500, mode=Timer.PERIODIC, callback=self.tim_callback)
def _cutonoff(self,val):
if val == 0:
Pin(self._pin, Pin.IN)
elif val == 1:
Pin(self._pin, Pin.OUT).value(1)
elif val == -1:
Pin(self._pin, Pin.OUT).value(0)
def _cutonoff(self, val):
if val == 0:
Pin(self._pin, Pin.IN)
elif val == 1:
Pin(self._pin, Pin.OUT).value(1)
elif val == -1:
Pin(self._pin, Pin.OUT).value(0)
def tim_callback(self,tim):
if self._pwm <= 25:
if self._pwm * 4 < self._index_pwm[0]:
self._cutonoff(1)
else:
self._cutonoff(0)
else:
if (self._pwm - 26) * 4 < self._index_pwm[1]:
self._cutonoff(-1)
else:
self._cutonoff(0)
self._pwm = self._pwm + 1 if self._pwm <= 51 else 0
def tim_callback(self, tim):
if self._pwm <= 25:
if self._pwm * 4 < self._index_pwm[0]:
self._cutonoff(1)
else:
self._cutonoff(0)
else:
if (self._pwm - 26) * 4 < self._index_pwm[1]:
self._cutonoff(-1)
else:
self._cutonoff(0)
self._pwm = self._pwm + 1 if self._pwm <= 51 else 0
def setbrightness(self,index,val):
if not 0 <= val <= 100:
raise ValueError("Brightness must be in the range: 0~100%")
self._index_pwm[index-1] = val
def getbrightness(self,index):
return self._index_pwm[index-1]
def setbrightness(self, index, val):
if not 0 <= val <= 100:
raise ValueError("Brightness must be in the range: 0~100%")
self._index_pwm[index-1] = val
def setonoff(self,index,val):
if(val == -1):
if self._index_pwm[index-1] < 50:
self._index_pwm[index-1] = 100
else:
self._index_pwm[index-1] = 0
elif(val == 1):
self._index_pwm[index-1] = 100
elif(val == 0):
self._index_pwm[index-1] = 0
def getbrightness(self, index):
return self._index_pwm[index-1]
def setonoff(self, index, val):
if (val == -1):
if self._index_pwm[index-1] < 50:
self._index_pwm[index-1] = 100
else:
self._index_pwm[index-1] = 0
elif (val == 1):
self._index_pwm[index-1] = 100
elif (val == 0):
self._index_pwm[index-1] = 0
def getonoff(self, index):
return True if self._index_pwm[index-1] > 0 else False
'''2LED-Independent'''
def getonoff(self,index):
return True if self._index_pwm[index-1] > 0 else False
'''2LED-Independent'''
class LED_I:
def __init__(self, pins=[]):
self._pins = [PWM(Pin(pin), duty_u16=0) for pin in pins]
@@ -244,44 +266,47 @@ class LED_I:
def setonoff(self, index, val):
if val == -1:
self.setbrightness(index, 100) if self.getbrightness(index) < 50 else self.setbrightness(index, 0)
self.setbrightness(index, 100) if self.getbrightness(
index) < 50 else self.setbrightness(index, 0)
elif val == 1:
self.setbrightness(index, 100)
self.setbrightness(index, 100)
elif val == 0:
self.setbrightness(index, 0)
self.setbrightness(index, 0)
def getonoff(self, index):
return True if self.getbrightness(index) > 50 else False
onboard_led=LED_I(pins=[42, 13]) if version else LED_T(42, timer_id=3)
onboard_led = LED_I(pins=[42, 13]) if version else LED_T(42, timer_id=3)
class Clock:
def __init__(self, x, y, radius, color, oled=onboard_tft): #定义时钟中心点和半径
def __init__(self, x, y, radius, color, oled=onboard_tft): # 定义时钟中心点和半径
self.display = oled
self.xc = x
self.yc = y
self.r = radius
self.color= color
self.color = color
self.hour = 0
self.min = 0
self.sec = 0
def set_time(self, h, m, s): #设定时间
def set_time(self, h, m, s): # 设定时间
self.hour = h
self.min = m
self.sec = s
def set_rtctime(self): #设定时间
def set_rtctime(self): # 设定时间
t = rtc_clock.datetime()
self.hour = t[4]
self.min = t[5]
self.sec = t[6]
def drawDial(self,color): #画钟表刻度
def drawDial(self, color): # 画钟表刻度
r_tic1 = self.r - 1
r_tic2 = self.r - 2
self.display.ellipse(self.xc, self.yc, self.r,self.r, self.color)
self.display.ellipse(self.xc, self.yc, 2, 2, self.color,True)
self.display.ellipse(self.xc, self.yc, self.r, self.r, self.color)
self.display.ellipse(self.xc, self.yc, 2, 2, self.color, True)
for h in range(12):
at = math.pi * 2.0 * h / 12.0
@@ -291,28 +316,28 @@ class Clock:
y2 = round(self.yc - r_tic2 * math.cos(at))
self.display.line(x1, y1, x2, y2, color)
def drawHour(self,color): #画时针
def drawHour(self, color): # 画时针
r_hour = int(self.r / 10.0 * 5)
ah = math.pi * 2.0 * ((self.hour % 12) + self.min / 60.0) / 12.0
xh = int(self.xc + r_hour * math.sin(ah))
yh = int(self.yc - r_hour * math.cos(ah))
self.display.line(self.xc, self.yc, xh, yh, color)
def drawMin(self,color): #画分针
def drawMin(self, color): # 画分针
r_min = int(self.r / 10.0 * 7)
am = math.pi * 2.0 * self.min / 60.0
xm = round(self.xc + r_min * math.sin(am))
ym = round(self.yc - r_min * math.cos(am))
self.display.line(self.xc, self.yc, xm, ym, color)
def drawSec(self,color): #画秒针
def drawSec(self, color): # 画秒针
r_sec = int(self.r / 10.0 * 9)
asec = math.pi * 2.0 * self.sec / 60.0
xs = round(self.xc + r_sec * math.sin(asec))
ys = round(self.yc - r_sec * math.cos(asec))
self.display.line(self.xc, self.yc, xs, ys, color)
def draw_clock(self): #画完整钟表
def draw_clock(self): # 画完整钟表
self.drawDial(self.color)
self.drawHour(self.color)
self.drawMin(self.color)
@@ -320,10 +345,11 @@ class Clock:
self.display.show()
self.clear(0)
def clear(self,color=0): #清除
def clear(self, color=0): # 清除
self.drawHour(color)
self.drawMin(color)
self.drawSec(color)
'''Reclaim memory'''
gc.collect()

119
boards/default_src/micropython_esp32s3/origin/build/lib/mixgo_nova_voice.py
View File

@@ -20,70 +20,81 @@ sample_rate = 22050
ob_code = es8374.ES8374(onboard_i2c)
time.sleep(0.2)
#ps 特殊改双全工i2s支持
ob_audio = I2S(0, sck=Pin(34), ws=Pin(47), dout=Pin(48), din=Pin(33), mck=Pin(35), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
# ps 特殊改双全工i2s支持
ob_audio = I2S(0, sck=Pin(34), ws=Pin(47), dout=Pin(48), din=Pin(33), mck=Pin(35), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
spk_midi = music_spk.MIDI(ob_audio, sample_rate)
def u2s(n):
return n if n < (1 << 15) else n - (1 << 16)
return n if n < (1 << 15) else n - (1 << 16)
def sound_level():
buf = bytearray(100)
values = []
ob_audio.readinto(buf)
for i in range(len(buf)//2):
values.append(u2s(buf[i * 2] | buf[i * 2 + 1]<<8))
return max(values) - min(values)
buf = bytearray(100)
values = []
ob_audio.readinto(buf)
for i in range(len(buf)//2):
values.append(u2s(buf[i * 2] | buf[i * 2 + 1] << 8))
return max(values) - min(values)
def play_audio(path):
file = open(path, 'rb')
header = file.read(44)
if header[8:12] != b'WAVE':
raise Error('not a WAVE file')
_rate = ustruct.unpack('<I', header[24:28])[0]
print("sample_rate", _rate)
file.seek(44)
ob_audio = I2S(0, sck=Pin(34), ws=Pin(47), dout=Pin(48), din=Pin(33), mck=Pin(35), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=_rate, ibuf=20000)
while True:
block = file.read(1024)
if not block:
break
ob_audio.write(block)
ob_audio = I2S(0, sck=Pin(34), ws=Pin(47), dout=Pin(48), din=Pin(33), mck=Pin(35), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
file.close()
file = open(path, 'rb')
header = file.read(44)
if header[8:12] != b'WAVE':
raise Error('not a WAVE file')
_rate = ustruct.unpack('<I', header[24:28])[0]
print("sample_rate", _rate)
file.seek(44)
ob_audio = I2S(0, sck=Pin(34), ws=Pin(47), dout=Pin(48), din=Pin(33), mck=Pin(
35), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=_rate, ibuf=20000)
while True:
block = file.read(1024)
if not block:
break
ob_audio.write(block)
ob_audio = I2S(0, sck=Pin(34), ws=Pin(47), dout=Pin(48), din=Pin(33), mck=Pin(
35), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
file.close()
def record_audio(path, seconds=5):
ob_audio = I2S(0, sck=Pin(34), ws=Pin(47), dout=Pin(48), din=Pin(33), mck=Pin(35), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate*4, ibuf=20000)
file_size = sample_rate * 16 * 1 * seconds // 8
wav_header = bytearray(44)
wav_header[0:4] = b'RIFF'
ustruct.pack_into('<I', wav_header, 4, file_size + 36)
wav_header[8:40] = b'WAVEfmt \x10\x00\x00\x00\x01\x00\x01\x00"V\x00\x00D\xac\x00\x00\x02\x00\x10\x00data'
ustruct.pack_into('<I', wav_header, 40, file_size)
ob_audio = I2S(0, sck=Pin(34), ws=Pin(47), dout=Pin(48), din=Pin(33), mck=Pin(
35), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate*4, ibuf=20000)
file_size = sample_rate * 16 * 1 * seconds // 8
wav_header = bytearray(44)
wav_header[0:4] = b'RIFF'
ustruct.pack_into('<I', wav_header, 4, file_size + 36)
wav_header[8:40] = b'WAVEfmt \x10\x00\x00\x00\x01\x00\x01\x00"V\x00\x00D\xac\x00\x00\x02\x00\x10\x00data'
ustruct.pack_into('<I', wav_header, 40, file_size)
buf = bytearray(512)
file = open(path, 'wb')
file.write(wav_header)
for _ in range(file_size // 512):
ob_audio.readinto(buf)
file.write(buf)
ob_audio = I2S(0, sck=Pin(34), ws=Pin(47), dout=Pin(48), din=Pin(33), mck=Pin(
35), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
file.close()
buf = bytearray(512)
file = open(path, 'wb')
file.write(wav_header)
for _ in range(file_size // 512):
ob_audio.readinto(buf)
file.write(buf)
ob_audio = I2S(0, sck=Pin(34), ws=Pin(47), dout=Pin(48), din=Pin(33), mck=Pin(35), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
file.close()
def play_audio_url(url):
import urequests
response = urequests.get(url, stream=True)
header = response.raw.read(44)
if header[8:12] != b'WAVE':
raise Error('not a WAVE file')
_rate = ustruct.unpack('<I', header[24:28])[0]
#print("sample_rate", _rate)
ob_audio = I2S(0, sck=Pin(34), ws=Pin(47), dout=Pin(48), din=Pin(33), mck=Pin(35), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=_rate, ibuf=20000)
while True:
block = response.raw.read(1024)
if not block:
break
ob_audio.write(block)
ob_audio = I2S(0, sck=Pin(34), ws=Pin(47), dout=Pin(48), din=Pin(33), mck=Pin(35), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
response.close()
import urequests
response = urequests.get(url, stream=True)
header = response.raw.read(44)
if header[8:12] != b'WAVE':
raise Error('not a WAVE file')
_rate = ustruct.unpack('<I', header[24:28])[0]
# print("sample_rate", _rate)
ob_audio = I2S(0, sck=Pin(34), ws=Pin(47), dout=Pin(48), din=Pin(33), mck=Pin(
35), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=_rate, ibuf=20000)
while True:
block = response.raw.read(1024)
if not block:
break
ob_audio.write(block)
ob_audio = I2S(0, sck=Pin(34), ws=Pin(47), dout=Pin(48), din=Pin(33), mck=Pin(
35), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
response.close()

320
boards/default_src/micropython_esp32s3/origin/build/lib/mixgo_sant.py
View File

@@ -6,14 +6,19 @@ Micropython library for the mixgo_sant Onboard resources
@dahanzimin From the Mixly Team
"""
from music import MIDI
from ws2812x import NeoPixel
from machine import *
import time, gc, st7789_cf, math
import time
import gc
import st7789_cf
import math
'''RTC'''
rtc_clock = RTC()
'''I2C-onboard'''
#inboard_i2c = I2C(0)
# inboard_i2c = I2C(0)
inboard_i2c = SoftI2C(scl=Pin(47), sda=Pin(48), freq=400000)
onboard_i2c = SoftI2C(scl=Pin(47), sda=Pin(38), freq=400000)
@@ -21,111 +26,115 @@ onboard_i2c = SoftI2C(scl=Pin(47), sda=Pin(38), freq=400000)
onboard_spi = SPI(1, baudrate=80000000, polarity=1, phase=1)
'''BOT035-Sensor'''
try :
import sant_bot
onboard_bot = sant_bot.BOT035(inboard_i2c)
try:
import sant_bot
onboard_bot = sant_bot.BOT035(inboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with BOT035 (Coprocessor) or",e)
print("Warning: Failed to communicate with BOT035 (Coprocessor) or", e)
'''TFT/240*240'''
onboard_tft = st7789_cf.ST7789(onboard_spi, 240, 240, dc_pin=45 ,reset=onboard_bot.tft_reset, backlight=onboard_bot.tft_brightness, font_address=0xF00000)
onboard_tft = st7789_cf.ST7789(onboard_spi, 240, 240, dc_pin=45, reset=onboard_bot.tft_reset, backlight=onboard_bot.tft_brightness, font_address=0xF00000)
'''ACC-Sensor'''
try :
import sc7a20
onboard_acc = sc7a20.SC7A20(inboard_i2c)
try:
import sc7a20
onboard_acc = sc7a20.SC7A20(inboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with SC7A20H (ACC) or",e)
print("Warning: Failed to communicate with SC7A20H (ACC) or", e)
'''ALS_PS-Sensor *2'''
try :
import ltr553als
onboard_als_l = ltr553als.LTR_553ALS(onboard_i2c)
try:
import ltr553als
onboard_als_l = ltr553als.LTR_553ALS(onboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with TR_553ALS-L (ALS&PS) or",e)
print("Warning: Failed to communicate with TR_553ALS-L (ALS&PS) or", e)
try :
#import ltr553als
onboard_als_r = ltr553als.LTR_553ALS(inboard_i2c)
try:
# import ltr553als
onboard_als_r = ltr553als.LTR_553ALS(inboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with TR_553ALS-R (ALS&PS) or",e)
print("Warning: Failed to communicate with TR_553ALS-R (ALS&PS) or", e)
'''THS-Sensor'''
try :
import shtc3
onboard_ths = shtc3.SHTC3(inboard_i2c)
try:
import shtc3
onboard_ths = shtc3.SHTC3(inboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with GXHTC3 (THS) or",e)
print("Warning: Failed to communicate with GXHTC3 (THS) or", e)
'''MGS-Sensor'''
try :
import mmc5603
onboard_mgs = mmc5603.MMC5603(inboard_i2c)
try:
import mmc5603
onboard_mgs = mmc5603.MMC5603(inboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with MMC5603 (MGS) or",e)
print("Warning: Failed to communicate with MMC5603 (MGS) or", e)
'''ASR-Sensor'''
try :
from ci1302x import CI1302
onboard_asr = CI1302(inboard_i2c, onboard_bot.asr_en)
try:
from ci1302x import CI1302
onboard_asr = CI1302(inboard_i2c, onboard_bot.asr_en)
except Exception as e:
print("Warning: Failed to communicate with CI130X (ASR) or",e)
print("Warning: Failed to communicate with CI130X (ASR) or", e)
'''2RGB_WS2812'''
from ws2812x import NeoPixel
'''2RGB_WS2812'''
onboard_rgb = NeoPixel(onboard_bot.rgb_sync, 4)
'''1Buzzer-Music'''
from music import MIDI
onboard_music = MIDI(46, pa_ctrl=onboard_bot.spk_en)
'''5KEY_Sensor'''
class KEYSensor:
def __init__(self, pin, range):
self.pin = pin
self.adc = ADC(Pin(pin))
self.adc.atten(ADC.ATTN_0DB)
self.range = range
self.flag = True
def __init__(self, pin, range):
self.pin = pin
self.adc = ADC(Pin(pin))
self.adc.atten(ADC.ATTN_0DB)
self.range = range
self.flag = True
def _value(self):
values = []
for _ in range(25):
values.append(self.adc.read())
time.sleep_us(5)
return (self.range-200) < min(values) < (self.range+200)
def _value(self):
values = []
for _ in range(25):
values.append(self.adc.read())
time.sleep_us(5)
return (self.range-200) < min(values) < (self.range+200)
def get_presses(self, delay = 1):
last_time,presses = time.time(), 0
while time.time() < last_time + delay:
time.sleep_ms(50)
if self.was_pressed():
presses += 1
return presses
def get_presses(self, delay=1):
last_time, presses = time.time(), 0
while time.time() < last_time + delay:
time.sleep_ms(50)
if self.was_pressed():
presses += 1
return presses
def is_pressed(self):
return self._value()
def is_pressed(self):
return self._value()
def was_pressed(self):
if(self._value() != self.flag):
self.flag = self._value()
if self.flag :
return True
else:
return False
def was_pressed(self):
if (self._value() != self.flag):
self.flag = self._value()
if self.flag:
return True
else:
return False
def irq(self, handler, trigger):
Pin(self.pin, Pin.IN).irq(handler=handler, trigger=trigger)
def irq(self, handler, trigger):
Pin(self.pin, Pin.IN).irq(handler = handler, trigger = trigger)
'''1KEY_Button'''
class Button(KEYSensor):
def __init__(self, pin):
self.pin = pin
self.key = Pin(pin, Pin.IN)
self.flag = True
def _value(self):
return not self.key.value()
class Button(KEYSensor):
def __init__(self, pin):
self.pin = pin
self.key = Pin(pin, Pin.IN)
self.flag = True
def _value(self):
return not self.key.value()
B1key = Button(0)
B2key = KEYSensor(17, 0)
@@ -134,108 +143,117 @@ A2key = KEYSensor(17, 1100)
A3key = KEYSensor(17, 550)
A4key = KEYSensor(17, 2100)
'''2-LED'''
'''2-LED'''
class LED:
def __init__(self, func):
self._func = func
def __init__(self, func):
self._func = func
def setbrightness(self, index, val):
self._func(index, val)
def setbrightness(self, index, val):
self._func(index, val)
def getbrightness(self, index):
return self._func(index)
def getbrightness(self, index):
return self._func(index)
def setonoff(self, index, val):
if val == -1:
self.setbrightness(index, 100) if self.getbrightness(index) < 50 else self.setbrightness(index, 0)
elif val == 1:
self.setbrightness(index, 100)
elif val == 0:
self.setbrightness(index, 0)
def setonoff(self, index, val):
if val == -1:
self.setbrightness(index, 100) if self.getbrightness(
index) < 50 else self.setbrightness(index, 0)
elif val == 1:
self.setbrightness(index, 100)
elif val == 0:
self.setbrightness(index, 0)
def getonoff(self, index):
return True if self.getbrightness(index) > 50 else False
def getonoff(self, index):
return True if self.getbrightness(index) > 50 else False
onboard_led = LED(onboard_bot.led_pwm)
class Voice_Energy:
def read(self, samples=10):
values = []
for _ in range(samples):
values.append(int.from_bytes(onboard_asr._rreg(0x08, 3)[:2], 'little')) #在语音识别里获取
return sorted(values)[samples // 2]
def read(self, samples=10):
values = []
for _ in range(samples):
values.append(int.from_bytes(onboard_asr._rreg(
0x08, 3)[:2], 'little')) # 在语音识别里获取
return sorted(values)[samples // 2]
onboard_sound = Voice_Energy()
class Clock:
def __init__(self, x, y, radius, color, oled=onboard_tft): #定义时钟中心点和半径
self.display = oled
self.xc = x
self.yc = y
self.r = radius
self.color= color
self.hour = 0
self.min = 0
self.sec = 0
def __init__(self, x, y, radius, color, oled=onboard_tft): # 定义时钟中心点和半径
self.display = oled
self.xc = x
self.yc = y
self.r = radius
self.color = color
self.hour = 0
self.min = 0
self.sec = 0
def set_time(self, h, m, s): #设定时间
self.hour = h
self.min = m
self.sec = s
def set_time(self, h, m, s): # 设定时间
self.hour = h
self.min = m
self.sec = s
def set_rtctime(self): #设定时间
t = rtc_clock.datetime()
self.hour = t[4]
self.min = t[5]
self.sec = t[6]
def set_rtctime(self): # 设定时间
t = rtc_clock.datetime()
self.hour = t[4]
self.min = t[5]
self.sec = t[6]
def drawDial(self,color): #画钟表刻度
r_tic1 = self.r - 1
r_tic2 = self.r - 2
self.display.ellipse(self.xc, self.yc, self.r, self.r, color)
self.display.ellipse(self.xc, self.yc, 2, 2, color,True)
def drawDial(self, color): # 画钟表刻度
r_tic1 = self.r - 1
r_tic2 = self.r - 2
self.display.ellipse(self.xc, self.yc, self.r, self.r, color)
self.display.ellipse(self.xc, self.yc, 2, 2, color, True)
for h in range(12):
at = math.pi * 2.0 * h / 12.0
x1 = round(self.xc + r_tic1 * math.sin(at))
x2 = round(self.xc + r_tic2 * math.sin(at))
y1 = round(self.yc - r_tic1 * math.cos(at))
y2 = round(self.yc - r_tic2 * math.cos(at))
self.display.line(x1, y1, x2, y2, color)
for h in range(12):
at = math.pi * 2.0 * h / 12.0
x1 = round(self.xc + r_tic1 * math.sin(at))
x2 = round(self.xc + r_tic2 * math.sin(at))
y1 = round(self.yc - r_tic1 * math.cos(at))
y2 = round(self.yc - r_tic2 * math.cos(at))
self.display.line(x1, y1, x2, y2, color)
def drawHour(self,color): #画时针
r_hour = int(self.r / 10.0 * 5)
ah = math.pi * 2.0 * ((self.hour % 12) + self.min / 60.0) / 12.0
xh = int(self.xc + r_hour * math.sin(ah))
yh = int(self.yc - r_hour * math.cos(ah))
self.display.line(self.xc, self.yc, xh, yh, color)
def drawHour(self, color): # 画时针
r_hour = int(self.r / 10.0 * 5)
ah = math.pi * 2.0 * ((self.hour % 12) + self.min / 60.0) / 12.0
xh = int(self.xc + r_hour * math.sin(ah))
yh = int(self.yc - r_hour * math.cos(ah))
self.display.line(self.xc, self.yc, xh, yh, color)
def drawMin(self,color): #画分针
r_min = int(self.r / 10.0 * 7)
am = math.pi * 2.0 * self.min / 60.0
xm = round(self.xc + r_min * math.sin(am))
ym = round(self.yc - r_min * math.cos(am))
self.display.line(self.xc, self.yc, xm, ym, color)
def drawMin(self, color): # 画分针
r_min = int(self.r / 10.0 * 7)
am = math.pi * 2.0 * self.min / 60.0
xm = round(self.xc + r_min * math.sin(am))
ym = round(self.yc - r_min * math.cos(am))
self.display.line(self.xc, self.yc, xm, ym, color)
def drawSec(self,color): #画秒针
r_sec = int(self.r / 10.0 * 9)
asec = math.pi * 2.0 * self.sec / 60.0
xs = round(self.xc + r_sec * math.sin(asec))
ys = round(self.yc - r_sec * math.cos(asec))
self.display.line(self.xc, self.yc, xs, ys, color)
def drawSec(self, color): # 画秒针
r_sec = int(self.r / 10.0 * 9)
asec = math.pi * 2.0 * self.sec / 60.0
xs = round(self.xc + r_sec * math.sin(asec))
ys = round(self.yc - r_sec * math.cos(asec))
self.display.line(self.xc, self.yc, xs, ys, color)
def draw_clock(self, bg_color=0): #画完整钟表
self.drawDial(self.color)
self.drawHour(self.color)
self.drawMin(self.color)
self.drawSec(self.color)
self.display.show()
self.drawHour(bg_color)
self.drawMin(bg_color)
self.drawSec(bg_color)
def draw_clock(self, bg_color=0): # 画完整钟表
self.drawDial(self.color)
self.drawHour(self.color)
self.drawMin(self.color)
self.drawSec(self.color)
self.display.show()
self.drawHour(bg_color)
self.drawMin(bg_color)
self.drawSec(bg_color)
def clear(self, color=0): # 清除
self.display.ellipse(self.xc, self.yc, self.r, self.r, color, True)
def clear(self, color=0): #清除
self.display.ellipse(self.xc, self.yc, self.r, self.r, color, True)
'''Reclaim memory'''
gc.collect()

273
boards/default_src/micropython_esp32s3/origin/build/lib/mixgo_soar.py
View File

@@ -6,116 +6,127 @@ Micropython library for the mixgo_soar onboard resources
@dahanzimin From the Mixly Team
"""
from ws2812 import NeoPixel
from machine import *
import time, gc, math, st7789_bf
import time
import gc
import math
import st7789_bf
'''RTC'''
rtc_clock = RTC()
'''I2C-onboard'''
#onboard_i2c = I2C(0)
# onboard_i2c = I2C(0)
onboard_i2c = SoftI2C(scl=Pin(47), sda=Pin(48), freq=400000)
'''SPI-onboard'''
onboard_spi = SPI(1, baudrate=80000000, polarity=0, phase=0)
'''BOT035-Sensor'''
try :
import soar_bot
onboard_bot = soar_bot.BOT035(onboard_i2c)
try:
import soar_bot
onboard_bot = soar_bot.BOT035(onboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with BOT035 (Coprocessor) or",e)
print("Warning: Failed to communicate with BOT035 (Coprocessor) or", e)
'''BPS-Sensor'''
try :
import spl06_001
onboard_bps = spl06_001.SPL06(onboard_i2c)
try:
import spl06_001
onboard_bps = spl06_001.SPL06(onboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with SPL06-001 (BPS) or",e)
print("Warning: Failed to communicate with SPL06-001 (BPS) or", e)
'''IMU-Sensor'''
try :
import qmi8658
onboard_imu = qmi8658.QMI8658(onboard_i2c)
try:
import qmi8658
onboard_imu = qmi8658.QMI8658(onboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with QMI8658 (IMU) or",e)
print("Warning: Failed to communicate with QMI8658 (IMU) or", e)
'''ALS_PS-Sensor'''
try :
import ltr553als
onboard_als = ltr553als.LTR_553ALS(onboard_i2c)
try:
import ltr553als
onboard_als = ltr553als.LTR_553ALS(onboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with TR_553ALS (ALS&PS) or",e)
print("Warning: Failed to communicate with TR_553ALS (ALS&PS) or", e)
'''MGS-Sensor'''
try :
import mmc5603
onboard_mgs = mmc5603.MMC5603(onboard_i2c)
try:
import mmc5603
onboard_mgs = mmc5603.MMC5603(onboard_i2c)
except Exception as e:
print("Warning: Failed to communicate with MMC5603 (MGS) or",e)
print("Warning: Failed to communicate with MMC5603 (MGS) or", e)
'''TFT/240*240'''
onboard_tft = st7789_bf.ST7789(onboard_spi, 240, 240, dc_pin=46, cs_pin=45, bl_pin=onboard_bot.tft_brightness, brightness=0, font_address=0x700000)
'''2RGB_WS2812'''
from ws2812 import NeoPixel
'''2RGB_WS2812'''
onboard_rgb = NeoPixel(Pin(40), 4)
'''5KEY_Sensor'''
class KEYSensor:
def __init__(self, pin, range):
self.pin = pin
self.adc = ADC(Pin(pin), atten=ADC.ATTN_0DB)
self.range = range
self.flag = True
def _value(self):
values = []
for _ in range(50):
values.append(self.adc.read())
time.sleep_us(2)
return (self.range-200) < min(values) < (self.range+200)
def __init__(self, pin, range):
self.pin = pin
self.adc = ADC(Pin(pin), atten=ADC.ATTN_0DB)
self.range = range
self.flag = True
def get_presses(self, delay = 1):
last_time,presses = time.time(), 0
while time.time() < last_time + delay:
time.sleep_ms(50)
if self.was_pressed():
presses += 1
return presses
def _value(self):
values = []
for _ in range(50):
values.append(self.adc.read())
time.sleep_us(2)
return (self.range-200) < min(values) < (self.range+200)
def is_pressed(self):
return self._value()
def get_presses(self, delay=1):
last_time, presses = time.time(), 0
while time.time() < last_time + delay:
time.sleep_ms(50)
if self.was_pressed():
presses += 1
return presses
def was_pressed(self):
if(self._value() != self.flag):
self.flag = self._value()
if self.flag :
return True
else:
return False
def is_pressed(self):
return self._value()
def was_pressed(self):
if (self._value() != self.flag):
self.flag = self._value()
if self.flag:
return True
else:
return False
def irq(self, handler, trigger):
Pin(self.pin, Pin.IN).irq(handler=handler, trigger=trigger)
def irq(self, handler, trigger):
Pin(self.pin, Pin.IN).irq(handler = handler, trigger = trigger)
'''1KEY_Button'''
class Button(KEYSensor):
def __init__(self, pin):
self.pin = pin
self.key = Pin(pin, Pin.IN)
self.flag = True
def _value(self):
return not self.key.value()
class Button(KEYSensor):
def __init__(self, pin):
self.pin = pin
self.key = Pin(pin, Pin.IN)
self.flag = True
def _value(self):
return not self.key.value()
B1key = Button(0)
B2key = KEYSensor(17,0)
A1key = KEYSensor(17,2300)
A2key = KEYSensor(17,1600)
A3key = KEYSensor(17,800)
A4key = KEYSensor(17,2900)
B2key = KEYSensor(17, 0)
A1key = KEYSensor(17, 2300)
A2key = KEYSensor(17, 1600)
A3key = KEYSensor(17, 800)
A4key = KEYSensor(17, 2900)
'''2LED-Independent'''
'''2LED-Independent'''
class LED:
def __init__(self, pins=[]):
self._pins = [PWM(Pin(pin), duty_u16=0) for pin in pins]
@@ -132,86 +143,90 @@ class LED:
def setonoff(self, index, val):
if val == -1:
self.setbrightness(index, 100) if self.getbrightness(index) < 50 else self.setbrightness(index, 0)
self.setbrightness(index, 100) if self.getbrightness(
index) < 50 else self.setbrightness(index, 0)
elif val == 1:
self.setbrightness(index, 100)
self.setbrightness(index, 100)
elif val == 0:
self.setbrightness(index, 0)
self.setbrightness(index, 0)
def getonoff(self, index):
return True if self.getbrightness(index) > 50 else False
onboard_led = LED([38, 39])
class Clock:
def __init__(self, x, y, radius, color, oled=onboard_tft): #定义时钟中心点和半径
self.display = oled
self.xc = x
self.yc = y
self.r = radius
self.color= color
self.hour = 0
self.min = 0
self.sec = 0
def __init__(self, x, y, radius, color, oled=onboard_tft): # 定义时钟中心点和半径
self.display = oled
self.xc = x
self.yc = y
self.r = radius
self.color = color
self.hour = 0
self.min = 0
self.sec = 0
def set_time(self, h, m, s): #设定时间
self.hour = h
self.min = m
self.sec = s
def set_time(self, h, m, s): # 设定时间
self.hour = h
self.min = m
self.sec = s
def set_rtctime(self): #设定时间
t = rtc_clock.datetime()
self.hour = t[4]
self.min = t[5]
self.sec = t[6]
def set_rtctime(self): # 设定时间
t = rtc_clock.datetime()
self.hour = t[4]
self.min = t[5]
self.sec = t[6]
def drawDial(self,color): #画钟表刻度
r_tic1 = self.r - 1
r_tic2 = self.r - 2
self.display.ellipse(self.xc, self.yc, self.r, self.r, color)
self.display.ellipse(self.xc, self.yc, 2, 2, color,True)
def drawDial(self, color): # 画钟表刻度
r_tic1 = self.r - 1
r_tic2 = self.r - 2
self.display.ellipse(self.xc, self.yc, self.r, self.r, color)
self.display.ellipse(self.xc, self.yc, 2, 2, color, True)
for h in range(12):
at = math.pi * 2.0 * h / 12.0
x1 = round(self.xc + r_tic1 * math.sin(at))
x2 = round(self.xc + r_tic2 * math.sin(at))
y1 = round(self.yc - r_tic1 * math.cos(at))
y2 = round(self.yc - r_tic2 * math.cos(at))
self.display.line(x1, y1, x2, y2, color)
for h in range(12):
at = math.pi * 2.0 * h / 12.0
x1 = round(self.xc + r_tic1 * math.sin(at))
x2 = round(self.xc + r_tic2 * math.sin(at))
y1 = round(self.yc - r_tic1 * math.cos(at))
y2 = round(self.yc - r_tic2 * math.cos(at))
self.display.line(x1, y1, x2, y2, color)
def drawHour(self,color): #画时针
r_hour = int(self.r / 10.0 * 5)
ah = math.pi * 2.0 * ((self.hour % 12) + self.min / 60.0) / 12.0
xh = int(self.xc + r_hour * math.sin(ah))
yh = int(self.yc - r_hour * math.cos(ah))
self.display.line(self.xc, self.yc, xh, yh, color)
def drawHour(self, color): # 画时针
r_hour = int(self.r / 10.0 * 5)
ah = math.pi * 2.0 * ((self.hour % 12) + self.min / 60.0) / 12.0
xh = int(self.xc + r_hour * math.sin(ah))
yh = int(self.yc - r_hour * math.cos(ah))
self.display.line(self.xc, self.yc, xh, yh, color)
def drawMin(self,color): #画分针
r_min = int(self.r / 10.0 * 7)
am = math.pi * 2.0 * self.min / 60.0
xm = round(self.xc + r_min * math.sin(am))
ym = round(self.yc - r_min * math.cos(am))
self.display.line(self.xc, self.yc, xm, ym, color)
def drawMin(self, color): # 画分针
r_min = int(self.r / 10.0 * 7)
am = math.pi * 2.0 * self.min / 60.0
xm = round(self.xc + r_min * math.sin(am))
ym = round(self.yc - r_min * math.cos(am))
self.display.line(self.xc, self.yc, xm, ym, color)
def drawSec(self,color): #画秒针
r_sec = int(self.r / 10.0 * 9)
asec = math.pi * 2.0 * self.sec / 60.0
xs = round(self.xc + r_sec * math.sin(asec))
ys = round(self.yc - r_sec * math.cos(asec))
self.display.line(self.xc, self.yc, xs, ys, color)
def drawSec(self, color): # 画秒针
r_sec = int(self.r / 10.0 * 9)
asec = math.pi * 2.0 * self.sec / 60.0
xs = round(self.xc + r_sec * math.sin(asec))
ys = round(self.yc - r_sec * math.cos(asec))
self.display.line(self.xc, self.yc, xs, ys, color)
def draw_clock(self, bg_color=0): #画完整钟表
self.drawDial(self.color)
self.drawHour(self.color)
self.drawMin(self.color)
self.drawSec(self.color)
self.display.show()
self.drawHour(bg_color)
self.drawMin(bg_color)
self.drawSec(bg_color)
def draw_clock(self, bg_color=0): # 画完整钟表
self.drawDial(self.color)
self.drawHour(self.color)
self.drawMin(self.color)
self.drawSec(self.color)
self.display.show()
self.drawHour(bg_color)
self.drawMin(bg_color)
self.drawSec(bg_color)
def clear(self, color=0): # 清除
self.display.ellipse(self.xc, self.yc, self.r, self.r, color, True)
def clear(self, color=0): #清除
self.display.ellipse(self.xc, self.yc, self.r, self.r, color, True)
'''Reclaim memory'''
gc.collect()

119
boards/default_src/micropython_esp32s3/origin/build/lib/mixgo_soar_voice.py
View File

@@ -17,70 +17,81 @@ sample_rate = 22050
ob_code = es8374.ES8374(onboard_i2c)
time.sleep(0.2)
#ps 特殊改双全工i2s支持
ob_audio = I2S(0, sck=Pin(37), din=Pin(36) , ws=Pin(35), dout=Pin(34), mck=Pin(33), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
# ps 特殊改双全工i2s支持
ob_audio = I2S(0, sck=Pin(37), din=Pin(36), ws=Pin(35), dout=Pin(34), mck=Pin(33), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
spk_midi = music_spk.MIDI(ob_audio, sample_rate)
def u2s(n):
return n if n < (1 << 15) else n - (1 << 16)
return n if n < (1 << 15) else n - (1 << 16)
def sound_level():
buf = bytearray(100)
values = []
ob_audio.readinto(buf)
for i in range(len(buf)//2):
values.append(u2s(buf[i * 2] | buf[i * 2 + 1]<<8))
return max(values) - min(values)
buf = bytearray(100)
values = []
ob_audio.readinto(buf)
for i in range(len(buf)//2):
values.append(u2s(buf[i * 2] | buf[i * 2 + 1] << 8))
return max(values) - min(values)
def play_audio(path):
file = open(path, 'rb')
header = file.read(44)
if header[8:12] != b'WAVE':
raise Error('not a WAVE file')
_rate = ustruct.unpack('<I', header[24:28])[0]
print("sample_rate", _rate)
file.seek(44)
ob_audio = I2S(0, sck=Pin(37), din=Pin(36) , ws=Pin(35), dout=Pin(34), mck=Pin(33), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=_rate, ibuf=20000)
while True:
block = file.read(1024)
if not block:
break
ob_audio.write(block)
ob_audio = I2S(0, sck=Pin(37), din=Pin(36) , ws=Pin(35), dout=Pin(34), mck=Pin(33), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
file.close()
file = open(path, 'rb')
header = file.read(44)
if header[8:12] != b'WAVE':
raise Error('not a WAVE file')
_rate = ustruct.unpack('<I', header[24:28])[0]
print("sample_rate", _rate)
file.seek(44)
ob_audio = I2S(0, sck=Pin(37), din=Pin(36), ws=Pin(35), dout=Pin(34), mck=Pin(
33), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=_rate, ibuf=20000)
while True:
block = file.read(1024)
if not block:
break
ob_audio.write(block)
ob_audio = I2S(0, sck=Pin(37), din=Pin(36), ws=Pin(35), dout=Pin(34), mck=Pin(
33), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
file.close()
def record_audio(path, seconds=5):
ob_audio = I2S(0, sck=Pin(37), din=Pin(36) , ws=Pin(35), dout=Pin(34), mck=Pin(33), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate*4, ibuf=20000)
file_size = sample_rate * 16 * 1 * seconds // 8
wav_header = bytearray(44)
wav_header[0:4] = b'RIFF'
ustruct.pack_into('<I', wav_header, 4, file_size + 36)
wav_header[8:40] = b'WAVEfmt \x10\x00\x00\x00\x01\x00\x01\x00"V\x00\x00D\xac\x00\x00\x02\x00\x10\x00data'
ustruct.pack_into('<I', wav_header, 40, file_size)
ob_audio = I2S(0, sck=Pin(37), din=Pin(36), ws=Pin(35), dout=Pin(34), mck=Pin(
33), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate*4, ibuf=20000)
file_size = sample_rate * 16 * 1 * seconds // 8
wav_header = bytearray(44)
wav_header[0:4] = b'RIFF'
ustruct.pack_into('<I', wav_header, 4, file_size + 36)
wav_header[8:40] = b'WAVEfmt \x10\x00\x00\x00\x01\x00\x01\x00"V\x00\x00D\xac\x00\x00\x02\x00\x10\x00data'
ustruct.pack_into('<I', wav_header, 40, file_size)
buf = bytearray(512)
file = open(path, 'wb')
file.write(wav_header)
for _ in range(file_size // 512):
ob_audio.readinto(buf)
file.write(buf)
ob_audio = I2S(0, sck=Pin(37), din=Pin(36), ws=Pin(35), dout=Pin(34), mck=Pin(
33), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
file.close()
buf = bytearray(512)
file = open(path, 'wb')
file.write(wav_header)
for _ in range(file_size // 512):
ob_audio.readinto(buf)
file.write(buf)
ob_audio = I2S(0, sck=Pin(37), din=Pin(36) , ws=Pin(35), dout=Pin(34), mck=Pin(33), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
file.close()
def play_audio_url(url):
import urequests
response = urequests.get(url, stream=True)
header = response.raw.read(44)
if header[8:12] != b'WAVE':
raise Error('not a WAVE file')
_rate = ustruct.unpack('<I', header[24:28])[0]
#print("sample_rate", _rate)
ob_audio = I2S(0, sck=Pin(37), din=Pin(36) , ws=Pin(35), dout=Pin(34), mck=Pin(33), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=_rate, ibuf=20000)
while True:
block = response.raw.read(1024)
if not block:
break
ob_audio.write(block)
ob_audio = I2S(0, sck=Pin(37), din=Pin(36) , ws=Pin(35), dout=Pin(34), mck=Pin(33), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
response.close()
import urequests
response = urequests.get(url, stream=True)
header = response.raw.read(44)
if header[8:12] != b'WAVE':
raise Error('not a WAVE file')
_rate = ustruct.unpack('<I', header[24:28])[0]
# print("sample_rate", _rate)
ob_audio = I2S(0, sck=Pin(37), din=Pin(36), ws=Pin(35), dout=Pin(34), mck=Pin(
33), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=_rate, ibuf=20000)
while True:
block = response.raw.read(1024)
if not block:
break
ob_audio.write(block)
ob_audio = I2S(0, sck=Pin(37), din=Pin(36), ws=Pin(35), dout=Pin(34), mck=Pin(
33), mode=I2S.RTX, bits=16, format=I2S.MONO, rate=sample_rate, ibuf=20000)
response.close()

247
boards/default_src/micropython_esp32s3/origin/build/lib/music_spk.py
View File

@@ -16,142 +16,155 @@ import math
import struct
normal_tone = {
'A1': 55, 'B1': 62, 'C1': 33, 'D1': 37, 'E1': 41, 'F1': 44, 'G1': 49,
'A2': 110, 'B2': 123, 'C2': 65, 'D2': 73, 'E2': 82, 'F2': 87, 'G2': 98,
'A3': 220, 'B3': 247, 'C3': 131, 'D3': 147, 'E3': 165, 'F3': 175, 'G3': 196,
'A4': 440, 'B4': 494, 'C4': 262, 'D4': 294, 'E4': 330, 'F4': 349, 'G4': 392,
'A5': 880, 'B5': 988, 'C5': 523, 'D5': 587, 'E5': 659, 'F5': 698, 'G5': 784,
'A6': 1760, 'B6': 1976, 'C6': 1047, 'D6': 1175, 'E6': 1319, 'F6': 1397, 'G6': 1568,
'A7': 3520, 'B7': 3951, 'C7': 2093, 'D7': 2349, 'E7': 2637, 'F7': 2794, 'G7': 3135,
'A8': 7040, 'B8': 7902, 'C8': 4186, 'D8': 4699, 'E8': 5274, 'F8': 5588, 'G8': 6271,
'A9': 14080, 'B9': 15804 }
'A1': 55, 'B1': 62, 'C1': 33, 'D1': 37, 'E1': 41, 'F1': 44, 'G1': 49,
'A2': 110, 'B2': 123, 'C2': 65, 'D2': 73, 'E2': 82, 'F2': 87, 'G2': 98,
'A3': 220, 'B3': 247, 'C3': 131, 'D3': 147, 'E3': 165, 'F3': 175, 'G3': 196,
'A4': 440, 'B4': 494, 'C4': 262, 'D4': 294, 'E4': 330, 'F4': 349, 'G4': 392,
'A5': 880, 'B5': 988, 'C5': 523, 'D5': 587, 'E5': 659, 'F5': 698, 'G5': 784,
'A6': 1760, 'B6': 1976, 'C6': 1047, 'D6': 1175, 'E6': 1319, 'F6': 1397, 'G6': 1568,
'A7': 3520, 'B7': 3951, 'C7': 2093, 'D7': 2349, 'E7': 2637, 'F7': 2794, 'G7': 3135,
'A8': 7040, 'B8': 7902, 'C8': 4186, 'D8': 4699, 'E8': 5274, 'F8': 5588, 'G8': 6271,
'A9': 14080, 'B9': 15804}
Letter = 'ABCDEFG#R'
class MIDI():
def __init__(self, i2s_bus, rate=22050):
self.reset()
self._rate = rate
self.i2s_bus = i2s_bus
def __init__(self, i2s_bus, rate=22050):
self.reset()
self._rate = rate
self.i2s_bus = i2s_bus
def _wave(self, frequency):
_period = self._rate // frequency
_samples = bytearray()
for i in range(_period):
sample = 32768 + int((32767) * math.sin(2 * math.pi * i / _period))
_samples.extend(struct.pack("<h", sample))
return bytes(_samples)
def _wave(self, frequency):
_period = self._rate // frequency
_samples = bytearray()
for i in range(_period):
sample = 32768 + int((32767) * math.sin(2 * math.pi * i / _period))
_samples.extend(struct.pack("<h", sample))
return bytes(_samples)
def _tone(self, frequency, duration_ms=1000):
_wave = self._wave(frequency)
_samples = self._rate * duration_ms // 1000
_data = _wave * (_samples // (len(_wave) // 2) + 1)
_data = _data[:_samples * 2]
def _tone(self, frequency, duration_ms=1000):
_wave = self._wave(frequency)
_samples = self._rate * duration_ms // 1000
_data = _wave * (_samples // (len(_wave) // 2) + 1)
_data = _data[:_samples * 2]
_wbytes = 0
while _wbytes < len(_data):
send_size = min(512, len(_data) - _wbytes)
self.i2s_bus.write(_data[_wbytes : _wbytes + send_size])
_wbytes += send_size
_wbytes = 0
while _wbytes < len(_data):
send_size = min(512, len(_data) - _wbytes)
self.i2s_bus.write(_data[_wbytes: _wbytes + send_size])
_wbytes += send_size
def set_tempo(self, ticks=4, bpm=120):
self.ticks = ticks
self.bpm = bpm
self.beat = 60000 / self.bpm / self.ticks
def set_tempo(self, ticks=4, bpm=120):
self.ticks = ticks
self.bpm = bpm
self.beat = 60000 / self.bpm / self.ticks
def set_octave(self, octave=4):
self.octave = octave
def set_octave(self, octave=4):
self.octave = octave
def set_duration(self, duration=4):
self.duration = duration
def set_duration(self, duration=4):
self.duration = duration
def get_tempo(self):
return (self.ticks, self.bpm)
def get_tempo(self):
return (self.ticks, self.bpm)
def get_octave(self):
return self.octave
def get_octave(self):
return self.octave
def get_duration(self):
return self.duration
def get_duration(self):
return self.duration
def reset(self):
self.set_duration()
self.set_octave()
self.set_tempo()
def reset(self):
self.set_duration()
self.set_octave()
self.set_tempo()
def parse(self, tone, dict):
time = self.beat * self.duration
pos = tone.find(':')
if pos != -1:
time = self.beat * int(tone[(pos + 1):])
tone = tone[:pos]
freq, tone_size = 1, len(tone)
if 'R' in tone:
freq = 20000
elif tone_size == 1:
freq = dict[tone[0] + str(self.octave)]
elif tone_size == 2:
freq = dict[tone]
self.set_octave(tone[1:])
return int(freq), int(time)
def parse(self, tone, dict):
time = self.beat * self.duration
pos = tone.find(':')
if pos != -1:
time = self.beat * int(tone[(pos + 1):])
tone = tone[:pos]
freq, tone_size = 1, len(tone)
if 'R' in tone:
freq = 20000
elif tone_size == 1:
freq = dict[tone[0] + str(self.octave)]
elif tone_size == 2:
freq = dict[tone]
self.set_octave(tone[1:])
return int(freq), int(time)
def midi(self, tone):
pos = tone.find('#')
if pos != -1:
return self.parse(tone.replace('#', ''), normal_tone)
pos = tone.find('B')
if pos != -1 and pos != 0:
return self.parse(tone.replace('B', ''), normal_tone)
return self.parse(tone, normal_tone)
def midi(self, tone):
pos = tone.find('#')
if pos != -1:
return self.parse(tone.replace('#', ''), normal_tone)
pos = tone.find('B')
if pos != -1 and pos != 0:
return self.parse(tone.replace('B', ''), normal_tone)
return self.parse(tone, normal_tone)
def set_default(self, tone):
pos = tone.find(':')
if pos != -1:
self.set_duration(int(tone[(pos + 1):]))
tone = tone[:pos]
def set_default(self, tone):
pos = tone.find(':')
if pos != -1:
self.set_duration(int(tone[(pos + 1):]))
tone = tone[:pos]
def play(self, tune, duration=None):
if duration is None:
self.set_default(tune[0])
else:
self.set_duration(duration)
for tone in tune:
tone = tone.upper()
if tone[0] not in Letter:
continue
midi = self.midi(tone)
self._tone(midi[0], midi[1])
self._tone(20000, 1)
time.sleep_ms(10)
def play(self, tune, duration=None):
if duration is None:
self.set_default(tune[0])
else:
self.set_duration(duration)
for tone in tune:
tone = tone.upper()
if tone[0] not in Letter:
continue
midi = self.midi(tone)
self._tone(midi[0], midi[1])
self._tone(20000, 1)
time.sleep_ms(10)
def pitch(self, freq):
pass
def pitch(self, freq):
pass
def pitch_time(self, freq, delay):
self._tone(freq, delay)
time.sleep_ms(10)
def pitch_time(self, freq, delay):
self._tone(freq, delay)
time.sleep_ms(10)
def stop(self):
pass
def stop(self):
pass
DADADADUM=['r4:2','g','g','g','eb:8','r:2','f','f','f','d:8']
ENTERTAINER=['d4:1','d#','e','c5:2','e4:1','c5:2','e4:1','c5:3','c:1','d','d#','e','c','d','e:2','b4:1','d5:2','c:4']
PRELUDE=['c4:1','e','g','c5','e','g4','c5','e','c4','e','g','c5','e','g4','c5','e','c4','d','g','d5','f','g4','d5','f','c4','d','g','d5','f','g4','d5','f','b3','d4','g','d5','f','g4','d5','f','b3','d4','g','d5','f','g4','d5','f','c4','e','g','c5','e','g4','c5','e','c4','e','g','c5','e','g4','c5','e']
ODE=['e4','e','f','g','g','f','e','d','c','c','d','e','e:6','d:2','d:8','e:4','e','f','g','g','f','e','d','c','c','d','e','d:6','c:2','c:8']
NYAN=['f#5:1','g#','c#:1','d#:2','b4:1','d5:1','c#','b4:2','b','c#5','d','d:1','c#','b4:1','c#5:1','d#','f#','g#','d#','f#','c#','d','b4','c#5','b4','d#5:2','f#','g#:1','d#','f#','c#','d#','b4','d5','d#','d','c#','b4','c#5','d:2','b4:1','c#5','d#','f#','c#','d','c#','b4','c#5:2','b4','c#5','b4','f#:1','g#','b:2','f#:1','g#','b','c#5','d#','b4','e5','d#','e','f#','b4:2','b','f#:1','g#','b','f#','e5','d#','c#','b4','f#','d#','e','f#','b:2','f#:1','g#','b:2','f#:1','g#','b','b','c#5','d#','b4','f#','g#','f#','b:2','b:1','a#','b','f#','g#','b','e5','d#','e','f#','b4:2','c#5']
RINGTONE=['c4:1','d','e:2','g','d:1','e','f:2','a','e:1','f','g:2','b','c5:4']
FUNK=['c2:2','c','d#','c:1','f:2','c:1','f:2','f#','g','c','c','g','c:1','f#:2','c:1','f#:2','f','d#']
BLUES=['c2:2','e','g','a','a#','a','g','e','c2:2','e','g','a','a#','a','g','e','f','a','c3','d','d#','d','c','a2','c2:2','e','g','a','a#','a','g','e','g','b','d3','f','f2','a','c3','d#','c2:2','e','g','e','g','f','e','d']
BIRTHDAY=['c4:4','c:1','d:4','c:4','f','e:8','c:3','c:1','d:4','c:4','g','f:8','c:3','c:1','c5:4','a4','f','e','d','a#:3','a#:1','a:4','f','g','f:8']
WEDDING=['c4:4','f:3','f:1','f:8','c:4','g:3','e:1','f:8','c:4','f:3','a:1','c5:4','a4:3','f:1','f:4','e:3','f:1','g:8']
FUNERAL=['c3:4','c:3','c:1','c:4','d#:3','d:1','d:3','c:1','c:3','b2:1','c3:4']
PUNCHLINE=['c4:3','g3:1','f#','g','g#:3','g','r','b','c4']
PYTHON=['d5:1','b4','r','b','b','a#','b','g5','r','d','d','r','b4','c5','r','c','c','r','d','e:5','c:1','a4','r','a','a','g#','a','f#5','r','e','e','r','c','b4','r','b','b','r','c5','d:5','d:1','b4','r','b','b','a#','b','b5','r','g','g','r','d','c#','r','a','a','r','a','a:5','g:1','f#:2','a:1','a','g#','a','e:2','a:1','a','g#','a','d','r','c#','d','r','c#','d:2','r:3']
BADDY=['c3:3','r','d:2','d#','r','c','r','f#:8']
CHASE=['a4:1','b','c5','b4','a:2','r','a:1','b','c5','b4','a:2','r','a:2','e5','d#','e','f','e','d#','e','b4:1','c5','d','c','b4:2','r','b:1','c5','d','c','b4:2','r','b:2','e5','d#','e','f','e','d#','e']
BA_DING=['b5:1','e6:3']
WAWAWAWAA=['e3:3','r:1','d#:3','r:1','d:4','r:1','c#:8']
JUMP_UP=['c5:1','d','e','f','g']
JUMP_DOWN=['g5:1','f','e','d','c']
POWER_UP=['g4:1','c5','e4','g5:2','e5:1','g5:3']
POWER_DOWN=['g5:1','d#','c','g4:2','b:1','c5:3']
DADADADUM = ['r4:2', 'g', 'g', 'g', 'eb:8', 'r:2', 'f', 'f', 'f', 'd:8']
ENTERTAINER = ['d4:1', 'd#', 'e', 'c5:2', 'e4:1', 'c5:2', 'e4:1',
'c5:3', 'c:1', 'd', 'd#', 'e', 'c', 'd', 'e:2', 'b4:1', 'd5:2', 'c:4']
PRELUDE = ['c4:1', 'e', 'g', 'c5', 'e', 'g4', 'c5', 'e', 'c4', 'e', 'g', 'c5', 'e', 'g4', 'c5', 'e', 'c4', 'd', 'g', 'd5', 'f', 'g4', 'd5', 'f', 'c4', 'd', 'g', 'd5', 'f', 'g4', 'd5',
'f', 'b3', 'd4', 'g', 'd5', 'f', 'g4', 'd5', 'f', 'b3', 'd4', 'g', 'd5', 'f', 'g4', 'd5', 'f', 'c4', 'e', 'g', 'c5', 'e', 'g4', 'c5', 'e', 'c4', 'e', 'g', 'c5', 'e', 'g4', 'c5', 'e']
ODE = ['e4', 'e', 'f', 'g', 'g', 'f', 'e', 'd', 'c', 'c', 'd', 'e', 'e:6', 'd:2', 'd:8',
'e:4', 'e', 'f', 'g', 'g', 'f', 'e', 'd', 'c', 'c', 'd', 'e', 'd:6', 'c:2', 'c:8']
NYAN = ['f#5:1', 'g#', 'c#:1', 'd#:2', 'b4:1', 'd5:1', 'c#', 'b4:2', 'b', 'c#5', 'd', 'd:1', 'c#', 'b4:1', 'c#5:1', 'd#', 'f#', 'g#', 'd#', 'f#', 'c#', 'd', 'b4', 'c#5', 'b4', 'd#5:2', 'f#', 'g#:1', 'd#', 'f#', 'c#', 'd#', 'b4', 'd5', 'd#', 'd', 'c#', 'b4', 'c#5', 'd:2', 'b4:1', 'c#5', 'd#', 'f#', 'c#', 'd', 'c#', 'b4', 'c#5:2', 'b4', 'c#5',
'b4', 'f#:1', 'g#', 'b:2', 'f#:1', 'g#', 'b', 'c#5', 'd#', 'b4', 'e5', 'd#', 'e', 'f#', 'b4:2', 'b', 'f#:1', 'g#', 'b', 'f#', 'e5', 'd#', 'c#', 'b4', 'f#', 'd#', 'e', 'f#', 'b:2', 'f#:1', 'g#', 'b:2', 'f#:1', 'g#', 'b', 'b', 'c#5', 'd#', 'b4', 'f#', 'g#', 'f#', 'b:2', 'b:1', 'a#', 'b', 'f#', 'g#', 'b', 'e5', 'd#', 'e', 'f#', 'b4:2', 'c#5']
RINGTONE = ['c4:1', 'd', 'e:2', 'g', 'd:1', 'e',
'f:2', 'a', 'e:1', 'f', 'g:2', 'b', 'c5:4']
FUNK = ['c2:2', 'c', 'd#', 'c:1', 'f:2', 'c:1', 'f:2', 'f#',
'g', 'c', 'c', 'g', 'c:1', 'f#:2', 'c:1', 'f#:2', 'f', 'd#']
BLUES = ['c2:2', 'e', 'g', 'a', 'a#', 'a', 'g', 'e', 'c2:2', 'e', 'g', 'a', 'a#', 'a', 'g', 'e', 'f', 'a', 'c3', 'd', 'd#', 'd', 'c',
'a2', 'c2:2', 'e', 'g', 'a', 'a#', 'a', 'g', 'e', 'g', 'b', 'd3', 'f', 'f2', 'a', 'c3', 'd#', 'c2:2', 'e', 'g', 'e', 'g', 'f', 'e', 'd']
BIRTHDAY = ['c4:4', 'c:1', 'd:4', 'c:4', 'f', 'e:8', 'c:3', 'c:1', 'd:4', 'c:4', 'g',
'f:8', 'c:3', 'c:1', 'c5:4', 'a4', 'f', 'e', 'd', 'a#:3', 'a#:1', 'a:4', 'f', 'g', 'f:8']
WEDDING = ['c4:4', 'f:3', 'f:1', 'f:8', 'c:4', 'g:3', 'e:1', 'f:8',
'c:4', 'f:3', 'a:1', 'c5:4', 'a4:3', 'f:1', 'f:4', 'e:3', 'f:1', 'g:8']
FUNERAL = ['c3:4', 'c:3', 'c:1', 'c:4', 'd#:3',
'd:1', 'd:3', 'c:1', 'c:3', 'b2:1', 'c3:4']
PUNCHLINE = ['c4:3', 'g3:1', 'f#', 'g', 'g#:3', 'g', 'r', 'b', 'c4']
PYTHON = ['d5:1', 'b4', 'r', 'b', 'b', 'a#', 'b', 'g5', 'r', 'd', 'd', 'r', 'b4', 'c5', 'r', 'c', 'c', 'r', 'd', 'e:5', 'c:1', 'a4', 'r', 'a', 'a', 'g#', 'a', 'f#5', 'r', 'e', 'e', 'r', 'c', 'b4', 'r', 'b', 'b', 'r', 'c5', 'd:5',
'd:1', 'b4', 'r', 'b', 'b', 'a#', 'b', 'b5', 'r', 'g', 'g', 'r', 'd', 'c#', 'r', 'a', 'a', 'r', 'a', 'a:5', 'g:1', 'f#:2', 'a:1', 'a', 'g#', 'a', 'e:2', 'a:1', 'a', 'g#', 'a', 'd', 'r', 'c#', 'd', 'r', 'c#', 'd:2', 'r:3']
BADDY = ['c3:3', 'r', 'd:2', 'd#', 'r', 'c', 'r', 'f#:8']
CHASE = ['a4:1', 'b', 'c5', 'b4', 'a:2', 'r', 'a:1', 'b', 'c5', 'b4', 'a:2', 'r', 'a:2', 'e5', 'd#', 'e', 'f', 'e', 'd#',
'e', 'b4:1', 'c5', 'd', 'c', 'b4:2', 'r', 'b:1', 'c5', 'd', 'c', 'b4:2', 'r', 'b:2', 'e5', 'd#', 'e', 'f', 'e', 'd#', 'e']
BA_DING = ['b5:1', 'e6:3']
WAWAWAWAA = ['e3:3', 'r:1', 'd#:3', 'r:1', 'd:4', 'r:1', 'c#:8']
JUMP_UP = ['c5:1', 'd', 'e', 'f', 'g']
JUMP_DOWN = ['g5:1', 'f', 'e', 'd', 'c']
POWER_UP = ['g4:1', 'c5', 'e4', 'g5:2', 'e5:1', 'g5:3']
POWER_DOWN = ['g5:1', 'd#', 'c', 'g4:2', 'b:1', 'c5:3']

163
boards/default_src/micropython_esp32s3/origin/build/lib/nova_g1.py
View File

@@ -18,94 +18,95 @@ _NOVA_G1_IO = const(0x03)
_NOVA_G1_PWM = const(0x04)
class NOVA_G1:
def __init__(self, i2c_bus, addr=_NOVA_G1_ADDRESS):
self._i2c=i2c_bus
self._addr = addr
if self._rreg(_NOVA_G1_ID)!= 0x25:
raise AttributeError("Cannot find a NOVA_G1")
self.reset()
def __init__(self, i2c_bus, addr=_NOVA_G1_ADDRESS):
self._i2c = i2c_bus
self._addr = addr
if self._rreg(_NOVA_G1_ID) != 0x25:
raise AttributeError("Cannot find a NOVA_G1")
self.reset()
def _wreg(self, reg, val):
'''Write memory address'''
try:
self._i2c.writeto_mem(self._addr, reg, val.to_bytes(1, 'little'))
except:
return 0
def _wreg(self, reg, val):
'''Write memory address'''
try:
self._i2c.writeto_mem(self._addr, reg, val.to_bytes(1, 'little'))
except:
return 0
def _rreg(self, reg, nbytes=1):
'''Read memory address'''
try:
self._i2c.writeto(self._addr, reg.to_bytes(1, 'little'))
return self._i2c.readfrom(self._addr, nbytes)[0] if nbytes<=1 else self._i2c.readfrom(self._addr, nbytes)[0:nbytes]
except:
return 0
def _rreg(self, reg, nbytes=1):
'''Read memory address'''
try:
self._i2c.writeto(self._addr, reg.to_bytes(1, 'little'))
return self._i2c.readfrom(self._addr, nbytes)[0] if nbytes <= 1 else self._i2c.readfrom(self._addr, nbytes)[0:nbytes]
except:
return 0
def reset(self):
"""Reset all registers to default state"""
for reg in range(_NOVA_G1_PWM,_NOVA_G1_PWM + 6):
self._wreg(reg,0x00)
def reset(self):
"""Reset all registers to default state"""
for reg in range(_NOVA_G1_PWM, _NOVA_G1_PWM + 6):
self._wreg(reg, 0x00)
def varistor(self, ratio=100/1023):
'''Read battery power'''
_adc= self._rreg(_NOVA_G1_ADC) << 2 | self._rreg(_NOVA_G1_ADC+1) >> 6
return round(_adc * ratio)
def pwm(self, index, duty=None):
"""Motor*2*2 & USB*2 PWM duty cycle data register"""
if duty is None:
return self._rreg(_NOVA_G1_PWM + index)
else:
duty = min(255, max(0, duty))
self._wreg(_NOVA_G1_PWM + index, duty)
def varistor(self, ratio=100/1023):
'''Read battery power'''
_adc = self._rreg(_NOVA_G1_ADC) << 2 | self._rreg(_NOVA_G1_ADC+1) >> 6
return round(_adc * ratio)
def motor(self, index, action, speed=0):
if not 0 <= index <= 1:
raise ValueError("Motor port must be a number in the range: 0~1")
speed = min(100, max(speed, -100))
if action=="N":
self.pwm(index * 2, 0)
self.pwm(index * 2 + 1, 0)
elif action=="P":
self.pwm(index * 2, 255)
self.pwm(index * 2 + 1, 255)
elif action=="CW":
if speed >= 0:
self.pwm(index * 2, 0)
self.pwm(index * 2 + 1, speed * 255 // 100)
else:
self.pwm(index * 2, 0)
self.pwm(index * 2 + 1, - speed * 255 // 100)
elif action=="CCW":
if speed >= 0:
self.pwm(index * 2, speed * 255 // 100)
self.pwm(index * 2 + 1, 0)
else:
self.pwm(index * 2, - speed * 255 // 100)
self.pwm(index * 2 + 1, 0)
elif action=="NC":
return round(self.pwm(index * 2) * 100 / 255), round(self.pwm(index * 2 + 1) * 100 / 255)
else:
raise ValueError('Invalid input, valid are "N","P","CW","CCW"')
def pwm(self, index, duty=None):
"""Motor*2*2 & USB*2 PWM duty cycle data register"""
if duty is None:
return self._rreg(_NOVA_G1_PWM + index)
else:
duty = min(255, max(0, duty))
self._wreg(_NOVA_G1_PWM + index, duty)
def usb_pwm(self, index, duty=None):
if not 0 <= index <= 1:
raise ValueError("USB-2.0 port must be a number in the range: 0~1")
if duty is None:
return round((self.pwm(index + 4) * 100 / 255))
else:
self.pwm(index + 4, duty * 255 // 100)
def motor(self, index, action, speed=0):
if not 0 <= index <= 1:
raise ValueError("Motor port must be a number in the range: 0~1")
speed = min(100, max(speed, -100))
if action == "N":
self.pwm(index * 2, 0)
self.pwm(index * 2 + 1, 0)
elif action == "P":
self.pwm(index * 2, 255)
self.pwm(index * 2 + 1, 255)
elif action == "CW":
if speed >= 0:
self.pwm(index * 2, 0)
self.pwm(index * 2 + 1, speed * 255 // 100)
else:
self.pwm(index * 2, 0)
self.pwm(index * 2 + 1, - speed * 255 // 100)
elif action == "CCW":
if speed >= 0:
self.pwm(index * 2, speed * 255 // 100)
self.pwm(index * 2 + 1, 0)
else:
self.pwm(index * 2, - speed * 255 // 100)
self.pwm(index * 2 + 1, 0)
elif action == "NC":
return round(self.pwm(index * 2) * 100 / 255), round(self.pwm(index * 2 + 1) * 100 / 255)
else:
raise ValueError('Invalid input, valid are "N","P","CW","CCW"')
def spk_en(self, onoff=True):
if onoff:
self._wreg(_NOVA_G1_IO, (self._rreg(_NOVA_G1_IO)) | 0x02)
else:
self._wreg(_NOVA_G1_IO, (self._rreg(_NOVA_G1_IO)) & 0xFD)
def usb_pwm(self, index, duty=None):
if not 0 <= index <= 1:
raise ValueError("USB-2.0 port must be a number in the range: 0~1")
if duty is None:
return round((self.pwm(index + 4) * 100 / 255))
else:
self.pwm(index + 4, duty * 255 // 100)
def ldo_en(self, onoff=True):
if onoff:
self._wreg(_NOVA_G1_IO, (self._rreg(_NOVA_G1_IO)) | 0x01)
else:
self._wreg(_NOVA_G1_IO, (self._rreg(_NOVA_G1_IO)) & 0xFE)
def spk_en(self, onoff=True):
if onoff:
self._wreg(_NOVA_G1_IO, (self._rreg(_NOVA_G1_IO)) | 0x02)
else:
self._wreg(_NOVA_G1_IO, (self._rreg(_NOVA_G1_IO)) & 0xFD)
#Constructor
def ldo_en(self, onoff=True):
if onoff:
self._wreg(_NOVA_G1_IO, (self._rreg(_NOVA_G1_IO)) | 0x01)
else:
self._wreg(_NOVA_G1_IO, (self._rreg(_NOVA_G1_IO)) & 0xFE)
# Constructor
ext_g1 = NOVA_G1(onboard_i2c)

2
boards/default_src/micropython_esp32s3/origin/build/lib/sant_bot.py
View File

@@ -94,7 +94,7 @@ class BOT035:
"""Convert to high level effective"""
value = value if value is None else ~ value & 0x01
return self._bits(5, 0x20, value, delay)
def cam_reset(self, value=None, delay=50):
return self._bits(4, 0x10, value, delay)

176
boards/default_src/micropython_esp32s3/origin/build/lib/st7789_bf.py
View File

@@ -7,7 +7,8 @@ MicroPython library for the ST7789(TFT-SPI)
@dahanzimin From the Mixly Team
"""
import time, uframebuf
import time
import uframebuf
from machine import Pin, PWM
from micropython import const
@@ -30,95 +31,98 @@ _CMD_COLMOD = const(0x3A)
_CMD_MADCTL = const(0x36)
class ST7789(uframebuf.FrameBuffer_Uincode):
def __init__(self, spi, width, height, dc_pin=None, cs_pin=None, bl_pin=None, brightness=0.6, font_address=0x700000):
self.spi = spi
self.dc = Pin(dc_pin, Pin.OUT, value=1)
self.cs = Pin(cs_pin, Pin.OUT, value=1)
self._buffer = bytearray(width * height * 2)
super().__init__(self._buffer, width, height, uframebuf.RGB565)
self.font(font_address)
self._init()
self.show()
if brightness > 0: time.sleep_ms(100)
self._brightness = brightness
if callable(bl_pin):
self.bl_led = bl_pin
else:
self.bl_led = PWM(Pin(bl_pin), duty_u16=int(self._brightness * 60000)) if bl_pin else None
def __init__(self, spi, width, height, dc_pin=None, cs_pin=None, bl_pin=None, brightness=0.6, font_address=0x700000):
self.spi = spi
self.dc = Pin(dc_pin, Pin.OUT, value=1)
self.cs = Pin(cs_pin, Pin.OUT, value=1)
self._buffer = bytearray(width * height * 2)
super().__init__(self._buffer, width, height, uframebuf.RGB565)
self.font(font_address)
self._init()
self.show()
if brightness > 0:
time.sleep_ms(100)
self._brightness = brightness
if callable(bl_pin):
self.bl_led = bl_pin
else:
self.bl_led = PWM(Pin(bl_pin), duty_u16=int(
self._brightness * 60000)) if bl_pin else None
def _write(self, cmd, dat = None):
self.cs.off()
self.dc.off()
self.spi.write(bytearray([cmd]))
self.cs.on()
if dat is not None:
self.cs.off()
self.dc.on()
self.spi.write(dat)
self.cs.on()
def _write(self, cmd, dat=None):
self.cs.off()
self.dc.off()
self.spi.write(bytearray([cmd]))
self.cs.on()
if dat is not None:
self.cs.off()
self.dc.on()
self.spi.write(dat)
self.cs.on()
def _init(self):
"""Display initialization configuration"""
for cmd, data, delay in [
#(_CMD_SWRESET, None, 20000),
(_CMD_SLPOUT, None, 120000),
(_CMD_MADCTL, b'\x00', 50),
(_CMD_COLMOD, b'\x05', 50),
(0xB2, b'\x0c\x0c\x00\x33\x33', 10),
(0xB7, b'\x35', 10),
(0xBB, b'\x19', 10),
(0xC0, b'\x2C', 10),
(0xC2, b'\x01', 10),
(0xC3, b'\x12', 10),
(0xC4, b'\x20', 10),
(0xC6, b'\x0F', 10),
(0xD0, b'\xA4\xA1', 10),
(0xE0, b'\xD0\x04\x0D\x11\x13\x2B\x3F\x54\x4C\x18\x0D\x0B\x1F\x23', 10),
(0xE1, b'\xD0\x04\x0C\x11\x13\x2C\x3F\x44\x51\x2F\x1F\x1F\x20\x23', 10),
(0x21, None, 10),
(0x29, None, 10),
# (_CMD_INVOFF, None, 10),
# (_CMD_NORON, None, 10),
# (_CMD_DISPON, None, 200),
]:
self._write(cmd, data)
if delay:
time.sleep_us(delay)
def _init(self):
"""Display initialization configuration"""
for cmd, data, delay in [
# (_CMD_SWRESET, None, 20000),
(_CMD_SLPOUT, None, 120000),
(_CMD_MADCTL, b'\x00', 50),
(_CMD_COLMOD, b'\x05', 50),
(0xB2, b'\x0c\x0c\x00\x33\x33', 10),
(0xB7, b'\x35', 10),
(0xBB, b'\x19', 10),
(0xC0, b'\x2C', 10),
(0xC2, b'\x01', 10),
(0xC3, b'\x12', 10),
(0xC4, b'\x20', 10),
(0xC6, b'\x0F', 10),
(0xD0, b'\xA4\xA1', 10),
(0xE0, b'\xD0\x04\x0D\x11\x13\x2B\x3F\x54\x4C\x18\x0D\x0B\x1F\x23', 10),
(0xE1, b'\xD0\x04\x0C\x11\x13\x2C\x3F\x44\x51\x2F\x1F\x1F\x20\x23', 10),
(0x21, None, 10),
(0x29, None, 10),
# (_CMD_INVOFF, None, 10),
# (_CMD_NORON, None, 10),
# (_CMD_DISPON, None, 200),
]:
self._write(cmd, data)
if delay:
time.sleep_us(delay)
def _write(self, command=None, data=None):
"""SPI write to the device: commands and data."""
if command is not None:
self.cs.off()
self.dc.off()
self.spi.write(bytes([command]))
self.cs.on()
if data is not None:
self.cs.off()
self.dc.on()
self.spi.write(data)
self.cs.on()
def _write(self, command=None, data=None):
"""SPI write to the device: commands and data."""
if command is not None:
self.cs.off()
self.dc.off()
self.spi.write(bytes([command]))
self.cs.on()
if data is not None:
self.cs.off()
self.dc.on()
self.spi.write(data)
self.cs.on()
def get_brightness(self):
return self._brightness
def get_brightness(self):
return self._brightness
def set_brightness(self, brightness):
if not 0.0 <= brightness <= 1.0:
raise ValueError("Brightness must be a decimal number in the range: 0.0~1.0")
self._brightness = brightness
if callable(self.bl_led):
self.bl_led(brightness * 100)
elif isinstance(self.bl_led, PWM):
self.bl_led.duty_u16(int(brightness*60000))
def set_brightness(self, brightness):
if not 0.0 <= brightness <= 1.0:
raise ValueError(
"Brightness must be a decimal number in the range: 0.0~1.0")
self._brightness = brightness
if callable(self.bl_led):
self.bl_led(brightness * 100)
elif isinstance(self.bl_led, PWM):
self.bl_led.duty_u16(int(brightness*60000))
def color(self, red, green=None, blue=None):
""" Convert red, green and blue values (0-255) into a 16-bit 565 encoding."""
if green is None or blue is None:
return red
else:
return (red & 0xf8) << 8 | (green & 0xfc) << 3 | blue >> 3
def color(self, red, green=None, blue=None):
""" Convert red, green and blue values (0-255) into a 16-bit 565 encoding."""
if green is None or blue is None:
return red
else:
return (red & 0xf8) << 8 | (green & 0xfc) << 3 | blue >> 3
def show(self):
"""Refresh the display and show the changes."""
self._write(_CMD_CASET, b'\x00\x00\x01\x3f')
self._write(_CMD_RASET, b'\x00\x00\x00\xef')
self._write(_CMD_RAMWR, self._buffer)
def show(self):
"""Refresh the display and show the changes."""
self._write(_CMD_CASET, b'\x00\x00\x01\x3f')
self._write(_CMD_RASET, b'\x00\x00\x00\xef')
self._write(_CMD_RAMWR, self._buffer)

149
boards/default_src/micropython_esp32s3/origin/build/lib/st7789_cf.py
View File

@@ -5,7 +5,8 @@ MicroPython library for the ST7789(TFT-SPI)
=======================================================
@dahanzimin From the Mixly Team
"""
import time, uframebuf
import time
import uframebuf
from machine import Pin
from jpeg import Decoder
from micropython import const
@@ -29,82 +30,84 @@ _CMD_COLMOD = const(0x3A)
_CMD_MADCTL = const(0x36)
class ST7789(uframebuf.FrameBuffer_Uincode):
def __init__(self, spi, width, height, dc_pin=None, backlight=None, reset=None, font_address=0x700000):
self.spi = spi
self.dc = Pin(dc_pin, Pin.OUT, value=1)
self._buffer = bytearray(width * height * 2)
super().__init__(self._buffer, width, height, uframebuf.RGB565)
reset(1, 100)
self.font(font_address)
self._init()
# self.show()
self._oneclight = True
self._backlight = backlight
def __init__(self, spi, width, height, dc_pin=None, backlight=None, reset=None, font_address=0x700000):
self.spi = spi
self.dc = Pin(dc_pin, Pin.OUT, value=1)
self._buffer = bytearray(width * height * 2)
super().__init__(self._buffer, width, height, uframebuf.RGB565)
reset(1, 100)
self.font(font_address)
self._init()
# self.show()
self._oneclight = True
self._backlight = backlight
def display(self, data=None, rotation=0, sync=True):
if type(data) is str:
with open(data, "rb") as f:
_jpeg = f.read()
_decoder = Decoder(pixel_format="RGB565_BE", rotation=rotation)
self._buffer[:] = _decoder.decode(_jpeg)
del _decoder
else:
self._buffer[:] = data #后期做图像大小处理
if sync: self.show()
return self._buffer
def display(self, data=None, rotation=0, sync=True):
if type(data) is str:
with open(data, "rb") as f:
_jpeg = f.read()
_decoder = Decoder(pixel_format="RGB565_BE", rotation=rotation)
self._buffer[:] = _decoder.decode(_jpeg)
del _decoder
else:
self._buffer[:] = data # 后期做图像大小处理
if sync:
self.show()
return self._buffer
def _write(self, cmd, dat=None):
self.dc.off()
self.spi.write(bytearray([cmd]))
if dat is not None:
self.dc.on()
self.spi.write(dat)
def _write(self, cmd, dat=None):
self.dc.off()
self.spi.write(bytearray([cmd]))
if dat is not None:
self.dc.on()
self.spi.write(dat)
def _init(self):
"""Display initialization configuration"""
for cmd, data, delay in [
##(_CMD_SWRESET, None, 20000),
(_CMD_SLPOUT, None, 120000),
(_CMD_MADCTL, b'\x00', 50),
(_CMD_COLMOD, b'\x05', 50),
(0xB2, b'\x0c\x0c\x00\x33\x33', 10),
(0xB7, b'\x35', 10),
(0xBB, b'\x19', 10),
(0xC0, b'\x2C', 10),
(0xC2, b'\x01', 10),
(0xC3, b'\x12', 10),
(0xC4, b'\x20', 10),
(0xC6, b'\x0F', 10),
(0xD0, b'\xA4\xA1', 10),
(0xE0, b'\xD0\x04\x0D\x11\x13\x2B\x3F\x54\x4C\x18\x0D\x0B\x1F\x23', 10),
(0xE1, b'\xD0\x04\x0C\x11\x13\x2C\x3F\x44\x51\x2F\x1F\x1F\x20\x23', 10),
(_CMD_INVON, None, 10),
(_CMD_DISPON, None, 10),
]:
self._write(cmd, data)
if delay:
time.sleep_us(delay)
def _init(self):
"""Display initialization configuration"""
for cmd, data, delay in [
# (_CMD_SWRESET, None, 20000),
(_CMD_SLPOUT, None, 120000),
(_CMD_MADCTL, b'\x00', 50),
(_CMD_COLMOD, b'\x05', 50),
(0xB2, b'\x0c\x0c\x00\x33\x33', 10),
(0xB7, b'\x35', 10),
(0xBB, b'\x19', 10),
(0xC0, b'\x2C', 10),
(0xC2, b'\x01', 10),
(0xC3, b'\x12', 10),
(0xC4, b'\x20', 10),
(0xC6, b'\x0F', 10),
(0xD0, b'\xA4\xA1', 10),
(0xE0, b'\xD0\x04\x0D\x11\x13\x2B\x3F\x54\x4C\x18\x0D\x0B\x1F\x23', 10),
(0xE1, b'\xD0\x04\x0C\x11\x13\x2C\x3F\x44\x51\x2F\x1F\x1F\x20\x23', 10),
(_CMD_INVON, None, 10),
(_CMD_DISPON, None, 10),
]:
self._write(cmd, data)
if delay:
time.sleep_us(delay)
def get_brightness(self):
return self._backlight() / 100
def get_brightness(self):
return self._backlight() / 100
def set_brightness(self, brightness):
if not 0.0 <= brightness <= 1.0:
raise ValueError("Brightness must be a decimal number in the range: 0.0~1.0")
self._backlight(int(brightness * 100))
def set_brightness(self, brightness):
if not 0.0 <= brightness <= 1.0:
raise ValueError(
"Brightness must be a decimal number in the range: 0.0~1.0")
self._backlight(int(brightness * 100))
def color(self, red, green=None, blue=None):
""" Convert red, green and blue values (0-255) into a 16-bit 565 encoding."""
if green is None or blue is None:
return red
else:
return (red & 0xf8) << 8 | (green & 0xfc) << 3 | blue >> 3
def color(self, red, green=None, blue=None):
""" Convert red, green and blue values (0-255) into a 16-bit 565 encoding."""
if green is None or blue is None:
return red
else:
return (red & 0xf8) << 8 | (green & 0xfc) << 3 | blue >> 3
def show(self):
"""Refresh the display and show the changes."""
if self._oneclight:
self.set_brightness(0.6)
self._oneclight = False
self._write(_CMD_CASET, b'\x00\x00\x00\xef')
self._write(_CMD_RASET, b'\x00\x00\x00\xef')
self._write(_CMD_RAMWR, self._buffer)
def show(self):
"""Refresh the display and show the changes."""
if self._oneclight:
self.set_brightness(0.6)
self._oneclight = False
self._write(_CMD_CASET, b'\x00\x00\x00\xef')
self._write(_CMD_RASET, b'\x00\x00\x00\xef')
self._write(_CMD_RAMWR, self._buffer)

97
boards/default_src/micropython_esp32s3/origin/build/lib/ws2812x.py
View File

@@ -7,60 +7,61 @@ Micropython library for the WS2812 NeoPixel-RGB(method inheritance)
"""
from time import sleep
class NeoPixel:
def __init__(self, func, n, bpp=3, ORDER=(0, 1, 2, 3)):
self.func = func
self.bpp = bpp
self.rgbs = n
self.ORDER = ORDER
self.rgb_buf = bytearray(self.rgbs * bpp)
self.write()
def __init__(self, func, n, bpp=3, ORDER=(0, 1, 2, 3)):
self.func = func
self.bpp = bpp
self.rgbs = n
self.ORDER = ORDER
self.rgb_buf = bytearray(self.rgbs * bpp)
self.write()
def __len__(self):
return self.rgbs
def __len__(self):
return self.rgbs
def __setitem__(self, n, v):
for i in range(self.bpp):
self.rgb_buf[n * self.bpp + self.ORDER[i]] = v[i]
def __setitem__(self, n, v):
for i in range(self.bpp):
self.rgb_buf[n * self.bpp + self.ORDER[i]] = v[i]
def __getitem__(self, n):
return tuple(self.rgb_buf[n * self.bpp + self.ORDER[i]] for i in range(self.bpp))
def __getitem__(self, n):
return tuple(self.rgb_buf[n * self.bpp + self.ORDER[i]] for i in range(self.bpp))
def fill(self, v):
for i in range(self.bpp):
j = self.ORDER[i]
while j < self.rgbs * self.bpp:
self.rgb_buf[j] = v[i]
j += self.bpp
def fill(self, v):
for i in range(self.bpp):
j = self.ORDER[i]
while j < self.rgbs * self.bpp:
self.rgb_buf[j] = v[i]
j += self.bpp
def write(self):
self.func(self.rgb_buf)
def write(self):
self.func(self.rgb_buf)
def color_chase(self,R, G, B, wait):
for i in range(self.rgbs):
self.__setitem__(i,(R, G, B))
self.write()
sleep(wait/1000)
def color_chase(self, R, G, B, wait):
for i in range(self.rgbs):
self.__setitem__(i, (R, G, B))
self.write()
sleep(wait/1000)
def rainbow_cycle(self, wait, clear=True):
for j in range(255):
for i in range(self.rgbs):
rc_index = (i * 256 // self.rgbs) + j
self.__setitem__(i,self.wheel(rc_index & 255))
self.write()
sleep(wait / 1000 / 256)
if clear:
self.fill((0, 0, 0))
self.write()
def rainbow_cycle(self, wait, clear=True):
for j in range(255):
for i in range(self.rgbs):
rc_index = (i * 256 // self.rgbs) + j
self.__setitem__(i, self.wheel(rc_index & 255))
self.write()
sleep(wait / 1000 / 256)
if clear:
self.fill((0, 0, 0))
self.write()
def wheel(self,pos):
if pos < 0 or pos > 255:
return (0, 0, 0)
elif pos < 85:
return (pos * 3, 255 - pos * 3, 0)
elif pos < 170:
pos -= 85
return (255 - pos * 3, 0, pos * 3)
else:
pos -= 170
return (0, pos * 3, 255 - pos * 3)
def wheel(self, pos):
if pos < 0 or pos > 255:
return (0, 0, 0)
elif pos < 85:
return (pos * 3, 255 - pos * 3, 0)
elif pos < 170:
pos -= 85
return (255 - pos * 3, 0, pos * 3)
else:
pos -= 170
return (0, pos * 3, 255 - pos * 3)