EL PSY CONGROO

小米R1d 刷机

发表于2026年9月8日由admin

1.下载 http://www1.miwifi.com/miwifi_download.html

U盘
R1D 必须带硬盘

2. 准备系统格式为FAT或FAT32的U盘一个；

3. 将下载的ROM包复制到U盘的根目录，并重命名为miwifi.bin；

4. 断开小米路由器的电源，将U盘插入路由器USB接口；

5. 用细长工具将reset键按下，重新接入电源，等待指示灯变为黄色闪烁状态后松开reset键；

6. 等待刷机完成，整个过程约为10分钟，完成后系统会自动重启并进入自动启动状态；如果出现异常、失败、U盘无法读取的状况，会进入红灯状态，建议重试或更换U盘再试。

原版的SAMBA只能连接路由器的情况下使用，不能挂载在同一个局域网内使用，且SAMBA在win10 下有点问题，安卓手机APP是32位已经不兼容，苹果可以，PC客户端已经没有了;且下载功能已经失效

发表在 None | 留下评论

UART 串口模块新思路 uasyncio异步

发表于2026年8月21日由admin

使用while True下的uart.any() 来获取是否读取，读取到\x04\x04表示结束

显示信息到ST7789 『A LCD』且输入到设备的数据也显示到『A LCD 』

使用asyncio 异步来实现数据显示

输入信息在另一块ST7789上『B LCD』

usyncio下UART 和SSD1306 获取数据然后显示

import uasyncio
from machine import UART, I2C, Pin
import ssd1306

i2c = I2C(0, sda=Pin(21), scl=Pin(22))
oled = ssd1306.SSD1306_I2C(128, 64, i2c)
uart = UART(2, baudrate=9600, tx=17, rx=16)

q = uasyncio.Queue(maxsize=8)   # 消息队列，最多缓存8条消息

async def task_uart_a():
    """A：UART接收任务"""
    while True:
        if uart.any():
            raw = uart.read()
            if raw:
                s = raw.decode("utf-8","ignore")
                # 放入队列，如果队列满，put会自动await阻塞等待队列有空位
                await q.put(s)
        await uasyncio.sleep(0)

async def task_oled_b():
    """B：SSD1306显示任务"""
    while True:
        # await get()，没有数据的时候，本任务挂起，事件循环去跑其他任务
        msg = await q.get()
        oled.fill(0)
        oled.text("UART DATA", 0, 0)
        # 简单换行处理，适配屏幕
        for idx, line in enumerate(msg.split("\n")[:4]):
            oled.text(line,0,16 + idx*14)
        oled.show()
        await uasyncio.sleep(0)

async def main():
    uasyncio.create_task(task_uart_a())
    uasyncio.create_task(task_oled_b())
    await uasyncio.sleep(30)

uasyncio.run(main())

发表在 None | 留下评论

每日做T小结

发表于2026年8月19日由admin

低开（对他充满信心赌博！！！）
挂一个比开盘价低0.5-1元的价格，或者开盘价，等待10点钱卖掉

1分钟线有承接即下跌放量阴线不加大！可以考虑左侧买入

卖出固定3%-4% 直接卖出

低开（不确定）：不要操作

成交量逐步放大才能买！金叉右侧买入前要成交量放大

B点

3根阳线量价都在升
第四根阳线缩量涨

虽然金叉但是后续上不去没有量

发表在 None | 留下评论

st7789 repl uart

发表于2026年8月15日由admin

更新

from machine import SPI, Pin,I2C,Timer,freq,RTC,WDT,UART
import st7789_spi
from easydisplay import EasyDisplay
import ntptime
import network,time,requests,json
import ubinascii

# ==================== 配置区 ====================
UART_ID = 1
BAUDRATE = 115200
TX_PIN = 5
RX_PIN = 4
RAW_REPL_TIMEOUT_MS = 3000  # Raw REPL 握手与执行超时(ms)
# ================================================

uart = UART(UART_ID, baudrate=BAUDRATE, tx=TX_PIN, rx=RX_PIN ,rxbuf=16384,txbuf=16384 )




    
    




spi = SPI(1, baudrate=40000000, polarity=0, phase=0, sck=Pin(2), mosi=Pin(3))
dp = st7789_spi.ST7789(width=320, height=240, spi=spi, cs=7, dc=6, res=10, rotate=2, bl=11,invert=False, rgb=False)
sm= EasyDisplay(display=dp, font="/text_full_16px_2312.v3.bmf", show=True, color=0xFFFF, auto_wrap=True, clear=True,color_type="RGB565")
sm.clear()


class lcdrepl():
    def __init__(self,lcd,uart):
        self.lcd=lcd
        self.uart=uart
        self.line=0
        self.swap=''
        self.line_list=[]
        self.line_num=[]
    def eline(self):
        self.line_list.append(self.swap)
        self.line=len(self.line_list)
        tn=str(self.line).count("\n")
        if tn>1:
            one_line_num=tn
        else:
            one_line_num=1
        self.line_num.append(one_line_num)
        if self.line>25:
            self.line_num.pop(0)
            self.line_list.pop(0)
        #更新已经有的行数
    def combine(self,show_num=3):
        return "\n".join(self.line_list[-3:])
    def clear(self):
        self.lcd.clear()
    def show_line(self,strx,cmd=False):
        self.clear()
        clear_str=" "
        if cmd:
            strx="> "+strx
        self.swap=strx
        self.eline()
        show_info=self.combine()
        self.lcd.text(show_info, 0, 0 ,clear=False,color=0xFFF)
    def lcd_cmd(self,inx):
        self.show_line(inx,True)
        self.raw_command(inx)
    def base64_encode(self,data):
        return ubinascii.b2a_base64(data).strip()
    def base64_decode(self,data):
        return ubinascii.a2b_base64(data)


    #打印显示文件 return 回传数据 print模拟显示
    #打印
    #打印
    def show_info(self,data):
        if data:
            print(data)
            self.show_line(data)
            return data
        return False

    def show_text(self,data):
        if data:
            print(data)
            self.show_line(data)
            return data
        return False
    #打印显示文件
    #打印
    #打印00000000000000000

    def raw_read(self,wt=100):
        time.sleep_ms(wt)
        bs=self.uart.read()
    #     print(bs)
        if bs is not None:
            if bs.endswith(b'\x04\x04>'):
                #直接舍弃4KB以上的大文件
                bsd=bs.decode()
                if bsd[2:-3]:
                    return bsd[2:-3]
        return False
    def raw_start(self):
        self.uart.write(b'\x03')
        time.sleep_ms(100)
        self.uart.write(b'\x01')
        time.sleep_ms(100)
        cnu=self.uart.read()
        if cnu is not None:	
            pass
    def raw_command(self,data,show_type=True,wt=100):
        self.uart.write(data)
        self.uart.write(b'\x04')
        if show_type:
            return self.show_info(self.raw_read(wt))
        return self.raw_read(wt)
        
    def show_dir(self,dirs):    
        self.raw_command(f"dir_data=json.dumps(os.listdir({repr(dirs)}))",False)
        sw=self.raw_command("print(base64_encode(dir_data).decode().strip())",False)
        swd=json.loads(self.base64_decode(sw))
        return swd
    #wt 为1000 可以最大8KB大文件
    def read_file(self,fn):
        mb=self.raw_command(f"print(read_file({repr(fn)}))",False,500)
        file_info=self.base64_decode(mb[:-2]).decode()
        return self.show_text(file_info)

    def write_file(self,fn,data):
        bd=self.base64_encode(data).decode()
        self.raw_command(f"write_file({repr(fn)},{repr(bd)})",False,500)

v=lcdrepl(sm,uart)

v.raw_command("import os,json,ubinascii,time",False)
v.raw_command("def base64_encode(data):\n    return ubinascii.b2a_base64(data).strip()",False)
v.raw_command("def base64_decode(data):\n    return ubinascii.a2b_base64(data)",False)
v.raw_command("def read_file(file_name):\n    f=open(file_name,'rb')\n    e=f.read()\n    f.close()\n    return base64_encode(e).decode()",False)
v.raw_command("def write_file(file_name,data):\n    f=open(file_name,'wb')\n    dd=base64_decode(data).decode()\n    f.write(dd)\n    f.close()",False)

v.raw_start()
v.lcd_cmd("112")
v.lcd_cmd("for i in range(5):\n    print(i)")

老旧

from machine import SPI, Pin,I2C,Timer,freq,RTC,WDT,UART
import st7789_spi
from easydisplay import EasyDisplay
import ntptime
import network,time,requests,json
import ubinascii

# ==================== 配置区 ====================
UART_ID = 1
BAUDRATE = 115200
TX_PIN = 5
RX_PIN = 4
RAW_REPL_TIMEOUT_MS = 3000  # Raw REPL 握手与执行超时(ms)
# ================================================

uart = UART(UART_ID, baudrate=BAUDRATE, tx=TX_PIN, rx=RX_PIN ,rxbuf=16384,txbuf=16384 )




    
    




spi = SPI(1, baudrate=40000000, polarity=0, phase=0, sck=Pin(2), mosi=Pin(3))
dp = st7789_spi.ST7789(width=320, height=240, spi=spi, cs=7, dc=6, res=10, rotate=2, bl=11,invert=False, rgb=False)
sm= EasyDisplay(display=dp, font="/text_full_16px_2312.v3.bmf", show=True, color=0xFFFF, auto_wrap=True, clear=True,color_type="RGB565")
sm.clear()


class lcdrepl():
    def __init__(self,lcd,uart):
        self.lcd=lcd
        self.uart=uart
        self.line=0
        self.swap=''
        self.swap_list=[]
        #用于文件修改
    def ssplit(self):
        self.swap_list=self.swap.split('\n')
    def clear(self):
        self.line=0
        self.lcd.clear()
    def show_line(self,strx,cmd=False,line_blank=True):
        clear_str=" "
        self.swap=strx
        self.ssplit()
        if cmd:
            strx="> "+strx
        if self.line>14:
            self.lcd.clear()
            self.line=0
        if line_blank:
           self.lcd.text(clear_str*20, 0, 16*self.line ,clear=False,color=0xFFF)
        self.lcd.text(strx, 0, 16*self.line ,clear=False,color=0xFFF)
        tn=strx.count("\n")
        t=1
        if tn>0:
            t=tn+1
        self.line=self.line+t
    def lcd_cmd(self,inx):
        self.show_line(inx,True)
        self.raw_command(inx)
    def base64_encode(self,data):
        return ubinascii.b2a_base64(data).strip()
    def base64_decode(self,data):
        return ubinascii.a2b_base64(data)


    #打印显示文件 return 回传数据 print模拟显示
    #打印
    #打印
    def show_info(self,data):
        if data:
            print(data)
            self.show_line(data)
            return data
        return False

    def show_text(self,data):
        if data:
            print(data)
            self.show_line(data)
            return data
        return False
    #打印显示文件
    #打印
    #打印00000000000000000

    def raw_read(self,wt=100):
        time.sleep_ms(wt)
        bs=self.uart.read()
    #     print(bs)
        if bs is not None:
            if bs.endswith(b'\x04\x04>'):
                #直接舍弃4KB以上的大文件
                bsd=bs.decode()
                if bsd[2:-3]:
                    return bsd[2:-3]
        return False
    def raw_start(self):
        self.uart.write(b'\x03')
        time.sleep_ms(100)
        self.uart.write(b'\x01')
        time.sleep_ms(100)
        cnu=self.uart.read()
        if cnu is not None:	
            pass
    def raw_command(self,data,show_type=True,wt=100):
        self.uart.write(data)
        self.uart.write(b'\x04')
        if show_type:
            return self.show_info(self.raw_read(wt))
        return self.raw_read(wt)
        
    def show_dir(self,dirs):    
        self.raw_command(f"dir_data=json.dumps(os.listdir({repr(dirs)}))",False)
        sw=self.raw_command("print(base64_encode(dir_data).decode().strip())",False)
        swd=json.loads(self.base64_decode(sw))
        return swd
    #wt 为1000 可以最大8KB大文件
    def read_file(self,fn):
        mb=self.raw_command(f"print(read_file({repr(fn)}))",False,500)
        file_info=self.base64_decode(mb[:-2]).decode()
        return self.show_text(file_info)

    def write_file(self,fn,data):
        bd=self.base64_encode(data).decode()
        self.raw_command(f"write_file({repr(fn)},{repr(bd)})",False,500)

v=lcdrepl(sm,uart)

v.raw_command("import os,json,ubinascii,time",False)
v.raw_command("def base64_encode(data):\n    return ubinascii.b2a_base64(data).strip()",False)
v.raw_command("def base64_decode(data):\n    return ubinascii.a2b_base64(data)",False)
v.raw_command("def read_file(file_name):\n    f=open(file_name,'rb')\n    e=f.read()\n    f.close()\n    return base64_encode(e).decode()",False)
v.raw_command("def write_file(file_name,data):\n    f=open(file_name,'wb')\n    dd=base64_decode(data).decode()\n    f.write(dd)\n    f.close()",False)

v.raw_start()
v.lcd_cmd("112")
v.lcd_cmd("for i in range(5):\n    print(i)")
v.clear()
v.read_file("boot.py")

发表在 None | 留下评论

RAW repl 功能录入

发表于2026年8月11日由admin

from machine import UART
import time
import ubinascii
import json

# ==================== 配置区 ====================
UART_ID = 1
BAUDRATE = 115200
TX_PIN = 5
RX_PIN = 4
RAW_REPL_TIMEOUT_MS = 3000  # Raw REPL 握手与执行超时(ms)
# ================================================

uart = UART(UART_ID, baudrate=BAUDRATE, tx=TX_PIN, rx=RX_PIN ,rxbuf=16384,txbuf=16384 )



def base64_encode(data):
    return ubinascii.b2a_base64(data).strip()

def base64_decode(data):
    return ubinascii.a2b_base64(data)


#打印显示文件 return 回传数据 print模拟显示
    
def show_info(data):
    if data:
        print(data)
        return data
    return False

def show_text(data):
    if data:
        print(data) 
        return data
    return False
#打印显示文件

def raw_read(wt=100):
    time.sleep_ms(wt)
    bs=uart.read()
    if bs is not None:
        if bs.endswith(b'\x04\x04>'):
            #直接舍弃4KB以上的大文件
            bsd=bs.decode()
            if bsd[2:-3]:
                return bsd[2:-3]
    return False
    
def raw_start():
    uart.write(b'\x03')
    time.sleep_ms(100)
    uart.write(b'\x01')
    time.sleep_ms(100)
    cnu=uart.read()
    if cnu is not None:
        pass
#         show_info(cnu.decode())

def raw_command(data,show_type=True,wt=100):
    uart.write(data)
    uart.write(b'\x04')
    if show_type:
        return show_info(raw_read(wt))
    return raw_read(wt)
    
def show_dir(dirs):    
    raw_command(f"dir_data=json.dumps(os.listdir({repr(dirs)}))",False)
    sw=raw_command("print(base64_encode(dir_data).decode().strip())",False)
    swd=json.loads(base64_decode(sw))
    return swd

#wt 为1000 可以最大8KB大文件
def read_file(fn):
    mb=raw_command(f"print(read_file({repr(fn)}))",False,500)
    file_info=base64_decode(mb[:-2]).decode()
    return show_text(file_info)

def write_file(fn,data):
    bd=base64_encode(data).decode()
    raw_command(f"write_file({repr(fn)},{repr(bd)})",False,500)
    
    

raw_start()
raw_command("import os,json,ubinascii,time",False)
raw_command("def base64_encode(data):\n    return ubinascii.b2a_base64(data).strip()",False)
raw_command("def base64_decode(data):\n    return ubinascii.a2b_base64(data)",False)
raw_command("def read_file(file_name):\n    f=open(file_name,'rb')\n    e=f.read()\n    f.close()\n    return base64_encode(e).decode()",False)
raw_command("def write_file(file_name,data):\n    f=open(file_name,'w')\n    dd=base64_decode(data).decode()\n    f.write(dd)\n    f.close()",False)

raw_command("import time",False)
raw_command("m=time.time()",False)
raw_command("print(m)")
# 调用print 会有\r\n 且只有print才会返回信息 否则 b'OK\x04\x04>'
#所有 结尾\x04\x04 b'OK798\r\n\x04\x04>'

多行功能【\n 只需要该符号实现换行】

code = b"""
import time
for i in range(3):
    print(i)
time.sleep(0.5)
print('done')
""" + b'\x04'


uart.write(code)

发表在 None | 留下评论

小米R1d 刷机

UART 串口模块新思路 uasyncio异步

usyncio下UART 和SSD1306 获取数据然后显示

每日做T小结

st7789 repl uart

RAW repl 功能录入

近期文章

近期评论

归档

分类

友情链接

其他操作