🌓 切换到窄版

 找回密码
 立即注册
在此学习《Ai8051U教学视频》发表七集 以上学习心得，送强大的 Ai8051U实验箱
国芯人工智能技术交流网站»STC技术论坛首页 › 技术交流 › WS2812，点灯，灯带，光立方，DMA-SPI点灯，DMA-PWM点灯，即将推出一线制 › 采用表驱动方式的基于AI8051U的流水灯程序 ...
返回列表 发新帖
查看: 66|回复: 1

采用表驱动方式的基于AI8051U的流水灯程序

[复制链接]
yyq_***
  • 打卡等级：常住居民I
  • 打卡总天数：73
  • 最近打卡：2026-07-22 07:12:16
已绑定手机

13

主题

17

回帖

319

积分

中级会员

积分
319
发表于 2026-7-8 19:11:30 | 显示全部楼层 |阅读模式
    最近学习了表驱动方式，总算基本搞明白了，下面通过一个实例介绍一下表驱动方式。

   表驱动法其实就三步：
1.建表：根据需求弄个数组或者结构体数组，把逻辑和数据塞进去。
2.查表：程序跑的时候，根据输入或者状态去表里找对应的条目。
3.干活：找到后按表里的指示执行操作，完事。
  本例要完成的是流水灯程序，具体到哪一个灯，亮的时间长短，两函数，灭函数，所以这里定义了一个结构，名为tagLEDFuncCB，把这几个元素包装起来，当然元素的个数不受限（我认为的），数据类型也不受限，函数要求是无参数无返回值类型的，这里的函数泛指一般函数，只是说明有2个函数而已。
  1. //====定义一个结构，把同一个灯的操作封装起来====

  2. struct  tagLEDFuncCB             //结构

  3. {

  4.         //封装元素的次序与表中对应，封装元素的个数不受限

  5.         u8   Index;       //索引，全局变量

  6.   u16 Time;      //时间间隔，全局变量     

  7.         void (*LedOn)(void);   //亮灯函数，必须无参数，无返回值

  8.   void (*LedOff)(void);         //灭灯函数，必须无参数，无返回值

  9. };
复制代码
针对结构，然后定义要完成的任务表。本例4个LED流水点亮，所以数组要有4个元素，即要完成4个任务，可以根据需要添加更多任务，结构表名（即数组名）叫LedOpTable。
  1. //====定义需要操作到的灯的表=====

  2. const   struct tagLEDFuncCB  LedOpTable[ ] =     //结构表

  3. {

  4.    //表中每个元素与每一个灯的封装对应一致，4个灯，状态只能为0,1,2,3

  5.          {1, 1, LED1_On, LED1_Off},   //LED1的状态，亮灯时间，亮灯函数，灭灯函数

  6.    {0, 2, LED2_On, LED2_Off},   //LED2的状态，亮灯时间，亮灯函数，灭灯函数

  7.    {2, 3, LED3_On, LED3_Off},  //LED3的状态，亮灯时间，亮灯函数，灭灯函数

  8.          {3, 4, LED4_On, LED4_Off},  //LED4的状态，亮灯时间，亮灯函数，灭灯函数

  9. };
复制代码
该数组有4个元素，由内层的4个大括号包括，每个大括号又包含4个元素，如{1, 1, LED1_On, LED1_Off}封装了LED1的元素，第1个元素1表示LED1的状态，第2个元素1表示亮灯时间，第3个元素LED1_On表示亮灯函数，第4个元素LED1_Off灭灯函数。
  干活就是处理任务，由void LED_Ctrl(void)来完成。
  1. void LED_Ctrl(void)      //LED灯处理  下载成功

  2. {

  3.     static u16 sta = 0;        // 当前正在亮的灯在表中的位置

  4.     static u16 cnt = 0;        // 当前灯已持续的时间计数

  5.     

  6.     // 时间到，切换到下一个灯

  7.     if (cnt >= LedOpTable[sta].Time)    //时间超过该状态的LED对应的时间值

  8.     {

  9.         // 熄灭所有灯

  10.         u8 i;

  11.         for (i = 0; i < sizeof(LedOpTable)/sizeof(LedOpTable[0]); i++)

  12.         {

  13.             LedOpTable[i].LedOff();

  14.         }

  15.         

  16.         // 切换到下一个灯

  17.         sta++;

  18.         if (sta >= (sizeof(LedOpTable) / sizeof(LedOpTable[0])))

  19.         {

  20.             sta = 0;

  21.         }

  22.         

  23.         // 点亮当前灯

  24.         LedOpTable[sta].LedOn();

  25.         

  26.         // 重置计数器

  27.         cnt = 0;

  28.     }

  29.     else

  30.     {

  31.         cnt++;            // 当前灯已持续的时间计数加 1

  32.     }

  33. }

  34.  
复制代码
  这里代码 sizeof(LedOpTable)/sizeof(LedOpTable[0]难理解，sizeof(LedOpTable) 求整个结构体数组占用的总字节数，sizeof(LedOpTable[0]) 求数组中第一个元素占用的字节数，这两者相除，得到的就是数组的元素个数，也可以说任务的个数。
完整代码如下：
  1. //表驱动法   

  2. 

  3. 

  4. //例  4个流水灯  

  5. 

  6. #include "AI8051U.h"               //AI8051U---32bit模式，Keil C251编译器

  7. #include "stdio.h"

  8. #include "intrins.h"

  9. 

  10. #define MAIN_Fosc        24000000UL  //时钟

  11. #define Timer0_Reload   (MAIN_Fosc / 500)      //Timer 0 中断,定时2毫秒,不分频

  12. 

  13. 

  14. typedef         unsigned char        u8;

  15. typedef         unsigned int        u16;

  16. typedef         unsigned long        u32;

  17.         

  18. sbit LED1 = P2^0;  //LED1位置

  19. sbit LED2 = P2^1;  //LED2位置

  20. sbit LED3 = P2^2;  //LED3位置

  21. sbit LED4 = P2^3;  //LED4位置

  22. 

  23. volatile u8 T0_flag = 0;    //100ms标志

  24. 

  25. //==========函数声明================

  26. 

  27. extern void LED1_On(void);   //LED灯1亮  

  28. extern void LED1_Off(void);  //LED灯1灭 

  29. 

  30. extern void LED2_On(void);   //LED灯2亮 

  31. extern void LED2_Off(void);   //LED灯2灭

  32. 

  33. extern void LED3_On(void);   //LED灯3亮 

  34. extern void LED3_Off(void);   //LED灯3灭  

  35. 

  36. extern void LED4_On(void);   //LED灯4亮 

  37. extern void LED4_Off(void);   //LED灯4灭  

  38. 

  39. extern void LED_Ctrl(void);    //LED灯处理

  40. extern void  timer0_init(void);         //timer0初始化函数  

  41. 

  42. 

  43. //=========函数定义=============        

  44. void LED1_On(void)   //LED灯1亮  

  45. {

  46.         LED1 = 0;

  47. }

  48. void LED1_Off(void)   //LED灯1灭 

  49. {

  50.         LED1 = 1;

  51. }

  52. void LED2_On(void)   //LED灯2亮 

  53. {

  54.         LED2 = 0;

  55. }

  56. void LED2_Off(void)   //LED灯2灭  

  57. {

  58.         LED2 = 1;

  59. }

  60. 

  61. void LED3_On(void)   //LED灯3亮 

  62. {

  63.         LED3 = 0;

  64. }

  65. void LED3_Off(void)   //LED灯3灭  

  66. {

  67.         LED3 = 1;

  68. }

  69. void LED4_On(void)   //LED灯4亮 

  70. {

  71.         LED4 = 0;

  72. }

  73. void LED4_Off(void)   //LED灯4灭  

  74. {

  75.         LED4 = 1;

  76. }

  77. 

  78. //====把同一个灯的操作封装起来====

  79. struct tagLEDFuncCB            //结构

  80. {

  81.         //封装元素的次序与表中对应，封装元素的个数不受限

  82.         u8   Index;              //增加的索引，全局变量

  83.   u16 Time;                 //增加时间间隔，全局变量     

  84.         void (*LedOn)(void);        //亮灯函数

  85.   void (*LedOff)(void);       //灭灯函数

  86. };

  87. //====定义需要操作到的灯的表=====

  88. const   struct tagLEDFuncCB  LedOpTable[ ] =     //结构表

  89. {

  90.    //表中每个元素与每一个灯的封装对应一致，4个灯，状态只能为0,1,2,3

  91.          {1, 1, LED1_On, LED1_Off},   //LED1的状态，亮灯时间，亮灯函数，灭灯函数

  92.    {0, 2, LED2_On, LED2_Off},   //LED2的状态，亮灯时间，亮灯函数，灭灯函数

  93.    {2, 3, LED3_On, LED3_Off},  //LED3的状态，亮灯时间，亮灯函数，灭灯函数

  94.          {3, 4, LED4_On, LED4_Off},  //LED4的状态，亮灯时间，亮灯函数，灭灯函数

  95. };

  96. 

  97. void LED_Ctrl(void)      //LED灯处理  下载成功

  98. {

  99.     static u8 sta = 0;        // 当前正在亮的灯在表中的位置

  100.     static u8 cnt = 0;        // 当前灯已持续的时间计数

  101.     

  102.     // 时间到，切换到下一个灯

  103.     if (cnt >= LedOpTable[sta].Time)    //时间超过该状态的LED对应的时间值

  104.     {

  105.         // 熄灭所有灯

  106.         u8 i;

  107.         for (i = 0; i < sizeof(LedOpTable)/sizeof(LedOpTable[0]); i++)

  108.         {

  109.             LedOpTable[i].LedOff();

  110.         }

  111.         

  112.         // 切换到下一个灯

  113.         sta++;

  114.         if (sta >= (sizeof(LedOpTable) / sizeof(LedOpTable[0])))

  115.         {

  116.             sta = 0;

  117.         }

  118.         

  119.         // 点亮当前灯

  120.         LedOpTable[sta].LedOn();

  121.         

  122.         // 重置计数器

  123.         cnt = 0;

  124.     }

  125.     else

  126.     {

  127.         cnt++;            // 当前灯已持续的时间计数加1

  128.     }

  129. }

  130.  

  131. //========================================================================

  132. // 函数: void Timer0_init(void)

  133. // 描述: timer0初始化函数.

  134. // 参数: none.

  135. // 返回: none.

  136. // 版本: V1.0, 2015-1-12

  137. //========================================================================

  138. void Timer0_init(void)

  139. {

  140.         TR0 = 0;    //停止计数

  141. 

  142.     #if (Timer0_Reload < 64)    // 如果用户设置值不合适， 则不启动定时器

  143.         #error "Timer0设置的中断过快!"

  144. 

  145.     #elif ((Timer0_Reload/12) < 65536UL)    // 如果用户设置值不合适， 则不启动定时器

  146.         ET0 = 1;    //允许中断

  147.     //  PT0 = 1;    //高优先级中断

  148.         TMOD &= ~0x03;

  149.         TMOD |= 0;  //工作模式, 0: 16位自动重装, 1: 16位定时/计数, 2: 8位自动重装, 3: 16位自动重装, 不可屏蔽中断

  150.     //  T0_CT = 1;  //计数

  151.         T0_CT = 0;  //定时

  152.     //  T0CLKO = 1; //输出时钟

  153.         T0CLKO = 0; //不输出时钟

  154. 

  155.         #if (Timer0_Reload < 65536UL)

  156.             T0x12 = 1;  //1T mode

  157.             TH0 = (u8)((65536UL - Timer0_Reload) / 256);

  158.             TL0 = (u8)((65536UL - Timer0_Reload) % 256);

  159.         #else

  160.             T0x12 = 0;  //12T mode

  161.             TH0 = (u8)((65536UL - Timer0_Reload/12) / 256);

  162.             TL0 = (u8)((65536UL - Timer0_Reload/12) % 256);

  163.         #endif

  164. 

  165.         TR0 = 1;    //开始运行

  166. 

  167.     #else

  168.         #error "Timer0设置的中断过慢!"

  169.     #endif

  170. }

  171. //========================================================================

  172. // 函数: void timer0_int (void) interrupt TIMER0_VECTOR

  173. // 描述:  timer0中断函数.

  174. // 参数: none.

  175. // 返回: none.

  176. // 版本: V1.0, 2015-1-12

  177. //========================================================================

  178. void timer0_int (void) interrupt 1

  179. {

  180.    static u8 T_Count = 0;

  181.    T_Count++;

  182.    if(T_Count == 50)                   //满100ms

  183.     {

  184.              T_Count = 0;

  185.              T0_flag = 1;     //100ms标志置1

  186.           }

  187. }

  188. 

  189. //主函数运行 

  190. //间隔100ms，而表中的time=5,1,20,所以亮的时间分别是，100ms的5,1,20倍，

  191. //即500ms,100ms，2s，完整循环用2.6s

  192. void  main(void)

  193. {

  194.           WTST = 0;  //设置程序指令延时参数，赋值为0可将CPU执行指令的速度设置为最快

  195.     EAXFR = 1; //扩展寄存器(XFR)访问使能

  196.     CKCON = 0; //提高访问XRAM速度

  197. 

  198.     P0M1 = 0x00;   P0M0 = 0x00;   //设置为准双向口

  199.     P1M1 = 0x00;   P1M0 = 0x00;   //设置为准双向口

  200.     P2M1 = 0x00;   P2M0 = 0x00;   //设置为准双向口

  201.     P3M1 = 0x00;   P3M0 = 0x00;   //设置为准双向口

  202.     P4M1 = 0x00;   P4M0 = 0x0b;   //设置为准双向口

  203.     P5M1 = 0x00;   P5M0 = 0x00;   //设置为准双向口

  204.     P6M1 = 0x00;   P6M0 = 0x00;   //设置为准双向口

  205.     P7M1 = 0x00;   P7M0 = 0x00;   //设置为准双向口

  206. 

  207.     EA = 1;     //打开总中断

  208.         Timer0_init();       //timer0初始化函数

  209.                 // 初始点亮第一个灯，亮灯顺序，始终1-2-3

  210.   //LedOpTable[0].LedOn();    //屏蔽此句，初始亮灯顺序，2-3-1，之后1-2-3

  211.          IE = 0x82;                                  //允许T0中断

  212.   while(1)

  213.   {

  214.     if(1 == T0_flag)   //100ms标志为1

  215.                 {

  216.                         T0_flag = 0;    //100ms标志清0

  217.                         LED_Ctrl();     //LED灯处理

  218.     }

  219.   }

  220. }
复制代码
    采用AI8051U擎天柱核心板，32bit模式，使用Keil C251编译器，下载成功，第1个LED亮100ms，第2个LED亮200ms，第3个LED亮400ms，第4个LED亮400ms，编译结果Program Size: data=8.0 edata+hdata=300 xdata=0 const=56 code=1177，可能是该编译器有问题，有8个类似的警告：*** WARNING L57: UNCALLED FUNCTION, IGNORED FOR OVERLAY PROCESS
                                                            NAME:    LED4_On/main
LED4_On函数定义了但未使用，但KeilC51则不会出现此警告。另外，STC的AI8051U例程提示：使用Keil C251编译器，Memory Model推荐设置XSmall模式，默认定义变量在edata，单时钟存取访问速度快。实际上若不采用XSmall模式，下载失败,，这可能是Keil C251编译器的一个bug吧。
如果改为8个LED流水点亮，那代码就太多了，把代码复制到STC AI助手让其优化一下，立即给出较好的方案，做了2点优化，下载成功，编译结果
Program Size: data=8.1 edata+hdata=300 xdata=0 const=36 code=1199，完整代码如下。
  1. //表驱动法   

  2. 

  3. //例  8个流水灯  每个动作执行时间不同        索引访问从0开始，<span style="white-space: normal;">亮灯顺序，始终1-2-3...8</span>

  4. //使用Keil C251编译器，Memory Model推荐设置XSmall模式，默认定义变量在edata，单时钟存取访问速度快。

  5. 

  6. #include "AI8051U.h"           //AI8051U---32bit模式，Keil C251编译器

  7. #include "stdio.h"

  8. #include "intrins.h"

  9. 

  10. #define MAIN_Fosc        24000000UL  //时钟

  11. #define Timer0_Reload   (MAIN_Fosc / 500)      //Timer 0 中断,定时2毫秒,不分频

  12. 

  13. 

  14. typedef         unsigned char        u8;

  15. typedef         unsigned int        u16;

  16. typedef         unsigned long        u32;

  17. 

  18. #define MAIN_Fosc        24000000UL

  19.         

  20. sbit LED1 = P2^0;  //LED1位置

  21. sbit LED2 = P2^1;  //LED2位置

  22. sbit LED3 = P2^2;  //LED3位置

  23. sbit LED4 = P2^3;  //LED4位置

  24. sbit LED5 = P2^4;  //LED5位置

  25. sbit LED6 = P2^5;  //LED6位置

  26. sbit LED7 = P2^6;  //LED7位置

  27. sbit LED8 = P2^7;  //LED8位置

  28. 

  29. 

  30. u8 T0_flag = 0;    //100ms标志

  31. 

  32. //==========函数声明================

  33. extern void LED_Ctrl(void);

  34. extern void timer0_init(void);

  35. 

  36. //=========函数定义=============        

  37. 

  38. //====优化点1：将16个独立的亮灭函数合并为2个通用函数====

  39. void LED_Set(u8 num, bit on_off)

  40. {

  41.     switch(num)

  42.     {

  43.         case 0: LED1 = on_off ? 0 : 1; break;  // 亮=0，灭=1

  44.         case 1: LED2 = on_off ? 0 : 1; break;

  45.         case 2: LED3 = on_off ? 0 : 1; break;

  46.         case 3: LED4 = on_off ? 0 : 1; break;

  47.         case 4: LED5 = on_off ? 0 : 1; break;  // 亮=0，灭=1

  48.         case 5: LED6 = on_off ? 0 : 1; break;

  49.         case 6: LED7 = on_off ? 0 : 1; break;

  50.         case 7: LED8 = on_off ? 0 : 1; break;

  51.                           default: break;

  52.     }

  53. } 

  54. //====优化点2：结构体简化，去掉函数指针，改用索引====

  55. struct tagLEDFuncCB

  56. {

  57.     u8   Index;              // LED编号(0/1/2)

  58.     u8    Time;               // 亮灯时间(单位:100ms)

  59. };

  60. 

  61. //====定义需要操作到的灯的表=====

  62. const struct tagLEDFuncCB LedOpTable[] =

  63. {

  64.     {0, 1},    // LED1，亮100ms

  65.     {1, 2},    // LED2，亮200ms

  66.     {2, 3},   // LED3，亮300ms

  67.     {3, 4},   // LED4，亮400ms

  68.     {4, 5},    // LED5，亮500ms

  69.     {5, 6},    // LED6，亮600ms

  70.     {6, 7},   // LED7，亮700ms

  71.     {7, 8},   // LED8，亮800ms

  72. };

  73. 

  74. extern void LED_Ctrl(void);    //LED灯处理

  75. extern void  timer0_init(void);         //timer0初始化函数  

  76. 

  77. void LED_Ctrl(void)      //LED灯处理  下载成功

  78. {

  79.     static u8 sta = 0;        // 当前正在亮的灯在表中的位置

  80.     static u8 cnt = 0;        // 当前灯已持续的时间计数

  81.     

  82.     // 时间到，切换到下一个灯

  83.     if (cnt >= LedOpTable[sta].Time)    //时间超过该状态的LED对应的时间值

  84.     {

  85.         // 熄灭所有灯

  86.         u8 i;

  87.         for (i = 0; i < sizeof(LedOpTable)/sizeof(LedOpTable[0]); i++)

  88.         {

  89.             LED_Set(LedOpTable[i].Index, 0);  // 灭

  90.         }

  91.         

  92.         // 切换到下一个灯

  93.         sta++;

  94.         if (sta >= (sizeof(LedOpTable) / sizeof(LedOpTable[0])))

  95.         {

  96.             sta = 0;

  97.         }

  98.         

  99.         // 点亮当前灯

  100.          LED_Set(LedOpTable[sta].Index, 1);    // 亮

  101.         

  102.         // 重置计数器

  103.         cnt = 0;

  104.     }

  105.     else

  106.     {

  107.         cnt++;            // 当前灯已持续的时间计数加1

  108.     }

  109. }

  110.  

  111. //========================================================================

  112. // 函数: void Timer0_init(void)

  113. // 描述: timer0初始化函数.

  114. // 参数: none.

  115. // 返回: none.

  116. // 版本: V1.0, 2015-1-12

  117. //========================================================================

  118. void Timer0_init(void)

  119. {

  120.         TR0 = 0;    //停止计数

  121. 

  122.     #if (Timer0_Reload < 64)    // 如果用户设置值不合适， 则不启动定时器

  123.         #error "Timer0设置的中断过快!"

  124. 

  125.     #elif ((Timer0_Reload/12) < 65536UL)    // 如果用户设置值不合适， 则不启动定时器

  126.         ET0 = 1;    //允许中断

  127.     //  PT0 = 1;    //高优先级中断

  128.         TMOD &= ~0x03;

  129.         TMOD |= 0;  //工作模式, 0: 16位自动重装, 1: 16位定时/计数, 2: 8位自动重装, 3: 16位自动重装, 不可屏蔽中断

  130.     //  T0_CT = 1;  //计数

  131.         T0_CT = 0;  //定时

  132.     //  T0CLKO = 1; //输出时钟

  133.         T0CLKO = 0; //不输出时钟

  134. 

  135.         #if (Timer0_Reload < 65536UL)

  136.             T0x12 = 1;  //1T mode

  137.             TH0 = (u8)((65536UL - Timer0_Reload) / 256);

  138.             TL0 = (u8)((65536UL - Timer0_Reload) % 256);

  139.         #else

  140.             T0x12 = 0;  //12T mode

  141.             TH0 = (u8)((65536UL - Timer0_Reload/12) / 256);

  142.             TL0 = (u8)((65536UL - Timer0_Reload/12) % 256);

  143.         #endif

  144. 

  145.         TR0 = 1;    //开始运行

  146. 

  147.     #else

  148.         #error "Timer0设置的中断过慢!"

  149.     #endif

  150. }

  151. //========================================================================

  152. // 函数: void timer0_int (void) interrupt TIMER0_VECTOR

  153. // 描述:  timer0中断函数.

  154. // 参数: none.

  155. // 返回: none.

  156. // 版本: V1.0, 2015-1-12

  157. //========================================================================

  158. void timer0_int (void) interrupt 1

  159. {

  160.    static u8 T_Count = 0;

  161.    T_Count++;

  162.    if(T_Count >= 50)                   //满100ms

  163.     {

  164.              T_Count = 0;

  165.              T0_flag = 1;     //100ms标志置1

  166.           }

  167. }

  168. 

  169. //主函数运行 

  170. //间隔100ms，而表中的time=5,1,20,所以亮的时间分别是，100ms的1,2,3...8倍

  171. void  main(void)

  172. {

  173.           WTST = 0;  //设置程序指令延时参数，赋值为0可将CPU执行指令的速度设置为最快

  174.     EAXFR = 1; //扩展寄存器(XFR)访问使能

  175.     CKCON = 0; //提高访问XRAM速度

  176. 

  177.     P0M1 = 0x00;   P0M0 = 0x00;   //设置为准双向口

  178.     P1M1 = 0x00;   P1M0 = 0x00;   //设置为准双向口

  179.     P2M1 = 0x00;   P2M0 = 0x00;   //设置为准双向口

  180.     P3M1 = 0x00;   P3M0 = 0x00;   //设置为准双向口

  181.     P4M1 = 0x00;   P4M0 = 0x0b;   //设置为准双向口

  182.     P5M1 = 0x00;   P5M0 = 0x00;   //设置为准双向口

  183.     P6M1 = 0x00;   P6M0 = 0x00;   //设置为准双向口

  184.     P7M1 = 0x00;   P7M0 = 0x00;   //设置为准双向口

  185. 

  186.     EA = 1;     //打开总中断

  187.         Timer0_init();       //timer0初始化函数

  188. 

  189.   while(1)

  190.   {

  191.     if(1 == T0_flag)   //100ms标志为1

  192.                 {

  193.                         T0_flag = 0;    //100ms标志清0

  194.                         LED_Ctrl();     //LED灯处理

  195.     }

  196.   }

  197. }

复制代码
  本文通过实例说明表驱动的用法，掌握了原理，在单片机中一样有得心应手的应用。





回复

使用道具 举报 送花
wul***
  • 打卡等级：常住居民III
  • 打卡总天数：136
  • 最近打卡：2026-07-22 07:08:11
已绑定手机

4

主题

190

回帖

922

积分

高级会员

积分
922
发表于 2026-7-9 07:09:15 | 显示全部楼层
此法适用于花样流水灯。
回复

使用道具 举报 送花
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|手机版|深圳国芯人工智能有限公司 ( 粤ICP备2022108929号-2 )

GMT+8, 2026-7-22 09:23 , Processed in 0.070695 second(s), 50 queries .

Powered by Discuz! X3.5

© 2001-2026 Discuz! Team.

快速回复 返回顶部 返回列表