设为首页收藏本站
首页 > 论坛 > ESP32

[ESP8266/ESP32]FireBeetle ESP32 制作一个自动输入器 精华

zoologist | 高级技匠 | 创造力： | 帖子： | 发消息 | 串个门 | 加好友 | 打招呼
2021-3-16 20:56:23 [显示全部楼层]
3163浏览
1回复
0收藏
查看: 3163|回复: 1

[ESP8266/ESP32] FireBeetle ESP32 制作一个自动输入器

[复制链接]
有个朋友问我是否可以帮忙做一个自动输入的工具，具体场景是：他们的图书馆为了避免病毒之类的影响，内网的机器无法使用U盘，这样对于制作一些文档来说非常麻烦，因此询问我能否在对于系统影响最小的情况下编写一个能够自动输入的工具，这样可以在自己的笔记本电脑上准备好文档，需要时直接输入即可。经过研究，我使用 FirBeetle 加 CH55X 来制作了一个自动输入器可以满足他的需求。
首先是硬件方案，选择了如下板卡
  
编号
  
板卡
用途
1
FireBeetle ESP32  
作为主控
2
FireBeetle萤火虫OLED  12864显示屏
板上有按钮，用于选择文件；同时  OLED用于展示当前的提示信息
3
FireBeetle 摄像头及音频扩展板
使用这个板子上的 SD 插槽用于读取事先准备好的文件
4
自制CH55X  Shield
通过CH55X模拟一个 USB键盘从而实现串口转 USB 的目的。这里可以使用 CH552 也可以使用 CH554
可以看到，上面的方案中自制 CH55X Shield 是最大的难点。
首先，绘制电路图如下，左侧是 FIreBeetle 的引脚，它和Shield是通过 IO16/17 相连的，这是ESP32的 Serial2。
FireBeetle ESP32 制作一个自动输入器图1
在 USB 引脚附件有一个跳线 H1，这是用来切换当前供电的。正常情况下是FIreBeetle给 Shield 供电，但是真正使用时，却需要从USB口对 FireBeetle 供电。因此，使用时需要将 H1 短接来给 FIreBeetle 供电。
FireBeetle ESP32 制作一个自动输入器图2

CH55X 部分，对于这个芯片使用3.3V供电，因此 V33和 VCC 是接在一起的。此外，在 USB+(P3.6) 上有一个按钮和跳线，它们的作用是相同的：短接后经过10K 电阻上拉，这样在上电时可以让 CH55X 进入 BootMode便于更新Firmware。如果没有焊接按钮，可以在上电时用镊子短接跳线位置实现同样的功能。
FireBeetle ESP32 制作一个自动输入器图3
另外，为了调试和日后扩展，预留了其他引脚出来：
FireBeetle ESP32 制作一个自动输入器图4
PCB 设计如下：
FireBeetle ESP32 制作一个自动输入器图5

3D预览如下：
FireBeetle ESP32 制作一个自动输入器图6

拿到手的板子如下，我使用的是 CH554T 芯片：
FireBeetle ESP32 制作一个自动输入器图7

设计 CH55X 代码：
  1. #ifndef USER_USB_RAM

  2. #error "This example needs to be compiled with a USER USB setting"

  3. #endif

  4. 

  5. #include "src/userUsbHidKeyboard/USBHIDKeyboard.h"

  6. 

  7. void setup() {

  8.   USBInit();

  9.   Serial0_begin(115200);

  10. }

  11. 

  12. void loop() {

  13. 

  14.   while (Serial0_available()) {

  15.     char serialChar = Serial0_read();

  16.     Keyboard_write(serialChar);

  17.   }

  18. }

复制代码
可以看到非常简单，就是从 Serial0 接收，然后从 USB 转发出去。具体的下载方法请参考之前的文章【参考1】。特别注意，板子上芯片使用3.3V供电，因此，下载时需要使用如下设置：FireBeetle ESP32 制作一个自动输入器图8

上面完成之后就可以开始给 FireBeetle编写代码了。代码流程如下：

1.上电后检查 SD 卡，如果无法识别就停止运行；
2.读取 INITDIR 指定的”LABZ”，枚举下面的全部文件，将文件名保存在 FilePool 结构体中。这个结构体中可以保存10个文件（对于 ESP32 来说，内存足够大，能够保存更多的文件，但是相信使用时不会有人想用按键来选择一个个的文件）；
3.进入 loop 循环，在屏幕上显示当前选中的文件信息，包括文件名，大小和该文件是目录下第几个文件。OLED 上有一个方向键，提供了4个方向加确定，具体是通过下面的多个电阻实现，在代码中通过read_key_analog() 函数来给出当前的选择值
FireBeetle ESP32 制作一个自动输入器图9

4.为了便于调试，代码中还提供了使用串口的调试方法，输入“a”表示上一个,输入“z”表示下一个，”x”确定；
5.在运行时如果收到确认键，就打开 SD 卡上对应名字的文件，然后将内容输出给 CH55X。

完整代码如下：
  1. #include "DFRobot_OLED12864.h"

  2. #include "FS.h"

  3. #include "SD_MMC.h"

  4. 

  5. 

  6. //设置文件名最大长度（目录名+文件名）

  7. //超过这个长度的文件名会被忽略掉

  8. const int MAXNAMELENGTH=16;

  9. #define ADC_BIT  4096

  10. #define ADC_SECTION 5

  11. #define EVERYSHOW 127

  12. 

  13. //读取这个目录下的内容

  14. char* INITDIR="/LABZ";

  15. 

  16. const uint8_t pin_analogKey = A0;

  17. 

  18. //文件名列表

  19. struct {

  20.     int      size;

  21.     char     name[MAXNAMELENGTH];

  22. } FilePool[10];

  23. 

  24. // 枚举到的文件数量

  25. int FileCounter=0;

  26. 

  27. enum enum_key_analog {

  28.   key_analog_no,

  29.   key_analog_right,

  30.   key_analog_center,

  31.   key_analog_up,

  32.   key_analog_left,

  33.   key_analog_down,

  34. } eKey_analog;

  35. 

  36. const uint8_t I2C_OLED_addr = 0x3c;

  37. const uint8_t pin_character_cs = D5, keyA = D3, keyB = D8;

  38. DFRobot_OLED12864 OLED(I2C_OLED_addr, pin_character_cs);

  39. 

  40. enum_key_analog read_key_analog(void)

  41. {

  42.   int adValue = analogRead(pin_analogKey);

  43.   if(adValue > ADC_BIT * (ADC_SECTION * 2 - 1) / (ADC_SECTION * 2)) {

  44.     return key_analog_no;

  45.   } else if(adValue > ADC_BIT * (ADC_SECTION * 2 - 3) / (ADC_SECTION * 2)) {

  46.     return key_analog_right;

  47.   } else if(adValue > ADC_BIT * (ADC_SECTION * 2 - 5) / (ADC_SECTION * 2)) {

  48.     return key_analog_center;

  49.   } else if(adValue > ADC_BIT * (ADC_SECTION * 2 - 7) / (ADC_SECTION * 2)) {

  50.     return key_analog_up;

  51.   } else if(adValue > ADC_BIT * (ADC_SECTION * 2 - 9) / (ADC_SECTION * 2)) {

  52.     return key_analog_left;

  53.   } else {

  54.     return key_analog_down;

  55.   }

  56. }

  57. 

  58. void setup(){

  59.     Serial.begin(115200);

  60.     Serial2.begin(115200);

  61.     pinMode(keyA, INPUT);

  62.     pinMode(keyB, INPUT);

  63.     

  64.     OLED.init();

  65.     OLED.flipScreenVertically();

  66.     OLED.clear();

  67.     OLED.disStr(0, 0, "自动键盘机");

  68.     OLED.display();

  69. 

  70.     if(!SD_MMC.begin()){

  71.         Serial.println("Card Mount Failed");

  72.         OLED.disStr(0, 16, "SD挂载失败");

  73.         OLED.display();

  74.         return;

  75.     }

  76.     uint8_t cardType = SD_MMC.cardType();

  77. 

  78.     if(cardType == CARD_NONE){

  79.         Serial.println("No SD_MMC card attached");

  80.         OLED.disStr(0, 16, "无SD卡");

  81.         OLED.display();        

  82.         return;

  83.     }

  84.         

  85.     //打开目录

  86.     File root = SD_MMC.open(INITDIR);

  87.     if(!root){

  88.         Serial.println("Failed to open directory");

  89.         OLED.disStr(0, 16, "无法读取目录");

  90.         OLED.display();         

  91.         return;

  92.     }

  93.     if(!root.isDirectory()){

  94.         Serial.println("Not a directory");

  95.         OLED.disStr(0, 16, "目录错误");

  96.         OLED.display(); 

  97.         return;

  98.     }

  99. 

  100.     // 枚举 INITDIR 目录下的所有文件

  101.     File file = root.openNextFile();

  102.     while(file){

  103.         if(file.isDirectory()==false){

  104.             Serial.print("  FILE: ");

  105.             Serial.print(file.name());

  106.             Serial.print("  SIZE: ");

  107.             Serial.println(file.size());

  108.             

  109.             // 只记录文件名小于最大长度的文件

  110.             if (strlen(file.name())<=MAXNAMELENGTH+strlen(INITDIR)+1) {

  111.                 // 将文件名保存起来

  112.                 char *p=(char*) file.name();

  113.                 strcpy(FilePool[FileCounter].name, p+strlen(INITDIR)+1);

  114.                 FilePool[FileCounter].size=file.size();  

  115.                 FileCounter++;  

  116.               }

  117.         }

  118.         file = root.openNextFile();

  119.     }

  120. 

  121.    

  122.    if (FileCounter==0) {

  123.       Serial.println("No file in directory!");

  124.       OLED.disStr(0, 16, "目录中无文件");

  125.       OLED.display(); 

  126.       return ;

  127.     }     

  128. 

  129. /*

  130.    for (int i=0;i<FileCounter;i++) {

  131.       Serial.println(FilePool[i].name);

  132.     }

  133. */

  134. 

  135. }

  136. 

  137. // 上一个文件的编号

  138. int LastIndex=0xFF;

  139. // 当前文件编号

  140. int CurrentIndex=0;

  141. 

  142. void loop(){

  143.     char  c=0xFF;

  144.     char Buffer1[32],Buffer2[32];

  145.     

  146.     eKey_analog = read_key_analog();

  147. 

  148.     // 如果当前文件编号和之前的记录不同，说明有文件切换动作

  149.     if (LastIndex!=CurrentIndex) {

  150.         // 串口输出

  151.         Serial.println("****************");

  152.         Serial.println(FilePool[CurrentIndex].name);

  153.         Serial.println(FilePool[CurrentIndex].size);

  154.         sprintf(Buffer1, "[%d/%d]", CurrentIndex+1, FileCounter);

  155.         Serial.println(Buffer1);

  156.         Serial.println("****************");

  157. 

  158.         // 屏幕输出

  159.         OLED.clear();

  160.         OLED.disStr(0, 0, "当前文件");

  161.         OLED.disStr(0, 16, FilePool[CurrentIndex].name);

  162.         sprintf(Buffer2, "%d bytes", FilePool[CurrentIndex].size);

  163.         OLED.disStr(0, 32, Buffer2);

  164.         OLED.disStr(0, 48, Buffer1);

  165.         OLED.display(); 

  166.         LastIndex=CurrentIndex;

  167.         eKey_analog=key_analog_no;

  168.         delay(700);

  169.       }

  170.       

  171.     while (Serial.available() > 0)  

  172.     {

  173.         byte k=Serial.read();

  174.         if ((k=='a')||(k=='z')||(k=='x')) {

  175.             c=k;

  176.           }

  177.     }  

  178.         if ((c=='a')||(eKey_analog==key_analog_up)) {

  179.                   CurrentIndex++;

  180.                   if (CurrentIndex==FileCounter) {

  181.                         CurrentIndex=0;

  182.                     }

  183.               }

  184.         if ((c=='z')||(eKey_analog==key_analog_down)) {

  185.                   CurrentIndex--;

  186.                   if (CurrentIndex==-1) {

  187.                         CurrentIndex=FileCounter-1;

  188.                     }

  189.               }

  190.         if ((c=='x')||(digitalRead(keyA)==LOW)) {

  191.                   char Buffer[MAXNAMELENGTH];

  192.                   strcpy(Buffer, INITDIR);

  193.                   strcat(Buffer, "/");

  194.                   strcat(Buffer, FilePool[CurrentIndex].name);

  195.                   Serial.printf("Reading file: %s\n", Buffer);

  196.               

  197.                   File file = SD_MMC.open(Buffer);

  198.                   if(!file){

  199.                       Serial.println("Failed to open file for reading");

  200.                       OLED.clear();

  201.                       OLED.disStr(0, 0, "读取文件失败");

  202.                       OLED.disStr(0, 16,"按B键返回");

  203.                       OLED.display();  

  204.                       while (digitalRead(keyB)==HIGH) {}                    

  205.                   } else {

  206.                       Serial.print("Read from file: ");

  207.                       int ByteSend=0;

  208.                       while(file.available()){

  209.                           char v=file.read();

  210.                           //Serial.write(v);

  211.                           Serial2.write(v);

  212.                           delay(20);

  213.                           ByteSend++;    

  214.                           if (ByteSend%EVERYSHOW ==0) {                      

  215.                           OLED.clear();

  216.                           OLED.disStr(0, 0, FilePool[CurrentIndex].name);

  217.                           sprintf(Buffer1, "[%d/%d]", ByteSend, FilePool[CurrentIndex].size);

  218.                           OLED.disStr(0, 16,Buffer1);

  219.                           OLED.display(); }                           

  220.                       }

  221.                       

  222.                       OLED.clear();

  223.                       OLED.disStr(0, 0, FilePool[CurrentIndex].name);

  224.                       sprintf(Buffer1, "[%d/%d]", ByteSend, FilePool[CurrentIndex].size);

  225.                       OLED.disStr(0, 16,Buffer1);

  226.                       OLED.disStr(0, 32,"发送完成,B键返回");

  227.                       OLED.display();

  228.                       // 强制刷新当前文件名 

  229.                       LastIndex=0xFF;

  230.                       while (digitalRead(keyB)==HIGH) {}  

  231.                   }

  232.               }  

  233.          

  234. }

复制代码

FireBeetle CH55X 电路图和 PCB:

OLED 的电路图:

参考：

1. https://mc.dfrobot.com.cn/thread-308130-1-1.html 国产主控芯片打造 USB 提醒器






回复

使用道具 举报

精彩评论(1)

zoologist  高级技匠
 楼主|

发表于 2021-3-16 21:00:26

工作的视频：


作品用到的板子：

FireBeetle ESP32 制作一个自动输入器图1


回复

使用道具 举报

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

为本项目制作心愿单
购买心愿单
心愿单 编辑
[[wsData.name]]

硬件清单

  • [[d.name]]
btnicon
我也要做!
点击进入购买页面
撰写新帖
关于楼主
勋章墙
创客造 编辑选择奖 编辑选择奖

楼主的其它帖子

background 创造力兑换 background 心愿单 background 创客导航
上海智位机器人股份有限公司 沪ICP备09038501号-4

© 2013-2024 Comsenz Inc. Powered by Discuz! X3.4 Licensed

mail