21ic电子技术开发论坛 › 单片机与嵌入式系统 › 灵动MM32 MCU › Python，让嵌入式应用开发更便捷、更高效、更专注 ...
返回列表 发新帖我要提问本帖赏金: 120.00元(功能说明)

[MM32生态] Python，让嵌入式应用开发更便捷、更高效、更专注

[复制链接]
2708|13
 楼主| xld0932 发表于 2022-7-4 13:16 | 显示全部楼层 |阅读模式
python, MM32F3270
本帖最后由 xld0932 于 2022-7-4 13:22 编辑

#申请原创#   @21小跑堂

前言
前面分享了基于PikaScript如何在MM32平台上部署Python开发环境的帖子，实现了Python基础开发环境的部署，可以通过串口终端软件在线编写Python，然后直接运行得到结果。

通过Python编程我们是想用来实现应用程序控制的，而非底层驱动程序的实现；基于开发板的底层驱动、以及对板载资源的外设驱动，是在开发板上部署Python开发环境的时候就需要实现的，相当于Python的基建；只有基建实现了，才能够搭建出上层建筑。

那如何实现基于开发板Python的应用编程呢？或者说，怎样才能做到通过Python编程实现对开发板、或者板载外设的控制？如何灵活的下载程序呢？

本文将一步步带你来完成Python在开发板上基建的部署，以及实现上层Python应用程序的开发例程。


串口下载Python脚本、运行程序
对于Python开发环境的部署本质还是在KEIL MDK或者IAR EWARM集成开发环境下通过C语言来开发的，编译后生成HEX执行文件，通过J-LINK或者CMSIS-DAP工具将执行文件下载到芯片当中去运行；那我们Python应用程序，是Python脚本源码文件，如何下载到芯片中去运行呢？

PikaScript提供了Python脚本源码解析的功能，它通过将Python脚本源码解析成Pika字节码，然后运行应用功能，所以我们只需要Python脚本源码传送给PikaScript解析运行即可；这样对于Python的存储方式就灵活很多了，你可以选择存放在MCU内部的FLASH空间、可以存放在外部SPI FLASH空间、也可以存放在TF/SD卡中，通过FatFs文件系统读取Python脚本源码给PikaScript解析运行。

我们这边的实现方式是通过串口的方式，将Python脚本源码存放在MCU内部的FLASH中，将串口接收到的Python脚本字符串完整写入到MCU内容FLASH即可。在启动时不再是直接使用pikaScriptInit()函数，而是通过定义的pikaMain根对象，使用obj_run(pikaMain, code)运行脚本功能。

要实现串口下载Python脚本，需要依据你使用的不同芯片进行相应的移植，参考如下几个步骤：

  • 配置串口参数、开启串口接收中断功能，将串口接收到的Python脚本字符存放在缓存中：
复制
  1. void MCU_InitUART(void)
    

  2. {
    

  3.     GPIO_InitTypeDef GPIO_InitStructure;
    

  4.     NVIC_InitTypeDef NVIC_InitStructure;
    

  5.     UART_InitTypeDef UART_InitStructure;
    


  6. 

  7.     RCC_APB2PeriphClockCmd(RCC_APB2ENR_UART1, ENABLE);
    


  8. 

  9.     NVIC_InitStructure.NVIC_IRQChannel = UART1_IRQn;
    

  10.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    

  11.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    

  12.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    

  13.     NVIC_Init(&NVIC_InitStructure);
    


  14. 

  15.     UART_StructInit(&UART_InitStructure);
    

  16.     UART_InitStructure.UART_BaudRate            = 115200;
    

  17.     UART_InitStructure.UART_WordLength          = UART_WordLength_8b;
    

  18.     UART_InitStructure.UART_StopBits            = UART_StopBits_1;
    

  19.     UART_InitStructure.UART_Parity              = UART_Parity_No;
    

  20.     UART_InitStructure.UART_HardwareFlowControl = UART_HardwareFlowControl_None;
    

  21.     UART_InitStructure.UART_Mode                = UART_Mode_Rx | UART_Mode_Tx;
    

  22.     UART_Init(UART1, &UART_InitStructure);
    


  23. 

  24.     UART_ITConfig(UART1, UART_IT_RXIEN, ENABLE);
    

  25.     UART_Cmd(UART1, ENABLE);
    


  26. 

  27.     RCC_AHBPeriphClockCmd(RCC_AHBENR_GPIOA, ENABLE);
    


  28. 

  29.     GPIO_PinAFConfig(GPIOA, GPIO_PinSource9,  GPIO_AF_7);
    

  30.     GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_7);
    


  31. 

  32.     GPIO_StructInit(&GPIO_InitStructure);
    

  33.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_9;
    

  34.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  35.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
    

  36.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    


  37. 

  38.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_10;
    

  39.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IN_FLOATING;
    

  40.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    

  41. }
    


  42. 

  43. void UART1_IRQHandler(void)
    

  44. {
    

  45.     if(UART_GetITStatus(UART1, UART_IT_RXIEN) != RESET)
    

  46.     {
    

  47.         pikaScript_RxData = UART_ReceiveData(UART1);
    

  48.         pikaScript_RxFlag = 1;
    


  49. 

  50.         UART_ClearITPendingBit(UART1,UART_IT_RXIEN);
    


  51. 

  52.         if(UART1_RxLength > sizeof(UART1_RxBuffer))
    

  53.         {
    

  54.             UART1_RxLength = 0;
    

  55.             memset(UART1_RxBuffer, 0, sizeof(UART1_RxBuffer));
    

  56.         }
    


  57. 

  58.         UART1_RxBuffer[UART1_RxLength++] = pikaScript_RxData;
    


  59. 

  60.         if(pikaScript_RxData == '\n')
    

  61.         {
    

  62.             if(pikaScript_ASM_ReceiveHandler(UART1_RxBuffer, UART1_RxLength))
    

  63.             {
    

  64.                 goto line_exit;
    

  65.             }
    


  66. 

  67.             memcpy(pikaScript_ShellBuffer, UART1_RxBuffer, sizeof(pikaScript_ShellBuffer));
    

  68.             pikaScript_ShellReady = 1;
    


  69. 

  70. line_exit:
    

  71.             UART1_RxLength = 0;
    

  72.             memset(UART1_RxBuffer, 0, sizeof(UART1_RxBuffer));
    

  73.         }
    

  74.     }
    

  75. }
复制
  1. uint8_t pikaScript_ASM_ReceiveHandler(char *RxData, uint32_t RxSize)
    

  2. {
    

  3.     char buff[64] = {0};
    


  4. 

  5.     if(0 == codeHeap.ena)
    

  6.     {
    

  7.         uint8_t is_launch_code_recive = 0;
    


  8. 

  9.         char *strLine = strGetLastLine(buff, RxData);
    


  10. 

  11.         /* auto erase mode, send python file directly */
    

  12.         if(strIsStartWith(strLine, "import "))
    

  13.         {
    

  14.             is_launch_code_recive = 1;
    

  15.             codeHeap.auto_erase   = 1;
    

  16.             codeHeap.content      = pikaMalloc(codeHeap.size + 1);
    

  17.         }
    


  18. 

  19.         /* manual erase mode, send "import" to erase first,
    

  20.            then send the python file.
    

  21.         */
    

  22.         if(strEqu(strLine, "import\r\n"))
    

  23.         {
    

  24.             is_launch_code_recive = 1;
    

  25.             codeHeap.auto_erase   = 0;
    

  26.             codeHeap.wait         = 2;
    


  27. 

  28.             __disable_irq();
    


  29. 

  30.             obj_deinit(__pikaMain);
    


  31. 

  32.             codeHeap.content = malloc(pikaScript_ASM_FINIS_ADDRESS - pikaScript_ASM_START_ADDRESS);
    


  33. 

  34.             if(codeHeap.content == NULL)
    

  35.             {
    

  36.                 printf("[error] no enough code buff, please reset the device.\r\n");
    


  37. 

  38.                 while(1);
    

  39.             }
    


  40. 

  41.             __enable_irq();
    


  42. 

  43.             printf("[info] in download mode, send python please.\r\n");
    

  44.         }
    


  45. 

  46.         /* launch the code reciver */
    

  47.         if(is_launch_code_recive)
    

  48.         {
    

  49.             codeHeap.reciveTime = SysTick_Tick;
    

  50.             codeHeap.ena        = 1;
    

  51.             RxData              = strLine;
    

  52.         }
    

  53.     }
    


  54. 

  55.     if(1 == codeHeap.ena)
    

  56.     {
    

  57.         if(!pikaScript_MomoryLocked)
    

  58.         {
    

  59.             pikaScript_MomoryLocked = 1;
    

  60.         }
    


  61. 

  62.         if(codeHeap.wait > 0)
    

  63.         {
    

  64.             codeHeap.wait--;
    

  65.         }
    


  66. 

  67.         codeHeap.reciveTime = SysTick_Tick;
    

  68.         codeHeap.oldSize    = codeHeap.size;
    

  69.         codeHeap.size      += RxSize;
    


  70. 

  71.         /* write to heap buff */
    

  72.         if(codeHeap.auto_erase)
    

  73.         {
    

  74.             codeHeap.content = realloc(codeHeap.content, codeHeap.size + 1);
    

  75.         }
    


  76. 

  77.         memcpy(codeHeap.content + codeHeap.oldSize, RxData, RxSize);
    


  78. 

  79.         codeHeap.content[codeHeap.size] = 0;
    


  80. 

  81.         return 1;
    

  82.     }
    


  83. 

  84.     /* not work */
    

  85.     return 0;
    

  86. }

  • 实现对MCU内部FLASH的读写操作，定义存储空间区域，用于存放Python脚本源码：
复制
  1. uint32_t pikaScript_FLASH_GetPageNumber(uint32_t Address)
    

  2. {
    

  3.     return (Address - MM32F327xG_FLASH_START_ADDRESS) / MM32F327xG_FLASH_PAGE_SIZE;
    

  4. }
    


  5. 

  6. void pikaScript_FLASH_EraseUserZone(void)
    

  7. {
    

  8.     uint32_t StartPage = 0, NumberOfPages = 0;
    


  9. 

  10.     printf("[info]: erising flash...\r\n");
    


  11. 

  12.     pikaScript_WriteAddress = 0;
    

  13.     pikaScript_FlashOffset  = 0;
    


  14. 

  15.     memset(pikaScript_FlashBuffer, 0, sizeof(pikaScript_FlashBuffer));
    


  16. 

  17.     StartPage     = pikaScript_FLASH_GetPageNumber(pikaScript_ASM_START_ADDRESS);
    

  18.     NumberOfPages = pikaScript_FLASH_GetPageNumber(pikaScript_ASM_FINIS_ADDRESS) - StartPage + 1;
    


  19. 

  20.     FLASH_Unlock();
    

  21.     FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
    


  22. 

  23.     while(NumberOfPages--)
    

  24.     {
    

  25.         FLASH_ErasePage(MM32F327xG_FLASH_PAGE_SIZE * StartPage);
    

  26.         FLASH_ClearFlag(FLASH_FLAG_EOP);             StartPage++;
    

  27.     }
    


  28. 

  29.     FLASH_Lock();
    


  30. 

  31.     printf("[ OK ]: erising flash ok!\r\n");
    

  32. }
    


  33. 

  34. uint32_t pikaScript_FLASH_ProgramWord(uint32_t BaseAddress, uint32_t FlashAddress, char ch)
    

  35. {
    

  36.     uint32_t pikaScript_FlashData = 0;
    


  37. 

  38.     if(pikaScript_FlashOffset > 3)
    

  39.     {
    

  40.         pikaScript_FlashOffset = 0;
    


  41. 

  42.         for(int i = 3; i >= 0; i--)
    

  43.         {
    

  44.             pikaScript_FlashData  = pikaScript_FlashData << 8;
    

  45.             pikaScript_FlashData += pikaScript_FlashBuffer[i];
    

  46.         }
    


  47. 

  48.         __platform_disable_irq_handle();
    


  49. 

  50.         FLASH_Unlock();
    


  51. 

  52.         FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
    


  53. 

  54.         FLASH_ProgramWord(BaseAddress + FlashAddress, pikaScript_FlashData);
    


  55. 

  56.         FLASH_ClearFlag(FLASH_FLAG_EOP);
    


  57. 

  58.         FLASH_Lock();
    


  59. 

  60.         __platform_enable_irq_handle();
    


  61. 

  62.         FlashAddress = FlashAddress + 4;
    

  63.     }
    


  64. 

  65.     pikaScript_FlashBuffer[pikaScript_FlashOffset++] = ch;
    


  66. 

  67.     return FlashAddress;
    

  68. }
    


  69. 

  70. void pikaScript_FLASH_WriteASM(char *ptr, uint32_t StartAddress, uint32_t FinisAddress, uint32_t Size)
    

  71. {
    

  72.     for(uint32_t i = 0; i < Size; i++)
    

  73.     {
    

  74.         pikaScript_WriteAddress = pikaScript_FLASH_ProgramWord(StartAddress, pikaScript_WriteAddress, ptr[i]);
    

  75.     }
    

  76. }
    


  77. 

  78. void pikaScript_FLASH_WriteEOF(void)
    

  79. {
    

  80.     uint32_t StartAddress = pikaScript_ASM_START_ADDRESS;
    


  81. 

  82.     for(uint8_t i = 0; i < 16; i++)
    

  83.     {
    

  84.         pikaScript_WriteAddress = pikaScript_FLASH_ProgramWord(StartAddress, pikaScript_WriteAddress, '\0');
    

  85.     }
    

  86. }
    


  87. 

  88. void pikaScript_FLASH_SaveString(char *str, uint32_t StartAddress, uint32_t FinisAddress)
    

  89. {
    

  90.     pikaScript_FLASH_WriteASM(str, StartAddress, FinisAddress, strGetSize(str));
    

  91. }

  • 在定时器中对Python下载进行处理，用于判断是否完成接收，接收完成后存储Python脚本源码：
复制
  1. void pikaScript_ASM_ProgramHandler(void)
    

  2. {
    

  3.     if(!codeHeap.ena)
    

  4.     {
    

  5.         /* recive not activate */
    

  6.         return;
    

  7.     }
    


  8. 

  9.     if(codeHeap.wait)
    

  10.     {
    

  11.         /* still waiting */
    

  12.         return;
    

  13.     }
    


  14. 

  15.     if(SysTick_Tick - codeHeap.reciveTime < 200)
    

  16.     {
    

  17.         /* still reciving */
    

  18.         return;
    

  19.     }
    


  20. 

  21.     printf("==============[Programer]==============\r\n");
    

  22.     
    

  23.     /* transmite is finished */
    

  24.     printf("[info]: recieved size: %d\r\n", codeHeap.size);
    


  25. 

  26.     /* write to flash from buff (heap.content) */
    

  27.     pikaScript_FLASH_EraseUserZone();
    


  28. 

  29.     printf("[info]: Writing flash... \r\n");
    


  30. 

  31.     FLASH_Unlock();
    


  32. 

  33.     /* write to flash */
    

  34.     pikaScript_FLASH_WriteASM(codeHeap.content,
    

  35.                               pikaScript_ASM_START_ADDRESS,
    

  36.                               pikaScript_ASM_FINIS_ADDRESS,
    

  37.                               codeHeap.size);
    


  38. 

  39.     /* write EOF */
    

  40.     pikaScript_FLASH_WriteASM("\n\n",
    

  41.                               pikaScript_ASM_START_ADDRESS,
    

  42.                               pikaScript_ASM_FINIS_ADDRESS,
    

  43.                               0x02);
    


  44. 

  45.     pikaScript_FLASH_WriteEOF();
    


  46. 

  47.     FLASH_Lock();
    


  48. 

  49.     printf("[ OK ]: Write flash ok! \r\n");
    


  50. 

  51.     char *codeInFlash = (char *)pikaScript_ASM_START_ADDRESS;
    


  52. 

  53.     printf("\r\n");
    

  54.     printf("----[code in flash]-----\r\n");
    


  55. 

  56.     for(int i = 0; i < strGetSize(codeInFlash); i++)
    

  57.     {
    

  58.         if('\n' == codeInFlash[i])
    

  59.         {
    

  60.             if(codeInFlash[i - 1] != '\r')
    

  61.             {
    

  62.                 fputc('\r', (FILE*)!NULL);
    

  63.             }
    

  64.         }
    


  65. 

  66.         fputc(codeInFlash[i], (FILE*)!NULL);
    

  67.     }
    


  68. 

  69.     printf("----[code in flash]-----\r\n");
    

  70.     printf("\r\n");
    


  71. 

  72.     printf("[ OK ]: Programing ok!  \r\n");
    

  73.     printf("[info]: Restarting...   \r\n");
    


  74. 

  75.     printf("==============[Programer]==============\r\n");
    

  76.     printf("\r\n");
    


  77. 

  78.     NVIC_SystemReset();
    

  79. }

  • 系统上电启动后对Python脚本源码进行解析、然后跳转运行：
复制
  1. int main(void)
    

  2. {
    

  3.     SysTick_Init();
    


  4. 

  5.     MCU_InitUART();
    


  6. 

  7.     printf("\r\nPikaScript SZ-III(MM32F3277G9P) %s %s", __DATE__, __TIME__);
    


  8. 

  9.     pikaScriptInfo();
    


  10. 

  11.     pikaScript_ASM_Init();
    


  12. 

  13.     /* boot pikaScript */
    

  14.     char *code = (char *)pikaScript_ASM_START_ADDRESS;
    


  15. 

  16.     if(((uint8_t)(code[0]) != 0xFF) && ((uint8_t)(code[1]) != 0xFF))
    

  17.     {
    

  18.         /* boot from flash */
    

  19.           pikaMain = newRootObj("pikaMain", New_PikaMain);
    

  20.         __pikaMain = pikaMain;
    


  21. 

  22.         if(code[0] == 'i')
    

  23.         {
    

  24.             printf("[info]: compiling the python script...\r\n");
    


  25. 

  26.             main_codeBuff = arg_setStr(NULL, "", code);
    

  27.             pikaCompile("", arg_getStr(main_codeBuff));
    


  28. 

  29.             NVIC_SystemReset();
    

  30.         }
    

  31.         else
    

  32.         {
    

  33.             pikaVM_runByteCode(pikaMain, (uint8_t *)code);
    

  34.             goto main_loop;
    

  35.         }
    

  36.     }
    

  37.     else
    

  38.     {
    

  39.         /* boot from firmware */
    

  40.         printf("[info]: boot from firmware.\r\n");
    


  41. 

  42.         pikaMain = pikaScriptInit();
    

  43.         goto main_loop;
    

  44.     }
    


  45. 

  46. main_loop:
    

  47.     pikaScriptShell(pikaMain);
    


  48. 

  49.     /* after exit() from pika shell */
    

  50.     NVIC_SystemReset();
    

  51. }


接下来，我们来演示一下通过串口方式来下载Python应用程序，以及查看运行结果：
https://www.bilibili.com/video/BV1s94y1R74x/


PikaScript标准库
PikaScript提供了5个标准库，分别是PikaStdLib标准库、PikaStdDevice标准设备、PikaStdData数据结构、PikaStdTask多任务、PikaDebug调试器；基于除了PikaStdDevice标准设备是由我们用户定义和实现的外，其它的都是PikaScript已经完成的功能代码，我们不需要再做修改，直接使用就可以了。

为了使基于PikaScript的Python应用程序对不同平台设备的操作具有统一性，官方提出了PikaStdDevice标准设备库，其中定义了固定的对GPIO、TIM、PWM、ADC、I2C、SPI、UART等基本MCU外设的操作函数，我们只需要根据使用的MCU来进行适配就可以了。


PikaScript C模块开发
Python的上层应用程序开发是基于PikaScript这个基建的，而PikaScript C模块开发可以给上层的Python应用程序提供丰富的功能，你可以理解为应用程序调用底层驱动的API接口函数或者库。接下来，我们使用神舟 III号开发板（板载MCU为MM32F3270）在完成串口下载功能的工程模板上，可以根据下面的描述和步骤来操作……

在附件工程中Source\PikaScript文件夹下需要有4个基础文件文件：requestment.txt、pikaPackage.exe、pikaBeforBuild-keil.bat、rust-msc-latest-win10.exe，根据requestment.txt的版本要求，双击pikaPackage.exe获取PikaScript源码到当前目录；pikaBeforBuild-keil.bat文件是用来在KEIL MDK中编译前预处理的指令集合，通过调用rust-msc-latest-win10.exe来自动运行PikaScript预编译器，将Python文件在PC开发时就转换成字节码并打包成一个库，就像C一样，可以通过KEIL进行编译下载到MCU运行，给Python上层应用程序提供基建模块。所以KEIL中需要有如下配置：
1.png

在获取/更新完PikaScript源码后，接着在Source\PikaScript文件夹下添加main.py、PikaStdDevice.pyi、MM32F3270.pyi、SHENZHOU3.pyi这4个文件：标准的设备驱动由PikaStdDevice结合MM32F3270来实现的，PikaStdDevice是一个抽象的设备驱动模块，定义了所有的用户API，各个平台的驱动模块只要从PikaStdDevice继承，就能名获得一模一样的用户API，而PikaStdDevice内部会间接调用平台驱动，通过多态特性重写底层的平台驱动，就可以在不同的平台工作了。如果是特定的开发板，你也可以选择不去实现PikaStdDevice也是可行的，通过MM32F3270和SHENZHOU3这两个文件来实现就可以了……
2.png

当前没有去实现标准设备库，只是通过MM32F3270.pyi基于SysTick实现了Task功能，这样在Python应用程序的时候，就可以使用Task来创建任务，进行任务调试；如下所示：
复制
  1. #include <stdint.h>
    

  2. #include "BaseObj.h"
    

  3. #include "config.h"
    

  4. #include "dataStrs.h"
    


  5. 

  6. extern uint32_t SysTick_Tick;
    


  7. 

  8. void MM32F3270_Task_platformGetTick(PikaObj* self)
    

  9. {
    

  10.     obj_setInt(self, "tick", SysTick_Tick);
    

  11. }

如果对Task任务调试的时序要求比较高的话，可以将PikaScript的优化配置将原来的PIKA_OPTIMIZE_SIZE切换到PIKA_OPTIMIZE_SPEED，优化后的结果就是在运行速度和代码占用空间这两者之间做了个平衡和取舍。

每一个PikaScript C模块都是由模块接口和模块实现两部分组成，其中SHENZHOU3.pyi实现了一个模块接口，在模块接口中我们可以根据板载的资源去定义不同的类（比如LED、KEY、LCD等等），每个类中再根据功能需求定义不同的调用/实现方法；将SHENZHOU3.pyi添加到KEIL工程进行编译（会报错缺少文件哦），此时会由PikaScript预编译会生成对应的API文件，即相应的模块实现，这是根据模块接口中的类定义来自动生成的，分别对应了多个模块实现（SHENZHOU3_LED-api.c、SHENZHOU3_KEY-api.c、SHENZHOU3_LCD-api.c等等）：
3.png 4.png

将这些模块实现添加到KEIL工程中来，再编译一下，这个时候会报警，有很多函数没有定义：
5.png

这时我们就需要新建文件（SHENZHOU3_LED.c、SHENZHOU3_KEY.c、SHENZHOU3_LCD.c），来实现这些调用接口函数，在实现了这些功能之后，我们的Python基建就完成了。
6.png

下面看一下SHENZHOU3_LED的具体实现，是不是很简单，其它就是实现PikaScript自动生成的SHENZHOU3_LED-api的接口函数，完成对底层板载LED灯的操作：
复制
  1. #include "SHENZHOU3_LED.h"
    

  2. #include <stdint.h>
    

  3. #include "BaseObj.h"
    

  4. #include "dataStrs.h"
    

  5. #include "config.h"
    


  6. 


  7. 

  8. void SHENZHOU3_LED_Init(PikaObj* self)
    

  9. {
    

  10.     GPIO_InitTypeDef GPIO_InitStructure;
    


  11. 

  12.     RCC_AHBPeriphClockCmd(RCC_AHBENR_GPIOF, ENABLE);
    


  13. 

  14.     GPIO_StructInit(&GPIO_InitStructure);
    

  15.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9;
    

  16.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  17.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_Out_PP;
    

  18.     GPIO_Init(GPIOF, &GPIO_InitStructure);
    


  19. 

  20.     GPIO_WriteBit(GPIOF, GPIO_Pin_6, Bit_SET);
    

  21.     GPIO_WriteBit(GPIOF, GPIO_Pin_7, Bit_SET);
    

  22.     GPIO_WriteBit(GPIOF, GPIO_Pin_8, Bit_SET);
    

  23.     GPIO_WriteBit(GPIOF, GPIO_Pin_9, Bit_SET);
    

  24. }
    


  25. 


  26. 

  27. void SHENZHOU3_LED_Toggle(PikaObj* self)
    

  28. {
    

  29.     if(!obj_isArgExist(self, "ledState"))
    

  30.     {
    

  31.         obj_setInt(self, "ledState", 0);
    

  32.     }
    


  33. 

  34.     int ledState = obj_getInt(self, "ledState");
    


  35. 

  36.     if(0 == ledState)
    

  37.     {
    

  38.         GPIO_WriteBit(GPIOF, GPIO_Pin_6, Bit_SET);
    

  39.         GPIO_WriteBit(GPIOF, GPIO_Pin_7, Bit_SET);
    

  40.         GPIO_WriteBit(GPIOF, GPIO_Pin_8, Bit_SET);
    

  41.         GPIO_WriteBit(GPIOF, GPIO_Pin_9, Bit_SET);
    

  42.     }
    

  43.     else
    

  44.     {
    

  45.         GPIO_WriteBit(GPIOF, GPIO_Pin_6, Bit_RESET);
    

  46.         GPIO_WriteBit(GPIOF, GPIO_Pin_7, Bit_RESET);
    

  47.         GPIO_WriteBit(GPIOF, GPIO_Pin_8, Bit_RESET);
    

  48.         GPIO_WriteBit(GPIOF, GPIO_Pin_9, Bit_RESET);
    

  49.     }
    


  50. 

  51.     obj_setInt(self, "ledState", (ledState + 1) % 2);
    

  52. }
    


  53.
参考SHENZHOU3_LED的实现方法，结合SHENZHOU3_KEY-api和SHENZHOU3_LCD-api的所需要实现的接口函数，就可以轻松完善整个工程代码啦……


Python应用示例
通过编写Python应用程序，在神舟III号开发板上实现一个贪吃蛇的小程序功能示例：
复制
  1. import PikaStdLib
    

  2. import MM32F3270
    

  3. import SHENZHOU3
    


  4. 

  5. snake_sx = 200
    

  6. snake_sy = 50
    

  7. snake_ex = 210
    

  8. snake_ey = 60
    

  9. snake_size = 10
    

  10. snake_dir = 1
    


  11. 

  12. food_idx = 0
    

  13. food_sx = [100,  20,  80, 160,  70, 200, 120, 180,  60, 220]
    

  14. food_sy = [100, 300,  80, 160, 230,  50, 140, 270, 200, 190]
    

  15. food_ex = [110,  30,  90, 170,  80, 210, 130, 190,  70, 230]
    

  16. food_ey = [110, 310,  90, 170, 240,  60, 150, 280, 210, 200]
    

  17.                           
    

  18. lcd = SHENZHOU3.LCD()     
    

  19. led = SHENZHOU3.LED()     
    

  20. key = SHENZHOU3.KEY()
    


  21. 

  22. lcd.Init()
    

  23. led.Init()
    

  24. key.Init()
    


  25. 

  26. mem = PikaStdLib.MemChecker()
    

  27. print('Hello PikaScript ^_^')
    

  28. print('memory used max  :  ')
    

  29. mem.max()
    


  30. 

  31. lcd.Clear(0)
    

  32. lcd.ShowText(0,  0, 'SZ-III(MM32):Hello PikaScript!')
    


  33. 

  34. lcd.FillArea(  8,  18, 232,  19, 0x07E0)
    

  35. lcd.FillArea(  8,  18,   9, 312, 0x07E0)
    


  36. 

  37. lcd.FillArea(231,  18, 232, 312, 0x07E0)
    

  38. lcd.FillArea(  8, 311, 232, 312, 0x07E0)
    


  39. 

  40. lcd.FillArea(100, 100, 110, 110, 0x07E0)
    


  41. 

  42. def led_Task():
    

  43.     led.Toggle()
    

  44.     return
    


  45. 

  46. def key_Task():
    

  47.     global snake_dir
    

  48.     keyState = key.Read()
    

  49.     if   keyState == 0:
    

  50.         snake_dir = 1
    

  51.         print('KEY WAKEUP : UP')
    

  52.     elif keyState == 1:
    

  53.         snake_dir = 2
    

  54.         print('KEY TAMPER : DOWN')
    

  55.     elif keyState == 2:
    

  56.         snake_dir = 3
    

  57.         print('KEY USER1  : LEFT')
    

  58.     elif keyState == 3:
    

  59.         snake_dir = 4
    

  60.         print('KEY USER2  : RIGHT')
    

  61.     return
    


  62. 

  63. def food_Run():
    

  64.     global snake_sx
    

  65.     global snake_sy
    

  66.     global snake_ex
    

  67.     global snake_ey
    

  68.     global snake_dir
    

  69.     global food_sx
    

  70.     global food_sy
    

  71.     global food_ex
    

  72.     global food_ey
    

  73.     global food_idx
    

  74.     sx = food_sx[food_idx]
    

  75.     sy = food_sy[food_idx]
    

  76.     ex = food_ex[food_idx]
    

  77.     ey = food_ey[food_idx]
    

  78.     food_eat = 0
    

  79.     if snake_dir == 1:
    

  80.         if snake_sx == sx:
    

  81.             if snake_sy == ey:
    

  82.                 lcd.FillArea(sx, sy, ex, ey, 0xF800)
    

  83.                 food_eat = 1
    

  84.                 food_idx = food_idx + 1
    

  85.     elif snake_dir == 2:
    

  86.         if snake_sx == sx:
    

  87.             if snake_ey == sy:
    

  88.                 lcd.FillArea(sx, sy, ex, ey, 0xF800)
    

  89.                 food_eat = 1
    

  90.                 food_idx = food_idx + 1
    

  91.     elif snake_dir == 3:
    

  92.         if snake_sy == sy:
    

  93.             if snake_sx == ex:
    

  94.                 lcd.FillArea(sx, sy, ex, ey, 0xF800)
    

  95.                 food_eat = 1
    

  96.                 food_idx = food_idx + 1
    

  97.     elif snake_dir == 4:
    

  98.         if snake_sy == sy:
    

  99.             if snake_ex == sx:
    

  100.                 lcd.FillArea(sx, sy, ex, ey, 0xF800)
    

  101.                 food_eat = 1
    

  102.                 food_idx = food_idx + 1
    

  103.     if food_idx == 10:
    

  104.         food_idx = 0
    

  105.     if food_eat == 1:
    

  106.         sx = food_sx[food_idx]
    

  107.         sy = food_sy[food_idx]
    

  108.         ex = food_ex[food_idx]
    

  109.         ey = food_ey[food_idx]
    

  110.         lcd.FillArea(sx, sy, ex, ey, 0x07E0)
    

  111.     return
    


  112. 

  113. def snake_Run():
    

  114.     global snake_sx
    

  115.     global snake_sy
    

  116.     global snake_ex
    

  117.     global snake_ey
    

  118.     global snake_size
    

  119.     global snake_dir
    

  120.     sx = snake_sx
    

  121.     sy = snake_sy
    

  122.     ex = snake_ex
    

  123.     ey = snake_ey
    

  124.     lcd.FillArea(sx, sy, ex, ey, 0x0000)
    

  125.     if snake_dir == 1:
    

  126.         if snake_sy > 20:
    

  127.             snake_sy = snake_sy - snake_size
    

  128.         else:
    

  129.             snake_dir = 4
    

  130.             snake_sx = snake_sx + snake_size
    

  131.     elif snake_dir == 2:
    

  132.         if snake_sy < 310 - snake_size:
    

  133.             snake_sy = snake_sy + snake_size
    

  134.         else:
    

  135.             snake_dir = 3
    

  136.             snake_sx = snake_sx - snake_size
    

  137.     elif snake_dir == 3:
    

  138.         if snake_sx > 10:
    

  139.             snake_sx = snake_sx - snake_size
    

  140.         else:
    

  141.             snake_dir = 1
    

  142.             snake_sy = snake_sy - snake_size
    

  143.     elif snake_dir == 4:
    

  144.         if snake_sx < 230 - snake_size:
    

  145.             snake_sx = snake_sx + snake_size
    

  146.         else:
    

  147.             snake_dir = 2
    

  148.             snake_sy = snake_sy + snake_size
    

  149.     else:
    

  150.         snake_dir = 0
    

  151.     if snake_sx  < 10:
    

  152.         snake_sx = 10
    

  153.     if snake_sy  < 20:
    

  154.         snake_sy = 20
    

  155.     if snake_sx  > 230 - snake_size:
    

  156.         snake_sx = 230 - snake_size
    

  157.     if snake_sy  > 310 - snake_size:
    

  158.         snake_sy = 310 - snake_size
    

  159.     snake_ex = snake_sx + snake_size
    

  160.     snake_ey = snake_sy + snake_size
    

  161.     sx = snake_sx
    

  162.     sy = snake_sy
    

  163.     ex = snake_ex
    

  164.     ey = snake_ey
    

  165.     food_Run()
    

  166.     lcd.FillArea(sx, sy, ex, ey, 0xF800)
    

  167.     return
    


  168. 

  169. task = MM32F3270.Task()
    


  170. 

  171. task.call_period_ms(led_Task,  250)
    

  172. task.call_period_ms(key_Task,  50 )
    

  173. task.call_period_ms(snake_Run, 500)
    


  174. 

  175. print('Task Running...')
    


  176. 

  177. task.run_forever()


下载运行、演示如下
https://www.bilibili.com/video/BV1yt4y1t7ep/


附件
Bootloader模版工程： 05.PiKaScript_Bootloader.zip (7.78 MB, 下载次数: 14)
贪吃蛇基建工程源码： PiKaScript_SZ-III_Snake.zip (7.81 MB, 下载次数: 17)
贪吃蛇Python脚本程序： snake.zip (1.14 KB, 下载次数: 6)
回复

收藏1 举报

打赏榜单

21小跑堂 打赏了 120.00 元 2022-07-06
理由：恭喜通过原创文章审核！请多多加油哦！

评论

21小跑堂
一文带你十分钟将PikaScript部署到新平台，并在神舟III号开发板上实现贪吃蛇  发表于 2022-7-6 13:33

相关帖子
daichaodai 发表于 2022-7-7 08:34 来自手机 | 显示全部楼层
Python确实方便
回复

收藏1 举报

麻花油条 发表于 2022-7-7 15:21 来自手机 | 显示全部楼层
这个确实不错，挺方便
回复

收藏1 举报

tpgf 发表于 2022-8-1 11:22 | 显示全部楼层
python是不是一种上位机语言啊
回复

收藏1 举报

nawu 发表于 2022-8-1 11:31 | 显示全部楼层
python入门简单精通难啊
回复

收藏1 举报

aoyi 发表于 2022-8-1 11:38 | 显示全部楼层
这种算法复杂吗
回复

收藏1 举报

zljiu 发表于 2022-8-1 11:46 | 显示全部楼层
这个语言就是为嵌入式而生的吧
回复

收藏1 举报

gwsan 发表于 2022-8-1 11:57 | 显示全部楼层
这种界面友好吗
回复

收藏1 举报

tfqi 发表于 2022-8-1 12:04 | 显示全部楼层
这个语言和哪种比较类似啊
回复

收藏1 举报

asmine 发表于 2022-8-6 16:33 | 显示全部楼层
Python一直以为是PC端的
回复

收藏1 举报

weifeng90 发表于 2022-8-6 17:53 来自手机 | 显示全部楼层
还能这样玩，学习了。
回复

收藏1 举报

内政奇才 发表于 2022-8-16 15:31 来自手机 | 显示全部楼层
这种算法容易上手吗
回复

收藏1 举报

cyclefly 发表于 2022-8-22 21:19 | 显示全部楼层
这也能用在嵌入式？
回复

收藏1 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

xld0932 Image
个人签名：King.Xu

77

主题

3024

帖子

38

粉丝
快速回复 在线客服 返回列表 返回顶部