from Maix import GPIO
def gpio_test():
for i in range(5):
led_b.value(1)
led_g.value(1)
time.sleep_ms(100)
print('woking...')
led_b.value(0)
led_g.value(0)
time.sleep_ms(100)
print('woking...')
print('register...')
fm.register(12, fm.fpioa.GPIO0)
fm.register(13, fm.fpioa.GPIOHS0)
led_b = GPIO(GPIO.GPIO0, GPIO.OUT)
led_g = GPIO(GPIO.GPIOHS0, GPIO.OUT)
gpio_test()
print('unregister...')
fm.unregister(12)
fm.unregister(13)
gpio_test()
print('register...')
fm.register(12, fm.fpioa.GPIO0)
fm.register(13, fm.fpioa.GPIOHS0)
gpio_test()
fm.unregister(12)
fm.unregister(13)
# register Coverage test
fm.register(12, fm.fpioa.GPIO0)
time.sleep_ms(500)
import network, socket, time, sensor, image
from machine import UART
from Maix import GPIO
from fpioa_manager import fm
from board import board_info
########## config ################
wifi_ap_ssid = "Sipeed_2.4G"
wifi_ap_passwd = "Sipeed123."
server_ip = "192.168.0.183"
server_port = 3456
##################################
# for new MaixGO board, if not, remove it
fm.register(0, fm.fpioa.GPIOHS1, force=True)
wifi_io0_en=GPIO(GPIO.GPIOHS1, GPIO.OUT)
wifi_io0_en.value(0)
# En SEP8285
fm.register(8, fm.fpioa.GPIOHS0, force=True)
wifi_en=GPIO(GPIO.GPIOHS0,GPIO.OUT)
fm.register(board_info.WIFI_RX,fm.fpioa.UART2_TX, force=True)
fm.register(board_info.WIFI_TX,fm.fpioa.UART2_RX, force=True)
def wifi_enable(en):
global wifi_en
wifi_en.value(en)
def wifi_reset():
global uart
wifi_enable(0)
import sensor import image import utime import lcd import uos from fpioa_manager import * from Maix import GPIO import KPU as kpu import ulab as np # Init LEDs fm.register(board_info.LED_R, fm.fpioa.GPIO0) led_r = GPIO(GPIO.GPIO0, GPIO.OUT) led_r.value(1) # 0 : ON, 1: OFF fm.register(board_info.LED_G, fm.fpioa.GPIO1) led_g = GPIO(GPIO.GPIO1, GPIO.OUT) led_g.value(1) # 0 : ON, 1: OFF fm.register(board_info.LED_B, fm.fpioa.GPIO2) led_b = GPIO(GPIO.GPIO2, GPIO.OUT) led_b.value(1) # 0 : ON, 1: OFF fm.register(board_info.LED_W, fm.fpioa.GPIO3) led_w = GPIO(GPIO.GPIO3, GPIO.OUT) led_w.value(1) # 0 : ON, 1: OFF # Init Button fm.register(board_info.BUTTON_A, fm.fpioa.GPIO4) button_a = GPIO(GPIO.GPIO4, GPIO.PULL_UP)
# https://gist.github.com/Shinichi-Ohki/b113b3d7b90cfb0aa52b97b955127542
# M5StickVのバッテリ電圧と放電電流を取得
import lcd
import utime
import sys
from machine import I2C
from Maix import GPIO
from fpioa_manager import *
i2c = I2C(I2C.I2C0, freq=400000, scl=28, sda=29)
# And a short delay to wait until the I2C port has finished activating.
utime.sleep_ms(100)
fm.register(board_info.BUTTON_A, fm.fpioa.GPIO1)
but_a=GPIO(GPIO.GPIO1, GPIO.IN, GPIO.PULL_UP) #PULL_UP is required here!
lcd.init()
i2c.writeto_mem(0x34, 0x82,b'\xff') # all ADC eneble
i2c.writeto_mem(0x34, 0xb8, b'\x80') # Coulomb counter eneble
i2c.writeto_mem(0x34, 0x91, b'\xa0') # LCD Backlight
while 1:
if but_a.value() == 0: #If dont want to run the demo
sys.exit()
buf = int.from_bytes(i2c.readfrom_mem(0x34, 0x78, 1), 'big')
buf2 = int.from_bytes(i2c.readfrom_mem(0x34, 0x79, 1), 'big')
lcd.draw_string(0, 0, "Battery Voltage " +
str(((buf << 4)+buf2)*1.4)+" mV", lcd.RED, lcd.BLACK)
buf = int.from_bytes(i2c.readfrom_mem(0x34, 0x7c, 1), 'big')
from fpioa_manager import *
import os, Maix, lcd, image
from Maix import FPIOA, GPIO
fpioa = FPIOA()
in_pin = 5 # Actual pin on the Maix
fpioa.set_function( in_pin, FPIOA.GPIO6) # How the k210 gpio6 gets routed to pin 22
in_gpio = GPIO(GPIO.GPIO6, GPIO.IN) # How the k210 knows what GPIO6 should do
lcd.init(color=lcd.WHITE)
lcd.draw_string(0,0, "Testing pin 5 as GPIO6", lcd.BLACK, lcd.WHITE )
while True:
lcd.draw_string(0, 50, "pin 5 value is: %d" % in_gpio.value(), lcd.BLACK, lcd.WHITE )
# #define SPI_IPS_LCD_MOSI_PIN_NUM 8
spi1 = SPI(SPI.SPI1, mode=SPI.MODE_MASTER, baudrate=600 * 1000,
polarity=0, phase=0, bits=8, firstbit=SPI.MSB, sck=21, mosi=8)
# w = b'1234'
# r = bytearray(4)
# spi1.write(w)
# spi1.write(w, cs=SPI.CS0)
# spi1.write_readinto(w, r)
# spi1.read(5, write=0x00)
# spi1.readinto(r, write=0x00)
fm.register(20, fm.fpioa.GPIOHS20, force=True) # #define SPI_IPS_LCD_SS_PIN_NUM 20
fm.register(15, fm.fpioa.GPIOHS15, force=True) # #define SPI_IPS_LCD_DC_PIN_NUM 15
fm.register(6, fm.fpioa.GPIOHS6, force=True) # #define SPI_IPS_LCD_BUSY_PIN_NUM 6
fm.register(7, fm.fpioa.GPIOHS7, force=True) # #define SPI_IPS_LCD_RST_PIN_NUM 7
cs = GPIO(GPIO.GPIOHS20, GPIO.OUT)
dc = GPIO(GPIO.GPIOHS15, GPIO.OUT)
busy = GPIO(GPIO.GPIOHS6, GPIO.IN, GPIO.PULL_DOWN)
rst = GPIO(GPIO.GPIOHS7, GPIO.OUT)
tmp = EPD(spi1, cs, dc, rst, busy)
tmp.init()
#tmp.set_memory_area(1, 1, 5, 5)
#tmp.display_frame()
print('test')
player.volume(100)
while True:
ret = player.play()
if ret == None:
print("format error")
break
elif ret == 0:
print("end")
break
player.finish()
# 音频使能IO
AUDIO_PA_EN_PIN = 32
fm.register(16, fm.fpioa.GPIO1)
KEY = GPIO(GPIO.GPIO1, GPIO.IN)
fm.register(12, fm.fpioa.GPIO0)
LED_B = GPIO(GPIO.GPIO0, GPIO.OUT)
LED_B.value(0)
#fm.register(14, fm.fpioa.GPIO2)
#fm.register(13, fm.fpioa.GPIO1)
LED_R = GPIO(GPIO.GPIO2, GPIO.OUT, value=1)
LED_G = GPIO(GPIO.GPIO1, GPIO.OUT, value=1)
img = None
LED_R.value(1)
LED_G.value(1)
#注册音频使能IO
if AUDIO_PA_EN_PIN:
fm.register(AUDIO_PA_EN_PIN, fm.fpioa.GPIO1, force=True)
audio_en = GPIO(GPIO.GPIO1, GPIO.OUT, value=1)
import utime
from Maix import GPIO
from board import board_info
from fpioa_manager import fm
# register pin to gpiohs0,
# arg force means force register no matter we have registered before or not
# if arg force=False(by default), register func will return a tuple that registered info,
# or return number 1
fm.register(board_info.LED_R, fm.fpioa.GPIO0, force=True)
fm.register(board_info.LED_G, fm.fpioa.GPIOHS0, force=True)
fm.register(board_info.LED_B, fm.fpioa.GPIO1, force=True)
led_r = GPIO(GPIO.GPIO0, GPIO.OUT)
led_g = GPIO(GPIO.GPIOHS0, GPIO.OUT)
led_b = GPIO(GPIO.GPIO1, GPIO.OUT)
i = 0
status = 0
while i < 50:
led_r.value(status)
utime.sleep_ms(500)
led_g.value(status)
utime.sleep_ms(500)
led_b.value(status)
utime.sleep_ms(500)
i += 1
status = 0 if (status == 1) else 1
fm.unregister(board_info.LED_R, fm.fpioa.GPIO0)
fm.unregister(board_info.LED_G, fm.fpioa.GPIOHS0)
PIXEL_LED_pin = 8
PIXEL_LED_num = 1
PIXEL_LED = class_ws2812 = ws2812(PIXEL_LED_pin, PIXEL_LED_num)
Color_Green = 0xE0
Color_Green_half = 0x80
Color_Green_min = 0x40
Color_Red_max = 0xFF
Color_Red = 0xE0
Color_Red_half = 0xA0
Color_Blue = 0xE0
print("GROVE port GND, VCC_5V, G35,G34 function: UART1")
#UnitV btns
#Btn A, capature image
fm.register(18, fm.fpioa.GPIO1)
Btn_A = GPIO(GPIO.GPIO1, GPIO.IN, GPIO.PULL_UP) #PULL_UP is required here!
#Btn B
fm.register(19, fm.fpioa.GPIO2)
Btn_B = GPIO(GPIO.GPIO2, GPIO.IN, GPIO.PULL_UP) #PULL_UP is required here!
isButtonPressedA = 0
isButtonPressedB = 0
#
GROVE_pin3 = 35 #chip physical port pin number
GROVE_pin4 = 34
fm.unregister(GROVE_pin3, fm.fpioa.GPIOHS13)
fm.unregister(GROVE_pin4, fm.fpioa.GPIOHS14)
# fit to m5stack fire grove C: pin 3 TX, pin4 RX
fm.register(GROVE_pin4, fm.fpioa.UART1_TX)
import image
import utime
import lcd
import uos
import math
from machine import SPI
from fpioa_manager import *
from Maix import GPIO
from board import board_info
# Show Board Info
#board_info.pin_map()
# Init Button
fm.register(board_info.BUTTON_A, fm.fpioa.GPIO4)
button_a = GPIO(GPIO.GPIO4, GPIO.PULL_UP)
# Init LCD
print("init LCD")
lcd.init(type=3, freq=400000)
lcd.clear()
lcd.rotation(2)
# Find /SD
if uos.getcwd() != "/sd":
sd_flag = False
else:
sd_flag = True
print("sd : ", sd_flag)
# Init IMU
self._register(_INTERRUPT_CLEAR, 0x01)
return value
if __name__ == "__main__":
################### config ###################
VL53L0X_I2C_NUM = I2C.I2C0
VL53L0X_FREQ = const(100000)
VL53L0X_SCL = const(6)
VL53L0X_SDA = const(7)
VL53L0X_SHT = const(8)
##############################################
# io configure
fm.register(VL53L0X_SHT, fm.fpioa.GPIOHS0, force=True)
XSHUT = GPIO(GPIO.GPIOHS0, GPIO.OUT)
XSHUT.value(1)
# i2c init
i2c = I2C(VL53L0X_I2C_NUM,
freq=VL53L0X_FREQ,
scl=VL53L0X_SCL,
sda=VL53L0X_SDA)
devices = i2c.scan()
print(devices)
# create obj and read distance
tof = VL53L0X(i2c)
while True:
mm = tof.read()
utime.sleep_ms(100)
''' CUBE
07 | V
15 | 21
20 | 08
G | 06
'''
''' AMIGO
24 | V
06 | 11
12 | 10
G | 27
'''
print("Welcome to MicroPython!")
fm.register(20, fm.fpioa.GPIO5, force=True)
cs = GPIO(GPIO.GPIO5, GPIO.OUT)
#cs.value(0)
#utime.sleep_ms(2000)
print(os.listdir())
spi = SPI(SPI.SPI1,
mode=SPI.MODE_MASTER,
baudrate=400 * 1000,
polarity=0,
phase=0,
bits=8,
firstbit=SPI.MSB,
sck=21,
mosi=8,
miso=15) #使用程序配置了 cs0 则无法读取 W25QXX
print(os.listdir())
pub_msg))
pub_msg = None
if pub_msg:
self.on_msg(pub_msg)
self.msg = self.msg[idx +
2:] # remove "+TCMQTTRCVPUB:...\r\n"
if __name__ == "__main__":
from Maix import GPIO
from machine import UART
from fpioa_manager import fm
fm.register(8, fm.fpioa.GPIOHS1, force=True)
fm.register(12, fm.fpioa.GPIOHS2, force=True)
wifi_rst = GPIO(GPIO.GPIOHS1, GPIO.OUT)
led_g = GPIO(GPIO.GPIOHS2, GPIO.OUT)
led_g.value(1)
wifi_rst.value(0)
t = time.ticks_ms()
def wifi_reset(uart):
wifi_rst.value(0)
time.sleep_ms(200)
wifi_rst.value(1)
read = b""
while 1:
time.sleep_ms(100)
msg = uart.read()
if msg:
read += msg
import sensor, image, time, lcd, audio
from fpioa_manager import *
from Maix import GPIO, I2S
fm.register(board_info.BUTTON_A, fm.fpioa.GPIO1)
fm.register(board_info.BUTTON_B, fm.fpioa.GPIO2)
but_a = GPIO(GPIO.GPIO1, GPIO.IN, GPIO.PULL_UP)
but_b = GPIO(GPIO.GPIO2, GPIO.IN, GPIO.PULL_UP)
fm.register(board_info.SPK_SD, fm.fpioa.GPIO0)
spk_sd = GPIO(GPIO.GPIO0, GPIO.OUT)
spk_sd.value(1)
fm.register(board_info.SPK_DIN, fm.fpioa.I2S0_OUT_D1)
fm.register(board_info.SPK_BCLK, fm.fpioa.I2S0_SCLK)
fm.register(board_info.SPK_LRCLK, fm.fpioa.I2S0_WS)
wav_dev = I2S(I2S.DEVICE_0)
lcd.init()
lcd.rotation(2)
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.skip_frames(30)
def play_sound(filename):
try:
player = audio.Audio(path=filename)
player.volume(50)
wav_info = player.play_process(wav_dev)
wav_dev.channel_config(wav_dev.CHANNEL_1,
def draw_string(img, x, y, text, color, scale, bg=None ):
if bg:
img.draw_rectangle(x-2,y-2, len(text)*8*scale+4 , 16*scale, fill=True, color=bg)
img = img.draw_string(x, y, text, color=color,scale=scale)
return img
lcd.init()
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.set_windowing((224, 224))
fm.register(board_info.BOOT_KEY, fm.fpioa.GPIOHS0)
key = GPIO(GPIO.GPIOHS0, GPIO.PULL_UP)
class_num = 3
sample_num = 15
THRESHOLD = 11
class_names = ['class1', 'class2', 'class3']
try:
del model
except Exception:
pass
try:
del classifier
except Exception:
pass
gc.collect()
model = kpu.load(0x300000)
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.set_windowing((224, 224))
if board_cube == 1:
sensor.set_vflip(True)
sensor.set_hmirror(True)
lcd.init(type=2)
lcd.rotation(2)
else:
lcd.init()
fm.register(board_info.BOOT_KEY, fm.fpioa.GPIOHS0)
key = GPIO(GPIO.GPIOHS0, GPIO.PULL_UP)
try:
del model
except Exception:
pass
try:
del classifier
except Exception:
pass
gc.collect()
model = kpu.load(0x300000)
classifier = kpu.classifier(model, class_num, sample_num)
cap_num = 0
train_status = 0
import sensor
import audio
from Maix import I2S, GPIO
from fpioa_manager import *
##################################################
# initialize
##################################################
# レジスタを設定
fm.register(board_info.SPK_SD, fm.fpioa.GPIO0)
fm.register(board_info.SPK_DIN, fm.fpioa.I2S0_OUT_D1)
fm.register(board_info.SPK_BCLK, fm.fpioa.I2S0_SCLK)
fm.register(board_info.SPK_LRCLK, fm.fpioa.I2S0_WS)
# GPIO設定
spk_sd = GPIO(GPIO.GPIO0, GPIO.OUT)
# スピーカーを有効化
spk_sd.value(1)
# 再生デバイスを設定
wav_dev = I2S(I2S.DEVICE_0)
##################################################
# function
##################################################
# 音声ファイルを再生
def play_sound(filename):
try:
# 音声ファイルを読み込み
def boot_set_IF():
fm.register(board_info.BUTTON_A, fm.fpioa.GPIO1)
but_a = GPIO(GPIO.GPIO1, GPIO.IN, GPIO.PULL_UP) #PULL_UP is required here!
fm.register(board_info.BUTTON_B, fm.fpioa.GPIO2)
but_b = GPIO(GPIO.GPIO2, GPIO.IN, GPIO.PULL_UP) #PULL_UP is required here!
fm.register(board_info.LED_W, fm.fpioa.GPIO3)
led_w = GPIO(GPIO.GPIO3, GPIO.OUT)
led_w.value(1) #RGBW LEDs are Active Low
fm.register(board_info.LED_R, fm.fpioa.GPIO4)
led_r = GPIO(GPIO.GPIO4, GPIO.OUT)
led_r.value(1) #RGBW LEDs are Active Low
fm.register(board_info.LED_G, fm.fpioa.GPIO5)
led_g = GPIO(GPIO.GPIO5, GPIO.OUT)
led_g.value(1) #RGBW LEDs are Active Low
fm.register(board_info.LED_B, fm.fpioa.GPIO6)
led_b = GPIO(GPIO.GPIO6, GPIO.OUT)
led_b.value(1) #RGBW LEDs are Active Low
fm.register(board_info.LED_B, fm.fpioa.GPIO6)
led_b = GPIO(GPIO.GPIO6, GPIO.OUT)
led_b.value(1) #
time.sleep(0.5) # Delay for few seconds to see the start-up screen :p
if but_a.value() == 0:
sys.exit()
lcd.draw_string(10, 10, 'Abfall Klassifizierung') lcd.draw_string(10, 30, 'Lade Modell ' + kmodel_path + ' ...') # Init camers sensor.reset() sensor.set_pixformat(sensor.RGB565) sensor.set_framesize(sensor.QVGA) sensor.set_windowing((224, 224)) sensor.set_vflip(1) sensor.run(1) # Init button fpioa = FPIOA() fpioa.set_function(board_info.PIN15, fm.fpioa.GPIOHS0) pin = fpioa.get_Pin_num(fm.fpioa.GPIOHS0) pin = GPIO(GPIO.GPIOHS0, GPIO.IN) # Init touchscreen i2c = I2C(I2C.I2C0, freq=400000, scl=30, sda=31) ts.init(i2c) # Load model task = kpu.load(kmodel_path) img = image.Image() img_icon = image.Image() # ===== Configure trash classification specific parameters ===== # Class label vector # Last entry is the label for values below the threshold -> unknown
import time
import uos
import KPU as kpu
from fpioa_manager import *
from machine import I2C
from Maix import I2S, GPIO
#
# initialize
#
lcd.init()
lcd.rotation(2)
i2c = I2C(I2C.I2C0, freq=400000, scl=28, sda=29)
fm.register(board_info.SPK_SD, fm.fpioa.GPIO0)
spk_sd=GPIO(GPIO.GPIO0, GPIO.OUT)
spk_sd.value(1) #Enable the SPK output
fm.register(board_info.SPK_DIN,fm.fpioa.I2S0_OUT_D1)
fm.register(board_info.SPK_BCLK,fm.fpioa.I2S0_SCLK)
fm.register(board_info.SPK_LRCLK,fm.fpioa.I2S0_WS)
wav_dev = I2S(I2S.DEVICE_0)
def play_sound(filename):
try:
player = audio.Audio(path = filename)
player.volume(100)
wav_info = player.play_process(wav_dev)
wav_dev.channel_config(wav_dev.CHANNEL_1, I2S.TRANSMITTER,resolution = I2S.RESOLUTION_16_BIT, align_mode = I2S.STANDARD_MODE)
import time import uos import KPU as kpu from fpioa_manager import * from machine import I2C from Maix import I2S, GPIO # # initialize # lcd.init() lcd.rotation(2) i2c = I2C(I2C.I2C0, freq=400000, scl=28, sda=29) fm.register(board_info.SPK_SD, fm.fpioa.GPIO0) spk_sd=GPIO(GPIO.GPIO0, GPIO.OUT) spk_sd.value(1) #Enable the SPK output fm.register(board_info.SPK_DIN,fm.fpioa.I2S0_OUT_D1) fm.register(board_info.SPK_BCLK,fm.fpioa.I2S0_SCLK) fm.register(board_info.SPK_LRCLK,fm.fpioa.I2S0_WS) wav_dev = I2S(I2S.DEVICE_0) fm.register(board_info.BUTTON_A, fm.fpioa.GPIO1) but_a=GPIO(GPIO.GPIO1, GPIO.IN, GPIO.PULL_UP) #PULL_UP is required here! fm.register(board_info.BUTTON_B, fm.fpioa.GPIO2) but_b = GPIO(GPIO.GPIO2, GPIO.IN, GPIO.PULL_UP) #PULL_UP is required here! fm.register(board_info.LED_W, fm.fpioa.GPIO3)
class RGB_LED:
def __init__(self, clk, data, number_leds, clk_gpiohs=0, data_gpiohs=1):
#fm.register(clk, fm.fpioa.GPIOHS0)
#fm.register(data, fm.fpioa.GPIOHS1)
self.clk = GPIO(clk, GPIO.OUT)
self.data = GPIO(data, GPIO.OUT)
self.clk.value(1)
self.data.value(0)
self.status = []
for i in range(number_leds):
self.status.append([0, 0, 0])
def check_RGB(self, value):
if not value in range(0, 256):
raise ValueError("value: [0, 255]")
def check_HSB(self, value):
if not value in range(0.0, 1.0):
raise ValueError("value: [0, 1]")
# red, green, blue
def set_RGB(self, led, r, g, b):
self.check_RGB(r)
self.check_RGB(g)
self.check_RGB(b)
self.send_byte(0x00)
self.send_byte(0x00)
self.send_byte(0x00)
self.send_byte(0x00)
for i in range(len(self.status)):
if i == led:
self.status[i] = [r, g, b]
self.send_color(self.status[i][0], self.status[i][1],
self.status[i][2])
self.send_byte(0x00)
self.send_byte(0x00)
self.send_byte(0x00)
self.send_byte(0x00)
def send_byte(self, data):
for i in range(8):
if data & 0x80:
self.data.value(1)
else:
self.data.value(0)
self.write_clk()
data <<= 1
def write_clk(self):
self.clk.value(0)
time.sleep_us(20)
self.clk.value(1)
time.sleep_us(20)
def send_color(self, r, g, b):
prefix = 0xC0
if (b & 0x80) == 0:
prefix |= 0x20
if (b & 0x40) == 0:
prefix |= 0x10
if (g & 0x80) == 0:
prefix |= 0x08
if (g & 0x40) == 0:
prefix |= 0x04
if (r & 0x80) == 0:
prefix |= 0x02
if (r & 0x40) == 0:
prefix |= 0x01
self.send_byte(prefix)
self.send_byte(b)
self.send_byte(g)
self.send_byte(r)
from Maix import GPIO
from Maix import I2S
from Maix import FFT
from fpioa_manager import *
import image
import lcd
lcd.init()
fm.register(8, fm.fpioa.GPIO0)
wifi_en = GPIO(GPIO.GPIO0, GPIO.OUT)
wifi_en.value(0)
fm.register(20, fm.fpioa.I2S0_IN_D0)
fm.register(19, fm.fpioa.I2S0_WS)
fm.register(18, fm.fpioa.I2S0_SCLK)
rx = I2S(I2S.DEVICE_0)
rx.channel_config(rx.CHANNEL_0, rx.RECEIVER, align_mode=I2S.STANDARD_MODE)
sample_rate = 2048
rx.set_sample_rate(sample_rate)
img = image.Image()
sample_points = 512
FFT_points = 256
lcd_width = 320
lcd_height = 240
#hist_num = FFT_points #changeable
hist_num = 32 #changeable
if hist_num > 320:
hist_num = 320
hist_width = int(320 / hist_num) #changeable
x_shift = 0
while True:
audio = rx.record(sample_points)
FFT_res = FFT.run(audio.to_bytes(), FFT_points)
def set_gpio_output(pin_number, status):
global board_info
_pin = board_info['gpio'][pin_number]
_pinObj = GPIO(_pin, GPIO.OUT, GPIO.PULL_NONE)
_pinObj.value(status)
lcd.init()
lcd.rotation(2)
# reduce screen brightness
pmu = axp192()
pmu.setScreenBrightness(8) #[0..15]
try:
from pmu import axp192
pmu = axp192()
pmu.enablePMICSleepMode(True)
except:
pass
fm.register(board_info.SPK_SD, fm.fpioa.GPIO0)
spk_sd = GPIO(GPIO.GPIO0, GPIO.OUT)
spk_sd.value(1) #Enable the SPK output
fm.register(board_info.SPK_DIN, fm.fpioa.I2S0_OUT_D1)
fm.register(board_info.SPK_BCLK, fm.fpioa.I2S0_SCLK)
fm.register(board_info.SPK_LRCLK, fm.fpioa.I2S0_WS)
wav_dev = I2S(I2S.DEVICE_0)
fm.register(board_info.BUTTON_A, fm.fpioa.GPIO1)
but_a = GPIO(GPIO.GPIO1, GPIO.IN, GPIO.PULL_UP) #PULL_UP is required here!
fm.register(board_info.BUTTON_B, fm.fpioa.GPIO2)
but_b = GPIO(GPIO.GPIO2, GPIO.IN, GPIO.PULL_UP) #PULL_UP is required here!
def get_gpio_input(pin_number):
global board_info
_pin = board_info['gpio'][pin_number]
_pinObj = GPIO(_pin, GPIO.IN, GPIO.PULL_NONE)
return _pinObj.value()
import utime
from Maix import GPIO
from board import board_info
from fpioa_manager import fm
# register pin to gpiohs0,
# arg force means force register no matter we have registered before or not
# if arg force=False(by default), register func will return a tuple that registered info,
# or return number 1
fm.register(board_info.LED_R, fm.fpioa.GPIO0, force=True)
fm.register(board_info.LED_G, fm.fpioa.GPIOHS0, force=True)
fm.register(board_info.BOOT_KEY, fm.fpioa.GPIO1, force=True)
led_r = GPIO(GPIO.GPIO0, GPIO.OUT)
led_g = GPIO(GPIO.GPIOHS0, GPIO.OUT)
input = GPIO(GPIO.GPIO1, GPIO.IN)
i = 0
status = 0
while i<20:
led_r.value(status)
led_g.value(status)
print("LED :", led_r.value())
print("-----input:", input.value())
i+=1
status = 0 if (status==1) else 1
utime.sleep_ms(500)
fm.unregister(board_info.LED_R, fm.fpioa.GPIO0)
fm.unregister(board_info.LED_R, fm.fpioa.GPIOHS0)
fm.unregister(board_info.BOOT_KEY, fm.fpioa.GPIO1)
import image
import utime
import lcd
import uos
import math
from machine import I2C
from fpioa_manager import *
from Maix import GPIO
# Init Button
fm.register(board_info.BUTTON_A, fm.fpioa.GPIO4)
button_a = GPIO(GPIO.GPIO4, GPIO.PULL_UP)
# Init LCD
print("init LCD")
lcd.init(type=3, freq=400000)
lcd.clear()
lcd.rotation(2)
# Find /SD
if uos.getcwd() != "/sd":
sd_flag = False
else:
sd_flag = True
print("sd : ", sd_flag)
# Init IMU
fm.register(25, fm.fpioa.GPIO5)
i2c_cs = GPIO(GPIO.GPIO5, GPIO.OUT)
i2c_cs.value(1)
fm.register(24, fm.fpioa.GPIO6)
class M5StickVSystem:
def __init__(self):
self.pmu = AXP192()
self.pmu.setScreenBrightness(0)
self.pmu.set_on_pressed_listener(self.on_pek_button_pressed)
self.pmu.set_on_long_pressed_listener(self.on_pek_button_long_pressed)
self.pmu.set_system_periodic_task(self.system_periodic_task)
self.app_stack = []
lcd.init()
self.pmu.setScreenBrightness(0)
lcd.rotation(2) # Rotate the lcd 180deg
# set brightness to zero before first draw to avoid flower screen
self.pmu.setScreenBrightness(0)
self.home_button = None
self.top_button = None
self.led_w = None
self.led_r = None
self.led_g = None
self.led_b = None
self.spk_sd = None
self.is_handling_irq = False
self.init_fm()
self.is_drawing_dirty = False
self.is_boot_complete_first_draw = True
self.show_provision()
self.navigate(LauncherApp(self))
def show_provision(self):
img = image.Image(resource.provision_image_path)
lcd.display(img)
del img
lcd.draw_string(54, 6, "NEXT", lcd.RED, lcd.BLACK)
lcd.draw_string(168, 6, "ENTER", lcd.RED, lcd.BLACK)
lcd.draw_string(152,
lcd.height() - 18, "BACK/POWER", lcd.RED, lcd.BLACK)
lcd.draw_string(21,
lcd.height() - 18, "StickV Computer", lcd.WHITE,
lcd.BLACK)
self.check_restore_brightness()
self.wait_event()
def button_irq(self, gpio, optional_pin_num=None):
print("button_irq start:", gpio, optional_pin_num)
# Notice: optional_pin_num exist in older firmware
if self.is_handling_irq:
print("is_handing_irq, ignore")
return
self.is_handing_irq = True
value = gpio.value()
state = "released" if value else "pressed"
# msg = {"type": "key_event", "gpio": gpio, "state": state}
print("button_irq:", gpio, optional_pin_num, state)
if self.home_button is gpio:
self.on_home_button_changed(state)
elif self.top_button is gpio:
self.on_top_button_changed(state)
self.is_handing_irq = False
print("button_irq end:", gpio, optional_pin_num, state)
#gpio.irq(self.button_irq, GPIO.IRQ_BOTH, GPIO.WAKEUP_NOT_SUPPORT, 7)
# noinspection SpellCheckingInspection
def init_fm(self):
# home button
fm.register(board_info.BUTTON_A, fm.fpioa.GPIOHS21)
# PULL_UP is required here!
self.home_button = GPIO(GPIO.GPIOHS21, GPIO.IN, GPIO.PULL_UP)
# self.home_button.irq(self.button_irq, GPIO.IRQ_BOTH,
# GPIO.WAKEUP_NOT_SUPPORT, 7)
if self.home_button.value() == 0: # If don't want to run the demo
sys.exit()
# top button
fm.register(board_info.BUTTON_B, fm.fpioa.GPIOHS22)
# PULL_UP is required here!
self.top_button = GPIO(GPIO.GPIOHS22, GPIO.IN, GPIO.PULL_UP)
# self.top_button.irq(self.button_irq, GPIO.IRQ_BOTH,
# GPIO.WAKEUP_NOT_SUPPORT, 7)
return # TODO: fix me
fm.register(board_info.LED_W, fm.fpioa.GPIO3)
self.led_w = GPIO(GPIO.GPIO3, GPIO.OUT)
self.led_w.value(1) # RGBW LEDs are Active Low
fm.register(board_info.LED_R, fm.fpioa.GPIO4)
self.led_r = GPIO(GPIO.GPIO4, GPIO.OUT)
self.led_r.value(1) # RGBW LEDs are Active Low
fm.register(board_info.LED_G, fm.fpioa.GPIO5)
self.led_g = GPIO(GPIO.GPIO5, GPIO.OUT)
self.led_g.value(1) # RGBW LEDs are Active Low
fm.register(board_info.LED_B, fm.fpioa.GPIO6)
self.led_b = GPIO(GPIO.GPIO6, GPIO.OUT)
self.led_b.value(1) # RGBW LEDs are Active Low
fm.register(board_info.SPK_SD, fm.fpioa.GPIO0)
self.spk_sd = GPIO(GPIO.GPIO0, GPIO.OUT)
self.spk_sd.value(1) # Enable the SPK output
fm.register(board_info.SPK_DIN, fm.fpioa.I2S0_OUT_D1)
fm.register(board_info.SPK_BCLK, fm.fpioa.I2S0_SCLK)
fm.register(board_info.SPK_LRCLK, fm.fpioa.I2S0_WS)
def invalidate_drawing(self):
print("invalidate_drawing")
self.is_drawing_dirty = True
def run(self):
try:
self.run_inner()
except Exception as e:
import uio
string_io = uio.StringIO()
sys.print_exception(e, string_io)
s = string_io.getvalue()
print("showing blue screen:", s)
lcd.clear(lcd.BLUE)
msg = "** " + str(e)
chunks, chunk_size = len(msg), 29
msg_lines = [
msg[i:i + chunk_size] for i in range(0, chunks, chunk_size)
]
# "A problem has been detected and windows has been shut down to prevent damange to your m5stickv :)"
lcd.draw_string(1, 1, "A problem has been detected and windows",
lcd.WHITE, lcd.BLUE)
lcd.draw_string(1, 1 + 5 + 16, "Technical information:", lcd.WHITE,
lcd.BLUE)
current_y = 1 + 5 + 16 * 2
for line in msg_lines:
lcd.draw_string(1, current_y, line, lcd.WHITE, lcd.BLUE)
current_y += 16
if current_y >= lcd.height():
break
lcd.draw_string(1, current_y, s, lcd.WHITE, lcd.BLUE)
lcd.draw_string(1,
lcd.height() - 17,
"Will reboot after 10 seconds..", lcd.WHITE,
lcd.BLUE)
time.sleep(10)
machine.reset()
def wait_event(self):
"""key event or view invalidate event"""
print("wait for all key release")
while self.home_button.value() == 0 or self.top_button.value() == 0:
pass
print("key released, now wait for a event")
while self.home_button.value() == 1 and self.top_button.value(
) == 1 and not self.is_drawing_dirty:
pass
print("some event arrived")
if self.is_drawing_dirty:
print("drawing dirty event")
return ("drawing", "dirty")
elif self.home_button.value() == 0:
print("home_button pressed")
return (self.home_button, "pressed")
self.on_home_button_changed("pressed")
elif self.top_button.value() == 0:
print("top_button pressed")
return (self.top_button, "pressed")
self.on_top_button_changed("pressed")
else:
return None
def check_restore_brightness(self):
if self.is_boot_complete_first_draw:
self.is_boot_complete_first_draw = False
self.pmu.setScreenBrightness(
config.get_brightness()) # 7-15 is ok, normally 8
def run_inner(self):
while True:
if self.is_drawing_dirty:
print("drawing is dirty")
self.is_drawing_dirty = False
current_app = self.get_current_app()
# print("before on_draw() of", current_app, "free memory:", gc.mem_free())
print("current_app.on_draw() start")
current_app.on_draw()
print("current_app.on_draw() end")
# print("on_draw() of", current_app, "called, free memory:", gc.mem_free())
# this gc is to avoid: "core dump: misaligned load" error
# print("after gc.collect(), free memory:", gc.mem_free())
self.check_restore_brightness()
# print("sleep_ms for 1ms")
# time.sleep_ms(1)
# print("sleep_ms for 1ms end")
else:
event_info = self.wait_event()
if event_info is not None and len(event_info) == 2:
event = event_info[0]
state = event_info[1]
if event == self.home_button:
self.on_home_button_changed(state)
elif event == self.top_button:
self.on_top_button_changed(state)
def navigate(self, app):
self.app_stack.append(app)
self.invalidate_drawing()
def navigate_back(self):
if len(self.app_stack) > 0:
self.app_stack.pop()
self.invalidate_drawing()
def get_current_app(self):
return self.app_stack[-1] if len(self.app_stack) > 0 else None
def on_pek_button_pressed(self, axp):
# treat short press as navigate back
print("on_pek_button_pressed", axp)
handled = False
current_app = self.get_current_app()
if current_app:
try:
handled = current_app.on_back_pressed()
except NeedRebootException:
machine.reset()
if not handled:
print("on_back_pressed() not handled, exit current app")
self.navigate_back()
def system_periodic_task(self, axp):
current = self.get_current_app()
if current:
current.app_periodic_task()
# noinspection PyMethodMayBeStatic
def on_pek_button_long_pressed(self, axp):
print("on_pek_button_long_pressed", axp)
axp.setEnterSleepMode()
def on_home_button_changed(self, state):
print("on_home_button_changed", state)
self.get_current_app().on_home_button_changed(state)
def on_top_button_changed(self, state):
print("on_top_button_changed", state)
self.get_current_app().on_top_button_changed(state)
import KPU as kpu
import time
from Maix import FPIOA, GPIO
import gc
from fpioa_manager import fm
from board import board_info
import utime
task_fd = kpu.load(0x300000)
task_ld = kpu.load(0x400000)
task_fe = kpu.load(0x500000)
clock = time.clock()
fm.register(board_info.BOOT_KEY, fm.fpioa.GPIOHS0)
key_gpio = GPIO(GPIO.GPIOHS0, GPIO.IN)
start_processing = False
BOUNCE_PROTECTION = 50
def set_key_state(*_):
global start_processing
start_processing = True
utime.sleep_ms(BOUNCE_PROTECTION)
key_gpio.irq(set_key_state, GPIO.IRQ_RISING, GPIO.WAKEUP_NOT_SUPPORT)
lcd.init()
sensor.reset()
