【youyeetoo X1 windows 开发板体验】少儿AI智能STEAM积木平台

不太理解，这个板子为啥要给一个NFC的天线？一般WIN开发板也没有这部分的功能啊
难道是给外挂IC卡用的么，官方有没有类似的历程？

Python操控GPIO

在Linux系统上，可以用GPIOD来操控GPIO，Windows上面，一般用WinIO来进行操作。
风火轮官方提供的C#实例中，封装了inpoutx64，来进行操作。


我使用Python开发，使用pywinio即可。
首先，使用安装Python3.11，然后使用pip install pywinio安装该模块。


安装完成后，就可以测试是否正常。
直接在cmd.exe中运行python，进入交互模式，然后运行下面的代码：

1. import pywinio
2. pywinio.WinIO()

开始使用的时候，可能会遇到下面的问题：

• 没有权限：需要使用管理员权限打开cmd.exe，然后测试
  
• 签名存在问题：需要使用 BCDEDIT /SET TESTSIGNING ON 命令设置测试模式，重启后，再继续测试
  

能够正常调用后，就可以开始编写代码了。


在官方提供的C#代码的IOApp.cs中，有对应的代码可供参考：
参考改代码，编写对应的Python代码：

运行上述代码，正常情况下，输出如下：


具体效果如下：


进一步的，可以参考上述代码，就能实现GPIO的输入输出控制了。

为了方便使用和测试，我专门购置了移远EC20 4G LTE模块，买到后，发现还需要一个转接卡才能正常使用，于是又购置了USB转接卡，并配置了专用天线。

相关的设备如下：


其中包括：

• 移远EC20 4G LTE模块
  
• 迷你minipcie转USB（移远EC20）
  
• 射频线
  
• 专用天线
  
• 4G nano卡 + 转接卡
  

其中的EC20模块和USB转接卡具体如下：




天线配置了两个，实际使用时，小的天线很好用，就没有用长的了。

将EC20模块插到USB转接卡上，并接线天线，插上卡：


最后，直接连接到USB即可：



接好USB后，无需再安装驱动，系统会自动识别，在设备管理器里面可以看到：


然后USB转接卡上的蓝灯会闪烁。
当它快闪的时候，表示正在联网。慢闪的时候，表示联网失败。很长时间闪一下，说明联网成功。
后续会根据网络使用情况，闪烁方式不同。

点击系统任务栏的网络图标，关闭Wlan/WiFi，开启手机网络，等待连接成功：

需要注意的是，如果不装天线，上面会显示Mobile正在准备，无法联网。

可以鼠标右键查看网络属性，查看当前的状态：


并查看流量的具体使用情况：

建议设置一个流量上线，以免用超了。当然，流量多的可以不用设置了。


网络连上了，就可以打开浏览器上网测试效果了。
使用测速网站进行测速，效果还不错：



现在，这个4G上网卡就可以正常使用了，非常的方便。

为了提供更好的性能，按照官方资料的指导，购置了SSD，安装使用后，性能大幅提升。


一、选购的SSD：


M.2，NGFF2280，512G


二、SSD安装

直接怼上去，上好螺丝即可。

三、系统安装
使用官方提供的Windows 11安装包：
解压到U盘，然后检查安装方式是否为SSD（1）:

安装完成后，成功进入Windows11系统


查看当前挂载的磁盘：


四、读写性能测试：
首先测一下，原有的EMMC：
读写性能有点惨不忍睹。

然后测一测刚装的SSD：
现在，读写性能，全面上升！！！

经过几天的使用，完全正常，日常使用非常的流畅。

一、了解不带线网卡模块
我之前准备的配件中，有不带线网卡模块和USB不带线网卡：


不带线网卡模块的具体型号为RTL 8852BE，接口是NGFF M2：


其支持能力爆棚：


二、安装不带线网卡模块

在开发板上的安装位置如下：



这个不带线网卡模块上，要连接两根天线，是IPEX4接口的：


IPEX4接口比IPEX1接口要小很多，常用于内置不带线网卡模块使用。

连接好不带线信号接受配件，就可以安装到开发板上使用了:


三、使用不带线网卡模块
在初次安装好不带线网卡模块后，发现了一个奇怪的问题。
不管是在Windows10，还是在Windows11中，系统会整体不定时的卡顿，就是什么都操作不了。
将不带线网卡模块取下来以后，则系统完全正常。
已经准备好，退回去让厂家测验检查了。

不过，这个时侯，我做了一个小动作。
我看了下系统事件中的记录，发现了一个小秘密：



原来装上不带线网卡模块后，板子自带的有线网卡处于"嫉妒"心理，开始罢工。
它一旦罢工，系统就会重置它，从而导致系统整体卡顿。


于是，我尝试着，将板子的有线网卡禁用：


然后，世界进入到大家开开心心过大年状态，系统能够正常使用了。

再然后，我又把板子的有线网卡给启用：


系统依然正常，再次重启，也没有发现之前的问题了。
真是奇异啊！

现在，可以好好看看不带线网卡模块的信息了:
设备管理器中的信息：


连接到WiFi：


连接信息：


另外，这个不带线网卡模块，还支持蓝牙：



可以很方便的连接我的多个蓝牙设备：


四、驱动更新
默认情况下，蓝牙可能不好使，可以从如下地址下载驱动：
http://www.wlan-wwan.com/2022/05/22/realtek-rtl8852bewuxianlanyamokuaiqudongjiguigeshu/


安装后重启电脑，就好使了。


现在，不用外接USB不带线网卡和蓝牙模块了，联网非常的方便了。

在 youyeetoo X1 上 部署 Stable Diffusion


一、openvino了解
在youyeetoo X1支持OpenVINO。OpenVINO™ 是一个用于优化和部署人工智能（AI）推理的开源工具平台。 它可以 提高计算机视觉、自动语音识别、自然语言处理和其他常见任务的深度学习性能。使用经过TensorFlow、PyTorch 等流行框架训练的模型。

在youyeetoo X1上部署Stable Diffusion，并应用OpenVINO支持，目前已有不少选择，可以用openvino_notebooks或者fastsdcpu。我部署了fastsdcpu进行测试，他提供了一个完整的Windows环境测试Stable Diffusion的工具包。

二、部署fastsdcpu
1. 安装Python
首先，安装Python3.11，可以从 https://www.python.org/downloads/ 下载对应的版本进行安装：



安装后，打开命令行工具，查看是否可以正常使用：


2. 安装virtualenv最终，进入如下的环境，表示安装成功：

3. 安装git
在使用Stable Diffusion的过程中，经常需要通过git下载文件，所以要先安装git。
在Windows11上，已经提供了系统内置的包管理工具，用于安装常见的工具包。
通过下面的命令，即可直接安装：安装后，检查是否可以正常使用：

4. 安装fastsdcpu工具包
首先使用下面的命令获取：然后，使用下面的命令，进行支持库和数据文件的安装：安装完成后，就可以启动进行测试。

三. 使用Stable Diffusion
1. 启动
部署完成后，启动包括WEB模式和桌面程序模式，用下面的命令可以启动：
在不同的模型和设置下，首次进行生成时，可能会需要从huggingface下载模型包大，大小和时间不等，可能要下载数G，下载时间从几分钟到数十分钟时。

2. WEB模式
启动WEB模式，界面如下：

可以输入Prompt进行测试，测试过程中，命令行会输出进度信息：


生成的过程中，CPU风扇呼呼呼的转，系统资源拉满：

生成成功后，命令行会提示：

此时可以查看生成的图片：

3. 桌面模式
启动桌面程序模式，界面如下：

4. 配置和openvino支持
可以在桌面模式的配置中，启用openvino支持：

然后再次进行生成。

不过，fastsdcpu提示了：

咱们得板子内存只有8G，而且系统本身还要占用，所以，开启了openvino支持，跑的很不顺，有时候内存不足，有的时候生成的莫名其妙的。



并且生成时，需要的时间大大变长，生成一次，可能需要15分钟或者半个小时。


在配置界面，如果开启了Tiny Auto Encoder配置，则生成的速度，会变快一些。

四、总结
经过使用测试，在youyeetoo X1 上是可以部署运行Stable Diffusion的，但是受限于内存只有8G大小，实际生成过程需要较长的时间，且不能生成过于复杂的图片。
另外，在使用的过程中，应该把其他所有的程序，应用，全部都关闭掉，以免消耗内存。

牛逼的板子，文章也很棒棒

板子很赞，帮主写的很好，羡慕

乔帮主配件准备的有点多呀，差不多这板子能接的各种外设，你都来了一个

LLAMA大模型部署测试

在Windows系统上，可以通过ollama来部署大模型进行测试。

1. 安装ollama
在 https://ollama.com/download 下载Windows版本，然后安装即可：


2. 检查是否正常运行
新开命令行窗口，运行：运行结果如下：

3. 测试llama2-chinese
首先，下载一个llama2-chinese试一下：

下载完成后，运行下面的命令进行测试：

不过，实际运行的速度，非常的不理想：


跑了1个小时，都没有生成完。
忍无可忍，ctrl+V了。

4. 测试llama2
同样的，首先下载：
然后运行测试：【中式英文，别笑】
这速度，比中文的要快，但是还是很慢：

5. 总结
看来，受限于CPU和内存，运行大模型，还是非常吃力的。
不过，ollama目前能够直接用的大模型还很有限，后续将会试一试其他的大模型方案，例如llama.cpp等。

不错啊不错啊,可惜没有时间玩板,不然我也申请了!

来了来了，楼主太厉害了，必须膜拜一下

不错，写的很详细，收藏后面仔细看看。

上个docker，WSL2…

Windows驱动开发【遇到问题，待官方解答】


参考官方资料，进行驱动开发部分，做 新设备加入到系统 时，出现问题。
官方指导步骤：


实际操作结果：
第1步：从注册表缓存中读取BIOS配置,并保存到DSDT0000.bin文件


第2步：反编译DSDT0000.bin文件,生成DSDT0000.dsl (ASL CODE文件)


第3步：修改DSDT0000.dsl 文件,添加新设备到改文件中
不修改，直接跳过

第4步：编译修改好的DSDT0000.dsl,会生成DSDT0000.aml文件





在第4步的时候，未能达到官方指导资料的结果，导致无法进一步进行添加设备的操作。
待官方解答。

大佬牛呀，文章太棒了

清理后，结果如下：

这4个未知设备，2个是NFC使用，1个是SPI使用，还有一个是I2C3使用。

二、添加新的设备和驱动
我后面需要连接SHT30进行测试，其I2C地址为0x44，参考官方资料，进行如下的操作：
1. 生成dsl文件：2. 修改dsl文件，去掉多余的信息，并修改对应的I2C3的配置：
将默认的0x50，修改为0x40
3. 生成aml文件：4. 将设备信息写入注册表：然后重启电脑，注册表中就会存在对应的设备信息了

5. 修改官方提供的驱动配置：

6. 安装驱动：


安装完成后，重启电脑，再查看设备管理器，就能够看到设备区东正确安装了：

从上图可以看到，0x44的设备，已经成功安装驱动。

三、不挂I2C设备测试
再不挂接I2C设备的情况下，打开I2C测试工具，可以连接I2C端口：

但是读取会失败：

写入也会失败：

需要注意的是，如果挂接了设备，但I2C设备的地址不是0x44，则出现的错误信息，和上面的完全一样。

四、挂接I2C设备测试
1. I2C从设备制作
为了方便测试，我用硬禾的12指神探，做了一个I2C从设备，方便进行I2C通讯的测试。

这个I2C从设备，内部有256个寄存器，地址为0x00~0xFF，设备初始化的时候，所有的寄存器设置为0x00，读取的时候，每次返回的数据宽度为4位8bits数据。

2. 连接I2C从设备到开发板
实际连到开发板上进行测试的时候，还挂接了一个逻辑分析仪，以便分析通讯的数据：


3. 默认读取测试：
默认情况下，从I2C从设备去读数据，返回的为 00 00 00 00

在I2C从设备的调试输出窗口，也能看到当前的I2C请求为从地址为0x00的寄存器读取数据，以及实际返回的数据。

4. 写入数据测试：
点击写入数据，会成功写入：

在I2C从设备的调试输出窗口，也能看到当前的I2C请求向0x00的寄存器写入数据，以及实际写入的数据。

5. 读取写入后的数据：
再次点击读取，就能够读取到前面写入的数据了：

五、逻辑分析仪分析通讯
写入数据的时候，逻辑分析仪抓取到的数据结果如下：
可以看到，操作的I2C设备地址为0x44，向寄存器地址0x00开始写入了12 34 56 78 90 AB CD EF 8位8bits数据。

读取数据的时候，逻辑分析仪抓取到的数据结果如下：
可以看到，操作的I2C设备地址为0x44，先向I2C从设备发送读数据的命令，然后过了一段时间后，I2C从设备开始返回数据
12 34 56 78，一共4位8bits数据。

通过以上的步骤，就能够完成I2C设备的正常通讯了，后续就可以在此基础上，操作I2C通讯，来完成具体传感器设备的数据读取了。

移植驱动读取SHT30温湿度传感器数据

在我的项目中，会涉及到接入多个传感器设备，并进行自动识别，然后结合AIGC大模型，进行特定情景的生成。
在上一部分，已经测试过I2C设备的读写操作了，在此基础上，进行SHT30温湿度传感器的数据读取。

一、硬件了解
有一点，我最近才注意到：


怪不得我测试SHT30的时候，温度数据偏高。
但是手头暂时没做4.7K的电阻，需要采购。暂时智能硬着头皮先上了。

SHT30如下：


二、I2CPython驱动移植
在官方提供的I2C测试程序中，有关于串口数据读取的实例，参考改示例，编写python调用DLL接口的入口文件：

1. import ctypes, sys
3. spbdll = ctypes.WinDLL("64" in sys.version and "SPBDLL.dll" or "SPBDLL.dll")
5. def __DllFunc(name, ret, args):
6.     func = spbdll[name]
7.     func.restype = ret
8.     func.argtype = args
9.     return func
11. # //-----连接设备驱动---
12. SPBDLL_ConnetDev = __DllFunc("SPBDLL_ConnetDev", ctypes.c_void_p, (ctypes.c_char_p))
13. SPBDLL_isOK = __DllFunc("SPBDLL_isOK", ctypes.c_bool, (ctypes.c_void_p))
14. SPBDLL_ReleaseDev = __DllFunc("SPBDLL_ReleaseDev", ctypes.c_void_p, (ctypes.c_void_p))
16. # //----I2C----
17. SPBDLL_I2C_Read = __DllFunc("SPBDLL_I2C_Read", ctypes.c_int, (ctypes.c_void_p, ctypes.c_uint16, ctypes.c_buffer, ctypes.c_int32))
18. SPBDLL_I2C_Write = __DllFunc("SPBDLL_I2C_Write", ctypes.c_int, (ctypes.c_void_p, ctypes.c_uint16, ctypes.c_buffer, ctypes.c_int32))
19. SPBDLL_I2C_Read_RegAddr8bit = __DllFunc("SPBDLL_I2C_Read_RegAddr8bit", ctypes.c_int, (ctypes.c_void_p, ctypes.c_uint8, ctypes.c_buffer, ctypes.c_int32))
20. SPBDLL_I2C_Write_RegAddr8bit = __DllFunc("SPBDLL_I2C_Write_RegAddr8bit", ctypes.c_int, (ctypes.c_void_p, ctypes.c_uint8, ctypes.c_buffer, ctypes.c_int32))

然后，在编写I2C操作的封装文件：

1. import SPBDLL as SPBDLL
3. class SpbDllCtrl:
4.     lpDev = None
5.     def __init__(self):
6.         self.lpDev = None
7.         pass
9.     # ///
10.     # /// 连接设备驱动
11.     # ///
12.     # /// 驱动名称,在asl和inf中对应的名称
13.     # ///
14.     def ConnetDev(self, devName):
15.         self.lpDev = SPBDLL.SPBDLL_ConnetDev(devName)
16.         return not self.lpDev == None
18.     # ///
19.     # /// 连接设备是否成功
20.     # ///
21.     # ///
22.     def isOK(self):
23.         if not self.lpDev == None:
24.             return 1 == SPBDLL.SPBDLL_isOK(self.lpDev)
26.         return False
29.     # ///
30.     # /// 释放设备
31.     # ///
32.     def ReleaseDev(self):
33.         if not self.lpDev == None:
34.             SPBDLL.SPBDLL_ReleaseDev(self.lpDev)
35.             self.lpDev = None
37.     # ///
38.     # /// 设置中断回调 def fn(fn_Context);需要在asl中配置了IO中断,这里设置才有意义
39.     # ///
40.     # /// 回调函数
41.     # /// 参数
42.     def SetInterruptCallBack(self, fn, fn_Context):
43.         if not self.lpDev == None:
44.             SPBDLL.SPBDLL_SetInterruptCallBack(self.lpDev, fn, fn_Context)
46.     # //----I2C----
47.     # ///
48.     # /// I2C读寄存器内容
49.     # ///
50.     # /// 寄存器地址,2字节的地址
51.     # /// 接收数据
52.     # /// 计划读取长度
53.     # ///
54.     def I2C_Read(self, regAddr, pData, len):
55.         if not self.lpDev == None:
56.             return 0 == SPBDLL.SPBDLL_I2C_Read(self.lpDev, regAddr, pData, len)
58.         return False
60.     # ///
61.     # /// I2C写数据到寄存器中
62.     # ///
63.     # /// 寄存器地址,2字节的地址
64.     # /// 数据
65.     # /// 数据长度
66.     # ///
67.     def I2C_Write(self, regAddr, pData, len):
68.         if not self.lpDev == None:
69.             return 0 == SPBDLL.SPBDLL_I2C_Write(self.lpDev, regAddr, pData, len)
71.         return False
73.     # ///
74.     # /// I2C读寄存器内容
75.     # ///
76.     # /// 寄存器地址,1字节的地址
77.     # /// 接收数据
78.     # /// 计划读取长度
79.     # ///
80.     def I2C_Read_RegAddr8bit(self, regAddr, pData, len):
81.         if not self.lpDev == None:
82.             return 0 == SPBDLL.SPBDLL_I2C_Read_RegAddr8bit(self.lpDev, regAddr, pData, len)
84.         return False
87.     # ///
88.     # /// I2C写数据到寄存器中
89.     # ///
90.     # /// 寄存器地址,1字节的地址
91.     # /// 数据
92.     # /// 数据长度
93.     # ///
94.     def I2C_Write_RegAddr8bit(self, regAddr, pData, len):
95.         if not self.lpDev == None:
96.             return 0 == SPBDLL.SPBDLL_I2C_Write_RegAddr8bit(self.lpDev, regAddr, pData, len)
98.         return False

通过以上的入口文件和操作封装，就可以在python程序中，进行I2C接口的操作了。

下面编写一个简单的，与之前的RP2040做的I2C从设备沟通的程序，讲一个计数器的值通过I2C写入到从设备，然后读取该值：

1. from SpbDllCtrl import *
2. import time
3. import atexit
5. # 数组转HEX字符串
6. to_hex=lambda ary : " ".join(["%02X" % i for i in ary])
8. devName = "I2C30001"
10. I2CCtrl = None
11. def __clear_i2c():
12.     global I2CCtrl
13.     if not I2CCtrl == None:
14.         print("Clear I2C device")
15.         I2CCtrl.ReleaseDev()
16.     I2CCtrl = None
17. atexit.register(__clear_i2c)
19. I2CCtrl = SpbDllCtrl()
20. I2CCtrl.ConnetDev(devName)
22. if not I2CCtrl.isOK():
23.     print("I2C device is not connected")
24. else:
25.     print("I2C device is connected")
27. rbuf = bytes(4)
28. r_len = 4
29. bRet = I2CCtrl.I2C_Read_RegAddr8bit(0x00, rbuf, r_len);
31. if not bRet:
32.     print("Read error")
33. else:
34.     print("Read data: ", to_hex(rbuf))
36. counter = 0
37. while True:
38.     counter += 1
39.     if counter > 0xffff:
40.         break
42.     hexstr= "%08X" % counter
43.     rbuf = bytes(bytearray.fromhex(hexstr))
45.     bRet = I2CCtrl.I2C_Write_RegAddr8bit(0x00, rbuf, r_len);
46.     if not bRet:
47.         print("Write error")
48.     else:
49.         print("Write data: ", to_hex(rbuf))
51.     time.sleep(0.1)
53.     rbuf = bytes(4)
54.     r_len = 4
55.     bRet = I2CCtrl.I2C_Read_RegAddr8bit(0x00, rbuf, r_len);
57.     if not bRet:
58.         print("Read error")
59.     else:
60.         print("Read data: ", to_hex(rbuf))
62.     time.sleep(1)
64. # I2CCtrl.ReleaseDev()

运行上述代码，最终结果如下：


从结果中可以看到，python程序将计数器数值写入到从设备，从设备收到并记录。
然后，python程序从从设备读取寄存器的值，就是之前写入的值。

三、SHT30驱动移植
在上一步，已经做好了I2C设备的数据读写了，在此基础上，根据SHT30的数据手册，就可以编写对应的驱动程序了。
为了保持和micropython中的程序一致，我编写了一个伪装接口：

1. from SpbDllCtrl import *
3. # 数组转HEX字符串
4. to_hex=lambda ary : " ".join(["%02X" % i for i in ary])
6. class I2C:
7.     def __init__(self, devname):
8.         self.devname = devname
10.         self.I2CCtrl = SpbDllCtrl()
11.         self.I2CCtrl.ConnetDev(self.devname)
13.         if not self.I2CCtrl.isOK():
14.             print("I2C device is not connected")
15.             raise Exception("连接失败")
16.         else:
17.             print("I2C device is connected")
19.     def write_byte_data(self, i2c_address, register_address, value):
20.         if self.I2CCtrl.isOK():
21.             rbuf = bytes(bytearray([value]))
22.             r_len = len(rbuf)
23.             bRet = self.I2CCtrl.I2C_Write_RegAddr8bit(register_address, rbuf, r_len);
24.             if not bRet:
25.                 print("Write error")
26.                 raise Exception("写入错误")
27.                 return False
28.             else:
29.                 print("Write data: ", to_hex(rbuf))
30.                 return True
32.     def write_i2c_block_data(self, i2c_address, register_address, values):
33.         if self.I2CCtrl.isOK():
34.             rbuf = bytes(values)
35.             r_len = len(rbuf)
36.             bRet = self.I2CCtrl.I2C_Write_RegAddr8bit(register_address, rbuf, r_len);
37.             if not bRet:
38.                 print("Write error")
39.                 raise Exception("写入错误")
40.                 return False
41.             else:
42.                 print("Write data: ", to_hex(rbuf))
43.                 return True
45.     def read_byte_data(self, i2c_address, register_address):
46.         if self.I2CCtrl.isOK():
47.             r_len = 1
48.             rbuf = bytes(r_len)
49.             bRet = self.I2CCtrl.I2C_Read_RegAddr8bit(register_address, rbuf, r_len)
50.             if not bRet:
51.                 print("Read error")
52.                 raise Exception("读取错误")
53.                 return None
54.             else:
55.                 print("Read data: ", to_hex(rbuf))
56.                 return rbuf
57.         else:
58.             return None
60.     def read_i2c_block_data(self, i2c_address, register_address, block_width):
61.         if self.I2CCtrl.isOK():
62.             r_len = block_width
63.             rbuf = bytes(r_len)
64.             bRet = self.I2CCtrl.I2C_Read_RegAddr8bit(register_address, rbuf, r_len)
65.             if not bRet:
66.                 print("Read error")
67.                 raise Exception("读取错误")
68.                 return None
69.             else:
70.                 print("Read data: ", to_hex(rbuf))
71.                 return rbuf
72.         else:
73.             return None

然后，编写实际读取SHT30数据的程序：

1. import smbusx as smbus
2. import time
4. i2c = smbus.I2C("I2C30001")
6. addr=0x44
7. i2c.write_byte_data(addr,0x30,0xa2)
9. time.sleep(0.5)
11. while True:
12.     i2c.write_byte_data(addr,0x2c,0x10)
13.     data = i2c.read_i2c_block_data(addr,0x00,6)
14.     if data == None:
15.         raise Exception("读取错误")
16.     else:
17.         rawT = ((data[0]) << 8) | (data[1])
18.         rawR = ((data[3]) << 8) | (data[4])
20.         temp = -45 + rawT * 175 / 65535
21.         RH = 100 * rawR / 65535
23.         print (str(temp) +"C", str(RH) +"%")
25.     time.sleep(1)

使用RP2040 I2C从设备的时候，读取和返回结果如下：

因为没有实际测量，所以显示的为-45℃。

四、实际硬件数据读取
首先，连接SHT30，务必需要注意第一部分的说明，要上拉电阻。
连接后，具体如下：


实际读取的结果如下：


现在，可以在python程序中，通过I2C接口，读取SHT30的数据了。
在后续的开发中，还会将读取到的数据，融合到AIGC大模型中，进行实际场景的生成和展示。